Persistencia (y ¡fin!)

Persistencia transparente

El mecanismo de persistencia funciona ya al 100%. Es posible que tenga algún bug, pero el trabajo en sí está hecho.

Trabajar con persistencia es muy, muy sencillo en Zero. Se trata de almacenar los objetos que se desee en un contenedor, y ya está.


reference disney = Container.createChild( "Disney" )
reference donald = Persona.createChild( "donald" )
reference daisy  = Persona.createChild( "daisy" )

donald.ponNombre( "Donald" )
daisy.ponNombre( "Daisy" )

disney.add( donald )
disney.add( daisy )
psRoot.add( disney )


Ésto hará que el contenedor disney, que cuelga del contenedor raiz del almacenamiento persistente (psRoot) se guarde con los objetos que contenga. Una vez éste proceso termina, y el contenedor está por tanto guardado en el almacenamiento persistente, es posible recuperarlo mediante la referencia simple, en otro proceso:


System.console.write( psRoot.Disney.donald.toString() )


... ¡y ya está! ... persistencia cuasi-ortogonal, es decir casi 100% transparente, si no fuese porque hay que elegir el contenedor donde guardar los objetos, pero eso no se considera un problema, sino de hecho, una ventaja sobre el modelo ortogonal puro.

En cuanto a interioridades técnicas, el almacenamiento de contenedores se hace en directorios. Así, el directorio del almacenamiento persistente es ZeroPS y contiene siempre al contenedor raíz.


$ cd ZeroPS
$ dir
Root
Root.zbj

$ cd Root
$ dir
Disney
Disney.zbj
IntStdLib.zbj


Los archivos *.zbj son los archivos de objetos Zero, que pueden lógicamente desensamblarse con la herramienta zd.

Este esquema de funcionamiento tiene varias ventajas: el almacenamiento persistente es manipulable, si se compila un objeto y se coloca en uno de los directorios, automáticamente ese objeto será encontrado por la máquina virtual si es referenciado como si siempre hubiera estado allí. Así, el almacenamiento persistente es manejable y no hay por qué tener miedo a una corrupción masiva ni nada por el estilo.

Persistencia

El desarrollo de persistencia está empezando a dar sus frutos.

Zero ya persiste ... es capaz de crear su PS si no existe, y hacer bootstrapping contra él si existe, además de guardarse ordenadamente, claro.

Los algoritmos de persistencia no involucran ni un solo algoritmo recursivo.

La prueba se hizo con dos programas, uno que guarda algo en el PS, y otro que espera encontrarlo allí (en ensamblador Zero):


OBJ Persona
ATR + nombre "juan"
ATR + email "juanillho@mixmail.com"

MTH + toString
MSG nombre toString
ASG __rr

STR ": "
MSG __rr concat __acc
ASG __rr

MSG email toString
MSG __rr concat __acc
ASG __rr

RET
ENM
ENO



OBJ PruebaPersistente ConsoleApplication
MTH + doIt
STR "\nComenzando guardado ...\n"
MSG System.console write __acc

SET __gp1 Persona
STR "Persona"
MSG . addAttribute __acc __gp1

STR "\nGuardado de manera persistente\n"
MSG System.console write __acc
RET
ENM
ENO


El segundo programa símplemente accede a Persona para obtener sus datos ...

---

OBJ VerPruebaPersistente
MTH + doIt
MSG System.console lf
SET .Persona
MSG System.console write __acc
MSG System.console lf
RET
ENM
ENO


Y la salida, después de ejecutar ambos, es:


Uncaught exception:
Persona threw EObjectNotFound: in Persona.toString(): _0_10000_1132255372_1311514264_A


De acuerdo :-), no es exactamente lo esperado, pero persona ya puede ser guardado y recuperado sin problemas, excepto algún detalle que habrá que seguir puliendo.

Programación por contrato

Zero, a través de su lenguaje de programación de alto nivel Prowl, soporta ya programación por contrato.

---

object ProgrPorContrato

method + dividir(a, b)
{

requires {
assert( a isInstanceOf Int, "Dividendo no numérico." );
assert( b isInstanceOf Int, "Divisor no numérico." );
assert( b != 0, "Divisor no puede ser 0" );
}

enforce {
assert( toret isInstanceOf Int, "Resultado no numérico (?)" );
}

reference toret;

toret = a / b;
return toret;

onException( e ) {
if ( e isInstanceOf EAssert ) {
System.console.write( e.getMessage() );
}
else System.console.write( "FATAL: Error interno" );
}
}
endObject


Herencia dinámica

Muchas cosas empieza a funcionar ya en Zero. Por ejemplo, el nuevo lenguaje Prowl (no se puede decargar todavía) que soporta herencia dinámica de una manera mucho más intuitiva. El siguiente código lo ejemplifica.


// Dinamica.pwl

