Angel "Java" Lopez : Proyectos de Código Abierto, AjSharp

Servidor y Cliente en AjSharp Distribuido

lopez — Mon, 14 Jun 2010 10:09:49 GMT

En mis anteriores posts:

AjSharp Distribuido: un Roadmap
Distributed AjSharp: a Roadmap
AjSharp Distribuido: Primeros pasos
Distributed AjSharp: First Steps

escribí una breve descripción de lo que quiero para un AjSharp distribuido (mi intérprete de código abierto), y mostré unas pocas “screenshots” de programas en ejecución distribuida. Examinemos y corramos un ejemplo simple pero concreto.

Podemos lanzar el intérprete interactivo con el comando de línea

AjSharp.Console

Podemos agregar una lista de archivos .ajs con código fuente, para ser ejecutados inmediatamente:

AjSharp.Console program1.ajs program2.ajs

La idea, en este primer ejemplo distribuido, es lanzar dos instancias del intérprete, y en una, lanzar un servidor, y en otra lanzar un programa cliente que se comunique con el servidor. Ni bien tenga la conexión con éste, el programa cliente envía comandos a ejecutar en el servidor.

Primero, el código del programa servidor:

server = new RemotingHostServer(10000, "Server");
PrintLine("Server started");

La clase interna RemotingHostServer lanza un servidor de remoting. El primer parámetro es la puerta TCP, y el segundo parámetro el nombre lógico del servidor. Se pueden lanzar varios servidores en la misma instancia del intérprete. En nuestro ejemplo, sólo necesitaremos uno.

Ahora, el código para el nodo cliente:

remote = new RemotingHostClient("localhost", 10000, "Server");
at remote PrintLine("New Node");
nodeid = System.Guid.NewGuid().ToString();
// evaluate a subroutine at server
at remote 
	sub(id)
	{
		for (k=1; k<=10; k++)
			PrintLine("Hello, server, from node " + id);
	}
	with (nodeid); // local parameter going to server
	
exit;

El objeto RemotingHostClient conecta con un servidor. Su constructor toma el nombre de la máquina destino, el puerto de TCP a usar, y el nombre lógico del servidor. Usando esos parámetros, internamente arma una dirección de remoting, usando un canal TCP.

Ahora que tenemos una conexión, con el comando at ejecutamos un comando en el servidor remoto. La sintaxis es:

at <server> <cmd>

Entonces

at remote PrintLine(“New Node”);

imprime un mensaje en la consola del servidor, no en el cliente. Otra variante es:

at <server> <functionorsub> with (<parameters>);

que evalúa una función o subrutina en el servidor, pasando una lista de parámetros cuyos valores se evalúan en el ambiente del cliente.

Preparé un ejemplo empaquedo, con el AjSharp ya compilado, que se puede bajar de mi Skydrive: AjSharpDistributed01.zip.

En una consola del sistema operativo, ejecutar

StartServer.cmd

Este comando arranca una nueva consola, que ejecuta el código Server.ajs.

Para ejecutar un nodo cliente

RunNode.cmd

Este es la típica salida en el código del servidor, luego de lanzar dos nodos:

Como siempre, pueden bajar el código completo desde:

http://code.google.com/p/ajcodekatas/source/browse/

en el directorio trunk/AjLanguage. Estoy escribiendo más ejemplos distribuidos: ejecutar un archivo de código fuente local en el servidor, ejecutar código en un servidor cuando un nuevo servidor informa su existencia, agentes distribuidos, etc…

Nos leemos!

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

Transacciones en memoria en AjSharp usando References

lopez — Tue, 08 Jun 2010 09:19:28 GMT

El año pasado me encontré con Clojure, un dialecto de Lisp que compila a Java. Estuve codificando AjSharpure (ver AjLisp Family: Implementing Lisp Interpreters in C#)(La familia AjLisp, implementando intérpretes Lisp en C#), un intérprete tipo Clojure (no un compilador) en .NET (si necesitan una más completa implementación en .NET, hay un ClojureCLR, compilado usando DLR, Dynamic Language Runtime).

Clojure tiene varias características interesantes, especialmente las estructuras persistentes (persistencia acá no es grabar en una base de datos, sino tener listas, diccionarios, árboles “inmutables”; cuando uno agregar algo a una lista, la lista original queda igual, y se construye una nueva lista…), concurrencia, agentes, y más. Una de sus características es su soporte de STM, Software Transactional Memory. Más sobre estos temas en links al final de este post. De acuerdo a:

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

In computer science, software transactional memory (STM) is a concurrency control mechanism analogous to database transactions for controlling access to shared memory in concurrent computing. It is an alternative to lock-based synchronization. A transaction in this context is a piece of code that executes a series of reads and writes to shared memory. These reads and writes logically occur at a single instant in time; intermediate states are not visible to other (successful) transactions.

Hace unas semanas, leí:

Clojure concurrency Part 4

Ese artículo describe la conducta de “ref”, “dosync” y operaciones relacionadas sobre “ref”. Quería experimentar con esas características, pero en mi intéprete AjSharp. Así, que escribí una clase Reference, y agregué soporte de transacciones al lenguaje.

Ahora, puedo escribir:

reference = new Reference();
reference <- 1;
result = @reference;

La clase Reference es una “built'-in”. En AjLanguage/AjSharp el operador <- es equivalente a ref.SetValue(newvalue). Ahora, agregué el operador @ para obtener el valor, y es equivalente a ref.GetValue() (incidentalmente, GetValue and SetValue son los métodos de las interfaces de Channels y Futures, ver:

AjSharp: Implementing Futures
AjSharp: Implementando Futures
Channels and Go Routines in AjSharp (Part 1)
Canales y Go Routines en AjSharp (Parte 1)
Channels and Go Routines in AjSharp (Part 2)
Canales y Go Routines en AjSharp (Parte 2)

En esos posts, todavía escribía <-channel o <-future para OBTENER el valor desde un channel o future; ahora, estoy decidiendo poner como obsoleta esa notación, en favor de @channel, @future, que me parece más clara).

Decidí hacer que las operaciones de get/set de valor sean explícitas, usando esos operadores, en vez de hacerlas transparentes. Eso mismo había decidido para manipular canales y valores futuros.

Pero, ¿cómo se usa una referencia? Bien, empieza a cobrar sentido con la nueva palabra clave transaction:

