Angel "Java" Lopez : Smalltalk, Javascript

Resoluciones del Nuevo Mes: Noviembre 2012

lopez — Wed, 07 Nov 2012 16:15:49 GMT

Revisión de mis resoluciones de Octubre:

- Dar una charla sobre lenguajes de programación en Javascript [completo] ver video
- Dar una chalar sobre Node.js/Socket.IO, aplicaciones web de tiempo real [completo] ver post
- Trabajar en PythonSharp [completo] ver repo
- Trabajar en AjTalk para Java [pendiente]
- Trabajar en AjConsorSite [parcial] solo tuve demo y reuniones
- Trabajar en GameServer [parcial] solo tuve demo y reuniones

Adicionalmente, estuve trabajando en:

- Actualizar mis ejemplos de Node.js [completo] ver repo
- Autómata celular en Javascript/Node.js [completo] ver repo
- Mejoras menores de AjTalkJs y AjLispJs
- Comenzar mi Basic Script (para Javascript/Node.js) [completo] ver repo
- Comenzar a portar AjGroups (librería de grupos finitos) a Javascript/Node.js [completo] ver repo

Para este nuevo mes:

- Trabajar en PythonSharp
- Dar una charla sobre Implementando Python, en PyCon 2012 Argentina
- Trabajar en AjTalk para Java
- Trabajar en AjTalk para Javascript
- Trabajar en BasicScript (quiero comenzar a usarlo para que se pueda definir la lógica de un juego ejemplo de mi GameServer)
- Comenzar páginas markdown con Tutorial de Java, en español
- Comenzar páginas markdown con Tutorial de Node.js en español

Nos leemos!

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

AjTalk en Javascript (1) Primeras Implementaciones desde 0

lopez — Fri, 23 Mar 2012 10:10:48 GMT

Hace unos días, migré mi proyecto AjTalk de Google Code a mi cuenta en GitHub:

https://github.com/ajlopez/AjTalk

Vengo trabajando en él, en mis tiempos libros, debe ser desde el 2008. Está escrito en C# e implementa una máquina virtual Smalltalk, basada en bytecodes. Codificado en C# plano, debería probarlo en otras plataformas, pero seguro que Mono lo soporta. En el 2011 le agregué la capacidad de compilar código Smaltalk de fileouts a Javascript, que se pueden usar tanto en el browser como en Node.js. El domingo pasado me decidí a crear otro proyecto:

https://github.com/ajlopez/AjTalkJs

como code kata del día. Tiene otro “approach”: implementar una máquina virtual AjTalk, desde 0, directamente en Javascript. La idea es compilar código Smalltalk a métodos y bloques con bytecodes, y tener el intérprete de esos método. Tanto la base del Lexer, Compiler, Block, Execution Block están funcionando. El código de la implementación principal está en:

https://github.com/ajlopez/AjTalkJs/blob/master/lib/ajtalk.js

En esa implementación, estoy usando un método sendMessage que usa un “custom lookup” para ubicar el método que atiende un mensaje, de acuerdo a su “selector”, su nombre. Un fragmento de lib/ajtalk.js:

BaseObject.prototype.sendMessage = function(selector, args)
{
    var method = this.lookup(selector);
    return method.apply(this, args);
};

function BaseClass(name, instvarnames, clsvarnames, supercls) {
    this.name = name;
    this.instvarnames = instvarnames;
    this.clsvarnames = clsvarnames;
    this.supercls = supercls;
    this.methods = {};
};

BaseClass.prototype.__proto__ = BaseObject.prototype;

BaseClass.prototype.defineMethod = function (selector, method) 
{
    this.methods[selector] = method;
};

BaseClass.prototype.getInstanceSize = function() {
    var result = this.instvarnames.length;
    if (this.supercls)
        result += this.supercls.getInstanceSize();
        
    return result;
};

BaseClass.prototype.lookupInstanceMethod = function (selector) 
{
    var result = this.methods[selector];
    if (result == null && this.supercls)
        return this.supercls.lookupInstanceMethod(selector);
    return result;
};

El lunes, se me ocurrió otra forma de hacerlo, que pensé que iba a tener dificultades: en vez de relegar la herencia a un “custom lookup”, podría aprovechar la cadena de prototipos para heredar métodos, e instancias por separado, para tener las variables de cada instancia. Escribí código en lib/ajtalknew.js:

