Reunión de Smalltalking, con Claus Gittinger y Smalltalk/X

 El sábado pasado, 13 de septiembre, asistí a la reunión de Smalltalking. Esta vez, la reunión fue un café cerca del edificion de la Biblioteca Nacional, aquí en Buenos Aires, Argentina. El grupo es pequeño pero entusiasta, y las discusiones fueron muy interesantes.

El primero en llegar fue Leonardo de Marco, que en estos días está cambiando su vida laborar, para dedicarse de tiempo completo al desarrollo de Smalltalk. Alejandro Reimonde, el “jefe” del grupo, llegó un poco más tarde de las 10hs. Otros miembros que asistieron fueron Esteban Lorenzano, Diego Coronel, Matías Castilla y Juan (sólo Juan, no tengo el apellido…).

Alejandro Reimondo es un referente en el campo del desarrollo en Smalltalk, conocido en el mundo, que ha trabajado desde hace décadas con esta tecnología. Es el fundador del grupo Smalltalking, dedicado a la difusión y discusión de desarrollo de software y más, con Ambientes de Objetes Virtuales. Ya había comentado por este blog sobre su actividad en el desarrollo de multitouch (ver Más sobre multitouch screen).

Esteban Lorenzano enseña arquitectura de proyectos IT, en la Universidad Tecnológica Nacional, de Buenos Aires. La página de la cátedra es:

http://apit.wikidot.com/

Es uno de los fundadores de la nueva empresa Smallworks, dedicada al desarrollo de software usando Smalltalk. Los fundadores son ex Snoop, entre ellos, veo a Evagenlista, al que conocí en algún curso mío hace años.

