Domain-Specific Languages: Links, News And Resources (3)

Previous Post

Domain-Specific Languages, implemented in different languages.

dsl – Mini-languages in Python – Stack Overflow
http://stackoverflow.com/questions/1547782/mini-languages-in-python

Creating Domain Specific Languages in Python
http://www.slideshare.net/Siddhi/creating-domain-specific-languages-in-python

Building Your Own Java, Part 2
http://www.infoq.com/presentations/JetBrains-MPS-DSL-2
Alex Shatalin and Václav Pech continue their language building demo using JetBrains MPS started in Part 1 of this presentations (see “Building Your Own Java, Part 1” on InfoQ).

DSLs in Clojure
http://www.infoq.com/presentations/DSL-Clojure

Building Your Own Java, Part 1
http://www.infoq.com/presentations/JetBrains-MPS-DSL
Alex Shatalin and Václav Pech hold a hands on demonstration on using JetBrains MPS to generate a new language, including version control, debugging, testing, refactoring, etc.

Mission: Impossible–Purely Declarative User Interface Modeling
http://www.infoq.com/presentations/S4-Declarative-DSL-UI

A DSL for Scripting Refactoring in Erlang
http://www.infoq.com/presentations/Wrangler-Refactoring-Erlang

Webr-DNQ – Web Application Development with Pleasure
http://www.infoq.com/presentations/Webr-DNQ
Maxim Mazin and Evgenii Schepotiev discuss the advantages of using DSLs by exemplifying application development with JetBrains MPS (Meta Programming System) and the Webr-DNQ framework.

Emulating "self types" using Java Generics to simplify fluent API implementation | Passion For Code
http://passion.forco.de/content/emulating-self-types-using-java-generics-simplify-fluent-api-implementation

dlitvakb/deklarativna
https://github.com/dlitvakb/deklarativna
A Declarative HTML DSL for Ruby

clojure @ runa :: dynamic pricing through DSLs
http://www.infoq.com/presentations/clojure-runa-dynamic-pricing-through-DSLs
Domain Model – Reference Guide 4.0 – Mendix Community Platform
https://world.mendix.com/display/refguide4/Domain+Model

Petter’s Random Thoughts on Software: DSL’s, UIX and Agile Development, Lessons Learned
http://pettergraff.blogspot.it/2012/05/overview-over-last-8-months-ive-been.html

cgrand/parsley
https://github.com/cgrand/parsley
A DSL for creating total and truly incremental parsers in Clojure

InfoQ: How to Integrate Models And Code
http://www.infoq.com/articles/combining-model-and-code

My Links
http://delicious.com/ajlopez/dsl

Keep tuned!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

Mass Programming Language (3) Commands

Previous Post

Today let’s review command implementation in Mass (see repo). In the class library project, I have a dedicated namespace and folder for commands:

There are commands for if, while, for, for each, etc… Every command implements the ICommand interface:

public interface ICommand
{
    object Execute(Context context);
}

See that is very similar to IExpression. But I wanted to keep a separation between commands and expressions, at least for this first implementation, in order to have a clear separation of basis concerns.

A typical example of command is WhileCommand, partial code:

public class WhileCommand : ICommand
{
    private static int hashcode = typeof(WhileCommand).GetHashCode();

    private IExpression condition;
    private ICommand command;

    public WhileCommand(IExpression condition, ICommand command)
    {
        this.condition = condition;
        this.command = command;
    }

    public object Execute(Context context)
    {
        for (object value = this.condition.Evaluate(context); 
            value != null && !false.Equals(value);
            value = this.condition.Evaluate(context))
        {
            this.command.Execute(context);
            if (context.HasContinue())
                context.ClearContinue();
            if (context.HasBreak())
            {
                context.ClearBreak();
                break;
            }
        }

        return null;
    }
}

In Mass, every null or false value is false. All other value is true. I should refactor the code to have a central method IsFalse to be invoked in the above While code and in other commands, like IfCommand.

Another sample of command is ForEachCommand, partial code:

public class ForEachCommand : ICommand
{
    private string name;
    private IExpression expression;
    private ICommand command;

    public ForEachCommand(string name, IExpression expression, ICommand command)
    {
        this.name = name;
        this.expression = expression;
        this.command = command;
    }

    public object Execute(Context context)
    {
        var values = (IEnumerable)this.expression.Evaluate(context);

        foreach (var value in values)
        {
            context.Set(this.name, value);
            this.command.Execute(context);
            if (context.HasContinue())
                context.ClearContinue();
            if (context.HasBreak())
            {
                context.ClearBreak();
                break;
            }
        }

