AjSharp: objetos y clases dinámicas

lopez — Sun, 27 Dec 2009 14:42:41 GMT

Estoy escribiendo un intérprete no tipado con sintaxis tipo C#, que bauticé AjSharp. Hace un tiempo escribí sobre este proyecto de código abierto en:

AjSharp Programming Language a C#-like Dynamic Language
AjSharp: un lenguaje dinámico en C#

Pueden bajarse la versión actual desde http://code.google.com/p/ajcodekatas en trunk/AjLanguage (AjLanguage define el árbol de ejecución del intérprete, AjSharp tiene un parser, un lenguaje definido para construir ese árbol; la idea es colocar otros parsers sobre AjLanguage, por ejemplo, AjBasic).

Ayer sábado, agregué una nueva característica, la definición de un objecto. Ya de antes, AjSharp soporta la definición de una clase dinámica:

class Person
{
  var Name;
  var Age;
  
  function AddYears(years) 
  {
    this.Age = this.Age + years;
  }
}

Pueden crear un objecto usando:

adam = new Person();
adam.AddYears(800);
adam.Name = "Adam";

El objeto creado es dinámico: se le pueden agregar variables de instancias y métodos, en cualquier momento:

adam.LastName = "unknown";
adam.EyeColor = "brown";
adam.SayHello = function() { PrintLine("Hello"); };

Pueden crear objetos, con esta notación, inicializando su estado:

adam = new Person() { FirstName = “Adam”, LastName = “Genesis”, Age = 800 };

Y hasta pueden definir un objeto sin tener una clase asociada:

dynobj = new { Name = “Adam”, Age = 800 };

Esto es equivalente a hacerlo más “programáticamente” así:

dynobj = new DynamicObject();
dynobj.FirstName = “Adam”;
dynobj.LastName = "Genesis”;
dynobj.Age = 800;
dynobj.FullName = function() { return FirstName + “ “ + LastName; }

Esto estaba implementado desde hace meses. Ayer agregué la notación:

object Adam
{
  var Name = "Adam";
  var Age = 700;
  
  function AddYears(years) 
  {
    this.Age = this.Age + years;
  }
}
Adam.AddYears(100);

donde se puede definir un objecto único, dándole estructura, conducta y nombre.

La idea de AjLanguage es que pueda acceder a todas las clases y objetos del framework subyacente (en este caso, .NET, pero está pensado para ser reescribible sobre Java, si fuera necesario, claro, cambiando cualquier referencia a tipos nativos):

ds = new System.Data.DataSet();
dinfo = new System.IO.DirectoryInfo(“.”);
foreach (fi in dinfo.GetFiles())
{
    PrintLine(fi.FullName);
}

Desde ayer, seguí implementando constructores. Tengo pensado definir visibilidades privadas y públicas (por ejemplo, las variables y métodos de instancia que comiencen con minúscula, hacerlas automáticamente privadas). También agregar propotipos, como en Javascript, lo que permitiría implementar cosas similares a los métodos de extensión de .NET.

Pero si van hoy al trunk, encontrarán que estuve implementando canales, como en en lenguaje Go de Google.

channel = new Channel();
go for (k=1; k<=5; k++) channel <- k;
for (j=1; j<=5; j++)
	result = result + <-channel;

Pero eso dará para otro post más detallado. Con esa característica quiero explorar temas como programación reactiva, agentes, actores, shared transactional memory, ver:

http://clojure.org/Agents

http://en.wikipedia.org/wiki/Actor_model

http://en.wikipedia.org/wiki/Axum_%28programming_language%29

Por ejemplo, sería interesante que los canales comunicaran no sólo dos códigos en paralelos, sino máquinas diferentes. Y definir esas máquinas en tiempo de deployment, sin cambiar el código del programa. Podría reescribir los ejemplos de Distributed Agents using DSS/VPL o Genetic Algorithms with AjAgents and Concurrency and Coordination Runtime (CCR)

Como verán, me estoy divirtiendo!

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

TDD and Code Kata: Writing a Lexer for AjRuby

lopez — Thu, 12 Mar 2009 05:11:00 GMT

Muchas veces, escribo programas tipo code kata, para entrenarme en algún tema de desarrollo de software. En estos últimos meses, escribí varios mini intérpretes, usando TDD, code coverage, y C#. La semana pasada, estuve trabajando en el lanzamiento de otro pet project, AjRuby. El punto de inicio: el analizador léxico, el lexer.

Un lexer es un programa que analiza el código fuente de un programa, y retorna sus tokens, las “palabras” que componen el programa. En el caso de AjRuby, escribí un lexer que sigue la gramática de Ruby. No está completo aún, pero funciona.

Pueden ver el progreso del proyecto, en el repositorio de Google Code:

http://code.google.com/p/ajcodekatas/source/browse#svn/trunk/AjRuby

La solución tiene un proyecto de librería de clases, y otro de tests:

Hay una clase Token, que representa cada token:

    public class Token
    {
        public string Value { get; set; }

        public TokenType TokenType { get; set; }
    }

El TokenType es una enumeración:

    public enum TokenType
    {
        Name,
        Integer,
        Real,
        Boolean,
        String,
        Operator,
        Separator
    }

Hay una clase LexerTest.cs, conteniendo tests como:

        [TestMethod]
        public void ShouldProcessName()
        {
            Lexer lexer = new Lexer("name");

            Token token;

            token = lexer.NextToken();

            Assert.IsNotNull(token);
            Assert.AreEqual(TokenType.Name, token.TokenType);
            Assert.AreEqual("name", token.Value);

            token = lexer.NextToken();

            Assert.IsNull(token);
        }

Hay un test para cada tipo de token a ser procesado. Otro ejemplo:

        [TestMethod]
        public void ShouldProcessNameWithInitialUnderscore()
        {
            Lexer lexer = new Lexer("_name");

            Token token;

            token = lexer.NextToken();

            Assert.IsNotNull(token);
            Assert.AreEqual(TokenType.Name, token.TokenType);
            Assert.AreEqual("_name", token.Value);

            token = lexer.NextToken();

            Assert.IsNull(token);
        }

Escribí los tests usando ideas TDD: escribir el test, compilar con error, arreglar los problemas de compilación, ejecutar los tests en rojo, arreglarlos, conseguir el verde para los tests. No estuve haciendo tanto refactoring. El código merece algún refactor, pero por ahora, estoy tratando de conseguir un lexer que trabaje. Los tests quedaron en verde:

Mi objetivo es tener más del 80% de code coverage, en cualquier momento del desarrollo del proyecto:

Es bueno escribir algo sólo por diversión y aprendizaje. Para mí, es parte de la mejora continua que todo desarrollador de software debe perseguir.

Nos leemos!

Angel "Java" Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

Angel "Java" Lopez : Lenguajes de Programación, Código Abierto

AjSharp: objetos y clases dinámicas

TDD and Code Kata: Writing a Lexer for AjRuby