channel1 = new Channel();
end1 = new Channel();
end2 = new Channel();
reference1 = new Reference();
reference2 = new Reference();
reference1 <- 1;
reference2 <- 2;
go transaction 
{ 
  reference1 <- @channel1; 
  result2original = @reference2; 
  end1 <- @reference1; 
}
go transaction 
{ 
  channel1 <- @reference2; 
  reference2 <- @reference2 + 1; 
  result1original = @reference1; 
  end2 <- @reference2; 
}
result1 = @end1; // 2
result2 = @end2; // 3

Las dos transacciones son lanzadas con el comando go (ver los posts citados más arriba para ver go routines en AjSharp). La primera transacción espera a recibir un valor de la segunda, usando un canal que está en la variable channel1. Los valores en reference1, reference2 en la primer transacción son los originales, aunque al mismo tiempo están siendo cambiados en la segunda. Esto es, una transacción ve un “snapshot” de los valores almacenados en referencias, tomados al comienzo de su vida. Un cambio en un valor de una referencia durante una transacción, es confirmada al final de la transacción, y entonces, se vuelve visible al resto de la transacción. Pero las transacciones que aún se encuentren en ejecución, ven el valor del “snapshot”. Si una transacción altera el valor de una referencia que ha sido alterado por otra transacción concurrente, se lanza una excepción.

Mi implementación es sencilla e ingenua. Podría mejorarla. Pero por ahora, los tests dan verde, y es lo bastante buena para mis experimentos. Internamente, cada referencia tiene un valor actual visible, un posible valor actualizado por una transacción en ejecución (no se admiten DOS valores actualizados), una lista de valores de “snapshots”, para alimentar a transacciones que aún estan en ejecución. Una instancia de Machine, asociada al thread en ejecución mantiene una lista de referencias con “snapshots”, y una lista de transacciones en ejecución.

Mis enlaces:

http://delicious.com/ajlopez/clojure
http://delicious.com/ajlopez/clojure+concurrency
http://delicious.com/ajlopez/clojure+tutorial
http://delicious.com/ajlopez/stm
http://delicious.com/ajlopez/clojure+stm

Como siempre, pueden bajarse el código en:

http://code.google.com/p/ajcodekatas/source/browse/

en el directorio trunk/AjLanguage.

Nos leemos!

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

AjSharp Distribuido: un roadmap

lopez — Sun, 23 May 2010 12:15:21 GMT

El pasado fin de semana, estuve agregando características a mi intérprete de código abierto AjSharp, para que comenzara a soportar ejecución distribuida. Escribí sobre el tema en:

Distributed AjSharp: First Steps
AjSharp Distribuido: Primeros Pasos

(más post en español http://msmvps.com/blogs/lopez/archive/tags/AjSharp/default.aspx)
(más post en inglés/Anglish (Angel´s English :-) http://en.wordpress.com/tag/ajsharp/)

En esta semana pasada, escribí más código para soportar la ejecución distribuida de una aplicación AjSharp. Es un “work in progress”. De alguna manera, es la continuación de mi trabajo con aplicaciones distribuidas, que comenzó luego de mi trabajo con Fabriq, antes un poco con AjServer, luego con AjMessages, y así. La escritura de un intérprete propio permite extender el lenguaje para soportar características que tal vez se complicarían de implementar en lenguajes tipados, compilados.

En este post, quiero escribir una lista de features que me gustaría agregar (algunas ya están agregadas en el código de trunk, pero tengo que revisarlas, probarlas mejor y escribir posts sobre cómo usarlas y cómo funcionan). Antes, algunas aclaraciones de nomenclatura:

Machine.Current es un objeto base que mantiene el Environment global (Machine.Current.Environment), que contiene los nombres/valores de las variables globales, las definiciones de las clases, funciones globales, etc.. Host es un objeto que expone una Machine para que sea accedida desde otros Host. Machine es un concepto básico de AjSharp/AjLanguage. Host es lo que le agrega funcionalidad de comunicación remota.

Esta es la lista de lo que quiero implementar:

- Arrancar un host local en una dirección (máquina física, puerta)

- Conetar con un host remoto dada una dirección

- Conectar a un host remoto y enviarle la dirección de un host (local o remoto) para que pueda ubicarlo y enviarle trabajo

- Ejecutar un callback (función, rutina) local cuando un host local reciba la dirección de un nuevo host existente en alguna máquina (una especie de OnRegisterHost).

- Enviar un comando definido localmente (en el programa enviador) a un host remoto, y ejecutar en ese host remoto.

- Enviar una expresión definida localmente a un host remoto y evaluarla en ese host remoto, retornando un resultado al host llamador.

- Enviar una función/subrutina definida localmente, a un host remoto, enviarle parámetros y evaluarla/ejecutarla en el host remoto.

- Enviar un texto al host remoto, parsearlo y ejecutarlo como comando.

- Enviar un texto al host remoto, parsearlo y evaluarlo como expresión, devolviendo un resultado.

- Enviar el contenido de un archivo local a un host remoto, parsearlo y ejecutarlo.

- Obtener la lista de host locales registrados en la máquine (machine) actual.

- Obtener la lista de host remotos registrados en la Machine.Current.

- Enviar un valor local a una variable o left value expression a un host remoto.

- Enviar una copia de un DynamicObject a un servidor remoto (tengo que resolver qué pasas si es DynamicObject con una clase asociada)

- Enviar una referencia a un objeto DynamicObject al host remoto, para usarla allá como un proxy al objecto original, que sigue residiendo en el host local.

- Enviar una copia de un agente a un host remoto, y arrancarlo para que ejecute tareas allá.

- Exportar un archivo local con código fuente AjSharp, para ser usado en cualquier Include(“…”) que aparezca en el proceso de parseo del host remoto.

- Exportar un assembly local a un host remoto (tengo que decidir si ahora necesito o no esta feature, interesante).

Otro punto más:

- Una aplicación de ejemplo, como “proof of concept”. Podría ser un web crawler distribuido, o la implementación de un algoritmo genético distribuido.

Pueden ver el progreso en:

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

Agregando todas estas features, y tener además go routines, futures, channels, y agentes, está haciendo interesante a este proyecto. Y me estoy “divigtiendo como loco” :-):-)

Nos leemos!

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

AjSharp distribuido: Primeros pasos

lopez — Tue, 18 May 2010 12:22:12 GMT

Fue un gran fin de semana, con code kata. En la tarde del sábado, comencé a jugar con serialización de comandos en mi intérprete AjSharp:

En ese momento estaba usando Windows Communication Foundation, con simple BasicHttpBindind y address. Elegí serializar comandos y expresiones en arreglos de bytes, usando BinaryFormatter, y enviarlos via WCF básico (No me gusta pelearme con serialización WCF).

Entonces, el domungi, escribí una implementación usando remoting. Es una mejor aproximación a esta situación: remoting me de soporte “out-of-the.box” para serialización de grafos de objetos, y el manejo de MarshalByRefObject, lo que es bueno para mi proyecto.

Mis primeros intentos usando remoting:

Noten el uso de las nuevas keywords expression y command. En este comando:

a = expression b+c;

se asigna una expresión b+c (pendiente de evaluación) a una variable local a. Podemos evaluarla con:

result = a.Evaluate(Machine.Environment);

(Machine es la máquina actual en ejecución, tiene un .Environment global, donde están los bindings para b y c, sus valores asociados).

El comando:

a = command PrintLine(“Hello, world”);

no imprime un mensaje. Almacena el comando en una variable local, para ser ejecutado más adelante como:

a.Execute(Machine.Environment);

En el ejemplo de arriba, podemos arrancar a un servidor programáticamente. Podemos también crear el objeto proxy a ese servidor en el cliente. Y entonces, podemos invocar comandos, o evaluar expressiones, en el otro servidor. Después de tener eso andando, agregué el llamado de funciones, pasando argumentos al servidor. Esta es la principal interface que fue surgiendo, IHost:

    public interface IHost
    {
        // Host Id
        Guid Id { get; }
        // Host Invocation
        void Execute(ICommand command);
        object Evaluate(IExpression expression);
        object Invoke(ICallable function, params object[] arguments);
        // Others... Work in progress... to review
    }

Un host se ejecuta en una máquina, y expone el acceso a esa máquina, con invocaciones de comandos, funciones y evaluaciones de expresiones. Hay host que son locales (class Host), y hosts que exponen su funcionalidad via remoting (RemotingHostServer), y que se consumen desde su correspondiente cliente proxy (RemotingHostClient). Estoy también trabajando en tener esas clases en WCF: hay un WcfHostServer, WcfHostClient, pero tengo que luchar con temas de serialización, todavía.

Debería agregar el pasar strings conteniendo commandos y expresiones, y que el servidor receptor los parsee y ejecute/evalúe (sería más fácil que enviar lo que estoy enviando ahora, el ICommand, IExpression ya armado).

Después de las pruebas exitosas de arriba, agregué “syntax sugar”: no hay que minimizar el efecto de una buena sintaxis, que puede simplificar el uso de una característica. Agregué la keyword at en AjSharp:

Podemos invocar un comando en el otro server usando:

at <host> <command>;

o podemos evaluar una expresión en otro servidor y devolver el resultado:

localvar = at <host> <expression>;

Tengo que trabajar más en algunos detalles de serialización. Resolví parte del callback al servidor. Esto es:

at host { adam = new DynamicObject(); adam.Name = “Adam”; adam.Age = 800; }
myadam = at host adam;

adam se crea en el host remoto. La variable local myadam, cuando uso remoting, es en realidad un transparent proxy que apunta al DynamicObject que todavía está en el host donde fue creado (hasta ahora, los DynamicObject los he puesto descendiendo de MarshalByRefObject; estoy pensando cambiar esta decisión, y hacer que se serializen por defecto, y agregar un método, tipo obj.AsProxy() para generar una referencia MarshalByRefObject explícitamente cuando el programador así lo solicite). Pero el transparent proxy que recibo no puede ser invocado directamente: no tiene un canal asociado de comunicación. Así que agregué un wrapper a ese objeto cuando lo recibo en el cliente. Si invocamos algo de myadam, como en:

PrintLine(myadam.Name);
myadam.Name = “NewAdam”;

el wrapper redirecciona todo a que se ejecute en el servidor que fue invocado, y la operación se ejecuta en el servidor.

Como siempre, pueden bajar y examinar el código desde:

http://code.google.com/p/ajcodekatas/source/browse/

en el directorio trunk/AjLanguage.

Tengo que confesar que estoy orgulloso de este avance en mi intérprete. Podría extender, llegado el caso, esta capacidad para otros intérpretes, como AjIo,, AjTalk (era la idea inicial de AjTalk, tener un Smalltalk-like VM con objetos distribuidos). Nació sólo como una idea, pero va tomando forma, un lenguaje distribuido es el camino a explorar para poder aprovechar más máquinas en algunas tareas. El proyecto es un bebé todavía, pero es mi bebé, y me divierte mucho codificarlo.

Nos leemos!

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

Haciendo Scripting sobre WatiN usando AjSharp

lopez — Tue, 16 Mar 2010 14:41:52 GMT

AjSharp es un lenguaje interpretado que escribí en C#. Es un lenguaje dinámico, con clases y objetos dinámicos, valores funcionales, canales y gorutinas, entidades similares a agentes, acceso a objetos .NET nativos. Fue creado como un derivativode mi trabajo previo en AjBasic, el lenguaje interpretado y dinámico que use como base de AjGenesis, mi proyecto de generación de código. Mi plan es unificar ambos lenguajes usando el núcleo AjLanguage, y agregarlos al AjGenesis, permitiendo también el uso de to otros lenguajes, como plugins. Pero eso todavía está en plan.

El código de esto post está en el trunk del AjCodeKatas Google Project:

http://code.google.com/p/ajcodekatas/source/browse/

en trunk/AjLanguage/Src/AjSharp.Examples

Uno de los objetivos de diseño de AjSharp es servir como un shell liviano para invocar librerías .NET. Como prueba de concepto, escribí una simple clase para acceder a WatiN, la librería de automatización de pruebas web. Esta es la clase que estoy usando (y aplicando en un proyecto de desarrollo actual):

class Wat
{
  var Browser;
  
  function Wat()
  {
    WatiN.Core.Settings.WaitForCompleteTimeOut = 480;
    this.Browser = new WatiN.Core.IE();
  }
  
  sub Browse(url)
  {
    this.Browser.GoToNoWait(url);
    this.Browser.WaitForComplete(480);
  }
  
  function Button(name)
  {
    button = this.Browser.Button(name);
    
    if (button.Exists)
      return button;
      
    button = this.Browser.Button(WatiN.Core.Find.ByName(name));
    
    if (button.Exists)
      return button;
      
    button = this.Browser.Button(WatiN.Core.Find.ByValue(name));
    if (button.Exists)
      return button;
      
    return null;
  }
  