        return null;
    }
}

See that for Mass every IEnumerable value can be used as the element provider for ForCommand. I added some methods to the current context to signal the present of a break or continue (in the current version, I added return treatment, too).

And, as usual, all this code was developed using TDD flow: you can read repo commit history.

Next posts: Lexer, Parser, Mass samples, Mass scripting, using Mass from our .NET programs.

Keep tuned!

Angel “Java” Lopez

http://www.ajlopez.com

http://twitter.com/ajlopez

Mass Programming Language (2) First Expressions

Previous Post
Next Post

Before using Mass language in samples (see repo), I want to visit some implementation points. First, a news: now there is a solution (at (en https://github.com/ajlopez/Mass/blob/master/Src/Mass.sln) that can be compiled with Visual Studio C# Express.

The Mass solution has a class library project. There is a namespace dedicated to expressions:

An expression implements IExpression:

  
public interface IExpression
{
	object Evaluate(Context context);
}

A Context keeps a key/value dictionary, to save the current variables:

  
public void Set(string name, object value)
{
	this.values[name] = value;
}

public object Get(string name)
{
	if (this.values.ContainsKey(name))
		return this.values[name];

	if (this.parent != null)
		return this.parent.Get(name);

	return null;
}

(notice that it supports nested context: each context can have a parent).

A simple expression is ConstantExpression, that returns a constant, without using the received context. A constant is any .NET value/object:

  
public class ConstantExpression : IExpression
{
	// ...

	private object value;

	public ConstantExpression(object value)
	{
		this.value = value;
	}

	public object Evaluate(Context context)
	{
		return this.value;
	}

	// ...
}

Another expression is the one that evaluates a variable name in the current context:

  
public class NameExpression : IExpression
{
	// ...

	private string name;

	public NameExpression(string name)
	{
		this.name = name;
	}

	public object Evaluate(Context context)
	{
		return context.Get(this.name);
	}

	// ...
}

The context is important: it could be the context of the current function, of a closure, of current object, of current module, etc… The same name could refer defers differente associated variables, as in other programming languages.

As usual, all these classes (expressions, Context, …) were written using the flow of TDD. You can check the test project and the repo commits history were there is evidence of that flow.

Next posts: some additional expressions, commands, using Mass for scripting, using Mass from our .NET programs.

Kee tuned!

Angel “Java” Lopez

http://www.ajlopez.com

http://twitter.com/ajlopez

Mass Programming Language (1) Inception

Next Post

Three weeks ago, I was working on the implementation of an interpreted language, written in C#. The new language is called Mass (dedicated to  @MArtinSaliaS):

https://github.com/ajlopez/Mass

The current solution has three projects: a class library, its tests, and a console program, mass.exe, that launches Mass programs

You can run a hello.ms:

mass hello.ms

The classic Hello world source code:

println("Hello, world")

An example with classes and objects

class Person
	define initialize(firstname, lastname)
		self.firstname = firstname
		self.lastname = lastname
	end
	
	define getName()
		return self.lastname + ", " + self.firstname
	end
end

adam = new Person("Adam", "TheFirst")

println(adam.getName())

An example with access to .NET types and objects:

dirinfo = new System.IO.DirectoryInfo(".")

for fileinfo in dirinfo.GetFiles()
	println(fileinfo.Name)
end

The idea is  to have a dynamic language that leverages an underlying language provided with a rich class library and ecosystem, like in AjSharp and other of my projects. Before Mass, I was working on:

- Implementing Python in C# (see PythonSharp)

- Implementing Ruby in C# (see RubySharp)

- AjSharp (see repo and post)

But this time I wanted to implement something with simple sintax and semantic. Indeed, I was playing with “simple” ideas for a compiler over Javascript, see SimpleScript (1) First Ideas.

Then, with Mass, I deliberately wanted to avoid:

- Multiple commands in the same line (I discarded ‘;’ like in Ruby)

- Syntax based in spaces and indentation (Python discarded)

- Function invocation using only the name; Mass impose the explicit use of parenthesis (Ruby discarded; Mass is like JavaScript)

- Base values and classes (integers, strings, lists, etc…) having a crowd of methods (like Ruby and Python). No, Mass prefers to expose and use the underlying language/class library.

Then, I wanted:

- Functional values, as first-class citizens, like in JavaScript. So, having to put explicit parenthesis to invoke a function allows me to use the name of the function as a functional value

- Dynamic objects: each object can be extended at any moment, with new instance variables, object functions, a la JavaScript

- Syntax based in lines: each command has its own line. No command separation

- Syntax based in keywords: the end of a command list is marked with ‘end’, no braces

- As far as possible, only one way to do something, instead of the many ways motto a la Perl

- Complete keywords, then ‘define’ instead of ‘def’

- Simple inheritance at classes. But Mass could be expressive without written classes, using native classes from .NET framework and other libraries. It could be used as an scripting language.

- Explicit setting of variables that are out of the local scope (a topic for next posts)

- Variable scope by file, like in the require of JavaScript/NodeJs/CommonJS

- Module by file, with a require that automatically searches in directories, a la NodeJs/CommonJs. Notably, Mass can consume node_modules folder, so Mass module can be published and installed using NPM!

- Package manager, using NPM. You can use package.json to declare the dependencies, and publish new modules at NPM (using ‘mass-‘ as the suggested namespace).

In upcoming posts, I will write more details about implementation, guiding design ideas, examples. But now, you can see the code and the test examples at public repo. And yes, all was written by baby steps, using TDD.

Keep tuned!

Angel “Java” Lopez

http://www.ajlopez.com

http://twitter.com/ajlopez

Scala: Links, News And Resources (3)

Previous Post

Scalaz
http://code.google.com/p/scalaz/
https://github.com/scalaz/scalaz
Scalaz: Type Classes and Pure Functional Data Structures for Scala
 
CLOJURE VS SCALA
http://hammerprinciple.com/therighttool/items/clojure/scala
Suppose you had to choose between Clojure and Scala, which would you pick?
 
ScalaIDE for Eclipse
http://scala-ide.org/

Scala for the Intrigued: Creating Higher Order Functions
http://pragprog.com/magazines/2012-02/scala-for-the-intrigued
 
Scala for the Intrigued: Working with Collections
http://pragprog.com/magazines/2012-01/scala-for-the-intrigued
n this fifth installment of his series on the Scala programming language, Venkat mixes object oriented and functional styles to reveal the power and grace of Scala collections.
 
Scala for the Intrigued: Cute Classes and Pure OO
http://pragprog.com/magazines/2011-11/scala-for-the-intrigued
This third installment of his series on Scala shows how Scala’s OO purity leads to simple, elegant code.
 
Scala for the Intrigued: Functional Style of Programming
http://pragprog.com/magazines/2011-12/scala-for-the-intrigued
Venkat delves into the functional style of programming in Scala.
 
Languages, Verbosity, and Java
http://www.informit.com/articles/article.aspx?p=1824790
With the new spate of programming languages emerging for the Java virtual machine and other platforms, it’s more important than ever that the rules of a language make code clear and concise. But clarity and conciseness don’t exactly go hand in hand.
 
Running Spring Java and Scala Apps on Heroku
http://www.infoq.com/presentations/Running-Spring-Java-and-Scala-Apps-on-Heroku
 
A little scalaz IO action
https://gist.github.com/1552195

Functional IO in Scala with Scalaz
http://www.stackmob.com/2011/12/scalaz-post-part-2/
 
Everything I Ever Learned about JVM Performance Tuning @twitter
http://www.infoq.com/presentations/JVM-Performance-Tuning-twitter
Attila Szegedi discusses performance problems encountered at Twitter running Java and Scala applications, presenting how they solve them through JVM tuning.
 
Offbeat: Scala by the end of 2011 – No Drama but Frustration is Growing
http://gridgaintech.wordpress.com/2011/12/11/offbeat-scala-by-the-end-of-2011-no-drama-but-frustration-is-growing/
 
Real life Scala feedback from Yammer
http://blog.joda.org/2011/11/real-life-scala-feedback-from-yammer.html

Actors: can we do better?
http://vimeo.com/20307408
Paul Chiusano presents to the Northeast Scala Symposium nescala.org

scala symposium Boston
http://nescala.org/
 
Continuations and Other Functional Patterns
http://vimeo.com/20305325

Building an HTTP streaming API with Scala
http://vimeo.com/20306881
 
Guerrilla Guide to Pure Functional Programming
http://vimeo.com/20293743

Referentially transparent nondeterminism
http://pchiusano.blogspot.com/2011/06/referentially-transparent.html
 
Scala’s version fragility make the Enterprise argument near impossible
http://lift.la/scalas-version-fragility-make-the-enterprise
An attribute of Scala is that the Scala compiler generates fragile byte-code.  This means that all the code in an executable (JAR or WAR) must be compiled with the same library and compiler versions.

Functional Scala: Curried Functions and spicy Methods
http://gleichmann.wordpress.com/2011/12/04/functional-scala-curried-functions-and-spicy-methods/
 
Functional Programming For Java Programmer Scala Or Clojure?
http://www.nairaland.com/nigeria/topic-718309.0.html

Scala vs Ceylon vs Kotlin
https://plus.google.com/105933370793992913359/posts/4ihU1TdzSA8

Scala feels like EJB 2, and other thoughts
http://blog.joda.org/2011/11/scala-feels-like-ejb-2-and-other.html
 
My Links
http://delicious.com/ajlopez/scala

Keep tuned!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

Scala: Links, News And Resources (2)

Previous Post
Next Post

More about Scala programming language and ecosystem

Learning Scala? Learn the Fundamentals First
http://tataryn.net/2011/10/learning-scala-learn-the-fundamentals-first/

Injectors and Extractors in Scala
http://blog.jayway.com/2011/10/11/injectors-and-extractors-in-scala/

How to maintain compatibility and language quality
https://gist.github.com/1241465

Akka 2.x roadmap…
https://docs.google.com/document/pub?id=1CMz_MEQA8oPcGw9oaFdq_KYYFB_5qZjsDYYwuXfZhBU&pli=1

Look ma…. location transparency

London Scala Users’ Group:Practical Scalaz: making your life easier the hard way
http://skillsmatter.com/podcast/home/practical-scalaz-2518/js-2679

jdegoes / blueeyes
https://github.com/jdegoes/blueeyes
A lightweight Web 3.0 framework for Scala, featuring a purely asynchronous architecture, extremely high-performance, massive scalability, high usability, and a functional, composable design.

Actors that Unify Threads and Events
http://lamp.epfl.ch/~phaller/doc/haller07actorsunify.pdf

Clojure vs Scala – anecdote Options
http://groups.google.com/group/clojure/browse_thread/thread/b18f9006c068f0a0?pli=1

Contrasting Performance : Languages, styles and VMs – Java, Scala, Python, Erlang, Clojure, Ruby, Groovy, Javascript
http://blog.dhananjaynene.com/2011/08/cperformance-comparison-languages-styles-and-vms-java-scala-python-erlang-clojure-ruby-groovy-javascript/

Scala: Making it easier to abstract code
http://www.markhneedham.com/blog/2011/07/23/scala-making-it-easier-to-abstract-code/

Scala: Companion Objects
http://www.markhneedham.com/blog/2011/07/23/scala-companion-objects/

Scala programming tutorial part 1. (environment setup)
http://www.youtube.com/watch?v=zicyW1EeRIU

Scala programming tutorial part 2. (executable, print)
http://www.youtube.com/watch?v=9mFV9pfUenU

Working Hard to Keep It Simple in Scala
http://www.softdevtube.com/2011/08/01/working-hard-to-keep-it-simple-in-scala/

Good article on Functional Programming #FunctionalProgramming #Scala #ErLang
http://vikasgoel.tumblr.com/post/8369381751/good-article-on-functional-programming

Working Hard to Keep It Simple
http://www.oscon.com/oscon2011/public/schedule/detail/21055

My Links
http://delicious.com/ajlopez/scala

More Scala resources are coming

Keep tuned!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

Programming Languages, Distributed Computing and Artificial Intelligence

It’s time to write a post, explaining my personal interest in some topics, like programming languages, messaging, distributed computing and artificial intelligence. English is not my mother tongue, so I’m afraid of not to be capable to express all what I want to transmit, but I hope this post will shade some light on my development activities.

I’m sure that most of you are interested in such topics. They are interesting, and studying and exploring them is a lot of fun. As software developers, we usually like to play with: writing a new programming language, implementing an existing one, building distributed applications, etc.

But in my case, there is a common ground for all these works. For example, programming languages. The current programming languages should be extended to support a better, with less friction, serialization of simple objects (without behavior, simple messages), to have distributed applications. There are two ways of doing it: extending the language with new syntax, or adding new libraries (see Scala and Akka as examples). So, in order to have a better understanding of what it is needed,  I wrote my own interpreted language (AjSharp), extended Smalltalk (AjTalk) to run distributed objects, writing agents and actors-like demos (AjAgents, and agents in AjSharp), distributed messaging (as in AjFabriq) and exploring JavaScript with Node.js (SimpleMessages, SimpleQueue, MultiNodes, SimpleRemote, SimpleActors… ), to have all in place to have an easy way of writing and running distributed applications. Ok, there are plenty of other projects that I could use. I wrote my own ones to practice and to better understanding of the underlying problems and opportunities. And to have my own fun

But, why distributed computing? I’m convinced that is the path to explore to have new kind of applications. Fundamentally, applications that solve complex problem, that can be tackled using parallel computation, and horizontal scalability. Not only Big Data processing. There are life beyond analyze tweets in real-time. The idea is to attack artificial intelligence problems, using commodity hardware.

That is the big background picture on my development landscape: flexible programming languages; messaging to support distributed application communications; distributed applications for the next generation of problems to solve.

Yes, the next frontier. Where no man has gone before

Keep tuned!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

Smalltalk: Links, News And Resources (11)

Previous Post

Do Smalltalk have shared variables…?
http://objectmix.com/smalltalk/311676-do-smalltalk-have-shared-variables.html
Smallissimo: Lazy initialization of Shared Variable Bindings
http://smallissimo.blogspot.com.ar/2011/08/lazy-initialization-of-shared-variable.html

Class Variables
http://esug.org/data/Articles/Columns/EwingPapers/class_variables.pdf
How to Use Class Variables and Class Instance Variables
http://esug.org/data/Articles/Columns/EwingPapers/cvars&cinst_vars.pdf

Leftshore
http://leftshore.wordpress.com/
By Boris Popov

Smalltalk at 30: STIC 2013
http://www.jarober.com/blog/blogView?showComments=true&title=Smalltalk+at+30%3A+STIC+2013&entry=3531653797

InfoWorld – Google Books
http://books.google.com.ar/books?id=4S8EAAAAMBAJ&pg=PA1&lpg=PA1&dq=smalltalk-8+0+balloon&source=bl&ots=y4eGGi6_ml&sig=DVucVnBA4cJDkvXs4kObvRE3LV8&hl=en&ei=4G9gT9rOMcbOiAKBnI2_BA&redir_esc=y#v=onepage&q&f=false

SmalltalkHub
http://smalltalkhub.com/

garduino (German Arduino)
https://github.com/garduino
Cuis work by @garduino

Ten is a good number: isKindOf: considered harmful
http://blogten.blogspot.com.ar/2007/09/iskindof-considered-harmful.html

Traits: Composable Units of Behaviour
http://scg.unibe.ch/archive/papers/Scha03aTraits.pdf
smalltalk – How to unload Traits from Pharo – Stack Overflow
http://stackoverflow.com/questions/6879432/how-to-unload-traits-from-pharo

smalltalk – What is the difference between a Squeak/Pharo Trait and a Newspeak Mixin? – Stack Overflow
http://stackoverflow.com/questions/2329724/what-is-the-difference-between-a-squeak-pharo-trait-and-a-newspeak-mixin

Code Completion and Syntax Highlighting – YouTube
http://www.youtube.com/watch?v=QKDVOPelqVc&feature=youtu.be&a
Cross Platform – YouTube
http://www.youtube.com/watch?v=5a-n3UjYQHM&feature=youtu.be&a

Redline Smalltalk V1.0 | Indiegogo
http://www.indiegogo.com/smalltalk?c=home

Smalltalks 2012 – 6th Argentine conference
http://www.fast.org.ar/smalltalks2012/talks/Objects%20in%20the%20Mist%3A%20The%20Design%20of%20a%20Non-Traditional%20Smalltalk?_s=4NRkHHU4m6wbF97d&_k=z08U0UJhHx6E-2j9
Mist Project

Smalltalks 2012 – 6th Argentine conference
http://www.fast.org.ar/smalltalks2012/talks

Issue 2581 – pharo – COG – Float access methods – A free open-source Smalltalk-inspired language and environment – Google Project Hosting
https://code.google.com/p/pharo/issues/detail?id=2581

Squeak – Dev – detecting if method has an prim error code
http://forum.world.st/detecting-if-method-has-an-prim-error-code-td4377050.html

My Links
http://delicious.com/ajlopez/smalltalk

Code Katas in JavaScript/Node.js using TDD

These past weeks, I was working in JavaScript/Node.js modules, using TDD at each step. Practice, practice, practice, the journey to mastery.

You can see my progress, reviewing the commits I did at each new test. This is a summary of that work:

CobolScript: See my posts, an implementation of COBOL as a compiler to JavaScript, having console program samples, dynamic web pages and access to Node.js modules. See web sample, using MySQL, and SimpleWeb.

SimplePipes: A way to define message-passing using ‘pipes’ to connect different defined nodes/functions. I want to extend it to have distributed process.

SimpleBoggle: Boggle solver, it is better than me! See console sample.

SimpleMemolap: Multidimensional OLAP-like processing, with in-memory model, and SimpleWeb site see sample:

SimpleChess: Work in progress, define a board using SimpleBoard, and make moves. I’m working on SimpleGo, too, to have a board, game, and evaluators.

SimpleRules: forward-chaing rule engine. I should add rule compilation to JavaScript. The engine works a la Rete-2, detecting the changes in the current state, and triggering actions.

SimpleScript: see post, my simple language, compiled to JavaScript. See posts. WIP.

Py2Script: Python language compiler to JavaScript, first step. WIP.

SimpleWeb: web middleware, a la Connect, with web sample.

BasicScript: My first steps to compile Basic to JavaScript. I want to use it to program and compile a game.

SimplePermissions: Today code kata. It implements subjects, roles, and permissions, granted by context.

SimpleFunc: Serialization of functions.

SimpleMapReduce: Exploring the implementation of a Map-Reduce algorithm.

SimpleTuring: Turing machine implentation.

Cellular: Cellular automata implementation, including a Game of Life console sample.

I will work on:

NodeDelicious: To retrieve my links from my Delicious account, now the site was revamped and no more pagination.

SimpleDatabase: In-memory database, maybe I will add file persistence.

SimpleSudoku: Rewrite of my AjSudoku solver, from scratch.

I’m having a lot of fun, as usual

Keep tuned!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

Smalltalk: Links, News And Resources (10)

Previous Post
Next Post

Sport – Smalltalk Portability
http://sourceforge.net/projects/sport/
Sport is a Smalltalk portability layer.

Aida
http://comments.gmane.org/gmane.comp.web.server.aida/2655
AIDA/Web is Web Application Server and Framework for building web apps

Sport and Swazoo released
http://dolphinseaside.blogspot.com.ar/2006/07/sport-and-swazoo-released.html

Seaside for Dolphin Smalltalk
http://www.seaside.st/download/dolphin

Swazoo Smalltalk Web Server
http://www.swazoo.org/download.html

pmon / Cuis-PetitParser
https://github.com/pmon/Cuis-PetitParser
PetitParser port to Cuis

A Fan Letter to Redline Smalltalk …
http://jamesladdcode.com/2010/01/30/a-fan-letter-to-redline-smalltalk/

SUnit Tutorial
http://stephane.ducasse.free.fr/Programmez/OnTheWeb/SUnitEnglish2.pdf

SUnit
http://wiki.squeak.org/squeak/1547
Kent Beck’s SUnit testing framework for Smalltalk

SUnit
http://sunit.sourceforge.net/manual.htm
The mother of all unit testing frameworks
initialize & new
http://vimeo.com/8058857
Friendly, predictable methods to cling to in a system of methods defined by seeming madmen.

Introduction to Smalltalk bytecodes
http://marianopeck.wordpress.com/2011/05/21/introduction-to-smalltalk-bytecodes/
Smalltalks 2012 Videos
http://www.youtube.com/playlist?list=PLCGAAdUizzH31VumrhrK2HHepHu3DBpY0

Redline Smalltalk V1.0
http://www.indiegogo.com/smalltalk?c=pledges
Smalltalk: A White Paper Overview
http://web.cecs.pdx.edu/~harry/musings/SmalltalkOverview.html

Allow me to reintroduce myself. My name is MagLev
http://confreaks.com/videos/1269-rubyconf2012-allow-me-to-reintroduce-myself-my-name-is-maglev
Remember when Avi Bryant spoke at RailsConf ’07 about Ruby’s future, and how it’d be slick if we could get to where Smalltalk was 30 years ago? Well, we kinda have, in some respects, with the 1.0 release of MagLev, a Ruby implementation running on a Smalltalk VM.

Debug Mode is the Only Mode
http://gbracha.blogspot.co.uk/2012/11/debug-mode-is-only-mode.html

The Early History Of Smalltalk
http://worrydream.com/EarlyHistoryOfSmalltalk/
by Alan C. Kay

Smalltalks 2012 photos
http://blogten.blogspot.com.ar/2012/11/smalltalks-2012-photos.html

Cincom Smalltalk at Twitter
https://twitter.com/simplypossible

My Links
http://delicious.com/ajlopez/smalltalk