object Persona
attribute + nombre = "juan";
attribute + salario = 18000;

method + toString()
{
return nombre.concat( "\n" );
}

method + ponSalario(s)
{
salario = s;
return;
}
endObject

object Empleado : Persona
method + toString()
{
return nombre.concat( " (empleado)\n" );
}
endObject

object Directivo : Persona
method + toString()
{
return nombre.concat( " (directivo)\n" );
}
endObject

object EmpleadoEmpresa : Empleado( salario < 20000 ),
Directivo( salario >= 20000)
method + toString()
{
return super();
}
endObject

object Dinamica : ConsoleApplication
method + doIt()
{
reference miEmplEmpt = EmpleadoEmpresa.copy("");

System.console.write("\nEjemplo Dinámica\n");

System.console.write( miEmplEmpt.toString() );
System.console.lf();

miEmplEmpt.ponSalario( 30000 );

System.console.write( miEmplEmpt.toString() );
System.console.lf();

return;
}
endObject


---
Con la siguiente salida:

Ejemplo Dinámica
juan (empleado)

juan (directivo)


Exceptuando a Cecil, que tiene algo parecido, creo que no existe nada igual, además Cecil a) es un lenguaje declarativo y b) es para clases.

Traducido el tutorial sobre VZero al inglés

Ahora, desde la página del tutorial Zero, ya es posible acceder a la versión en inglés. Desde la parte superior del tutorial, un enlace nos conducirá a la versión inglesa, y un enlace similar en la versión inglesa conduce a la española.

También es posible acceder a este tutorial traducido desde la página principal de Zero, desde el menú de la izquierda. El enlace en español nos llevará al tutorial en español, mientras el enlace en inglés nos llevará al traducido.

El tutorial de manejo de Visual Zero es realmente interesante, puesto que a) enseña a manejar la máquina virtual Zero con interfaz visual, lo cuál es realmente interesante para estudiantes de ingeniería informática, para los que va especialmente dirigido este proyecto; y b) el tutorial enseña cómo crear objetos; atributos y métodos; y como modificar atributos ya existentes. Además, explica cómo se programa desde un punto de vista genérico en un sistema que sigue el modelo de orientación a objetos basado en prototipos, y, especialmente, como utilizar de forma útil la herencia dinámica.

Vuelta de vacaciones

Los esfuerzos en la obtención del módulo de persistencia están dando ya su fruto: está terminado en un 60%. También se está desarrollando el módulo de optimizaciones.

Varios bugs corregidos, y la capa de optimización también va mejorando día a día. Se está añadiendo la posibilidad de marcar métodos y objetos con etiquetas (como en C#).


Dos compiladores de lenguajes de alto nivel están ya en camino: uno, J--, es un subconjunto de Java, mientras el otro es más parecido a Smalltak y Self.

Optimización

Aunque el módulo de persistencia debería estar ya completado, se ha visto retrasado por un repentino interés en un nuevo módulo de optimización de código.

Las optimizaciones consisten en a) mover los datos nativos (proporcionados por los opcodes INT, FLT y STR), b) tratar de reducir los movimientos redundantes entre registros, y c) resolver los saltos a etiquetas,

Visual ZVM

Publicada la versión 2.0.61, que corrige algún pequeño error en la versión 2.0.6 y añade respecto a la 2.0.5 un entorno que permite crear objetos, atributos y métodos; compilar métodos y cambiar el objeto al que apunta un atributo; y finalmente explorar el espacio de contenedores de Zero de una manera excepcionalmente interactiva, como Self.


Cambios en el web: se añade un tutorial para el entorno, se completan las publicaciones y se actualizan los pantallazos.

Más ejemplos y mejor web

Una gran actualización: se ha mejorado la web, incorporando ahora ejemplos y un nuevo manual de documentación (la documentación nunca es suficiente). En cuanto a la máquina virtual, ahora dispone de reflexión estructural (antes sólo para atributos, ahora incluso se pueden compilar nuevos métodos en tiempo de ejecución), y se han pulido varios pequeños errores.

También hay una nueva sección de publicaciones.

Algunos ejemplos en Zero.

Reflexión estructural

La reflexión estructural consiste en poder consultar atributos y métodos de un objeto (introspección), y además, poder cambiarlos.

Lo más complicado es permitir cambiar (es decir, recompilar) los métodos, y ésto supone que el compilador debe estar dentro de la máquina virtual, lo cuál supone una pequeña reorganización del código.

Con la nueva versión ya publicada en la web, se pueden hacer cosas así:


__this.addAttribute( "color", "black" )

__this.addAttribute( "doors", 4 )

reference args = VectorInstance.copy( "" )

__this.addMethod( "f", args )

__this.compileToMethod(

          __this.getMethodNumberByName( "f" ),

          "STR \"¡Hola!\"\nMSG System.console write __acc\nRET"

)