  function TextField(name)
  {
    textfield = this.Browser.TextField(name);
    
    if (textfield.Exists)
      return textfield;
      
    textfield = this.Browser.TextField(WatiN.Core.Find.ByName(name));
    
    if (textfield.Exists)
      return textfield;
      
    return null;
  }
  
  function Link(name)
  {
    link = this.Browser.Link(name);
    
    if (link.Exists)
      return link;
      
    link = this.Browser.Link(WatiN.Core.Find.ByUrl(name));
    
    return link;
    
    if (link.Exists)
      return link;
      
    return null;
  }
  
  function Contains(text)
  {
    return this.Browser.ContainsText(text);
  }
  
  sub Close()
  {
    this.Browser.Close();
  }
}

Se puede extenderla con otras características. Igual deja expuesto el WatiN browser, por si necesitamos algo que no esté expuesto en el código de arriba. Un ejemplo de uso:

Include("Tests.ajs");
System.Reflection.Assembly.Load("WatiN.Core");
Include("Wat.ajs");
wat = new Wat();
wat.Browse("http://google.com");
wat.TextField("q").TypeText("Angel Java Lopez");
wat.Button("Google Search").Click();
Assert(wat.Contains("ajlopez.com"), "No content");
wat.Browse("http://www.ajlopez.net/");
Assert(wat.Contains("Java"), "No content");
Assert(wat.Link("http://ajlopez.zoomblog.com/").Exists, "No link 4");
wat.Link("http://ajlopez.zoomblog.com/").Click();
Assert(wat.Contains("Ciencia"), "No content 2");
wat.Close();
exit;

El único problema que encontré al invocar a WatiN, es su requerimiento de ejecutarse dentro de un STAThread (Single Thread Apartment model). Así que cambié el método de main de AjSharp.Console, agregádole el atributo STAThread (¿habrá forma de elegir ese modelo por código, al lanzar un thread?). Estoy usando este tipo de scripts para probar una aplicación web real en desarrollo en un equipo ágil. Una cosa que podría agregar es soporte de excepciones y logueo de los mensajes de Assert (esto no es de Wat, sino de Test.ajs).

Pueden usar utilitarios más robustos sobre WatiN, como el Wax, que permite escribir tests usando planillas Excel. Por ahora, con lo que uso de arriba, me ha sido suficiente en el proyecto actual. Es un buen ejercicio para ir haciendo dog-fooding y probar las capacidades, fortalezas y debilidades de AjSharp en un requerimiento real.

Nos leemos!

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

Web Crawler usando Agentes y AjSharp

lopez — Tue, 23 Feb 2010 10:16:11 GMT

El pasado año, escribí un ejemplo de web crawler usando mensajes, detalles en los posts:

Distributed Web Crawler using AjMessages
Web Crawler distribuido usando AjMessages

Antes, escribí otros ejemplos usando DSS/CCR, tecnologías incluidas en Microsoft Robotics Developer Studio:

Distributed Agents using DSS/VPL
Web Crawler example using DSS (Decentralized Software Services)
Aplicaciones Distribuidas con AjMessages usando DSS/CCR
Ejemplo de Web Crawler usando DSS

Ahora, escribí un ejemplo local (no distribuido) usando agentes en AjSharp. Recordemos, cada agente se ejecuta en su propio thread, y sus invocaciones son encoladas, y ejecutadas de una en una. Más sobre agentes en AjSharp en:

Agents in AjSharp (Part 1)
Agentes en AjSharp (Parte 1)
Agents in AjSharp (Part 2)
Agentes en AjSharp (Parte 2)

Hace dos días, tomé el código de mis anteriores ejemplos, y lo reensamblé en agentes de AjSharp. Este es el primer resultado de ese experimiento. Primero, definí un objeto para armara una red de agentes que se ocupen de visitar un sitio, y lanzar el proceso:

// Build and launch agents
object WebCrawler
{
  sub Process(url, fn)
  {
    uri = new System.Uri(url);
    downloader = new Downloader();
    harvester = new Harvester();
    resolver = new Resolver(uri,5);
    processor = new Processor(fn);
    
    downloader.Harvester = harvester;
    downloader.Processor = processor;
    harvester.Resolver = resolver;
    resolver.Downloader = downloader;
    
    downloader.Process(uri, 0);
  }
}

El Downloader toma una URI, baja su contenido y envía el resultado a dos agentes asociados: Processor y Harvester. El parámetro Depth indica la profundidad de esta página en el proceso de crawling del sitio:

// Downloads a page
agent Downloader 
{
  sub Process(uri,depth)
  {
    client = new System.Net.WebClient();
    content = client.DownloadString(uri);
    PrintLine("Downloaded: " + uri);
    this.Harvester.Process(uri,depth,content);
    this.Processor.Process(uri, content);
  }
}

The Processor executes a user function/routine, receiving the URI and its retrieved content:

// Process the content retrieved
agent Processor
{
  function Processor(fn)
  {
    this.fn = fn; // function to invoke
  }
  
  sub Process(uri, content)
  {
    // Add your logic
    this.fn(uri, content);
  }
}

El Harvester detecta otros enlaces en el contenido, y los envía, uno a uno, a otro agente, el Resolver:

// Get links from page
agent Harvester
{
  sub Process(uri,depth,content)
  {
    matches = System.Text.RegularExpressions.Regex.Matches(content, "href=\\s*\"([^&\"]*)\"");
    results = new List();
    
    foreach (match in matches) {
      value = match.Groups[1].Value;
      
      if (!results.Contains(value))
        results.Add(value);
    }
    
    foreach (result in results) 
      if (result.StartsWith("http"))
        this.Resolver.Process(new System.Uri(result), depth+1);
  }
}

El Resolver mantiene una lista de URIs procesados, y filtra aquellas que no se encuentran en el host original. El proceso se limita entonces hasta una cierta profundidad de exploración y dentro del sitio original:

// Filter invalid or already processed links
agent Resolver
{
  var processed = new List();  
  
  function Resolver(uri,maxdepth)
  {
    this.host = uri.Host;
    this.maxdepth = maxdepth;
  }
  
  sub Process(uri,depth) 
  {
    if (depth > this.maxdepth)
      return;
      
    if (uri.Host != this.host)
      return;
    
    if (uri.Scheme != System.Uri.UriSchemeHttp && uri.Scheme != System.Uri.UriSchemeHttps)
      return;
      
    if (processed.Contains(uri))
      return;
      
    processed.Add(uri);
      
    PrintLine("New Link: " + uri);
    this.Downloader.Process(uri,depth);     
  }
}