function createClass(name, superklass, instvarnames, clsvarnames)
{
    var protoklass = new Function();
    
    if (superklass)
    {
        // Chain class prototypes
        protoklass.prototype.__proto__ = superklass.proto;
    }
    else
    {
        // First class methods
        protoklass.prototype.basicNew = function()
        {
            var obj = new this.func;
            obj.klass = this;
            return obj;
        }
        
        protoklass.prototype.defineSubclass = function(name, instvarnames, clsvarnames)
        {
            return createClass(name, this, instvarnames, clsvarnames);
        }
        
        protoklass.prototype.defineMethod = function(name, method)
        {
            var mthname = name.replace(/:/g, '_');
            if (typeof method == "function")
                this.func.prototype[mthname] = method;
            else
                this.func.prototype[mthname] = method.toFunction();
        }
        
        protoklass.prototype.defineClassMethod = function(name, method)
        {
            var mthname = name.replace(/:/g, '_');
            if (typeof method == "function")
                this.proto[mthname] = method;
            else
                this.proto[mthname] = method.toFunction();
        }

        // TODO Quick hack. It should inherits from Object prototype
        protoklass.prototype.sendMessage = function(selector, args)
        {
            return this[selector].apply(this, args);
        }
    }
    
    var klass = new protoklass;
    
    // Function with prototype of this klass instances
    klass.func = new Function();
    klass.proto = protoklass.prototype;
    klass.name = name;
    klass.super = superklass;
    klass.instvarnames = instvarnames;
    klass.clsvarnames = clsvarnames;
    
    klass.func.prototype.klass = klass;
    
    if (superklass) 
    {
        // Chaining instances prototypes
        klass.func.prototype.__proto__ = superklass.func.prototype;
    }
    else 
    {   
        // First instance methods
        klass.func.prototype.sendMessage = function(selector, args)
        {
            return this[selector].apply(this, args);
        }
    }
    
    Smalltalk[name] = klass;
    
    return klass;
}

createClass('Object');

Smalltalk.Object.defineClassMethod('compileMethod:', function(text)
    {
        var compiler = new Compiler();
        var method = compiler.compileMethod(text, this);
        this.defineMethod(method.name, method);
        return method;
    });

Smalltalk.Object.defineClassMethod('compileClassMethod:', function(text)
    {
        var compiler = new Compiler();
        var method = compiler.compileMethod(text, this);
        this.defineClassMethod(method.name, method);
        return method;
    });

Ok, es un poco “tricky” pero funciona!. Y ambos códigos fueron desarrollados con TDD, así que los refactors que hice fueron bien soportados y bienvenidos.

Esta vez, no usé QUnit para TDD en el browser. Usé línea de comando, con Node.js, y su “built-in” módulo assert (no tenía conexión a Internet cuando comencé a escribir, así que no me traje en NodeUnit). Es una experiencia interesante, porque fue la forma más simple de escribir tests: un largo programa con assert tras otro. Puedo en cualquier momento refactorizarlo, pero no ví que me complicara mucho en el desarrollo: avancé tan rápido como cuando escribo tests más organizados.

Tengo una función/”clase” javascript llamada Compilar que puede compilar código Smalltalk (un subconjunto de la gramática, por ahora) en bytecodes. Soporta mensajes unarios, binarios y de “keywords”. Sólo unos pocos bytecodes fueron necesarios para implementar la funcionalidad actual:

var ByteCodes = {
    GetValue: 0,
    GetArgument: 1,
    GetLocal: 2,
    GetInstanceVariable: 3,
    GetGlobalVariable: 4,
    GetSelf: 5,
    SetLocal: 10,
    SetInstanceVariable: 11,
    SetGlobalVariable: 12,
    Add: 20,
    Subtract: 21,
    Multiply: 22,
    Divide: 23,
    SendMessage: 40,
    Return: 50
};

Hay ejemplos index.html, indexnew.html para probar interactivamente ambas implementaciones.

Trabajo pendiente: implementar variables de clases, metaclases, como siempre usando TDD. Mejorar los ejemplos de browser, y escribir posts sobre todo eso.

Nos leemos!

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

AjTalk y Javascript (Parte 2) Compilando una Clase Simple

lopez — Tue, 20 Dec 2011 10:05:11 GMT

Post Anterior

En este post explicaré con un ejemplo simple cómo código Smalltalk puede ser compilado a Javascript usando el proyecto AjTalk.Compiler, el nombre del ejecutable es ajtalkc. El compilador está escrito desde cero en C#. La forma de compilar (la salida) fue fruto de investigar temas dinámicos de Javascript, y para Smalltalk en particular, leí los posts que mencioné en Smalltalk y Javascript sin ver la implementación interna, sólo lo publicado en post. En cada proyecto trato de ver cómo implementar lo que quiero, sin “infectarme” de otras implementaciones, simplemente para ver hasta donde puedo llegar desde las ideas básicas. Y usando TDD, la implementación interna va surgiendo a medida que se va desarrollando.

