Quercus es una implementación de PHP 5.2 escrita totalmente en Java, algo similar al famoso Hiphop de facebook sólo que en lugar de un traductor a C++ se trata de un intérprete PHP que corre en Java.
Se ha oído hablar mucho menos de Quercus que de HipHop pero es probable que Hiphop no llegue a utilizarse tanto como ya se está utilizando Quercus.
¿En qué casos puede ser interesante utilizar Quercus?

• Desplegar aplicaciones web en entornos muy controlados donde sólo se acepta Java o en plataformas cloud computing que no soportan PHP pero sí Java (Google App Engine).
• Necesitar cierta mejora en rendimiento que puede suponer utilizar Quercus en ciertas situaciones.
• Desplegar scripts PHP encapsulados en una aplicación Java.
• Utilizar PHP como motor de scripting de una aplicación Java, desarrollando el frontend por ejemplo en Swing y dejando el trabajo sucio para los scripts PHP.
• Integrar aplicaciones PHP desde Java. (Alfresco lo utiliza).
• Estás aburrido, probar por curiosidad.

Este post se compone de dos partes. En la primera veremos cómo correr un wordpress sobre Quercus y en la segunda introduciré una prueba de concepto de uso de Quercus en el escritorio.

1. Wordpress sobre Quercus.

• Descargamos Resin 3.1, la versión opensource del paquete que incluye Quercus junto a un servidor web.

  wget http://www.caucho.com/download/resin-4.0.6.tar.gz

• Descargamos wordpress:

  wget http://wordpress.org/latest.zip

• Descomprimimos Resin:

  tar xvzf resin-4.0.6.tar.gz

• Ejecutamos resin:

  sh resin-4.0.6/bin/resin.sh  start

• Podemos visitar http://127.0.0.1:8080/
• Ahora, sorpresa tratándose de Java , toca editar algo de XML:
  Copiamos lo siguiente en un fichero resin-web.xml colocado en webapps/ROOT/WEB-INF/:

<web-app xmlns="http://caucho.com/ns/resin">
   <servlet-mapping url-pattern="*.php"
                    servlet-class="com.caucho.quercus.servlet.QuercusServlet">
   </servlet-mapping>
</web-app>

PHP Version => 5.2.0
System => Linux 2.6.31-14-generic i386
Build Date => 20100413T085542
Configure Command => n/a
Server API => CGI
Virtual Directory Support => disabled
Configuration File (php.ini) Path => null
PHP API => 20031224
PHP Extension => 20041030
Debug Build => no
Thread Safety => enabled
Registered PHP Streams => php, file, http, https

sh resin.sh restart

Ya lo tendremos funcionando, 100% Java, 0% Zend, pero PHP al fin y al cabo, no ha hecho falta cambiar ni una línea de Wordpress.

2. QuercusFun, prueba de concepto de aplicación Swing y CLI con Quercus.