Estos son ejemplos de uso, creando dos redes de agentes, dedicados a obtener el contenido de dos sitios:

// Example
WebCrawler.Process("http://ajlopez.wordpress.com", function(uri,content) { PrintLine("From ajlopez.wordpress "+uri);});
WebCrawler.Process("http://ajlopez.zoomblog.com", function(uri,content) { PrintLine("From ajlopez.zoomblog "+uri);});

Pueden bajar el AjSharp desde el trunk:

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

El código de web crawler está en Examples/WebCrawler.ajs dentro del proyecto AjSharp.Console. Despues de compilar a este programa de consola, pueden lanzar:

AjSharp.Console Examples/WebCrawler.ajs

Esta es una salida parcial:

Pueden ver el ejemplo completo en Pastie http://pastie.org/835926

Próximo paso: usar agentes distribuidos. Hay dos caminos a explorar: uno, declarar que algunos agentes sean distribuidos usando código adicional o configuración, pero sin cambiar el código original. Dos, hacer la distribución explícita en el código.

Nos leemos!

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

Cantidad variable de Argumentos en AjSharp

lopez — Sun, 21 Feb 2010 13:44:14 GMT

En mis experimentos con agentes, usando el intérprete AjSharp, encontré que me faltaba algo para implementar lo que quería: soportar una cantidad variable de parámetros en la llamada a una función, rutina o método. Así, que volví a codificar, con el sombrero de Test-Driven Development puesto, durante un desayuno de codificación, y salió lo que describo en este post.

Tuve que implementar dos facetas de esa característica. Primero, la declaración de recibir una cantidad variable de argumentos:

function FirstParameter(pars...)
{
	if (pars.Length>0)
		return pars[0];
		
	return null;
}
function SecondParameter(pars...)
{
	if (pars.Length>1)
		return pars[1];
		
	return null;
}
result = FirstParameter(1,2,3);		// 1
result2 = SecondParameter(1,2,3);	// 2
result3 = SecondParameter();		// null

La otra parta, qué pasa si quiero usar los parámetros recibidos con … (tres puntos) como parámetros para entregar a otra función? El pars… recibido es un arreglo de objetos. Para usarlo pasándolo no como arreglo, sino como los propios valores “expandidos”, usé el mismo operador … (tres puntos), pero ahora, desde la invocación:

function FirstParameter(pars...)
{
	if (pars.Length>0)
		return pars[0];
		
	return null;
}
function SecondParameter(pars...)
{
	if (pars.Length>1)
		return pars[1];
		
	return null;
}
function JustDoIt(fn,pars...)
{
	return fn(pars...);
}
result = JustDoIt(FirstParameter,1,2,3);		// 1
result2 = JustDoIt(SecondParameter,1,2,3);	// 2
result3 = JustDoIt(SecondParameter);		// null

Curiosamente, hace dos días, encontré el lenguaje

CoffeeScript

que compila a JavaScript normal. En la página de tutorial, encontré un término nuevo para mí : Splats para denominar el operador … (tres puntos). Decidí usar ese operador hace unas semanas, y ahora me lo encuentro ahí. No recuerdo cuándo fue que se sembró en mi mente la idea de usar ese operador.

Podría emplear este operador en algún ejemplo de agente.

Nos leemos!

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

Agentes en AjSharp (Parte 2)

lopez — Fri, 19 Feb 2010 10:23:38 GMT

Estuve implementando una especie de soporte de agentes en mi intérprete AjSharp. En el anterior post:

Agents in AjSharp (Part 1)
Agentes en AjSharp (Parte 1)

describí algo de esa implementación y las principales características. Dos puntos para recordar:

- Cada agente ejecuta en su propio thread
- Cada agente tiene una cola de proceso para recibir sus invocaciones (método y argumentos)

Quiero mostrar en este post dos simples ejemplos de uso. Primero, uno donde los agentes se encadenan, implementando algo así como message passing, procesando un dato y produciendo resultados.

agent IncrementAgent 
{
  function IncrementAgent(next, channel)
  {
    this.channel = channel;
    this.next = next;
  }
  
  sub Process(value)
  {
    newvalue = value + 1;
    
    if (channel)
      channel <- newvalue;
      
    if (next)
      next.Process(newvalue);
  }
}
channel = new Channel();
thirdAgent = new IncrementAgent(null, channel);
secondAgent = new IncrementAgent(thirdAgent, channel);
firstAgent = new IncrementAgent(secondAgent, channel);
firstAgent.Process(0);
for (k = 1; k <= 3; k++)
  result = result + <-channel; 
// result == 1 + 2 + 3 == 6

Vean que cada agente es un eslabon de la cadena de proceso, y que se usa un channel para coleccionar los resultados. La combinación de colaboración de objetos se puede hacer en formas más complejas.

En el segundo ejemplo, implementé el problema de Collatz usando una ronda de dos agentes:

if (number % 2)
    {
      this.Next.Process(number, list);
      return;
    }
    
    list.Add(number);
  
    number = number / 2;
    
    this.Next.Process(number, list);
  }
}
agent OddAgent 
{
  sub Process(number, list)
  {
    if ((number % 2)==0)
    {
      this.Next.Process(number, list);
      return;
    }
    
    list.Add(number);
    
    if (number == 1) 
    {
      this.Channel <- list;
      return;
    }
    
    number = number * 3 + 1;
    
    this.Next.Process(number, list);
  }
}
channel = new Channel();
even = new EvenAgent();
odd = new OddAgent();
even.Channel = channel;
even.Next = odd;
odd.Channel = channel;
odd.Next = even;
even.Process(22, new List());
result = <-channel;
// result = { 22 11 34 17 52 26 13 40 20 10 5 16 8 4 2 1 }

Más sobre la interesante conjetura de Collatz:

Collatz 3n+1 Problem Structure
Programming 3n+1 problem

Estos son ejemplos simples. Quiero implementar un web crawler, o un web scraping, o un algoritmo genético en paralelo, usando agentes. También tengo como próximo paso: agentes distribuidos.

Nos leemos!

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

Default methods en AjSharp

lopez — Tue, 16 Feb 2010 10:02:23 GMT

