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.