En github ya existe una prueba de concepto de integrar quercus sin servlet, es decir, como aplicación de escritorio: ( http://code.google.com/p/phpandallthat/#Detached_Quercus ) pero no es funcional debido a que no autocarga los módulos con lo cual las funciones de php no están disponibles y tampoco cuida otros aspectos como que los scripts no den timeout demasiado pronto. Es decir, en la práctica no funciona.

Mi aportación se llama “QuercusFun” y se trata de una aplicación que se puede ejecutar tanto con GUI (Swing) como desde línea de comandos… y funciona.

A continuación pantallazo y enlaces tanto al repositorio donde he subido el código como a un JAR.

Bajar quercusFun.jar

Para ejecutar como CLI:

java -jar quercusFun.jar fichero.php

y para ejecutar con GUI

java  -jar quercusFun.jar

Repositorio en GITHUB: http://github.com/ivmos/QuercusFun

En este primer post veremos en profundidad cómo se trabajan las variables en PHP y su idiosincrasia.

El PECL que he desarrollado para el mismo se llama “ejemplovars” y aporta las siguientes funciones:

• ejemplovars_print_type($variable)
• ejemplovars_print_refcount($variable)
• ejemplovars_dump_globalsymtable
• ejemplovars_dump_currentsymtable

Algunas cosas que veremos ya se trataron en otro post pero he preferido retomar el tema desde el principio.
.

El zval

PHP es un lenguaje de tipado débil, esto implica que se realizan un montón de conversiones implícitas entre los tipos de valores hasta el punto que desde el punto de vista del programador PHP puede dar la impresión de que en lugar de haber tipos las cosas funcionan mágicamente.

Los datos en php se almacenan en una estructura de datos llamada “zval” (Zend Value). Podemos encontrar esta estructura en “Zend/Zend.h”.

Podemos ver que un zval está compuesto por 4 miembros: value, refcount, type y is_ref. refcount es un unsigned integer mientras que type y is_ref son unsigned char.
El miembro “value” sin embargo es una estructura union. La diferencia entre un struct y una union es que sólo ocupa lo que necesite el miembro más grande de la union, en lugar de reservarse memoria dedicada a cada uno de los miembros.
Tiene perfecto sentido por tanto que esta estructura de datos sea una union ya que un “value” sólo puede ser de un tipo cada vez, usar un struct sería un gran desaprovechamiento.

Los tipos

Según la guía de Zend los tipos de datos en PHP son:

• boolean
• int
• float
• string
• array
• object
• NULL
• resource

Sin embargo, internamente los tipos son los siguientes (constantes numéricas):

• IS_NULL: se asigna automáticamente a las variables no inicializadas. La asignación se realiza en php con la palabra reservada NULL. Hay que tener en cuenta que NULL no es lo mismo que FALSE ni que cero, desde php lo parece debido a los casting implícitos que realiza.
• IS_BOOL: sólo puede tomar los valores TRUE y FALSE. Cuando se evalúan expresiones como WHILE o IF, lo que se hace es un casting implícito a ese tipo. Es decir, como en NULL, no se trata de que 0 sea lo mismo que FALSE sino que ese es un casting que se realiza automáticamente.
• IS_LONG: los int en php son internamente “signed long”, dependiente de la plataforma (en 32bit el rango es menor que en 64bit). Si en un script php una variable int se sale del rango, se convierte automáticamente al tipo que veremos a continuación.
• IS_DOUBLE: para números de coma flotante se utiliza el tipo “signed double” del sistema. Esto supone que la precisión no es exacta. Se entiende con este ejemplo :
  1. <? echo (int) ((0.1 + 0.7) * 10); ?>

  Cuando la precisión es una factor crítico se recomienda el uso de BCMath.

• IS_STRING: cadena de caracteres, se reserva un bloque de memoria para acomodar el string en cuestión, guardando en el zval un puntero al mismo. La longitud del string se guarda también en el zval. Esto permite que el string contenga datos binarios ya que un “\0″ no lo va a truncar dado que se maneja la longitud independientemente. Debido a esta práctica se dice que los string de php son “binary safe”. El bloque de memoria reservado es siempre la longitud del string + 1 ya que se añade “\0″ al final para que el string se pueda trabajar desde cualquier función sin tener que depender de la longitud guardada en el zval.
• IS_ARRAY: un array en php en realidad no cumple con la definición clásica de array, sino que se trata de un mapa ordenado o tabla. Esto hace que muchos programadores que sólo conocen PHP se lleven una gran sorpresa al enfrentarse a otros lenguajes y ver que los arrays son mucho más limitados que en php. Quizá habría sido más afortunado llamar a este tipo collection o map directamente, pero a efectos prácticos es irrelevante. Aclarado esto, un array de php está implementado con una tabla Hash donde la clave (o label) puede ser un índice numérico o un string asociativo y está relacionada con un valor (o data).

  Internamente también se sigue esa generalización y se usa el tipo HashTable en lugar de usar arrays o listas enlazadas. Supongo que habrán considerado que la flexibilidad y facilidad de uso que supone compensa con creces el impacto que pueda tener en cuanto a eficiencia. El tipo HashTable se encuentra definido en :

  1.  
  2. typedef struct _hashtable {
  3.         uint nTableSize;
  4.         uint nTableMask;
  5.         uint nNumOfElements;
  6.         ulong nNextFreeElement;
  7.         Bucket *pInternalPointer;       /* Used for element traversal */
  8.         Bucket *pListHead;
  9.         Bucket *pListTail;
  10.         Bucket **arBuckets;
  11.         dtor_func_t pDestructor;
  12.         zend_bool persistent;
  13.         unsigned char nApplyCount;
  14.         zend_bool bApplyProtection;
  15. #if ZEND_DEBUG
  16.         int inconsistent;
  17. #endif
  18. } HashTable;
• IS_OBJECT: Un objeto de php viene a ser un array (de php) al que se le añaden métodos, modificadores de acceso y constantes. El modelo de objetos cambió radicalmente de PHP4 a PHP5.
• IS_RESOURCE: se trata de un tipo especial utilizado para casos como un puntero FILE o una conexión a base de datos.

Probando con nuestro PECL

Un ejemplo con nuestro PECL:

El resultado en una máquina de 32bits será:

El resultado será:

El código de las dos funciones de ejemplovars es el siguiente, he evitado utilizar macros para trabajar con el zval para que quede claro el acceso a la estructura. Está probado en PHP 5.2, para 5.3 es probable que sea necesario algún cambio ya que para el nuevo recolector de basura han tocado el struct zval. La función ejemplovars_print_type usa paso por valor mientras que ejemplovars_print_refcount usa paso por referencia implícito.

Las tablas de símbolos

Una tabla de símbolos es un HashTable con punteros a zvals. Hay una tabla de símbolos global que se crea al comienzo, y que podemos ver desde nuestros scripts php : $GLOBALS.

Veremos que la variable $b no figura en esa tabla de símbolos. Esto es así ya que al entrar en nuevos ámbitos locales, ya sea por entrar en una función o en el método de una clase, se crea una nueva tabla de símbolos y se establece esta como la tabla de símbolos activa. Es decir, en cada momento sólo tendremos acceso a dos tablas de símbolos: la global y la del ámbito concreto en que estemos. Al terminar la vida de una función su tabla de símbolos se destruye. Podemos caer en el error de pensar que entonces sólo va a haber dos tablas de símbolo en memoria como mucho, pero repito: se crea una por cada nuevo ámbito. Si desde una función o método llamas a otro, ya tienes otra tabla de símbolos iniciada sólo que la de la función invocadora no está activa. Con este diseño es fácil entender cómo funciona el concepto de visibilidad de variables locales.

La tabla de símbolos global así como el puntero a las demás se guarda en la estructura _zend_executor_globals. A continuación un fragmento, si quieres verla entera la encontrarás en zend_globals.h.

Podemos acceder fácilmente a la estructura zend_globals con la macro EG. ejemplovars tiene dos funciones que acceden a la tabla de símbolos global y la activa respectivamente:

La tabla de símbolos global se pasa por referencia ya que zend_executor_globals la incluye directamente en lugar de simplemente un puntero a la misma.

Próximamente subiré “ejemplovars” a github o similar.

Si te interesa el tema de PECL recomiendo el libro “Extending and Embedding PHP” de Sara Golemon.

Dana prefiere Haskell

Doctest es un módulo de Python que permite incluir tests en los comentarios (en los llamados docstring para ser exactos). Pues bien, existe una implementación para PHP en PEAR.

Para desarrollos rápidos (o ágiles que se dice últimamente), Doctest representa una buena forma de escribir tests debido a que utilizar otras herramientas típicas como PHPUnit o Simpletest requiere una metodología de primero escribir los tests y luego implementar, que está muy bien pero la curva de aprendizaje no es despreciable y tiene más sentido en proyectos de cierto recorrido. En realidad los doctest no se suelen considerar una alternativa a los tests unitarios sino una opción más centrada en la documentación y más sencilla aunque menos potente.

Instalamos la herramienta vía PEAR:

A continuación un ejemplo de un doctest en php.

El doctest se incluye entre unas etiquetas <code>. La salida esperada para que el test sea satisfactorio se escribe tras “// expects:”.

Para ejecutar los tests :

Dará como resultado:

El doctest se suele incluir en la misma cabecera de comentario de phpdoc pero lo he omitido para que quede más claro lo necesario estrictamente para Doctest.

Doctest por defecto sólo considerará que el test ha sido satisfactorio si la salida del script es exactamente la misma que la salida que hemos escrito como esperada pero ¿y si queremos un comportamiento algo más flexible ?

Para ello podemos usar flags que alteren el comportamiento:

• NORMALIZE_WHITESPACE: se ignoran los espacios en blanco.
• CASE_INSENSITIVE: ignorar mayúsculas/minúsculas
• SKIP: ignorar el test
• ELLIPSIS: permitir utilizar el comodín [...]. Útil para los casos en que parte de la salida es variable

A continuación un ejemplo que usa un flag de ELLIPSIS. También sirve para ver que podemos incluir varios tests en la misma cabecera.

Si la salida esperada para un test es demasiado grande podemos utilizar “expects-file:” en lugar de “expects :”. El ejemplo de mostrarNumeros quedaría así con expects-file:

En el fichero mostrarNumeros.txt incluiremos la salida en bruto, es decir, sin comentar.

Existe también la posibilidad de incluir todo el test en un fichero externo:

Por último, existe la posibilidad de insertar cierto código a interpretar antes que todo lo demás. Esto es útil para establecer variables de entorno o para simular una petición HTTP.

Como conclusión, los doctest son una pequeña joya de Python que por suerte ha sido portada también a PHP. Permite incrustar los pequeños scripts que probablemente ya haces para probar tus clases y te obliga a ver tus clases desde el punto de vista del usuario de las mismas, de modo que te ayudará a pensar en si la encapsulación es correcta, en si tiene demasiadas dependencias, en si hace demasiadas cosas etc.. Sirve como complemento a los tests unitarios pero también como iniciación a la escritura de tests.

Se suele decir que el código fácil de testear es propio de un software bien diseñado.

Enlaces:

http://code.google.com/p/testing-doctest/
http://pear.php.net/package/Testing_DocTest
http://en.wikipedia.org/wiki/Doctest
Para ver más ejemplos de uso, lo mejor es ver el fichero de pruebas de Testing-DocTest, disponible en el repositorio:
http://svn.php.net/repository/pear/packages/Testing_DocTest/trunk/tests/test1.php

elefante

Según un estudio reciente, PHP es actualmente el tercer lenguaje de programación más popular.  Puede sorprender teniendo en cuenta los buenos comentarios que han recibido durante años lenguajes como Ruby y que se daba por seguro el retroceso de PHP. Yo creo que esto es debido a que la gente que está detrás de PHP ha sabido adaptarse a las nuevas tendencias y responder a tiempo. Dos ejemplos muy significativos:

• PHP5
• Zend Framework (y otros)

La comunidad “phpera” lejos de quedarse parada ante el adelantamiento por la derecha que parecía que les iba a hacer Ruby/Python/etc han mejorado el lenguaje increíblemente hasta el punto que el diseño OO de PHP tiene poco que envidiar a Java. Me imagino a los desarrolladores allá por el 2003 diciéndo “Dicen que PHP4 no es enterprise-ready, que su OO da asco, vale, tienen razón.”. Y de ahí salió PHP5, miras la lista de cambios entre PHP4 y PHP5, y resulta increíble que sólo les separe un número de versión. Algo parecido se puede decir de “Zend Framework”: “Ruby on Rails mola mucho, un killer app, hagamos algo parecido”. Y acabó surgiendo Zend Framework, un excelente framework MVC con “total” cobertura de test unitarios y completamente modular. Además, surgieron muchos otros framework que rivalizan con ZF, el “oficial”, creando una competencia absolutamente sana. Se trata de ejemplos como CakePHP, Symfony o CodeIgniter. El último episodio donde se ha demostrado este pragmatismo de los phperos ha sido dejar Zend_Entity y pasar a adoptar el ORM supuestamente de la competencia : Doctrine. Esto contrasta con la gente de Perl que ha dedicado la mayor parte de sus esfuerzos a crear una máquina virtual, académicamente muy interesante pero en la práctica ¿Hay nuevos usuarios de Perl existiendo PHP, Python y Ruby?.

Vale, a estas alturas te estarás preguntando a qué viene el título de esta entrada. Pues bien, todo esto de la actitud pragmática, los grandes avances etc. está muy bien pero existe un problema en PHP si bien en mi opinión es un mal menor: se trata de mantener la compatibilidad hacia atrás. No sólo un mal menor sino además un mal necesario que permite que los desarrolladores vayan adaptándose a los nuevos cambios progresivamente. La opción contraria podría resultar crítica para muchos usuarios, hay pocos casos donde ha sido necesario ese caso extremo, me viene a la cabeza VisualBasic 6 y poco más.

PHP es un lenguaje que empezó con objetivos mucho más modestos, seguramente Rasmus Lerdof ni en sus sueños más húmedos se imaginó que su herramienta evolucionaría hasta soportar sitios de la escala de Facebook. La política en PHP ha sido ir corrigiendo cosas y manteniendo compatibilidad hacia atrás avisando al desarrollador de las malas prácticas mediante warnings. En esta entrada hablaré de porqué no se debe utilizar a día de hoy referencias en PHP.

¿Qué son las referencias? “&”

Las referencias de PHP se parecen en esencia a las referencias (que no punteros) de C++. Son algo parecido a los enlaces duros de UNIX. Se han utilizado mucho en PHP debido a que en PHP4 el diseño OO era bastante distinto. En POO se trabaja con referencias de objetos en lugar de con los datos directamente debido a que la idea es mandar mensajes a los objetos y que ellos mismos sean los encargados de modificar su propio estado, y para eso basta la referencia del objeto para mandarle mensajes, difícilmente vas a necesitar acceder al objeto en sí mismo.
En PHP4, la implementación OO hacía que fuera necesario utilizar el operador referencia para hacer POO ya que de lo contrario estabas copiando objetos. También hay que tener en cuenta que hasta hace relativamente poco no se programaba OO en PHP por lo que se asumía que al igual que en C, si quieres trabajar con una estructura de datos muy grande, lo suyo es pasarlo por referencia y así evitar la copia. Esto me lleva a explicar un hecho poco conocido de PHP.

copy-on-write

La práctica de usar paso por referencia por motivos de optimización es equivocada actualmente debido a que PHP hace copy-on-write. Esto consiste en que PHP cuando se pasa por valor (casi siempre), no hace una copia de la variable desde el principio sino que trabajará en realidad con la referencia y hará una copia sólo en el momento en que detecte que vas a intentar modificar. Es decir, tú como programador feliz, estás en el ámbito de la función y con un parámetro por valor, y parece que estás trabajando desde el principio con una copia con lo cual si la estructura de datos es muy grande te puedes ver tentado a pasar por referencia pero es un error debido a que PHP internamente no hace la copia hasta que sea realmente necesario. Vale, pero puedes estar pensando: ¡ pero es que precisamente mi función va a modificar esa estructura y mucho así que se va a hacer esa costosa copia! Bien, el problema subyacente es que no se está pensando suficientemente a lo OO sino más bien proceduralmente. En PHP5 el modelo de objetos está rediseñado de modo que los objetos se trabajan con referencias como en Java, por lo que deja de ser necesario utilizar el operador referencia para hacer POO. Esto supone que el operador ‘=’ en la práctica es como si copiara sólo para los tipos primitivos mientras que para los objetos copia la referencia. Esta suele ser la típica explicación pero en realidad es errónea, lo cierto es que esta misma mala explicación también se suele dar en Java como simplificación. Lo que ocurre en realidad es que en PHP5 no trabajas con el objeto directamente, trabajas con su referencia, de modo que cuando pasas el objeto por valor, como mucho estarás provocando (copy-on-write) la copia de la referencia pero no del objeto. Si quieres una copia física del objeto lo que necesitarás es clonar el objeto (clone). Puedes utilizar el operador de referencia con objetos también pero resulta innecesario.

Vamos a ver más en profundidad cómo trabaja el intérprete de PHP las variables.

La estructura de datos que almacena una variable en PHP se llama “zval_struct” (zval entre amigos). Un “zval” tiene los siguientes campos:

• tipo (el tipo de la variable)
• valor (el valor de la variable)
• is_ref (flag que indica si la variable es una referencia &)
• refcount (contador del número de símbolos que apuntan a este zval)

La estructura está definida en zend.h:

Un zvalue_value puede ser muchas cosas. Ahí reside la magia del tipado de php. Tenemos en la misma estructura de datos las distintas posibilidades, tanto tipos primitivos como objetos, en Ikuspro realicé una implementación similar sólo que la genericidad de Java facilita mucho las cosas. Los objetos no se almacenan en esta estructura sino que únicamente se guarda el puntero (en PHP-5).

En PHP4 probablemente el diseño era distinto de manera que en el valor iba directamente el objeto de manera que era necesario usar continuamente el operador referencia para hacer programación orientada a objetos correctamente.

Un zend_object_value es lo siguiente (zend_types.h):

El handle es un ID único de entre ese tipo concreto de objetos (no global). El tipo del objeto y su funcionalidad está en esta otra estructura que es encuentra en una tabla. Desde zend_object_value vemos que se apunta con handlers en la entrada adecuada.

Los símbolos (nombres de variables) que apuntan a un zval se guardan en una tabla de símbolos. Normalmente solemos hablar de variables locales, variables globales, ámbitos de variables… Bien, de lo que se trata es que tenemos una tabla de símbolos por ámbito y en PHP el ámbito está unido a las funciones o métodos. En C por ejemplo, es diferente y los ámbitos van unidos a los bloques directamente de modo que tenemos tablas de símbolos por bloques. Por ejemplo en PHP tenemos:

El resultado será “hola/jaja/jaja/”

En C:

El resultado es “hola/jaja/hola/”.

Si te parece un detalle de importancia echa un vistazo a este código:

Este código en C no tiene sentido.

Podemos ver los zval con xdebug_debug_zval

Veamos un ejemplo:

El resultado es:

a: (refcount=1, is_ref=0)='Hola'
b: (refcount=1, is_ref=0)=2
obj: (refcount=1, is_ref=0)=class stdClass { public $atrib1 = (refcount=1, is_ref=0)='foo'; public $atrib2 = (refcount=1, is_ref=0)='bar' }
obj2: (refcount=2, is_ref=0)=class stdClass { public $atrib1 = (refcount=1, is_ref=0)='foo'; public $atrib2 = (refcount=1, is_ref=0)='bar' }
obj3: (refcount=2, is_ref=1)=class stdClass { public $atrib1 = (refcount=1, is_ref=0)='foo'; public $atrib2 = (refcount=1, is_ref=0)='bar' }

Como puedes ver el único con is_ref=1 es la variable referencia. Un zval se elmina cuando refcount pasa a ser cero y esas referencias van desaparenciendo a medida que se van resolviendo los ámbitos. Es decir, si hemos creado un zval dentro de una función (localmente) tendremos en principio símbolos pertenecientes a la tabla de símbolos de esa función. Al terminar la función ese zval pasará a tener 0 de refcount y por tanto se podrá liberar. Se suele decir que la función unset() de php destruye objetos pero creo que eso no es cierto. Un ejempo:

El resultado es:

a: (refcount=2, is_ref=0)=4
a: (refcount=2, is_ref=1)=4
b: (refcount=1, is_ref=0)=4
4
obj: (refcount=2, is_ref=1)=class stdClass { public $foo = (refcount=1, is_ref=0)='bar' }
obj2: (refcount=1, is_ref=0)=class stdClass { public $foo = (refcount=1, is_ref=0)='bar' }
bar

Como podemos ver lo que hace unset en realidad es disminuir el número del contador. Por último un ejemplo en el que pasamos la referencia de un objeto con lo cual hacemos que deje de apuntar a un objeto y pase a ser un string (tipo primitivo):

El resultado es:

a: (refcount=1, is_ref=0)=class stdClass { public $foo = (refcount=1, is_ref=0)='bar' }
a: (refcount=1, is_ref=0)='Sorpresa'

Como conclusión: no merece la pena trabajar con el operador referencia si estamos haciendo POO, lo único que vamos a conseguir es liar el código y provocar bugs, los punteros y referencias no están al nivel de abstracción que solemos manejar en nuestra vida diaria mientras que los objetos, atributos y métodos sí. Desgraciadamente existe mucho código “legacy” que hace uso intensivo de pasos por referencia, incluyendo algunas funciones de ordenación de PHP. Una opción para convertir esas funciones es sustituir los parámetros por referencia por un objeto stdClass que los encapsule pasado por valor.

Links:

Para escribir este post me he basado en el código citado del intérprete de PHP y en los siguientes enlaces. Si crees que he cometido algún error pon un comentario, estaré encantado en aprender:

http://php.net/manual/en/features.gc.refcounting-basics.php

http://schlueters.de/blog/archives/125-Do-not-use-PHP-references.html

http://blog.libssh2.org/index.php?/archives/51-Youre-being-lied-to..html ]]> http://ivanmosquera.net/index.php/2010/02/13/las-referencias-en-php-que-son-y-porque-no-usarlas/feed/ 4