En estos días, agregué lo que llamo default methods en AjSharp, mi intérprete de código abierto. ¿Qué es un default method en la jerga de AjSharp? Me inspiré por el mensaje #doesnotunderstand que está en los objetos Smalltalk. AjSharp es un intérprete dinámico, así que podemos invocar cualquier método, aún uno no existente. Si el método no está definido, pero hay un default method declarado, entonces éste es invocado, recibiendo dos parámetors, el nombre del método original, y sus argumentos.

Primer ejemplo:

object Incrementor
{
  function Increment(n) 
  {
    return n+1;
  }
}
class Proxy
{
  var Object;
  
  function Proxy(obj)
  {
    this.Object = obj;
  }
  
  default function InvokeMethod(name, parameters)
  {
    return this.Object.Invoke(name,parameters);
  }
}
proxy = new Proxy(Incrementor);
result = proxy.Increment(3); // result == 4

La palabra clave default marca el default method (estoy aún reluctante a usa una palabra clave para esto, pero no tengo todavía otra idea para implementarlo). Notemos que esta implementación de proxy solamente funciona encapsulando instancias de DynamicObject, que tienen un méetodo .Invoke. Podría extenderlo para que maneje objetos CLR también.

Por ahora, otro ejemplo sencillo:

class Incrementor
{
  function Increment(n) 
  {
    return n+1;
  }
}
class LoadBalancer
{
  var objects;
  var random;
  
  function LoadBalancer()
  {
    this.random = new System.Random();
    this.objects = new List();
  }
  
  sub Add(obj)
  {
    this.objects.Add(obj);
  }
  
  default function InvokeMethod(name, parameters)
  {
    n = random.Next(objects.Count);
    
    return this.objects.Invoke(name,parameters);
  }
}
  
balancer = new LoadBalancer();
balancer.Add("Foo");
for (k=1; k<=10; k++)
  balancer.Add(new Incrementor());
  
result = 0;
for (k=0; k<4; k++)
  result = result + balancer.Increment(k);
  
// result == 1 + 2 + 3 + 4 == 10

Es una especie de “load balancer”, que usa al azar, podría llamarlo “distributor”. La instancia LoadBalancer envía cada llamada a método a uno de sus objetos, al azar.

Podría escribir otro ejemplo, donde el balancer envía cada invocación a TODOS sus objetos. Tengo pensado usar estas características en agentes, en especial, en agentes distribuidos. Podría agregar default methods a objetos AjSharp (recuerde, AjSharp puede definir objetos sin clase asociada).

Como siempre, el código está disponible en:

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

Nos leemos!

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

Agentes en AjSharp (Parte 1)

lopez — Sat, 13 Feb 2010 10:51:09 GMT

Comencé a implementar ideas de agentes en mi intérprete AjSharp. Ya había explorado channel2, queue channels y futures en anteriores posts:

Channels and GoRoutines in AjSharp (Part 1)
Channels and GoRoutines in AjSharp (Part 2)
GoRoutines y Canales en C#
GoRoutines and Channels in C#
AjSharp: Implementing Futures
AjSharp: Implementando Futures
Queue Channels in AjSharp
Queue Channels en AjSharp

y una implementación paralela de un algoritmo directamente en C#:

Genetic Algorithms using GoRoutines and Channels in C#
Algoritmos Genéticos usando GoRoutines y Channels en C#

pero sería interesante tener un modelo más claro para la computación en paralelo. En programas no triviales, el manejo de varios canales puede ser “convoluted”, como mostré en la implementación del algoritmo genético. Así que extendí el lenguaje para soporte objetos similares a agentes, en dirección a un actor model parcial, con declaraciones como:

agent MyAgent {
    // ....
}

Una definición de agente es como la definición de una clase. Podemos crear agentes usando el operador new y constructores:

agent = new MyAgent(parameter);

La diferencia con un objeto es: cuando una instancia de agente es creada, se lanza un background thread para procesar una cola, donde se van guardando las llamadas a métodos del agente y sus parámetros. Esas llamadas son procesadas por el thread el propio agente. Un ejemplo:

agent IncrementAgent 
{
  sub Process(channel, value)
  {
    channel <- value + 1;
  }
}
myagent = new IncrementAgent();
channel = new Channel();
myagent.Process(channel, 1);
result = <-channel; // result == 2

La llamada myagent.Process(..) no se ejecuta en el thread principal, sino que es guardada en el queue interno del agente, y será procesada por el thread propio del agente. En la actual implementación, la queue interna es un queue channel, así que la sincronización entre invocadores y el agente es automática.

Para implementar este tipo de agentes, agregué la clase AgentFunction, representado el método a llamar. Cuando se lo invoca, no se ejecuta directamente sino que su invocación es enviada a la cola del agente:

public object Invoke(IBindingEnvironment environment, object[] arguments)
{
    AgentObject agent = (AgentObject)((ObjectEnvironment)environment).Object;
    agent.SendInvoke(this.function, environment, arguments);
    // TODO if function, return a Future
    return null;
    // Old direct code
    //            return this.function.Invoke(environment, arguments);
}

La llamada SendInvoke pone los datos de la invocación en la cola de proceso del agente.

Hay una AgentClass, derivada de DynamicClass (que es la definición normal de una clase dinámica en AjSharp), extendida con una nueva manera de crear una instancia:

public override object NewInstance(object[] parameters)
{
    AgentObject dynobj = new AgentObject(this);
    this.NewInstance(dynobj, parameters);
    dynobj.Launch();
    return dynobj;
}

La clave está en dynobj.Launch() que lanza el thread de proceso que ejecutará todas las llamadas al agente, tomando sus datos de la cola interna.

De esta forma, llamar a un método de un agente recuerda a una message passing invocation. Si recordamos Smalltalk, una llamada es en realidad un mensaje con nombre y argumentos. En mi opinión, al usar la convención de <agente>.<método>(<parametros>) es una forma clara y transparente de implementar un message passing usando sintaxis “normal”.

