Source code published

I have released the source code of the Zero programming system today.

Yes, I'm afraid that means this project is ended. I won't develop it anymore. This does not mean that it would not be possible to develop interesting tasks of polishing, improvement and new functionality. However, you have to say enough at some time, and actually the subject that motivated this software is not even active anymore.

And it should be noted that the software is good enough, i.e. it can be used for what it was initially designed (though it is true that the Prowl and J-- compiler could use a rewriting), and its inner workings can be perfectly shown.

Actually the source code contains a folder called prowlc, which is a true multiplatform compiler. Unfortunaltely, it is not complete, as it lacks decision and looping structures.

This has been an interesting story, in which I've learned a lot. I've learned it so well that I am perfectly sure I wouldn't had started this project if I knew (like today I know) the amount of work needed. I've also realised the problems related to multiplatform software: problems will arise there where you would not expect them to happen.

In the end, the important thing is that his software has accomplished its designed task. And probably, it will be useful for a few years still to come.

Código fuente liberado

Hoy he puesto el código fuente de Zero a disposición de cualquiera que le interese.

Sí, esto significa que este proyecto está acabado. No seguiré desarrollándolo. Esto no quiere decir que no se pudieran hacer labores interesantes de pulido, de mejora, y sobre todo, añadirle más funcionalidades. Sin embargo, en algún momento hay que decir basta, y lo cierto es que ya ni siquiera la asignatura que motivó este software está en activo.

Y en cualquier caso, el software es "suficientemente bueno", esto es, se puede usar para lo que se diseñó inicialmente (si bien los compiladores Prowl y J-- necesitarían una reescritura) y se puede mostrar el funcionamiento perfectamente.

El código incluye una carpeta prowlc, que es un compilador multiplataforma real, a medio escribir, es decir, es perfectamente funcional pero no soporta estructuras de decisión y repetición.

Ha sido una anadadura interesante, en la que he aprendido muchísimo. Tanto, que estoy perfectamente seguro que de saber inicialmente el trabajo que supondría, no lo habría abordado. También me ha permitido darme cuenta de las penalidades involucradas en crear software multiplataforma: las vías de agua surgen allí donde menos te lo esperas.

En fin, lo importante es que el software ha cumplido, y seguirá cumpliendo durante al menos algunos años más, su cometido.

Pooi

Aunque no está directamente relacionado con Zero, sí está relacionado con la programación basada en prototipos, por lo que he pensado que merecía la pena comentarlo aquí.

Pooi es un intérprete de objetos basados en prototipos. Lleva bastante tiempo en desarrollo, aunque justo hasta ahora no soportaba métodos... ¡Ahora está completo!

Hay también disponible un tutorial sobre Pooi, que permite adentrarse en este interesante mundillo.

Pooi

Though not directly related to Zero, it is related to object-oriented, prototype-based programming, so I think it can be interesting.

Pooi is a prototype-based object-oriented interpreter. It has been in development for a while, and until now it did not support methods. Now is complete! There is also a nice tutorial to follow available.

Persistencia en Zero

He actualizado el tutorial (también práctica de la asignatura Tecnología de Objetos de la ESEI), sobre persistencia cuasi-ortogonal en Zero.

El tutorial ahora incluye un nuevo ejemplo, mucho más sencillo, como introducción, y explica cómo se pueden guardar objetos con un programa y recuperarlos con otro, y, aprovechando la existencia de la excepción EObjectNotFound, fusionar ambos programas en uno, como de hecho hace la agenda telefónica, presente al final del tutorial.

La implantación de persistencia, y su uso educativo como muestra de cómo debería haberse implantado persistencia mediante sistemas operativos orientados a objetos, son la verdadera razón de ser del sistema de programación Zero. La mayor influencia sobre Zero para su sistema de persistencia proviene de Barbados. El PS (almacenamiento persistente) se divide en contenedores, que guardan los objetos como si de directorios se tratase. El objetivo es no padecer el problema de que los spaghetti pointer hagan que sacar un solo objeto del PS suponga llevarse, eventualmente, todos los objetos residentes en él.

El tutorial comienza con un primer ejemplo muy sencillo, que se reproduce a continuación.

Supóngase que se desea almacenar un objeto como el punto:

object Punto
    attribute + x = 0;
    attribute + y = 0;
   
    method + set(a, b)
    {
        x = a;
        y = b;
       
        return;
    }
   
    method + toString()
    {
        reference toret = x.toString();
       
        toret = toret.concat( ", " );
        toret = toret.concat( y.toString() );
       
        return toret;
    }
endObject

Así, para guardar un objeto en el almacenamiento persistente es necesario crear un contenedor, e introducir el objeto en él.

       object GuardaPunto: ConsoleApplication
            method + doIt()
            {
                reference p = Punto.createChild( "p" );
                reference c = ContainerInstance.copy( "PruebaPunto" );
                   
                // Rellenar el punto
                p.set( 100, 150 );
                   
                // Hacerlo persistente
                c.add( p );
                psRoot.add( c );
                   
                return;
            }
        endObject

Lo lógico sería hacer ahora un programa para recuperarlo, aunque sucede que este programa es extremadamente sencillo:

            object RecuperaPunto: ConsoleApplication
                method + doIt()
                {
                    System.console.writeLn( psRoot.PruebaPunto.p );
                   
                    return;
                }
            endObject