Como es usual, el código está en mi repo:

http://code.google.com/p/ajtalk/

Yo hice “fileOut” de una clase simple de Pharo: Point. El fragmento del principio:

Object subclass: #Point
	instanceVariableNames: 'x y'
	classVariableNames: ''
	poolDictionaries: ''
	category: 'Graphics-Primitives'!
!Point commentStamp: '<historical>' prior: 0!
I represent an x-y pair of numbers usually 
designating a location on the screen.!
!Point methodsFor: '*Polymorph-Geometry' stamp: 'gvc 10/31/2006 11:01'!
directionToLineFrom: p1 to: p2
	"Answer the direction of the line from the receiver
	position.
	< 0 => left (receiver to right)
	= => on line
	> 0 => right (receiver to left)."
	^((p2 x - p1 x) * (self y - p1 y)) -
		((self x - p1 x) * (p2 y - p1 y))! !
....

Lo compilé usando el programa de comando de línea ajtalkc.exe (vean el proyecto de consola AjTalk.Compiler en la solución AjTalk; tiene un directorio CodeFiles con varios fileouts):

ajtalkc CodeFiles\PharoCorePoint.st

Se crea un nuevo archivo: Program.js. Exploremos cómo una clase Smalltalk puede ser representada en Javascript. Estas líneas definen la clase Point como una función Javascript, y su clase como otra función BLOCKED SCRIPT

function PointClass()
{
}
function Point()
{
}

Nada especial. Las siguientes dos líneas son:

Point.prototype.__class = PointClass.prototype;
Point.classPrototype = PointClass.prototype;

De esta manera, cada instancia de la clase Point tiene una variable __class que apunta al singleton PointClass.prototype. Y la función/”clase” Point tiene una variable classPrototype para apuntar al mismo singleton, si es necesario.

¿Cómo creamos una nueva instancia de Point? Usando un método de PointClass, en este caso definiendo su método basicNew:

PointClass.prototype['_basicNew'] = function() { return new Point(); };

Agregué un carácter _ para evitar la colisión de nombres con cualquier método Javascript.

Ahora, ¿Cómo asegurar que todas las instancias tengan sus variables de instanca? Definiéndolas en su prototipo:

Point.prototype.x = null;
Point.prototype.y = null;

Y la parte más interesante: ¿Cómo traducir un método Javascript a Smalltalk? Sea el método min en Smalltalk:

min
	"Answer a number that is the minimum
	of the x and y of the receiver."
	^self x min: self y! !

Su traducción a un método del prototipo de Point:

Point.prototype['_min'] = function()
{
    var self = this;
    return send(send(self, '_x'), '_min_', [send(self, '_y')]);
};

Noten que definí la variable self para ser usado por el resto del método (especialmente como variable libre en cualquier closure Javascript que encuentre, donde this podría apuntar a otro objeto). Y el uso de un método ayudante send que recibe: un objeto destino, el nombre del método a invocar, y un arreglo con sus argumentos.

Todo esto es trabajo en progreso. Ahora, estoy generando las líneas adicionales para usar Program.js desde Node.js (pueden ver el repo, con un ejemplo de Node.js), y también con otras líneas adicionales, usarlo desde el browser (ver el repo, ya hay un ejemplo cliente). Debería escribir diferentes compiladores para el server y el cliente, todos usando el mismo núcleo: el compilador de NodeJs ahora es una subclase del compilador básico de Javascript. Lo mismo el compilador para el browser. Tengo planeado compilar a Ruby. Todo esto es una prueba de concepto para mostrar el poder de tener un modelos abstracto del programa a ejecutar/compilar. Hasta podría usar ese modelo abstracto para ejecutar un programa, en lugar de compilar a bytecodes. O podría usar ese modelo abstracto, para compilar a bytecodes de AjTalk.

Próximos temas a visitar en posts: opciones de compilación, ejemplo para el browser, ejemplo para Node.js. Cómo acceder desde el código generado a objectos Javascript. Las funciones utilitarias. Implementación de herencia, bloques y clausuras.

Nos leemos!

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

AjTalk y Javascript (Parte 1) El Modelo Abstracto

lopez — Fri, 14 Oct 2011 11:44:00 GMT

Post Siguiente

Hace tres semanas escribí los posts:

Smalltalk and Javascript
Smalltalk y Javascript