Esta es la actual implementación ingenua del agente:

    public class AgentObject : DynamicClassicObject
    {
        // TODO 100 is hard coded
        private QueueChannel channel = new QueueChannel(100);
        public AgentObject(IClass objclass) 
            : base(objclass)
        {
        }
        public IChannel Channel { get { return this.channel; } }
        public void Launch()
        {
            Thread thread = new Thread(new ParameterizedThreadStart(this.Execute));
            thread.IsBackground = true;
            thread.Start(Machine.Current);
        }
        public void SendInvoke(ICallable function, IBindingEnvironment environment, object[] arguments)
        {
            AgentTask task = new AgentTask() { Callable = function, Environment = environment, Arguments = arguments };
            this.channel.Send(task);
        }
        private void Execute(object parameter)
        {
            Machine machine = (Machine) parameter;
            machine.SetCurrent();
            while (true)
            {
                object obj = this.channel.Receive();
                AgentTask task = (AgentTask) obj;
                task.Callable.Invoke(task.Environment, task.Arguments);
            }
        }
    }
    internal class AgentTask
    {
        internal ICallable Callable;
        internal IBindingEnvironment Environment;
        internal object[] Arguments;
    }

Como siempre, el código está publicado en:

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

Próximos pasos:

Explorar el proceso de agente con un ejemplo. Podría portar el ejemplo de algoritmo genético que escribí en C# o anteriores ejemplos míos de web crawler.
Soportar la invocación de funciones que devuelvan valores en un agente: el resultado de retorono sería un future, que sería llenado por el agente en paralelo. Problemas: estaríamos en algún momento esperado el valor del future, con posibles dead-locks.
Algo más ambicioso: agentes distribuidos. Que el new o algo similar, provoque que el agente se ejecute en otra máquina, y nosotros lo manipulamos como siempre a través de un proxy.

Nos leemos!

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

Functional values en AjSharp

lopez — Sat, 06 Feb 2010 14:21:49 GMT

Una de las características que quería tener desde el principio en mi intérprete AjSharp era que las funciones y rutinas sean ciudadanos de primera clase en el lenguaje (en este post uso la palabra clave function pero se puede usar también sub para definir una subrutina).

El código está en el proyecto de código de Google:

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

AjLanguage es el lenguaje núcleo (que no tiene ni parser ni lexer, sólo lo esencial del intérprete). AjSharp es el parser y el lexer implementado sobre el AjLanguage. De esta forma, podría implementar AjBasic u otros lenguajes similares, usando AjLanguage como base y núcleo.

En AjSharp, podemos definir funciones como en otros lenguajes:

function Square(n) { return n*n; }

Podemos definir una función anónimca y asignarla a una variable:

MySquare = function (n) { return n*n; };

Un functional value puede ser usado como parámetro:

function Apply(func,values)
{
  list = new List();
  
  foreach (value in values)
    list.Add(func(value));
    
  return list;
}
numbers = new List();
numbers.Add(1);
numbers.Add(2);
numbers.Add(3);
function Square(n) { return n*n; }
squared = Apply(Square, numbers);
squared2 = Apply(function (n) { return n*n; }, numbers);

La función Apply definida arriba, toma una función, una lista, y retorna otra lista de elementos que resultan de evaluar f(e), donde f es la función recibida, aplicada a cada elemento e de la lista que se pasó como parámetro. Podemos invocar Apply con el nombre de la función (que en realidad es el nombre de la variable que contiene al functional value) o definidiendo la función directamente en la invocación.

Estoy pensando sobre algunas alternativas de implementación del alcance y visibilidad de variables en expresiones funcionales (dará para otro post el tema). Si definimos una función, AjLanguaje (el núcleo de AjSharp) usa una closure (clausura), así que cuando la función es invocada, el binding environment original es usado. En los ejemplos de más abajo se usa esa característica.

Cada función implementa:

    public interface ICallable
    {
        int Arity { get; }
        IBindingEnvironment Environment { get; }
        object Invoke(IBindingEnvironment environment, object[] arguments);
        object Invoke(object[] arguments);
    }

esto es, cuando es invocada, recibe un binding environment (un diccionario que dado el nombre de una variable nos da su valor asociado). Un funcional value no usa ese binding environment recibido, y lo reemplaza por el environment original que tenía en el momento de haber sido definida, creada.

Podemos retornar una función como retorno de una función:

function MakeIncrement(x) 
{
  return function(n) { return n + x; }; // x is bounded to local parameter
}
Increment2 = MakeIncrement(2);
result = Increment2(2);
// result == 4
Increment3 = MakeIncrement(3);
result2 = Increment3(2);
// result2 == 5
result3 = MakeIncrement(4)(3);
// result3 == 7
x = 4;
result4 = function(n) { return n+x; }(5);
// result4 == 9

MakeIncrement retorna una función que usa y accede a la variable x, ligada en el binding environment de llamada.

En el último comando, la función es definida e invocada en el mismo comando.

AjSharp tiene clases, y podemos definir funciones y rutinas como métodos:

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

Pero también podemos agregar funciones en cualquier momento:

class Person
{
  var Name;
  var Age;
  
  function Person()
  {
    x = 100;
    this.GetYears = function () { return this.Age; };
    this.GetX = function() { return x; };
  }
}
adam = new Person() { Name = "Adam", Age = 800 };
result = adam.GetYears();
// result == 800
result2 = adam.GetX();
// result2 == 100

o agregar funciones/rutinas directamente a objetos:

adam.AddYears = sub(n) { this.Age = this.Age + n; };

Hace unas semanas, leí el post:

Functional Programming in Javascript

de James Carr, así que decidí probar las capacidades de AjSharp para manejar functional values adaptando algunos de esos ejemplos, como:

function runningSum(start){  
  sum = start;  // you could use var sum, it's local
  
  return function(a){  
    sum = sum + a;  // function access the "outer" sum
    return sum;
  };
}  
sum = runningSum(3);  // makes function
result = sum(2); // returns 5  
result2 = sum(10); // returns 15

Podemos usar directamente el parámetro como acumulador:

function runningSum(start){  
  return function(a){  
    start = start + a;  // function access the "outer" start
    return start;
  };
}  
sum = runningSum(3);  // makes function
result = sum(2); // returns 5  
result2 = sum(10); // returns 15

Agregué soporto para aplicar una función como si fuera un método a un objeto, como en uno de los ejemplos de Carr (este tipo de llamada es soportada en Javascript que tiene la clase Function):

person = new { Name = "Adam", Age = 800 };
GetAdjustedAge = function (x) { return x + this.Age; };
result = GetAdjustedAge.Call(person, 10); // result == 810

Próximos pasos: estabilizar el alcance de las varaibles y el acceso al environment global. Por ahora, me divertí bastante implementando valores funcionales

Nos leemos!

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

Queue Channels en AjSharp

