Archive for the '3462' Category

AjTalk Implementando Smalltalk en C# (4) El Proyecto

Sunday, June 29th, 2014

Anterior Post

Hace ya año y medio que no escribo de este proyecto en C#, pero fui trabajando en él, y en la implementación paralela que tengo en JavaScript (de hecho, presenté algunos conceptos de ambos en la Smalltalks 2013 que se realizó el año pasado, en Rosario, Argentina).

El proyecto está en:

https://github.com/ajlopez/AjTalk

La estructura actual:

Veamos. Los proyectos son:

AjTalk: librería de clases, con la implementación de un compilador a bytecodes (y también a JavaScript), y un intérprete de los bytecodes compilados.

AjTalk.Compiler: un proyecto de consola que permite, usando el compilador mencionado en el proyecto anterior, generar código JavaScript.

AjTalk.Console: un REPL (Read Eval Print Loop)

AjTalk.Gui: una implementación sin terminar de ventanas

AjTalk.Tests: los tests que fui escribiendo, siguiendo el flujo de trabajo de TDD (Test-Driven Development)

El compilador a JavaScript creo que no lo voy a necesitar, porque en el último año he conseguido que el proyecto de JavaScript:

https://github.com/ajlopez/AjTalkJs

sea autosuficiente (ahora compila a bytecodes, pero también podría compilar a JavaScript; el tema que el intérprete de bytecodes me permite algunas operaciones más flexibles).

Y la implementación de ventanas (muy primitiva) la voy a sacar, para seguir por el camino de crear ventanas desde el propio AjTalk, en Smalltalk, accediendo a los tipos y objetos de .NET.