Este año (2011) escribo un montón de código Javascript, así que ya estoy más entrenado en su uso. Como comentaba en los posts mencionados, estoy trabajando mi VM de código abierto AjTalk (implementada en C#) para que pueda generar código Javascript (sí, yo también! ;-). Este primer post está dedicado a describir el nuevo modelo abstracto que reside en el projecto de librería de clases AjTalk.

El AjTalk tradicional procesa y “parsea” código Smalltalk desde consola o archivos, lo arma en memoria (armando los métodos como secuencias de bytecods de la máquina virtual), y los puede ejecutar. Pero ahora, tengo un nuevo modelo abstracto en memoria. Vean, en la actual versión, el Model:

La idea es tener representaciones en memoria de clases, métodos, expresiones. Algunas interfaces:

Hay varias clases que implementan IExpressio: SetExpression, ConstantExpression, MessageExpression, ArrayExpression, etc. La más interesante, quizás, es MessageExpression: representa código que tiene un receptor, un selector de mensaje y tiene a otras expresiones como parámetros:

a + b. “binary messages”
anObject doSomething. “unary messages”
anObject do: aParameter with: anotherParameter. “keyword messages”

La clase ModelParser se encarga de leer un stream de chars y los convierte en el modelo abstracto en memoria:

En el estado actual del proyecto, pude procesar un file out de la clase Object de Squeak. Mi idea es procesar todas las clases del kernel de Squeak (jeje … estoy un poco perezoso para escribir mi propia librería ;-)

Las principales clases del modelo abstracto:

CodeModel tiene una lista de elementos: cada “chunk” de código se parsea a memoria y es agregado a esta lista. Si un “chunk” representa la definición de una nueva clase, se crea un nuevo objecto ClassModel para representarla. Por cada métedo definido, se crea un objeto MethodModel.

Ahora, puedo manipular esta representación abstracta en memoria. Quiero experimentar este modelo para usar un patrón Interpreter: evaluar las expresiones, DIRECTAMENTE usando este modelo abstracto, en vez de compilar a Bytecodes. Pero por ahora, el camino a explorar es usar el patrón Visitor para recorrer el modelo abstracto, mientras se lo va traduciendo a código BLOCKED SCRIPT

Estas son las clases que estoy escribiendo para este paso:

Vean que podría implementar otros Visitor: puedo generar otro código (¿Ruby? ¿otra forma de pasar a Javascrip? ¿Dart? ;-) o, como escribí más arriba, podría ejecutar el código en memoria usando un patrón Interpreter, por ejemplo, haciendo que cada IExpression tenga un método Evaluate (usar un Visitor me parece algo extremo).

El proyecto AjTalk.Compiler es una aplicación de consola que toma un archivo como parámetro (por ejemplo, Object.st) y genera un archivo Program.js en Javascript. Parte del código generado luego de procesar el file out de Squeak de Object (Work in progress):

Ya saben: soy adicto a Twitter: así que quedó capturado parte de mi TweetDeck en el rincón de abajo a la derecha ;-). Tome el código de arriba y lo procesé con Node.js sin errores (sólo define funciones, todavía no probé si la semántica es la correcta). Debería implementar algunas primitivas (vean que en el código de arriba, las primitivas las genero como comentarios Javascript). Las estrategias que estoy usando para traducir elementos de Smalltalk a Javascript puede cambiar en el futuro cercano. Estoy experimentando distintas soluciones.

Próximos temas: cómo implementar elementos de Smalltalk (clases, herencia, expresiones) en Javascript.

Nos leemos!

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

Smalltalk y Javascript

lopez — Fri, 23 Sep 2011 11:06:38 GMT

Por décadas Smalltalk fue "la fragata bandera” de las ideas de objetos y clases implementadas en un lenguaje, ambiente de desarrollo e imagen viva. Pero ha sido un caso de “demasiado, y demasiado temprano”. Aparecieron Smalltalks diferentes, compañías que lo implementaban distintos, no había tanta comunicación en línea y masa crítica como para formar una comunidad que lo desarrollado. Se necesitaba mucho hardware, su ambiente de desarrollo era (y es) muy “lo hago a mi manera”, todo eso conspiró para que no llegara a la corriente principal de lenguajes usados hoy en día. Mientras tantos, nuevos lenguajes de los 90s (noten el paralelismo con el desarrollo de la web) aparecen Javascript hasta Ruby, tomando ideas de Smalltalk. Y son lenguajes más usados que Smalltalk. En este siglo, Javascript, Ruby, Python, CLR (la VM de .NET con varios lenguajes), JVM (la VM de java con scala, Groovy, Clojure (“look ma.. Lisp for the masses” ;-) siguen ganando momento. Con la emergencia de múltuples dispositivos, móbiles, tables, smart phones, distintos sistemas operativos, estos nuevos lenguajes están siendo desarrollados para ejecutar en muchos entornos diferentes. Y están soportados por una comunidad vibrante, con cantidad de buenos proyectos de código abierto que contribuyen a la popularidad y adopción de estas tecnologías. Vean como ejemplo a Node.js, una implementación en Javascript/Google V8 Engine del patrón reactor. Tiene cantidad de módulos que se montan sobre su implementación núcleo.