lopez — Fri, 29 Jan 2010 10:47:17 GMT

Hace una semanas, implementé channels en mi intérprete AjSharp. Pueden leer sobre el tema en:

Channels and GoRoutines in AjSharp (part 1)
Channels and GoRoutines in AjSharp (part 2)

Canales y GoRoutines en AjSharp (Part 1)
Canales y GoRoutines en AjSharp (Part 2)

Si uno lee el valor de un canal, y no hay valor disponible, el thread que está tratando de leer se bloquea hasta que el valor esté disponible. Esta es una manera de sincronizar consumidores y productores que operan sobre el canal. Pero algunas veces queremos poner un valor en un canal y continua, sin bloqueo. Para eso, agregué una “queue channel” (podría llamarla queued channel): pueden poner N valores en el canal sin bloqueo, porque se van guardando en una cola interna. El tamaño de la cola se determina en un parámetro en el constructor. La cola está limitada en tamaño para poder preservar sus capacidades de sincronizació.

El nombre de la nueva clase es QueueChannel. Un test:

        [TestMethod]
        public void CreateAndUseQueueChannelWithTenElements()
        {
            QueueChannel channel = new QueueChannel(10);
            for (int k = 1; k <= 10; k++)
                channel.Send(k);
            for (int k = 1; k <= 10; k++)
                Assert.AreEqual(k, channel.Receive());
        }

El canal recibe 10 valores sin bloquearse. Si enviamos más valores, debemos usar otro thread:

        [TestMethod]
        public void CreateAndUseQueueChannelWithMoreEntriesThanSize()
        {
            QueueChannel channel = new QueueChannel(10);
            Thread thread = new Thread(new ThreadStart(delegate()
            {
                for (int k = 1; k <= 20; k++)
                    channel.Send(k);
            }));
            thread.Start();
            for (int k = 1; k <= 20; k++)
                Assert.AreEqual(k, channel.Receive());
        }

Para probarlo en un ejemplo, reescribí el ejemplo de números primos usando queue channels:

numbers = new QueueChannel(10);
running = true;
k = 1;
go while(running) { k++; numbers <- k; }
function filter(in, out, prime)
{
  while (true) 
  {
    value = <-in;
    if (value % prime)
      out <- value;
  }
}
function makefilter(channel, number)
{
  newchannel = new QueueChannel(10);
  go filter(channel, newchannel, number);
  return newchannel;
}
channel = numbers;
number = <-channel;
while (number < 1000) 
{
  PrintLine("Prime " + number);
  
  channel = makefilter(channel, number);
  
  number = <-channel;
}
running = false;

El código está en mi Google code project:

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

Mi motivación para un queue channel apareció en ejemplo de algoritmo genético en paralelo, que sufría de demasiados bloqueos. Veo que un buen algoritmo no necesitaría colas, pero si uno tiene muchos consumidores y productores, y un thread produce valores para ser colocados en más de un canal, podría pasar que al colocar el valor en el canal A, no lleguemos a entregar el valor en el canal B, por bloqueo en la primera operación. Una forma de evitar el bloqueo es usando el comando go:

go channel <- newvalue;

Pero me parece que es demasiado lanzar una goroutine solamente para alimentar un canal.

Tendría que presentar el algoritmo genético en paralelo (que ya hace unos meses presenté), y escribir algunas ideas para implementar un actor model en AjSharp, y usar agentes distribuidos.

Nos leemos!

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

AjSharp: Implementando Futures

lopez — Thu, 28 Jan 2010 10:57:40 GMT

Había implementado canales en mi intérprete AjSharp. Describí el trabajo y ejemplos en:

Channels and GoRoutines in AjSharp (part 1)
Channels and GoRoutines in AjSharp (part 2)

Canales y GoRoutines en AjSharp (Part 1)
Canales y GoRoutines en AjSharp (Part 2)

También los usé directamente en C#:

GoRoutines y Canales en C#

Podría usar canales para implementar futures. Una opción es usar Task Parallel Library de Microsoft, pero entonces debería usar .NET 4: aparentemente, la librería original no está más disponible para .NET 3.x. Imagino que podría aprovecharme de las nuevas clases del nuevo framework, pero mientras, quiero explorar las ideas de programación con futures por mi cuenta.

Los canales pueden ser usados para implementar el proceso de futures:

channel = new Channel();
go channel <- SomeLengthlyCalculation();
// .. more process
result = <- channel;

Pero los canales han sido diseñados para resolver otros problemas: para tener varios valores durante su vida, y ser usados como objetos de sincronización entre productores y consumidores de esos valores. La variable channel del ejemplo de arriba, si se usara como un future, podría ser consultada sólo una vez. Es un pequeño problema, pero señala una diferencia entre canales y futures.

Así, escribí una nueva clase nativa, accesible desde programas AjSharp, llamada Future:

    public class Future : IReference
    {
        private object value;
        private ManualResetEvent handle = new ManualResetEvent(false);
        private bool set = false;
        public void SetValue(object value)
        {
            lock (this)
            {
                if (this.set)
                    throw new InvalidOperationException("Future value already calculated");
                set = true;
                this.value = value;
                this.handle.Set();
            }
        }
        public object GetValue()
        {
            this.handle.WaitOne();
            return this.value;
        }
    }

En la versión actual en el trunk, la interface IReference (que contiene méteodos SetValue, GetValue) está implementada por la clase Channel. Los operadores AjSharp a <- b, a = <-b, son mapeados a esos métodos. Entonces podemos usar Futures de esta forma:

future = new Future();
go future <- SomeLenghtlyProcess();
// ... more process
result = <-future;
result2 = <-future;

La consulta del valor del future es explícita, usando el operador <-. De esta forma, podemos pasar la variable future a cualquier otra función, usando el nombre, sin ver todavía su valor. Podría eliminar el go en el seteo de la variable future, asumiendo que el valor a la derecha de ese valor se calcula en paralelo. Pero prefiero hacer que el paralelismo quede explícito, usando el comando go.

Esta es una mejora menor en el procesamiento en paralelo de AjSharp. Estoy trabajando en queue channels: channels que soporten el manejo de más de un valor, sin bloquearse. Pueden ver el código y ejemplos en:

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

Quiero implementar agentes, para soportar la programación basada en el actor model. Podría ser interesante tener a la palabra agent como palabra clave, como la palabra class. Y que esos agentes puedan ser ejecutados en máquinas remotas.

Nos leemos!

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