Diego Coronel tiene una compañía, Informagine (no dió el enlace, supongo que es http://www.informagine.com ), con trabajos para el estado argentina, usando Smalltalk, ahora está trabajando mucho con México. Vive en los dos paises. Curiosamente, Diego y Esteban conocían los mismo lugares de México DF, e intercambiaron impresiones sobre cómo es vivir en esa ciudad, y cómo México albergó y recibió a argentinos, tanto en los años difíciles del siglo pasado, como en este siglo, luego de la “debacle” de 2001.

Matías Castillas es estudiante, vino desde la La Plata (unos 70 km de Buenos Aires). Nos faltó otro platense, Elvio Fernandez, que esta vez no pudo asistir a la reunión. El año pasado, el bueno de Elvio fue anfitrión de otra reunión del grupo, donde hubo buenas charlas, discusiones, una raviolada, y algunas botellas de tinto, que muchos de los integrantes actuales estamos extrañando.

En esta reunión, como en otras, hubo varias discusiones, exposiciones, de distintos temas. Las reuniones no se organizan por temas y tiempo, o apenas, así que muchas veces derivan en temas que no se habían propuesto. Pero siguen siendo interesantes. Entre los temas discutidos estuvieron: la sustentabilidad del desarrollo de código abierto, la situación de la educaciónde objetos y conceptos de arquitectura en Argentina, la escasez de gente, en Smalltalk y otras tecnologías, la rotación de los desarrolladores en las compañías, y el alto salario que se ofrece a desarrolladores juniors, debido a la situación global del desarrollo, y el cambio peso/dólar en Argentina, que hace redituable el trabajo para el exterior.

Con respecto a la rotación, yo podría dar referencias de cómo no tener ese tipo de problema. Pero eso será tema de otros posts. En resumen: hay que dar el ambiente y los desafíos adecuados, para que la gente quiera seguir participando en la misma compañía. También, es importante elegir bien a la gente: es más importante tener la gente adecuada, con una actitud proactiva, y de constante aprendizaje y mejora, en vez de buscar “desarrolladores Java que conozcan Struts” o ese tipo de pedidos.

No se mencionó mucho sobre el tema de metodologías ágiles, que me parecen hoy por hoy, fundamentales para encarar el desarrollo con poca gente. He conocido casos de éxito (y también de fracaso) de excelentes desarrollo con poca gente. Incluso los fracasos enseñan qué tipo de proyectos y de gente necesitamos para avanzar, si tenemos una empresa o un grupo interno de desarrollo.

Alejandro comentó su viaje a Postdam, donde asistió a

Workshop on Self-Sustaining Systems (S3) 2008

The Workshop on Self-sustaining Systems (S3) is a forum for discussion of topics relating to computer systems and languages that are able to bootstrap, implement, modify, and maintain themselves. One property of these systems is that their implementation is based on small but powerful abstractions; examples include (amongst others) Squeak/Smalltalk, COLA, Klein/Self, PyPy/Python, Rubinius/Ruby, and Lisp. Such systems are the engines of their own replacement, giving researchers and developers great power to experiment with, and explore future directions from within, their own small language kernels.

Acá había posteado sobre el tema y el trabajo de Piumarta en:

Self-sustaining Systems, Cola, Pepsi, Coke y Mate

Alejandro comentó que le interesó el trabajo de Richard Gabriel, de IBM (su página personal y bio en Richard Gabriel personal page). Pueden ver el trabajo presentado por Gabriel en:

http://www.tele-task.de/page50_lecture3625.html

Esperamos que sea un tema a tratar en una próxima reunión de Smalltalking (con raviolada y pingüinos de tinto en lo de Elvio… ;-)

Pero la estrela de la reunión, fue Claus Gittinger, fundador de Exept Software AG, y creador de Smalltalk/X. Vino de Alemania, el viernes a la noche, por primera vez visita mi país. Pueden leer su perfil en LinkedIn, encontraran todos los trabajos del bueno de Claus, desde los ochentas. Ha trabajado en varias tecnologías y compañías. En 1995, funda Exept Software, que:

provides solutions, advice and consulting services in the Telecom, Automation, Automobile and other technology oriented software areas.
Products include a state of the art OO-development framework and environment (www.smalltalk-x.de) and frameworks for Test- and Qualitymanagement (www.expecco.de)

Claus se dedica a

Architecture, Project Management, Team Building and Leading, Coaching, Teaching, Testing, Test Management, Prototyping,
Programming Language Implementation, VM design & Implementation, Compiler Construction, IDE Design & Implementation, GUI Framework Design & Implementation, OS-Kernel, OO, Smalltalk, ESUG

También dicta cursos en una universidad de su país. Está visitando Argentina, acompañado de Félix Madrid, un desarrollador argentino que trabaja para Except en Alemania. Como escribía arriba, es la primera visita de Claus a la Argentina, espero que disfrute el viaje y la visita.

Smalltalk/X

Claus fue muy gentil, dedicándonos algunas horas a mostrarnos su trabajo, demostrarnos su producto  Smalltalk/X (noto en Claus el entusiasmo de alguien que ha creado algo y lo ha llevado hasta el nivel de producto, fundando una empresa alredor de ese primer producto). Su empresa se dedica a otros temas (como el testing a partir de un modelo), estas son características de Smalltalk/X (disculpen que no traduzca):

Smalltalk/X, a product from eXept Software AG, is a complete implementation of the programming language, class library and development environment, providing:

  • An object-oriented programming language
  • Graphic development environment with editors, browsers, debuggers, GUI builders, etc.
  • Incremental compilation, byte code interpreter and dynamic (just in time) compiler
  • Static compilation and DLL generation, controlled by make-files
  • Comprehensive class library with ready-to-use modules for applications
  • Open Smalltalk source code

Implementation of the language and class library complies with the draft ANSI standard and the industry standard.

Claus nos mostró la compilación de archivos .st (con código fuente de Smalltalk) a archivos .stc que contiene código C, que puede compilarse en varias plataformas (en Windows, podemos compilar el sistema completo usando Borland C, o con Microsoft Visual C++). De esta manera, podemos producir programas nativos ejecutables desde nuestro proyecto Smalltalk. Más características de la documentación:

ST/X Smalltalk is a complete implementation of the Smalltalk language. Smalltalk/X is not based on the original ST-80 virtual machine implementation and has been written from scratch. However, the API, class libraries and language semantic is highly compatible to ST-80 based smalltalks, such as VisualWorks, Squeak and others.

Smalltalk/X consists of both an integrated environment for program development AND a standalone smalltalk compiler(1), which generates true machine code, shared code libraries and binary executables without a need for a so called “image”. However, traditional image-based development is also supported and typically used for program development.

The programming environment includes editors, browsers, compiler and debugger and a large library of ready to use building blocks for application writers.
The standalone compiler generates true machine code from smalltalk source files – and can be used in a batch environment for production/delivery.

Features

  • Language syntax and semantic compatible to the industry standard, including arbitrary precision arithmetic and automatic number conversion, exception handling, automatic memory management, threads, contexts, blocks (block closures), metaprogramming and much more.
  • Additional (mostly backward compatible) extensions to the smalltalk language include: private classes, multiple namespaces, method privacy and end of line comments.
  • A comprehensive threadsafe library of basic classes, including collection classes, numeric classes, streams, lightweight processes, exception handling and metaclass hierachy.
  • Many user interface widget classes usable as building blocks for graphical applications. These are fully (non-polling) event driven, multithreaded and support multiple displays, parametrized view styles, wide characters (unicode) and national languages.
  • Integrated programming environment including browsers with sophisticated refactoring and code generation support, GUI- and Menu builders, monitors and symbolic debugger for efficient program development.
  • The additional Scripting Engine allows for command-line execution of smalltalk scripts. These script files can be generated by any other editor, or alternatively by saving code from the IDE (file-out from the browser).
  • Debug once – run everywhere !
    complete Source- and Byte-Code compatibility between Unix and Windows versions. Write your application once, run it without change on Win-NT, Linux, Alpha-OSF, Sun-solaris, HPUX, AIX, Silicon-Graphics IRIX(4).
  • Many demo and ‘how-to’ example programs
  • Online HTML documentation and class documentation generator, visualized by the ST/X HTML document viewer.
    Well documented classes and methods.
  • Very liberal licensing conditions

Implementation hilights

  • Incremental compilation to internal bytecodes for short turn around cycles during development.
    Binary files containing bytecode are portable across different machine architectures.
  • Dynamic (just-in-time) compilation from internal bytecodes to machine code (2).
    Except for the faster execution, this is transparent to the program or user.
  • Batch compilation to real machine code for high performance production code, enabling the creation of binary object modules, class libraries or even shared class libraries.
    Since more optimizations and code analysis are performed by this (offline) compiler, the resulting code executes faster – even when compared to dynamic compiled machine code.

    Although static compiled machine code leads to bigger executables, the main advantage (beside faster execution) is the deterministic runtime behavior, which cannot always be guaranteed, if bytecodes are compiled dynamically at execution time.
    In addition, big applications benefit from static compilation by the sharability of this compiled code among multiple applications, if shared libraries and/or shared text segments are supported by the operating system.

    Applications can (and do) use a mix of precompiled machine code classes and interpreted bytecode classes – this is transparent to the program or programmer.

    If supported by the operating system (3), machine compiled modules can be dynamically added to and removed from the running system.

  • Easy creation of standalone executables and applications without graphical user interfaces. This includes self-extracting installation code for windows platforms (null-soft self installing executables).
  • Easy binding to C-language by allowing inline c code (even inline assembler by using asm statements) or via the ffi-callout mechanism to dynamically loaded shared libraries (dll’s).
  • Sophisticated window interface combining event and process driven techniques.
    ST/X supports multiple display devices – you can work with others in the same object environment, or write applications which serve multiple screens.
    Your application can even run on a display-less host, serving multiple xTerminals or client applications via TCP connections.
  • Additional protocol provided in the process, semaphore and processor classes, for better thread synchronization. ST/X’s process handling includes additional mechanisms for recovery (semaphore cleanup) in exceptional situations, which is required in technical applications. The ST/X’s process scheduler supports timeSlicing and dynamic thread priorities. This allows for better response behavior in multiwindow applications and allows progress of background processes even in case of busy foreground processing.
  • Modern generational garbage collector, with dynamic adjustable newSpace, adaptive tenuring, both incremental and non-incremental collectors for the oldSpace, both copying and non-copying compressors for the oldSpace.
  • Object finalization via the WeakArray mechanism; in addition, a number of other collection classes are available with weak references (WeakSet, WeakDictionary etc.)
  • Both ANSI compliant class based exceptions and (VW-) backward compatible Signal-based exceptions are supported.
    In addition, process specific and global default exception handlers are avaliable, to allow for non scoped, global exception handling.
  • The byteCode interpreter and just-in-time compilers support multiple bytecode sets, for total integration of different languages into a single unified system.
    In the current release, this feature is used to support execution of compiled Java code.

Claus también mostró que se puede compilar al vuelo, en el entorno de desarrollo. Uno puede escribir un método, y se traduce a los bytecodes clásicos de una máquina virtual Smalltalk. Pero durante su ejecución, esos bytecodes se compilan a código nativo.

Es aquí donde atiborré de preguntas al paciente de Claus. Su implementación se desvía de una implementación clásica de Smalltalk, no es una implementación como otras. Esto para mí es interesante, así que pregunté en detalle algunos temas.

Smalltalk/X no usa una tabla de objetos, con lo cual cada objeto apunta directamente a otros objetos. Esto facilita algunas cosas, pero complica otras, como el ajuste de los “punteros” durante el proceso del garbage collector (garbage collector), la implementación de become: es prácticamente difícil (no ví todavía si consigue implementarlo Smalltalk/X), y el garbage collector tiene que tomar control en algún momento, para ajustar todos los objetos. El garbage collector es un mark and sweep, con copy de objetos. No usa generaciones de objetos, aunque mantiene un age en la cabecera de cada objeto. (Corrección, el bueno de Claus me comenta en Smalltalking meeting, with Claus Gittinger and Smalltalk/X que lo de mark and sweep, es sólo una de cuatro estrategias, y se aplica solamente a los objetos viejos).

Podemos bajar los binarios del sistema, o podemos bajar el CVS de la compañía (esten preparados para un download con tiempo: son más de 20000 files, >180 megas, a mí me tomó algunas horas de bajada).

Como notan, estuve muy interesado en los detalles de implementación de la VM. Me interesó desde siempre la construcción de ese tipo de sistemas, pueden leer algo de lo que estoy haciendo con mi trabajo en progreso sobre el AjTalk en AjTalk- un intérprete tipo Smalltalk). Algo interesante: como genera código C, en los archivos .st se pueden incluir fragmentos de ese lenguaje, además de llamadas a las clásicas primitivas. Por ejemplo, en el archivo Object.st, que define la conducta de Object, encuentro:

basicAt:index
"return the indexed instance variable with index, anInteger..." ... %{ /* NOCONTEXT */ REGISTER int nbytes, indx; OBJ myClass; REGISTER char *pFirst; REGISTER int n; ... if (__isSmallInteger(index)) { myClass = __qClass(self); indx = __intVal(index) - 1; n /* nInstVars */ = __intVal(__ClassInstPtr(myClass)->c_ninstvars); n /* nInstBytes */ = OHDR_SIZE + __OBJS2BYTES__(n /* nInstVars */); nbytes = __qSize(self) - n /* nInstBytes */; pFirst = (char *)(__InstPtr(self)) + n /* nInstBytes */; ... }%

Despues de pasearlo por temas de implementación, Claus nos siguió mostrando temas del entorno gráfico de desarrollo, con los clásicos workspaces, browsers, implementados directamente en Smalltalk. El producto de Claus maneja directamente distintas implementaciones GUI, sean Windows, Unix, Linux, y demás. Desde un entorno GUI que trae el producto, podemos definir controles, formularios, asociarlos a métodos. También hay soporte de MVC (Model View Controller), donde rápidamente el valor de un control puede modificar el modelo, y su cambio se refleja en otros controles, si queremos. Claus igual comentó que los controles los tienen que diseñar ellos, cuando en el mercado aparece un nuevo tipo de control, por ejemplo, una grilla, ellos no la aprovecha, sino que la implementan en su base de código. Eso permite que ese nuevo control, automáticamente esté disponible en todas las plataformas donde ejecuta Smalltalk/X. Pero imagino que se complica estar al día en el desarrollo de widgets gráficos.


También mostró un servidor HTTP. Con el servidor HTTP funcionando, uno puede definir clases que atiendan pedidos por URL. Implementamos un método que recibe un objeto request, de ese objeto obtenemos un response, y con éste, comenzamos a emitir el contenido del documento, generalmente un HTML. No llegué a ver el soporte que tiene de controles dentro de una página. No llegué a probar eso en mi máquina todavía, y no vi “screenshots” en el sitio de Exept.


Independientemente de Smalltalk/X como producto, si estan interesados en Smalltalk, pueden visitar la página de enlaces y la de documentación (con libros sobre Smalltalk, para bajarse libremente).


Gracias desde acá a Claus Gittinger, por dedicarnos tiempo y compartir su conocimiento con todos. Fue una interesante reunión. Claus es alguien que cumple con el mindset Don’t be a canuto.


No estuve hasta el final (tuve que ir a dar mi charla de Microsoft Robotics, en Puerta 18, más datos en Robótica en Puerta 18). Una de las últimas preguntas mías a Claus, fue si usan metodologías ágiles en su empresa. Contestó que sí, pero hubiera sido interesante conversar más en detalle. (Curiosamente, uno de mis contactos en LinkedIn que me unen a Claus, es el bueno de Tobias Mayer, que fue mi entrenador en Scrum).


Espero que tengamos por lo menos una reunión más este año de Smalltalking. Tengo minutas de otras reuniones anteriores, tengo que pasarlas en limpio, ya aparecerán por aquí en formato post. Ya conocen el otro mindset: Lo que no está escrito, no existe. ;-)


Nota adicional: Alejandro, en ánimo turístico, nos comentó sobre el monte del infierno, en las afueras de Berlin. Pueden ver la ciudad desde ese “monte” artificial, armado con los escombros que quedaron al final de la segunda guerra mundial, desde


http://www.panoramio.com/photo/7847858


También comentó sobre Praga, una ciudad que no fue afectada por bombardeos, y no tuvo que ser reconstruida:


http://www.panoramio.com/user/592876/tags/Praga


Nos leemos!


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

This entry was posted in 3462. Bookmark the permalink.

Leave a Reply

Your email address will not be published. Required fields are marked *

You may use these HTML tags and attributes: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>