Resulta mucho más lógico y coherente fusionar ambos programas en uno, aprovechándose del hecho de que se lanzará una excepción si no se encuentra el objeto en el PS, pasando por tanto a crearlo.

 object RecuperaPruebaPersistenciaPunto: ConsoleApplication
    method + crea()
    {
        reference p = Punto.createChild( "p" );
        reference c = ContainerInstance.copy( "PruebaPunto" );
       
        // Rellenar el punto
        p.set( 100, 150 );
       
        // Hacerlo persistente
        c.add( p );
        psRoot.add( c );
       
        return;
    }
   
    method + recupera()
    {
        return psRoot.PruebaPunto.p;
       
        onException( e ) {
            System.console.writeLn( "Creando punto..." );
            this.crea();
            return psRoot.PruebaPunto.p;
        }
    }
   
    method + doIt()
    {
        System.console.writeLn( this.recupera() );
        return;
    }
   
endObject

The history of Zero

It is curious how fast time goes by. I started Zero in 2003, with the assembler and bytecode specifications, and the next year, around this dates, Zero will turn 10.

The development of Zero is not competely stopped. I still have the PROWL compiler very present, obtaining a lot more stability and portability, specially with Windows 7 (it seems that with Win7 it does not feel comfortable, in contrast to the Linux version, maybe the first example of a non-deterministic program). It is nevertheless true that the system is quite complete since a few years ago, and it has been used for the practices part of an undergraduate subject, as a multilanguage, programmable systems offering dynamicity and persistence. Students have also volunteered with exercises written in PROWL, such as polish calculator, interactive fiction, etc.

The question I have been more frequently asked during these years is about the VM's registers... why so few? The answer is that, when I designed it, I was trying to make it as minimalist as possible, and that within the reasonable, to be as simple as possible so its characteristics and registers could easily be mapped to the x86 family, with a possible JITter in mind. So, it presents the __ip, i.e., the program counter, hidden but modified by JMP, JOT and JOF; __exc holding a reference to the object describing the exception thrown. It could be used as a generic, extra register, but this would be more hacking that anything else. The accumulator, or __acc, working as in x86, since the result of any assembler opcode goes there (I was however, more romatically inspired by the Z80; this chip derives from the 8080, and that is the father of the x86 family ).

There are four general purpuse registers, abbreviated as gp: __gp1, __gp2, __gp3 and __gp4. Finally, the __rr register holds a references to the result returned by a given method. This register is of course manipulable during the method execution, provided that the it holds the final result at the end of the method (it is directly set by RET, which must be the last instruction in the method).

The programmer can also count with __this, which references the object executing the method (not the method containing the method, that's another, rather different concept). It won't be a good idea to manipulate that, unless you exactly now what you're doing.

The meaning of general purpose for registers has something anecdotical: the now famous jeep of the USA army during WWII have their name deriving from exactly "general purpose" -> "gp" -> "jeep". Actually, the name of this cars does not mean anything specific. The name of the Zero's registers then is general purpose 1, general purpose 2... and for me, just jeep1, jeep2...

Anécdotas sobre Zero

Es curioso como pasa el tiempo. Comencé Zero en el 2003, con la especificación del ensamblador y del bytecode. El año que viene serán ya 10 años los que se cumplan desde aquel nacimiento.

El desarrollo en Zero no está parado del todo, sigo teniendo muy presente el compilador de PROWL, que proporcionará muchísima más estabilidad, y compatibilidad con Windows 7 (parece que con Win7 no acaba de funcionar bien, en contraste con Linux, es el primer ejemplo de programa no determinista). Lo que sí es cierto es que hace ya algunos años que el sistema está ya lo bastante completo como para que se utilice en las prácticas de la asignatura, como un ejemplo de sistema programable multilenguaje que presenta dinamicidad y persistencia. Los alumnos también lo han utilizado, creando prácticas como aventuras conversacionales, calculadoras polacas, etc.

Una de las preguntas que más me han realizado a lo largo de estos años es sobre los registros... ¿por qué tiene tan pocos? La respuesta es que, cuando la diseñé, pensaba en que fuera lo más minimalista posible, y que, dentro de lo razonable, pudiesen mapearse con facilidad los registros de Zero a los registros de la arquitectura x86 (pensando en un futuro JITer). Así, tiene los siguientes registros: __ip (contador de instrucciones, que es oculto pero modificado por JMP, JOT y JOF), __exc, que lleva la referencia al objeto de descripción de excepciones cuando se produce una (se podría usar de manera genérica, aunque eso ya sería más para hacking que para cosas normales). El __acc, el acumulador, que funciona efectivamente como en un 486, ya que el resultado de cualquier operación va ahí (aunque yo me inspiré más en un Z80 de Zilog cuando lo diseñé, quizás por algún sentimiento romántico [por otra parte, el z80 "viene del" 8080, y el 8080 es la base de todos los 80x86, especialmente el 8086).

Hay cuatro registros de propósito general (general purpose), ó gp: __gp1, __gp2, __gp3 y __gp4. Finalmente, el registro __rr lleva la referencia a devolver por un método. También se puede manipular durante la ejecución de un método, siempre que al final tenga lo que se quiere devolver.

También está __this, que señala al objeto que está ejecutando el método. No creo que sea muy buena idea manipularlo, a no ser que se sepa exactamente lo que se está haciendo.

Por cierto, lo de "general purpose" tiene un significado anecdótico: los famosos jeep del ejército estadounidense deben su nombre a "general purpose" -> "gp" -> "jeep". En realidad, es un coche sin un nombre realmente significativo. Así, para mi "__gp1" es "jeep1", "__gp2", es "jeep2"... etc.

The scite-bin-* package has been updated, and the color schema improved, with a better (monospaced) font.

Actualizado el paquete scite-bin-*, de tal forma que se ha actualizado tanto el editor como el esquema de colores y la fuente utilizada, ampliamente mejorada.

Prowl 2.0

The development of the new Prowl compiler is steaming at good pace, only lacking:

- decission: if
- loops: for, foreach, do... while y while.
- Dynamic inheritance.

It is already fully implemented:

- definition of local references
. messages
. assignments

It is able to compile most programs except those with loops and decisions