Los Smalltalkers clásicos preferiran sus entornos, pero es una realidad que el código Smalltalk podría aprovecharse de los lenguajes, máquinas virtuales y librerías existentes. Un camino promisorio: compilar Smalltalk a Javascript, y conseguir el sueño “run everywhere”. (Noten que Clojure (special Lisp over JVM and CLR) tiene una nueva rama: ClojureScript ver su rationale). Este post de hoy es una enumeración de proyectos que usan alguna variación de Smalltalk compilado a Javascript.

Está el ST2JS (Smalltalk to Javascript translator):

ST2JS - Smalltalk to Javascript translator
http://www.squeaksource.com/ST2JS/

ST2JS - Traductor de Smalltalk a JavaScript (Parte I) (Spanish)
http://diegogomezdeck.blogspot.com/2006/07/st2js-traductor-de-smalltalk.html

ST2JS - Traductor de Smalltalk a JavaScript (Parte II) (Spanish)
http://diegogomezdeck.blogspot.com/2006/07/st2js-traductor-de-smalltalk_28.html

Hay un Smalltalk Web Toolkit basado en el ST2JS (no pude encontrar el código fuente):

Smalltalk Web Toolkit (Smalltalks 2009)
http://www.slideshare.net/garduino1/swt-2009

Introducción a Smalltalk Web Toolkit (SWT) « CEIBO
http://ceibo.wordpress.com/2008/01/06/introduccion-a-smalltalk-web-toolkit-swt/ (with detailed mini examples of Smalltak to Javascript translations, like closures, blocks, etc)

Nicolas Petton tiene Amber (antes era JTalk), que crea archivos Javascript traduciendo código Smalltalk (tiene ejemplo ejecutando en Node.js):

ST 4U 133: Amber
http://www.jarober.com/blog/blogView?entry=3493610269

NicolasPetton/amber - GitHub
https://github.com/NicolasPetton/amber

Peter Fisk (creador VistaSmalltak, GWT Smalltalk, y ahora SilverSmalltalk) estuvo escribiendo Smalltalk usando Silverlight, herramientas de Google, y ahora, BLOCKED SCRIPT

Implementing Smalltalk’s Non-Local Returns in JavaScript « Silver Smalltalk
http://silversmalltalk.wordpress.com/2011/02/02/implementing-smalltalks-non-local-returns-in-javascript/

Smalltalk Classes in JavaScript « Silver Smalltalk
http://silversmalltalk.wordpress.com/2011/02/02/smalltalk-classes-in-javascript/

Vean el Lively Kernel, Javascript inspirado por Smalltalk, y JTalk (ahora Amber):

InfoQ: Smalltalk IDEs Come to the Browser: Jtalk, tODE, Lively Kernel 2.0
http://www.infoq.com/news/2011/08/smalltalk-in-browser

InfoQ: Dan Ingalls on the History of Smalltalk and the Lively Kernel
http://www.infoq.com/interviews/ingalls-smalltalk

Lively Kernel
http://en.wikipedia.org/wiki/Lively_Kernel

Hay una implementación de Smalltalk a Javascript, llamada S8, trabajo en progreso. Ver:

Blog de Leo De Marco: Lanzamiento de S8 en Smalltalking
http://leodemarco.blogspot.com/2011/09/lanzamiento-de-s8-en-smalltalking.html

Y sí, adivinaron! Hay Smalltalk a Javascript (y espero, a otros lenguajes dinámicos) en mi proyecto AjTalk (Work in Progress) (tengo que escribir post!). Estoy trabajando en cómo implementar algunas características como:

doesNotUnderstand for JavaScript?
http://stackoverflow.com/questions/3918920/doesnotunderstand-for-javascript

Is there an equivalent of the __noSuchMethod__ feature for properties, or a way to implement it in JS?
http://stackoverflow.com/questions/2266789/is-there-an-equivalent-of-the-nosuchmethod-feature-for-properties-or-a-way-t

Mis enlaces:
http://www.delicious.com/ajlopez/smalltalk+javascript

Gracias a @garduino por sus enlaces acerca de ST2JS y el Smalltalk Web Toolkit. Y a @leodmarco por su post aclaratorio sobre S8.

Se viene más Smalltalk a Javascript (usando AjTalk) ;-)

Nos leemos!

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