July 2008 - Posts
Soy un entusiasta de escribir intérpretes, especialmente del tipo Lisp. Mi primer intérprete Lisp fue escrito al principio de los 80, usando el lenguaje assembler de un Intel 808x. Era un trabajo muy "geek". Una de las características más "tricky" de implementar es un recolector de basura (garbage collector). Por suerte, desde mediados de los 90 tenemos Java y su librería de clases como una tecnología ampliamente disponible con un garbage collector decente. En este siglo, .NET es la nueva plataforma de lenguajes con GC..
En el 2005, Martin Salias y yo dimos un TechNight, aquí en Buenos Aires, Argentina, para la oficina local de Microsoft. Trató sobre lenguajes implementados en .NET. Fue la primera vez que presenté F#, así como P# y otros. Despues de esa charla, la misma noche viajé a Mar del Plata, para dar otra charla sobre ASP.NET. Mar del Plata es una bella ciudad, en frente del océano Atlántico, a la que trato de volver cada año. Entonces, era mi primer visita luego de treinta años. En el viaje, "nació" AjLisp.
Esa versión era un intérprete Lisp escrito en Visual Basic .NET. El pasado domingo, lo porté a C# (usando alguna opción de menú de SharpDevelop, ¿alguna otra herramienta que conozcan?). El código original fue usado hace unas semanas en mi post sobre VPL:
Lisp-like interpreter using DSS and VPL
Intérprete tipo Lisp usando DSS y VPL
La nueva versión C# version está publicada en Google Code en:
http://code.google.com/p/ajlisp/
Me gusta Google Code: tiene soporte de SVN, asi que uso mi cliente local TortoiseSVN para enviar los cambios en el proyecto.
La solución
Tiene tres proyectos:
AjLisp: el proyecto núcleo, una librería, que puede ser invocada desde otra aplicación.
AjLisp.Tests: Todos los tests, usando NUnit 2.2.8. Si no tienen NUnit, pueden remover el proyecto de la solución.
AjLisp.Console: un simple programa de consola.
Los tipos
Una interfaz base es IAtom:
public interface IAtom
{
bool IsAtom();
}
Otra es IList:
public interface IList
{
SymbolicExpression First
{
get;
set;
}
SymbolicExpression Rest
{
get;
set;
}
bool IsList();
}
Todos los tipos derivan de una SymbolicExpression:
namespace AjLisp.Types
{
public abstract class SymbolicExpression : IList, IAtom
{
....
Implementé los tipos comunes a usar en un Lisp, como List, Atom, Identifier, Function (para invocar a primitivas y funciones generadas por lambdas), True, Nil...:
Existe una clase Environment para mantener valores asociados a nombres. Cada Environment tiene un Environment padre, para mantener una lista de ambientes con valores.
La clase Interpreter es la principal a manejar: tiene un Environment y define algunos nombres para las primitivas iniciales:
public class Interpreter
{
private Environment environment = new Environment();
public Interpreter()
{
Define("nil", Nil.Value);
Define("t", True.Value);
Define("cons", new SubrCons());
Define("first", new SubrFirst());
Define("car", new SubrFirst());
Define("rest", new SubrRest());
Define("cdr", new SubrRest());
Define("list", new SubrList());
Define("quote", new FSubrQuote());
Define("append", new SubrAppend());
Define("cond", new FSubrCond());
Define("atom", new SubrAtom());
Define("eval", new SubrEval());
Define("null", new SubrNull());
Define("lambda", new FSubrLambda());
Define("progn", new FSubrProgN());
Define("flambda", new FSubrFLambda());
Define("nlambda", new FSubrNLambda());
Define("mlambda", new FSubrMLambda());
Define("numberp", new SubrNumberP());
Define("functionp", new SubrFunctionP());
Define("idp", new SubrIdP());
Define("define", new FSubrDefine());
Define("definef", new FSubrDefineF());
Define("definen", new FSubrDefineN());
Define("definem", new FSubrDefineM());
Define("eq", new SubrEq());
Define("if", new FSubrIf());
Define("let", new FSubrLet());
Define("lets", new FSubrLetS());
Define("set", new SubrSet());
Define("consp", new SubrConsP());
Define("less", new SubrLess());
Define("greater", new SubrGreater());
Define("plus", new SubrPlus());
Define("difference", new SubrDifference());
Define("times", new SubrTimes());
Define("quotient", new SubrQuotient());
Define("remainder", new SubrRemainder());
}
....
Uds. pueden escribir sus propias primitivas y agregarlas a este constructor.
Las primitivas
El intérprete tiene las primitivas usuales:
Hay primitivas, que antes de su invocación, evalúan los argumentos recibidos. Son las que derivan de Subr:
public abstract class Subr : Function
{
public abstract SymbolicExpression Execute(SymbolicExpression args, Environment env);
public override SymbolicExpression Apply(SymbolicExpression form, Environment env)
{
return Execute(form.Rest.Evaluate(env), env);
}
}
form.First es la función, y form.Rest es la lista de argumentos. Para evaluar el form, Function usa un objeto Environment.
Otras primitivas no evalúan sus argumentos, derivan de FSubr:
public abstract class FSubr : Function
{
public abstract SymbolicExpression Execute(SymbolicExpression args, Environment env);
public override SymbolicExpression Apply(SymbolicExpression form, Environment env)
{
return Execute(form.Rest, env);
}
}
Una de las primitivas más interesantes, es la implementación de lambda, llamada FSubrLambda:
public class FSubrLambda : FSubr
{
public override SymbolicExpression Execute(SymbolicExpression args, Environment env)
{
return new SubrClosure(args.First, env, args.Rest);
}
}
Crea un Closure, una manera de recordar el Environment actual para usarlo en una futura invocación de la expresión lambda. Implementé también NLambda, FLambda, MLambda: N es por NonSpread (maneja su lista de argumentos como si fuera un solo argumento), F es cuando no son evaluados los argumentos antes de la invocación, y M es por Macro (tengo que revisar hasta donde implementé esta "feature").
Los tests
Toda la funcionaliad está cubierta por tests. Configuré el proyecto AjLisp.Test para ejecuter NUnit GUI:
La consola
AjLisp.Console es un simple programa de consola. Pueden ingresar una expresión y la evalúa:
Es tan simple, que hay que usar Control-C para salir... ;-).
Próximos pasos
Hay tanto para hacer. Quiero mejorar algunos puntos:
- Reescribir interfaces y clases de base
- Manejar e invocar objetos .NET nativos
- Tratar a Reales y Enteros por separado (hoy a ambos, al operar, los trata como valores double)
- Revisar Macro expansion
- Mejor consola
- Librería de ejemplos
- Un manual mínimo
La idea es llegar a extender este mini lenguaje para ser usado como la base programación de agentes distribuidos. Sería bueno portarlo a Java. Entonces, la conducta de los agentes y su estado puede ser escrito en este lenguaje, y viajar a distintos nodos de la grilla, de forma independiente a la plataforma.
Bueno, son sueños. Ahora, el estado actual: está funcionando, y me divertí escribiéndolo. Disfruten!
(Este artículo es una traducción a Spanish, desde el Anglish (Angel's English) original:
AjLisp- a Lisp interpreter in .NET
)
Angel "Java" Lopez
http://www.ajlopez.com/en
Hay varios temas de los que quisiera bloguear más en detalle. Pero vaya hoy una lista de enlaces y comentarios cortos:
Primero de todo, tenemos nuevos Microsoft MVPs por aquí en Argentina, felicitaciones a Rodolfo Finochietti, Pablo Galiano, y al pibe Matías Woloski. El bueno de Finochietti visita de vez en cuando este blog, y deja comentarios, por ejemplo, sobre programación funcional y el lenguaje Cat. Tenemos varios intereses en común, como el estudio de lenguajes, compiladores, y compartimos la afición por la historia de las matemáticas.
Si se interesan en Smalltalk, es interesante The Smalltalk programming language.
Gracias al bueno de Martin Salias, que me avisó de este texto en la web The Early History of Smalltalk de Alan Kay (yo había anunciado una versión en PDF en La historia de Smalltalk). Es un "DEBESERLEIDO" por todo aquel que esté realmente interesado en la programación. Uno debe conocer la historia de las ideas, para realmente entender la situación actual tanto de ideas, como de tecnologías, y para tener un "grasp" de lo que podría venir.
Modu: gracias al twitter de @parancibia, vean este mobile modular. Muy interesante el concepto.
De vez en cuando, Microsoft Directions publica un artículo público. Lean Software Plus Services and Developers. ¿The next big thing?
Dentro del proyecto NHContrib, de herramientas para NHibernate, existe NHibernate.LINQ, que permite usar LINQ sobre NHibernate. Vean ahora lo que se hizo con Silverligh en Silverlight 2 + NHibernate.LINQ == Sweet y el ejemplo de nhibernate con Northwind
Para aprender NHibernate NHibernate - Relational Persistence for Idiomatic .NET. Si quieren contribuir al proyecto hibernate.org - Getting Started with the NHibernate Source Code. Si tienen dudas, ver la lista de NHibernate Hispano.
Siguiendo con LINQ, leo cómo usar un DataContext en memoria, esta vez desde ASP.NET MVC, en ASP.NET MVC Tip #21 – Fake the Data Context
Las aventuras de Scott Hanselman para agregar un OpenSearch en sus páginas: Adding OpenSearch to your website and getting in the Browser's Search Box
Steve Clayton está en Software + Services en Microsoft. Lean su encuentro con Ray Ozzie, no puede decir todo, pero S+S se viene cada vez más. El tiempo dirá qué será eso.
No llegué a tiempo para anunciarla. Diego Jancic realizó una encuesta en línea sobre cómo programamos. Vean los resultados en el blog de Darío Quintana.
El Composite Application Guidance para WPF tiene su nueva página en MSDN.
Jeff Atwood tiene algunas ideas interesantes y discutibles sobre no normalizar base de datos.
.NET Terrarium está de vuelta!
Me interesó el proyecto Jackrabbit, tengo que estudiar más en detalle la especificación Content Repository API de la JSR-170.
Twitter adquiriendo a Summize.
Y hay que visitar y usar 10 herramientas para un tech.
Nuevo Blog de la comunidad MSDN en español. Gracias a Miguel Angel Saez por el aviso.
Si alguien necesita acá está: Implementing Finite State Machines with Physhun and Spring (en Java)
Cada vez más lenguajes dinámicos sobre máquinas virtuales, ver Java 6: Using Python via the new Scripting Engine.
Interesante código y artículo, sobre un tema que se necesita conocer: Single Sign-on in ASP.NET and Other Platforms
Para entender la historia de MVC: The Model-View-Controller, Its past and present
Más sobre Model-View-Controller, Model-View-Presenter, y Presentation-Abstraction-Control en Interactive Application Architecture Patterns.
MVC en ASP.NET en ASP.NET MVC - The Official Microsoft ASP.NET Site
Una interesante comparación de David Hayden ASP.NET MVC Framework Compared To Web Client Software Factory ( WCSF )
¿Necesitan un manejar un proyecto de software? No lo uso, vería el open source Trac Project, via web en Java (gracias a J. Franco, por este enlace). Al parecer, trabaja con Subversion.
¿Necesitan open source en Java? De todo en http://java-source.net/.
Off topic total: mi mejor post hasta ahora del 2008, con gráfica incluida, en Posmopolitan.
Nos leemos!
Angel "Java" Lopez
http://www.ajlopez.com/
http://twitter.com/ajlopez
http://friendfeed.com/ajlopez
El lunes 28 de Julio daré una charla gratuita en el Club de Programadores, sobre Microsoft Robotics, acá en Buenos Aires.
La idea es presentar la herramienta y su modelo de programación. Visitaremos el entorno de simulación, el manejo de robots simulados (que pueden reemplazarse por robots reales), el Visual Programming Language, y las librerías Decentrilized Software Services (DSS), y Concurrent and Coordination Runtime (CCR).
Más informes e inscripción a esta charla gratuita en:
http://www.clubdeprogramadores.com/cursos/CursoMuestra.php?Id=458
Ya escribí algo sobre estos temas en este blog:
Robótica
Decentralized Software Services
Concurrency and Coordination Runtime
Presentaré algunos de los ejemplos que había usado en el último Microsoft Regional Architect Forum, en base a la presentación de Arvindra Sehmi, y otros ejemplos adicionales.
Todo sobre Microsoft Robotics Developer Studio, desde
http://www.microsoft.com/robotics
Concursos, desafíos, videos explicativos, desde el nuevo sitio de Robotics
http://www.robochamps.com/
Enlaces que he coleccionado sobre estos temas en:
http://del.icio.us/ajlopez/dss
http://del.icio.us/ajlopez/ccr
http://del.icio.us/ajlopez/robotics
http://del.icio.us/ajlopez/msrs
Nos leemos!
Angel "Java" Lopez
http://www.ajlopez.com/
Hace unas semanas, estuve trabajando en mi proyecto de código abierto AjTalk, un intérprete tipo Smalltalk, escrito en .NET (con C#, para facilitar la migración a Mono, si alguien lo necesita), y ahora, quiero presentar el estado actual de ese trabajo. Desde los tempranos ochenta del siglo pasado, me ha interesado Smalltalk y siempre vuelvo al tema, aunque sólo en mi tiempo libre, no como desarrollador profesional. No es la primera vez que escribo un intérprete de este tipo (el primero que escribí en aquellos años era muy simple: en C, sin recolector de basura, interface solo texto), pero ahora quiero implementar uno más, esta vez más completo, apoyándome en la librería de clases .NET.
La versión actual es mínima, pero va tomando forma. La idea es tener objetos dinámicos, como en Smalltalk, y, en algún momento, agregarle el soporte de prototipos. Los objetos y el intérprete accederían a todo el framework .NET y otras librerías. Tengo la experiencia previa de haber logrado eso en mi intérprete AjBasic, que uso en mi proyecto de generación de código AjGenesis.
La versión inicial de AjTalk está publicada en Google Code:
http://code.google.com/p/ajtalk/
La solución
Estoy usando Visual Studio 2005 Professional. La solución contiene cuatro proyectos.
AjTalk es el proyecto principal, una librería de clases conteniendo el núcleo del sistema.
AjTalk.Test01 y AjTalk.Test02 son aplicaciones de consola, para usar en pruebas manuales.
AjTalk.Tests contiene los unit tests, escritos usando NUnit framework 2.2.8.
Mucho del sistema núcleo consiste en interfaces, que definen las conductas de base, y clases implementando esas interfaces.
El objeto
El proyecto contiene una interface para representar cualquier objeto:
using System;
namespace AjTalk
{
public interface IObject
{
IClass Class { get; }
object this[int n] { get; set;}
object SendMessage(string msgname, object [] args);
}
}
Podría hacer que un mensaje sea un objeto (del tipo Message), pero por ahora, el mensaje es sólo un nombre y un arreglo de argumentos.
El índice this[int n] accesde a las variables de instancia. Cada valor en AjTalk puede apuntar a cualquier objeto .NET, no solamente a objetos que implementen IObject. De esta forma, puedo manejar int, long, String, DataSet, desde objetos IObject.
La clase
Estoy implementando una interface simple IClass, sin distinción entre clase, behavior, y otras clases, como sería en el Smalltalk clásico. Separaré esas clases en una futura versión, cuando llegue a ser necesario. Por ahora, estoy manejando sólo una interface:
using System;
using System.Collections;
using System.Collections.Generic;
namespace AjTalk
{
public interface IClass : IObject
{
IClass SuperClass { get; }
string Name { get; }
void DefineClassMethod(IMethod method);
void DefineInstanceMethod(IMethod method);
void DefineClassVariable(string varname);
void DefineInstanceVariable(string varname);
IObject NewObject();
IMethod GetClassMethod(string mthname);
IMethod GetInstanceMethod(string mthname);
int GetClassVariableOffset(string varname);
int GetInstanceVariableOffset(string varname);
}
}
Hay un diccionaro para los métodos de clase y otro para los de instancia, y listas de variables de instancia y de clase. No soporta todavía variables indexadas. La interface IClass está implementada en la clase BaseClass.
El método
Hay una interface IMethod:
using System;
namespace AjTalk
{
public interface IMethod
{
string Name { get; }
IClass Class { get; }
object Execute(IObject receiver, object [] args);
}
}
La clase concreta Método implementa esa interfaces. Su método Execute tiene:
public object Execute(IObject receiver, object[] args)
{
return (new ExecutionBlock(receiver,receiver,this,args)).Execute();
}
Los Execution blocks tienen variables locales y argumentos. El Execute de un bloque de ejecución toma instrucciones (bytecodes) desde métodos "compilados", y los ejecuta. Aquí, me aparto de nuevo de Smalltalk original: acá el bloque de ejecución no es un objeto AjTalk. De esta forma, yo puedo ejecutar este intérprete sin necesidad de implementar gran cantidad de clases de base. Tengo que investigar las ventajas y problemas que esta decisión podría tener sobre el diseño e implementación de esta solución.
Los bytecodes
Tengo que meditar sobre usar un árbol de objetos (como en el patrón Interpreter) o bytecodes. En esta versión, uso bytecodes. Son las instrucciones básicas que mi "máquina virtul" entiende y ejecuta paso a paso.
Esta es su enumeración:
namespace AjTalk
{
public enum ByteCode : byte
{
Nop = 0,
GetVariable = 1,
SetVariable = 2,
GetArgument = 3,
SetArgument = 4,
GetConstant = 5,
GetLocal = 6,
SetLocal = 7,
GetClassVariable = 8,
SetClassVariable = 9,
GetSelf = 20,
GetClass = 21,
GetSuperClass = 22,
NewObject = 23,
Pop = 24,
ReturnSub = 25,
ReturnPop = 26,
Add = 40,
Substract = 41,
Multiply = 42,
Divide = 43,
Send = 50
}
}
Los bytecodes contenidos en un método, son interpretados y ejecutados en un Execution Blog. Un fragmento de ese código:
while (ip < method.ByteCodes.Length)
{
ByteCode bc = (ByteCode) method.ByteCodes
;
Byte arg;
switch (bc)
{
case ByteCode.ReturnSub:
return null;
case ByteCode.ReturnPop:
return Top;
case ByteCode.GetConstant:
ip++;
arg = method.ByteCodes;
Push(method.GetConstant(arg));
break;
case ByteCode.GetArgument:
ip++;
arg = method.ByteCodes;
Push(arguments[arg]);
break;
....
Todo con Test
El código inicial había sido escrito en VB.NET. El año pasado lo comencé a pasar a C#. Este año cambié a modo "TDD", tarde pero seguro, y agregué varios tests para el NUnit:
Bootstraping
Uso un archivo de texto, con un formato ad'hoc, para inyectar las definiciones iniciales de clases y objetos. Ahora, en el proyectos AjTest.Test02, hay un ejemplo de ese formato en el archivo Definitions.txt:
class Point
variables x y
method
x ^x.
method
y ^y.
class Rectangle
variables point1 point2
class Square Rectangle
Próximos pasos
Hay una pila de trabajo pendiente:
- Completar la jerarquía de clases base (Behavior, Class, ....)
- Implementar más bytecodes
- Soporte de variables locales en métodos
- Un archivo de text estándard
- Acceso a objetos .NET nativos
- Usar AjTalk desde aplicaciones .NET (no veo necesario entonces implementar una interface de ventanas en AjTalk, solamente consumirlo adecuadamente desde cualquier aplicación .NET)
- Definir las clases y métodos para una implementación mínima
- Serialización/deserialización de la imagen en memoria
- Soporte de agregado de variables en una clase que ya tenga instancias creadas (puede ser un tema difícil)
- Soporte de become: (el problema de todo intérprete)
- Y mil más....
Pero tengo confianza en la forma que va tomando el proyecto. Estoy aplicando "baby steps", para mejorar el código de base y su funcionalidad.
Este artículo en Anglish (Angel's English):
AjTalk: a Smalltalk-like interpreter
Nos leemos!
Angel "Java" Lopez
http://www.ajlopez.com/en
Sigo volviendo la mirada atrás, como en El origen de mi nickname. Recuerdo hace ya más de dos décadas atrás, mis primeros pasos con un Xenix de Microsoft y un AIX (creo que se llamaba así el sistema que usuaba, hubo varios flavors y versiones) de IBM. Luego de CP/M y DOS y el Job Control Language de los mainframe de IBM, el shell de línea de comando era toda una herramienta (lo que son las cosas, esta semana me encuentra programando en PowerShell, una especie de tataranieto de eso). Recuerdo los ps y ls y los pipes, los apóstrofes invertidos, las discusiones sobre qué shell usar, desde la csh hasta la bourne. No había threads en esos años, todo procesos, y comunicación entre procesos, como habían imaginado Ken Thompson y compañía en los comienzos del Unix (recordemos, inspirado en parte, en los trabajos de Fano con el Multics). Tantos fork descontrolados, éramos tan jóvenes... ;-)... Y por supuesto, el kill. En una lista privada, el bueno de Daniel V envía este video:
Parece que es Stanford University, parte de un documental del estilo de vida de esta gente.
Otros videos:
El primer usuario
Un clásico: Windows Share Your Pain
Videos para programadores
Nos leemos!
Angel "Java" Lopez
http://www.ajlopez.com/
Hace un tiempo escribí sobre el libro The Pragmatic Programmer en:
Un programador pragmático
Los autores enumeran a lo largo del libro "tips", que van comentando y explicando en el contexto de otros temas. Visitemos hoy el primero. El Tip 1 es
Care About your Craft
Como desarrolladores de software, tenemos que tomar la responsabilidad de la calidad de nuestro trabajo. A veces, no están dadas todas las circunstancias para que podamos dedicar todo el esfuerzo a eso. Pero deberíamos buscar la forma.
Algunos piensan que el desarrollo de software es sólo ingeniería, que hay un proceso a seguir, y que simplemente hace falta poner a la gente a seguir el proceso, y voila! Cualquiera que haya dirigido un proyecto de software sabe que eso no es cierto. También veo tantos avisos pidiendo gente que conozca de tal tecnología o de tal otra, en vez de buscar gente que realmente quiera hacer las cosas bien.
Es importante que la gente que forme el equipo sean gente a la que le importe lo produce. Pensemos en las catedrales europeas, construidas en la Edad Media. Tomó miles de años-hombres construirlas, a lo largo de décadas de trabajo, entre varios oficios. No había Microsoft Project y nada por el estilo para organizar semejante trabajo. Una generación seguía a la otra, y aún se seguía construyendo. Pero, como dice el libro, aquellos que cortaban piedras, hacían algo más que eso. Recordemos una historia (versión en español de Enrique Zamorano, en su libro "Las causas del fracaso de las empresas"):
Tres canteros al pie de una catedral, que están haciendo el mismo trabajo: tallar piedras.
Un hombre se acerca al primero y le dice “¿Qué haces?”
El cantero le dice: “Tallo piedras” y la hosquedad de su mirada parece que añade: “¿No lo está viendo?”
El segundo responde diciendo: “Me gano la vida” y con su gesto de resignación parece añadir: “Es duro, ¿sabe usted?”
El tercer cantero, al escuchar la pregunta, levanta la cabeza, mira a lo alto, le brillan los ojos y dice: “Estoy construyendo una catedral”
Como dice el libro "From Good to Great", lo importante es tener la gente correcta, despues podemos construir lo que queramos: "Right People First". Esto se aplica aún más en los equipos ágiles: cuando tenemos un equipo de gente orgullosa de lo que está haciendo, sea un simple ejemplo, o la próxima "Big Thing" de la web, es cuando más brilla lo ágil.
Asegurémonos de formar un equipo, donde todos los que cortan piedras, vean una catedral.
Nos leemos!
Angel "Java" Lopez
http://www.ajlopez.com/
Este año cumplo treinta años con el desarrollo de software, así espero me permitan algunos posts nostálgicos, y algo personales. Hoy me da pie a escribir este post, una pregunta que me hicieron: ¿cómo surgió lo de Angel "Java" Lopez? ¿y por qué "ajlopez"?
Es simple. En los noventa, yo no tenía teléfono (en general no lo uso) en casa. Pero veía que cada vez más aparecían BBS. Mi primera visión de un modem fue en alguna Byte de los ochenta, y en el clásico film "Juegos de Guerra" (que habré visto varios veces en el mismo día). Así que comencé a comprar Boardwatch, contraté un teléfono para mi cubil, alguna placa o algo así para mi PC, y me sumergí en el mundo de los BBS. Recuerdo la FidoNet de aquel entonces. ¿Recuerdan los ASCII art de presentación? ¿Y el ruido del modem conectando? Eramos tan pobres... .;-)
El BBS más popular de aquel entonces para el tema de programación, por aquí en Argentina, resultó ser el de MP Ediciones. ¿Cómo se llamaba? ¿Feedback? Ya no recuerdo. La cuestión que para inscribirme tuve que ir a la editorial misma, en la calle Moreno, acá en Buenos Aires. Me preguntaron el nombre completo, y en aquel entonces, habituaban a poner como nick las iniciales y el apellido del usuario. Así quedó mi código de usuario: ajlopez.
En ese BBS, en 95/96, participaba yo en foros de programación, en general. Yo estaba viendo y estudiando Java, que acababa de aparecer. Para mí, Java fue un avance: un lenguaje que llevaba garbage collector y una librería de clases para las masas. Le faltaba un golpe de horno (AWT era para mí Asqueroso Windows Toolkit...;-), pero pintaba interesante.
De tanto predicar sobre Java en el BBS de MP Ediciones, y al ser firmar como ajlopez, Angel J Lopez, el bueno de Sebastián Barraza, otro usuario activo del BBS, me bautizó Angel "Java" Lopez.
De ahí el origen de ese nick más completo.
A partir de la actividad de MP Ediciones, se formó el Club Byte, que en algun momento se escindió, y se formó el Microsoft User Group, que ya va para los 13 años de existencia, creo.
¿Tienen algún recuerdo de esos tiempos?
Nos leemos!
Angel "Java" Lopez
http://www.ajlopez.com/
Gracias al Microsoft User Group de Argentina, ayer dí una charla sobre Scrum, explicando cómo funciona, y algunas experiencias que he tenido en diversos proyectos desde finales de 2006.
Para mí fue interesante poder exponer algunos temas que quería compartir, y bajarlos a la tierra, para que se entienda bien hacia donde va Scrum, y para que sirve. Dejo la presentación en mi Skydrive:
Scrum200801.ppt
Fuente: http://www.implementingscrum.com
Dentro de dos semanas, espero dictar un curso práctico, donde los asistentes se dividiran en grupos, para trabajar a la Scrum:
Práctica de Scrum
Algunos enlaces y recursos adicionales:
http://agilethinking.net/
El sitio de Tobias Meyer, que me inició en el ScrumMastering en el 2006.
http://agilemanifesto.org/
Manifesto for Agile Software Development
http://softwareagil.blogspot.com
El blog de Juan Gabardini, dedicado a Software Agil, en especial Scrum
Ágiles 2008
Se vienen las jornadas Agiles 2008, acá en Buenos Aires, Argentina.
http://www.implementingscrum.com/
Sitio donde encontraran la clásica historia:
The classic story of the pig and chicken
El libro que me sirvió de base para esta presentación
Agile Project Management with Scrum
by Ken Schwaber
ISBN:073561993x
Microsoft Press © 2004
De este libro he tomado estos recursos:
Agile Software Development with Scrum, Ken Schwaber and Mike Beedle (Prentice Hall, 2001)
Teoría y práctica de Scrum.
www.controlchaos.com/
El sitio de Ken Schwaber sobre Scrum.
http://www.jeffsutherland.com/
Jeff Sutherland tiene contenido relacionado con desarrollo de software, programación, tecnología, objetos, componentes y Scrum.
www.mountaingoatsoftware.com/scrum/
El sitio de Mike Cohn sobre Scrum.
www.scrumalliance.org
El hogar de los ScrumMaster certificados.
www.agilealliance.org
El sitio de la AgileAlliance, con recursos sobre Agile y Scrum.
http://groups.yahoo.com/group/scrumdevelopment/
El grupo de discusión de Scrum, con años de existencia.
www.xprogramming.com
El sitio de Ron Jeffries acerca de Extreme Programming (XP). XP provee varias de las prácticas que Scrum implementa para asegurar el incremento de funcionalidad potencialmente entregable.
Process Dynamics, Modeling, and Control, Babatunde A. Ogunnaike and W. Harmon Ray (Oxford University Press, 1994)
La teoría que subyace a Scrum.
The Alphabet Versus the Goddess, Leonard Shlain (Viking Penguin, 1998)
El conflicto entre las palabras y la imagen.
Wicked Problems, Righteous Solutions, Peter Degrace and Leslie Hulet Stahl (Yourdon Press, 1990)
A Universe of Consciousness, Gerald Edelman (Basic Books, 2000)
Por qué es tan difícil pasar de requerimientos a código.
Managing the Unknowable, Ralph D. Stacey (Josey-Bass, 1992)
Explicando las dificultades del manejo de la complejidad.
Complexity and Emergence in Organisations, Ralph D. Stacey (Routledge, 2000)
Una crítica de cómo la teoría de la complejidad ha sido aplicada para entender organizaciones y marcar nuevas direcciones. Este libro promueve un reexamen radical del pensamiento gerencial.
Artful Making, Rob Austin and Lee Devin (Prentice Hall, 2003)
Como manejar el trabajo creativo, adaptado del teatro.
Dejo más enlaces que colleciono en
http://del.icio.us/ajlopez/scrum
http://del.icio.us/ajlopez/agile
Nos leemos!
Angel "Java" Lopez
http://www.ajlopez.com/
En mi post del domingo pasado
Tato Bores y el desarrollo de software
no incluí a nadie de Python. Bueno, ya voy a agregar algo y de otros lenguajes y tecnologías. La semana pasada, el bueno de Daniel Ajoy pasó esta información en una lista dedicada al lenguaje Logo:
Inventa tu propio juego en Python
http://pythonbook.coffeeghost.net/
Según el autor Al Sweigart:
"Invent Your Own Computer Games with Python" is a free e-Book that teaches you how to program in the Python programming language. Each chapter gives you the source code for a new game, along with an explanation of how each line works.
IYOCGwP ("eye-yawk-gwip") is designed to be understandable by 9 to 12 year olds, although teenagers and adults with no previous programming experience can use it to teach themselves programming as well.
Se puede bajar en PDF o verlo en línea como HTML. Todavía no lo leí completo, pero por el vistazo que le di, parece interesante para comenzar a programar. Muchas veces me pregunta gente que no es "del gremio" cómo comenzar a programar. El lenguaje Python (bastante poderoso, ver también Ruby) puede ser usado a un nivel básico, sin necesidad de tener que aprender una sintaxis muy complicada. Con la llegada de estos lenguajes a las máquinas virtuales de Java y .NET, tenemos todavía más uso para estos "nuevos lenguajes", que igualmente tienen años de desarrollo.
Hoy, ya no somos "programadores del lenguaje X". Somos desarrolladores de software, con conocimientos de arquitectura, ingeniería de software, manejo de equipo, comunicación interpersonal, y actitudes ágiles. Aprender un lenguaje nuevo nos entrena la neurona y nos abre a nuevas perspectivas.
Nos leemos!
Angel "Java" Lopez
http://www.ajlopez.com/