Un punto que me parece muy interesante (en ambos proyectos, el de C# y el de JavaScript) es tener una implementación modular: en vez de cargar una imagen con todo definido, poder definir módulos a cargar, como pasa en el ambiente Node.js. Los módulos estarían publicados en el NPM (El Node Package Manager), y cada cual podría indicar qué módulos necesita en su programa, en lugar de levantar todo Smalltalk.

Otro tema: en este proyecto de C# tengo implementado que pueda levantar más de una máquina AjTalk al mismo tiempo. E incluso puedo hacer que una máquina “ayude” a la otra. Por ejemplo, si la máquina A no tiene los métodos para compilar nuevos métodos, la máquina B puede ir en su auxilio. Así, la máquina A (y su imagen, que ya estoy grabando imagen binaria) puede mantenerse de tamaño pequeño.

Otra característica que tengo implementada: la capacidad de enviar un mensaje a un objeto, sin esperar una respuesta, un “fire and forget”. Y que el objeto destino pueda atender esos mensajes DE A UNO, como en los modelos de actores.

Tengo que revisar la implementación de objetos remotos (hoy basada en el viejo Remoting de .NET). Pero pienso que es una característica importante a mantener y explorar.

Bien, como ven, quedan multitud de temas para otros posts, como detalles de implementación de conceptos de Smalltalk, como Object, Class, ClassDescription, Behavior, MetaClass, etc.

Nos leemos!

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

Rearmando Smalltalk (Smalltalk from Scratch)

Thursday, May 1st, 2014

Pienso que Smalltalk es una tecnología maravillosa que ha influenciado la programación durante las pasadas décadas. Pero no directamente: su influencia mayor no ha sido a través de uso o de aparición de “killer apps” sobre Smalltalk. Lo que veo que ha pasado es que Smalltalk influenció a programadores. La marca de las ideas de Smalltalk se pueden rastrear en las decisiones de diseño de lenguajes como Python y Ruby. Y muchos programadores se han visto atraídos por las ideas de Smalltalk, trantándolas de aplicar a otros ámbitos. Pero Smalltalk, como tecnología, no ha tomando al mundo. Podemos discutir las razones: una temprana “balcanización” de los proveedores, la falta de una temprana implementación de código abierto. Mi postura: está muy ligado a su propia “GUI IDE”, y es un poco demasiado (tiene demasiadas piezas).

Pienso que es tiempo de explorar caminos alternativos. Durante años, visité tecnologías, lenguajes, y en la pasada década y media (más o menos), tomé de nuevo a Smalltalk, intentando encontrar uno de esos caminos alternativos.

Pienso que un camino a explorar es intentar armar un Smalltalk más simple. Un Smalltalk no tanto ligado a una GUI ID, no ligado a miles de clases. Me imagino una implementación simple que pueda acceder al resto de los avances de programación (como el ecosistema de Node.js).

Para poner manos en la masa, estuve armando tres implementaciones: Smalltalk sobre .NET, en Java y en los últimos tres años en JavaScript/Node.js:

https://github.com/ajlopez/AjTalk
https://github.com/ajlopez/AjTalkJava
https://github.com/ajlopez/AjTalkJs

Más información en posts en http://ajlopez.wordpress.com/category/smalltalk/ y en http://msmvps.com/blogs/lopez/archive/tags/Smalltalk/default.aspx

Pero este post no es para repasar esas implementaciones. Lo que quisiera es pasar en limpio, escribir sobre algunas ideas sobre cómo crear un Smalltalk, sin tener que pasar por el achicamiento de imágenes de uno ya existente.

El Núcleo

Pienso que se puede armar un nuevo Smalltalk, desde un núcleo mínimo. Para eso, podemos partir de un Smalltalk que ejecute albergado por otra tecnología, como puede ser .NET, Java, o JavaScript, o cualquier otra. Pero es hora te dener un Smalltalk que no sea tan aislado, que converse con un ecosistema: tiene que apalancar lo logrado en otros ámbitos. Por ejemplo, un Smalltalk ejecutando sobre JavaScript puede acceder a todo el ecosistema de ese lenguaje, o al ecosistema de Node.js si estamos trabajando en el servidor.

El núcleo de Smalltalk debería implementar:

Object: el objeto y clase base, con algunos métodos iniciales como #subclass:.

Array: para arreglos con acceso por índice numérico, comenzando desde 1 para no romper con la tradición Smalltalk.

Dictionary: para mapear claves (nombres) a valores.

Tipos Primitivos: para acceder a la tecnología albergadora (.NET, Java, JavaScript), a sus tipos primitivos.

Aceso a tipos y objetos nativos: para crearlos, llamar sus métodos de tipo y de instancia.

La Librería

Primero, una implementación mínima de algunas clases, que pueden ser empaquetadas en una implementación inicial.

Pero luego, viene algo importante: tratar de vivir en un ecosistema de paquetes. En vez de tener centenares o miles de clases, que cada aplicación pueda referenciar y obtener los paquetes de un ecosistema. En mis implementaciones, he tomado el camino de usar NPM (Node Package Manager) para publicar y consumir paquetes, para instalarlos por aplicación, aún usando las versiones específicas que necesite cada aplicación y paquete.

Algunos candidatos a paquetes, como ejemplo:

– Una librería de tests (con un método assert)
– Un servidor HTTP
– Un framework MVC (tengo un ejemplo en Smalltalk sobre JavaScript/Node.js usando Express)
– Mensajes distribuidos (tengo una implementación en C#, el objetivo de este año es tener algo similar en JavaScript/Node.js)
– etc.

De esta manera, la adopción de un paquete será más fácil: no se necesita portar un paquete a otro dialecto, sólo consumirlo, teniendo las dependencias en su lugar. Para eso, cada paquete describe las dependencias que necesita.

Items Adicionales

Quiero implementar ambientes/environments: cada clase o paquete puede cargar otras clases pero para uso interno, sin interferir con el ambiente Smalltalk global, previniendo colisión de clases y versiones.

Otra cosa que quiero es poder ejecutar más de una imagen al mismo tiempo. Y que una imagen ayude a otra. Por ejemplo, que una imagen chica pueda ir agregando métodos a sus clases, pero los métodos de compilación los encuentre en otra imagen. De esta forma, una imagen puede comenzar chica, de poco tamaño, siendo ayudada por otra para ir creciendo e implementando los casos de uso que necesita. De esta forma, nos evitamos tener que partir de una imagen grande, e ir reduciédola. Tengo una implementación de estas ideas en mi versión de Smalltalk en C#.

En algunas implementaciones, quiero una imagen (para leer y grabar). Pero primero puedo explorar hasta donde llegar sin tener la necesidad de persistir una imagen.

Cualquier GUI debería ser creada fuera del núcleo, tal vez usando el ambiente albergador. Por ejemplo, usar Windows.Form si estamos sobre .NET o Mono, o Swing o SWT si estamos en Java, o el notable Canvas en caso de HTML5/JavaScript. Pero la idea es que el manejo de la GUI tiene que estar claramente separado de la implementación núcleo. Los Smalltalk populares actuales están muy ligados a la GUI que contienen en toda imagen. Veamos otras tecnologías: Python, Ruby, Node.js, Go, etc… Hay multitud de ellas que avanzaron sin estar ligadas a una GUI y a una IDE. Y sus programadores siguien creando aplicaciones útiles.

Como siempre digo: hay que explorar. Ese es el verbo a usar. Tenemos que explorar caminos alternativos, aún cuando no queden en claro la ganancia a obtener. Si hubiera visto, a esta altura, alguna “killer app” en Smalltalk, o el uso de Smalltalk para la creación de aplicaciones (como pasa en Python, Ruby, Java, JavaScript, Node.js, .NET, y otros), yo no pensaría de esa forma. Pero por alguna razón, Smalltalk no llegó a ese estadío. Veo entonces que hay alternativas, flotando alrededor nuestro, listas para ser exploradas.

Nos leemos!

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

Smalltalk, JavaScript, NodeJs, C#, y Tutti Li Fiocci

Monday, February 3rd, 2014

El año pasado tuve el gran placer de asistir a Smalltalks 2013, en la ciudad de Rosario, Argentina.  Asistir a esa conferencia fue una gran experiencia para mí, con charlas interesantes, implementaciones más interesantes y muchas ideas para digerir. Además de encontrarme con gente como @garduino, @morplenauta y @hernanwilkinson.

Dí una charla sobre cómo implementar Smalltalk en C# y en JavaScript. Los principales repositorios están en:

http://github.com/ajlopez/AjTalk (lo presenté por primera vez en Smalltalks 2010)
https://github.com/ajlopez/AjTalkJs (lo presenté en Smalltalks 2011)

Mi charla, grabada gracias a la organización:

http://www.youtube.com/watch?v=-KFjSneVE2s

[View:http://www.youtube.com/watch?v=-KFjSneVE2s]

La presentación:

https://github.com/ajlopez/Talks/tree/master/Smalltalks2013
http://ajlopez.github.io/Talks/Smalltalks2013/index.html
Mis otras charlas del año en http://ajlopez.github.io/Talks/

El primer proyecto, en C#, compila a bytecodes y los interpreta. También puede compilar a JavaScript, pero en los últimos meses conseguí que el proyecto de JavaScript no necesitara de este compilador. Pero quedó implementado un patrón Visitor que podría modificar para recorrer el árbol de expresiones y generar código para otros lenguajes, por ejemplo Python o Ruby. Lo bueno de la VM en C# es que puede acceder a tipos y objetos nativos de C#. Además hay actores, ejecución remota, ver mis posts.

El segundo proyecto es una implementación de Smalltalk en JavaScript. Internamente, tiene un compilador a JavaScript, pero también tiene un compilador a un arreglo de bytecodes, que luego puede interpretar. Ambos proyectos, el de C# y el de JavaScript, ahora soportan el consumo de módulos que se instalan usando NPM (el manejador de paquetes de Node.js).

En 2013, a AjTalkJs le agregué mucho mejor soporte de Node.js, con acceso a módulos, así que ahora puedo ejecutar aplicaciones Express desde Smalltalk:

 

Próximos experimentos: mensajes distribuidos. Esto es, un objecto en una máquina enviando un mensaje a un objeto en otra máquina/proceso, en una forma “fire and forget”. Pienso que el ecosistema de Node.js puede ser un buen lugar para estos experimentos. Mi trabajo en el tema en Distributed Applications with Node.js. Quiero ahora una aplicación Smalltalk distribuida. Quizás, si consigo que el protocolo de comunicación sea simple y enchufable, podría implementarlo en otras implementaciones de Smalltalk, o en otros lenguajes. Pero primero, “baby steps”  😉

Nos leemos!

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

Resoluciones del Nuevo Mes: Diciembre 2013

Friday, December 6th, 2013

Primero, revisar mis resoluciones de Noviembre:

– Comenzar un compilador de Python reducido a C, usando JavaScript [complet] repo
– Dar una charla sobre implementación de Ruby en C# [completo] slides repo
– Comenzar intérprete Ruby en JavaScrip [completo] repo
– Completar el alcance de variables en lenguaje Mass [pendiente]
– Dar una charla sobre interpretar y compilar lenguajes en JavaScript [completo] slides
– Escribir un framework web para AjTalkJs (para ser usado desde Node.js) (plano o MVC) [pendiente]
– Mejorar módulos NPM en AjTalkJs y AjTalk [parcial] repo
– Mejorar soporte de tests en AjTalkjs y AjTalk [pactial] repo
– Mejorar las estructuras de datos en AjErl [pendiente]

Mis resoluciones para Diciembre:

– Dar un curso de un día sobre Node.js
– Refactorizar y mejorar CobolScript
– Continuar escribiendo en intérprete de Ruby en JavaScript
– Terminar de definir el alcance de variables en el lenguaje Mass
– Más módulos iniciales para AjTalkJs

Nos leemos!

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

Resoluciones del Nuevo Mes: Noviembre 2013

Tuesday, November 5th, 2013

Estas fueron mis resoluciones de Octubre:

– Dar una charla sobre PHP and Node.js [complete] see post and PHP/Node repo and PageJs repo at PHP Dev Argentina 2013

– Dar una charla sobre TDD con ASP.NET MVC [completo] ver repo

– Dar una charla sobre la implementación de Scala [completo] ver slides y ejemplos simples

– Dar una charla sobre Python en JavaScript [completo] ver repo y slides para PyCon 2013 Argentina

– Dar una charla sobre Smalltalk en JavaScript y C# [completo] ver repo y slides para Smalltalks 2013

Las resoluciones para este nuevo mes:

– Comenzar un compilador de Python reducido a C, usando JavaScript

– Dar una charla sobre Ruby en C#

– Compezar un compilador de Ruby a JavaScript

– Completar el alcance de variables en el lenguaje Mass

– Dar una charla sobre compilando lenguajes a JavaScript (a confirmar)

– Escribir un framework web para AjTalkJs (a ser usado en Node.js) (plano? con MVC?)

– Mejorar la implementación de módulos NPM en AjTalkJs y AjTalk

– Mejorar el soporte de tests en AjTalkjs y en AjTalk

– Mejorar el manejo de estructuras y match en AjErl

Nos leemos!

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

 

Conferencias en Argentina

Wednesday, August 28th, 2013

Ayer listé las reuniones que se vienen en Buenos Aires.

Veamos hoy una lista de conferencias en Argentina, de acá a fin de año. Primero, mañana jueves 29 comienza:

Hacks/Hackers BA Media Party 2013

en Buenos Aires

http://lanyrd.com/2013/hhba/

The Media Party http://mediaparty.info. Three awesome days of keynotes, workshops, demos and a huge hackathon; journalists, editors, designers and software developers working together for the future of media; interactive storytelling, visualizations, mapping, scraping and more.

Tengo que confesar que me aburre un poco el temario, pero cumplo con avisarles que existe esa conferencia.

PHP Conference Argentina
4-5 October 2013, Buenos Aires

http://www.phpconference.com.ar/?lang=en

his year we gathered the best of the programming world. With several talks that cover a wide range of topics related to web development, PHP Conference Argentina is a conference no programmer wishes to miss (whether or not they use PHP.) These are just some of our speakers:…

Uy, vienen todos los popes de PHP, incluido Lerdorf

PyCon Argentina

en Rosario

http://ar.pycon.org/

¡Python en Rosario! 24 y 25 de Octubre
Python es un lenguaje dinámico comparable con Java, .NET, PHP y Ruby mucho más intuitivo y fácil de aprender, alentando la colaboración. Disfruta programar tan rápido como piensas, de forma clara y expresiva. Ven y conoce porqué Google, Yahoo, Disney, Cisco, LucasFilm, Red Hat, Pixar, VMware, Canonical (Ubuntu), NASA, YouTube y varias empresas nacionales, universidades locales, docentes e investigadores usan Python!

Smalltalks 2013

October 30, 31 and November 1st
UTN Facultad Nacional Rosario

http://www.fast.org.ar/smalltalks2013

The Fundación Argentina de Smalltalk (FAST) proudly invites you to participate in the seventh edition of one of the most exciting Smalltalk conferences around

Smalltakers from every corner of the world will attend this international event. Outstanding guest personalities from the community will deliver the conference keynotes. This is an opportunity you do not want to miss!

Smalltalks 2013 will feature a research track for papers, complete with published proceedings and an outstanding program commitee. As always, the conference will also feature an industry track for those preferring a more informal setting.

RubyConf Argentina

Buenos Aires, November 27 & 28, 2013

http://rubyconfargentina.org/en/

We are very proud to announce the third edition of RubyConf Argentina,
a regional conference about Ruby and related technologies.

Bueno, falta ver dónde se hace el Día del Programador, vía el MUG. Faltaría una de .NET (ya avisé en Microsoft que todo el mundo hace conferencia anual, menos de .NET; están muy ocupados vendiendo pantallitas y programas para pantallitas, esas cosas que se llaman mobile… y bueh… )

No digan que no les avisé de estas conferencias. Lo mío es un apostolado 😉

Nos leemos!

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

Explorando Smalltalk (1)

Tuesday, July 30th, 2013

Pienso que hay cosas para difundir que aprovechan lo escrito, diagramas, imágenes. Por ejemplo, estudiar topología general u otro tema duro, se beneficia de tener algo publicado en forma escrita, con dibujos aclaratorios. Pero otras veces, hay que ver cómo se hace algo. Explorar lo que nos puede dar Smalltalk es uno de esos casos. Por eso inicio esta serie de Google Hangouts para mostrar lo que estoy explorando con este ambiente de objetos, en particular con Pharo 2.0. He aquí el primer video:

http://www.youtube.com/watch?v=mcvYXz2nZts&feature=youtu.be

[View:http://www.youtube.com/watch?v=mcvYXz2nZts]

Lo primero que quiero destacar, como lo hago en el video, es que lo estan viendo NO ES UNA IDE, como Visual Studio o Eclipse. Es Smalltalk mismo.

Segundo, algo que en el video todavía no usé: se puede levantar y grabar una imagen, con los objetos que estemos manejando en ese momento. Al comienzo, levantamos una imagen. Uds. pueden ir armando una imagen que evoluciona, y algunos objetos pueden sobrevivir por años en esa imagen.

Ya voy a seguir mostrado otros temas, como construit la primera clase, sus métodos, programar usando TDD, y publicar paquetes.

Nos leemos!

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

Introducción a Smalltalk, en Buenos Aires

Tuesday, July 23rd, 2013

Siguiendo con mi serie de charlas presenciales sobre lenguajes de programación, voy a presentar Smalltalk (que es más que un lenguaje), algo que tenía pendiente desde hace tiempo. Gracias a la gente del Microsoft User Group de Argentina, el próximo jueves 1 de Agosto, a las 18:30, voy a dar ese charla en Buenos Aires. Es gratuita, pero tienen que inscribirse previamente. Más detalle e información en:

http://www.mug.org.ar/Eventos/3920.aspx

La idea es presentar Smalltalk para quien es programador y no sepa Smalltalk. Como “padre de todos los objetos” es interesante visitar el tema. Actualmente, hay implementaciones de código abierto, incluso sobre JavaScript, y pueden ponerse a programar en diversas plataformas, incluso sitios web.

Temas a visitar:

– Imagen y Entorno

– Evaluando expresiones

– Inspeccionando valores

– Sintaxis básica

– Escribiendo nuestras propias clases

– Desarrollando con tests

– Paquetes Monticello

– Elementos de desarrollo web

– Perspectiva: historia, situación actual, otras implementaciones

Usaré principalmente Pharo 2.0, pero también mencionaré otros dialectos.

Lo mío es un apostolado 😉 😉

Nos leemos!

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

AjTalk en C# (3) Environments

Thursday, December 27th, 2012

Anterior Post 
Siguiente Post 

Hace unas semanas, agregué el soporte de environments (ambiente, entorno) a mi proyecto de código abierto AjTalk, una máquina virtual Smalltalk escrita en C# (hay otras versiones, en Java y en JavaScript). ¿Qué es un environment en mi jerga? Es un diccionario, donde puedo guardar artefactos por nombre, un directorio. Por ejemplo, para guardar clases por nombre. La variable global Smalltalk es un environment clásico. Pero en un Smalltalk clásico, todas las clases definidas van a parar a ese diccionario global, lo que puede dar lugar a colisión de nombres. La forma normal de solucionar (p.ej. en Squeak y Pharo) es agregarle un prefijo (de dos letras) a cada clase de nuestra librería. Pero yo quiero tener el soporte de tener otros environments, como pasa con los namespaces de .NET o los package de Java. Smalltalk clásico también tiene los llamados pool dictionary, pero hasta donde sé, son para usar desde una clase y sus derivados. Yo quiero tener la noción de paquete: todas estas clases se ven entre sí, pero no están en el environment del tope, en Smalltalk, sino en un environment dedicado a mi librería. Agregué una implementación inicial, con estos tests:

https://github.com/ajlopez/AjTalk/blob/master/Src/AjTalk.Tests/AssertTests/EnvironmentTests.st

Al comienzo, verifico que Smalltalk es un ambiente, un environment y es el actual:

"Current environment is Smalltalk"
[Environment current == Smalltalk] assert.

Puedo crear nuevos entornos:

env := Environment new: #MyEnvironment.

Automáticamente, el nuevo entorno se registra/agrega al entorno actual, en este caso, a Smalltalk:

"The new environment was defined as global at Smalltalk"

[(Smalltalk at: #MyEnvironment) isNil not] assert.
[(Smalltalk at: #MyEnvironment) == MyEnvironment] assert.
[(Smalltalk at: #MyEnvironment) == env] assert.

[MyEnvironment isNil not] assert.
[MyEnvironment == env] assert.

Cada nuevo entorno tiene automáticamente una entrada Smalltalk que apunta al original global:

"Dotted expression syntax sugar for MyEnvironment at: #Smalltalk"

[MyEnvironment.Smalltalk == Smalltalk] assert.

Podemos pasar a tener un nuevo entorno actual:

env setCurrent.

"Current environment check"

[Environment current == env] assert.
[Environment current == Smalltalk.MyEnvironment] assert.

Y ahora, la característica principal de lo que quería implementar, de ahora en más, las definiciones de clases (sin cambiar el código de su definición) quedan registradas en el entorno actual:

"Define a class at current env environment, no change to syntax"

Object subclass:#MyClass
    instanceVariableNames:''
    classVariableNames:''
    poolDictionaries:''
    category:''
.

[(env at: #MyClass) isNil not] assert.
[(Smalltalk at: #MyClass) isNil] assert.

Ortogonal a esto de environments, implementé además módulos (algo apareció en el post anterior): una forma de buscar y leer archivos file out, y ejecutarlos dentro de un nuevo entorno. Esto es similar al import de Python, y algo menos parecido, al require de Node.js/CommonJS. Bueno, pero eso es tema para otro post 😉

Nos leemos!

Angel “Java” Lopez

http://www.ajlopez.com

http://twitter.com/ajlopez

AjTalk en C# (2): Un Simple Servidor Web

Monday, December 17th, 2012

Anterior Post 
Siguiente Post 

Estoy trabajando completando mi máquina virtual Smalltalk, escrita en C#, el AjTalk, el repositorio en https://github.com/ajlopez/AjTalk . Hace unas semanas, escribí un ejemplo de simple servidor web, basado en mi trabajo previo en PythonSharp (1) Un servidor web mínimo. El código de este nuevo servidor en:

https://github.com/ajlopez/AjTalk/blob/master/Src/AjTalk.Console/Programs/WebServer.st

Object subclass: #WebServer
	instanceVariableNames: 'root listener bytes'
	classVariableNames: ''
	poolDictionaries: ''
	category: ''
!

!WebServer class methods!

new
	^self basicNew initialize
! !

!WebServer methods!

initialize
	bytes := @System.Array !!CreateInstance: @System.Byte with: 1024 * 16.
	listener := @System.Net.HttpListener !!new.
	listener !!Prefixes !!Add: 'http://*:8000/'.
	root := 'c:/apache-tomcat-6.0.18/webapps/docs'.
	@System.Console !!WriteLine: 'initialize'
!

process: context
	| filename input nbytes |
	filename := context !!Request !!Url !!AbsolutePath.
	
	@System.Console !!WriteLine: filename.
	
	(filename = '' or: [filename = '/']) ifTrue: [filename := 'index.html'].
	
	(filename !!StartsWith: '/') ifTrue: [filename := filename !!Substring: 1].
	@System.Console !!WriteLine: filename.
	
	filename := @System.IO.Path !!Combine: root with: filename.

	@System.Console !!WriteLine: filename.	
	
	(@System.IO.File !!Exists: filename) 
	ifFalse: [ context !!Response !!Abort. ]
	ifTrue: [		
		input := @System.IO.FileStream !!new: filename with: @System.IO.FileMode !!Open.
		[[nbytes := input !!Read: bytes with: 0 with: bytes !!Length] value > 0] whileTrue: [
			context !!Response !!OutputStream !!Write: bytes with: 0 with: nbytes.
		].
		
		input !!Close.
		
		context !!Response !!OutputStream !!Close
	]
!

start
	listener !!Start.
	@System.Console !!WriteLine: 'start'.
	[true] whileTrue: [
		| context |
		@System.Console !!WriteLine: 'get context'.
		context := listener !!GetContext.
		@System.Console !!WriteLine: 'new request'.
		self process: context.
	].
	@System.Console !!WriteLine: 'end start'
! !

WebServer new start
!

Como el anterior, es una prueba de concepto, “quick and dirty”, para mostrar que puedo reutilizar las clases de .NET. Pueden lanzarlo desde el programa de consola de AjTalk (el resultado de compilar el proyecto AjTalk.Console):

ajtalk lib\Library.st Programs\WebServer.st

El resultado en http://localhost:8000 (jeje, reusando unas páginas estáticas que tengo en mi disco local):

Luego escribí un ejemplo más claro y modular en

https://github.com/ajlopez/AjTalk/blob/master/Src/AjTalk.Console/Programs/WebSiteTomcat.st

Module import: #Web.

!

| server |

server := Web.Server new
	root: 'c:/apache-tomcat-6.0.18/webapps/docs';
	addPrefix: 'http://*:8000/';
	start
!

Pero ahí estoy usando Module import:, algo que implementé basado en lo que hice de PythonSharp import para cargar programas. Pero esa lógica ya es tema para otro post.

Nos leemos!

Angel “Java” Lopez

http://www.ajlopez.com

http://twitter.com/ajlopez