So you’re still using Eclipse/PDT because you see no way to rsync your local files with your remote dev machine.

This is the workaround I use:

•  Create a “rsync.php” file in your project root, with this content. You’ll see this would be the Mac version, change the bits according yo your OS:

<?php

system(“/opt/local/bin/rsync -uvrz –chmod=uga+rx –delete-after –exclude-from=/Users/USERNAME/rsyncExclude.txt .  USERNAME@HOSTNAME:/home/USERNAME/PROJECT_PATH”);

•  Create a rsyncExclude.txt file with the file patterns you need to avoid syncing and place it in your home dir:

.settings
.buildpath
.project
.hg
rsync.php

• Project > Properties > Run configuration

Run As: “script (run in command line)”

Make sure you configure the php cli.

Index file: rsync.php

Working directory: your project directory.

•  That’s all. Now you can use “Run Project (F6)” to rsync.

Let me know if you’ve found another way to achieve this without hacking Netbeans.

 Eric A. Meyer , also author of other CSS books like CSS: The Definitive Guide tries to provide a good tool for  the daily CSS work.

The book features the following parts:

• 1. Basic concepts.
• 2. Values
• 3. Selectors.
• 4. Property Reference.

As a pocket reference it is, don’t expect learning CSS from this book but a quick reference for your daily work. You’ll find a few references to chapters of CSS: The Definitive Guide. This edition is updated to CSS3.

Basic concepts: you’ll find a guide to the CSS key concepts. Just and introduction, something which could have been avoided as the reference it is but it’s useful having those key concepts together in a few pages.

Values: a reference to the values you can use, descriptive information ordered by different categories like key words, colors, numbers, percentages…

Selectors: a reference to selectors, information structured as pattern, description and examples.

Property Reference : it lacks property categories, an alphabetic list is all you get. You need to know the name of the property you’re looking for, which isn’t always the case. For each property the information is well structured with: name, values, initial value, applies to, computed value, description, examples and note. Note usually refers to browser compatibility but just generally (“as of 2011″), not a complete browser compatibility reference.

Summary: a good CSS reference, perhaps lacking property categories and better information about browser compatibility.

Link to catalog: http://oreilly.com/catalog/9781449399030/

]]> http://ivanmosquera.net/2011/08/20/css-pocket-reference-fourth-edition-by-eric-a-meyer-oreilly-media/feed/ 0 ivmos CSS Pocket Reference http://ivanmosquera.net/2010/11/02/php-barcelona-conference-2010/ http://ivanmosquera.net/2010/11/02/php-barcelona-conference-2010/#comments Tue, 02 Nov 2010 19:59:55 +0000 Ivan Mosquera Paulo http://ivanmosquera.net/?p=353 ]]> Este año he tenido la suerte de asistir como ponente a la PHP Barcelona Conference para presentar “PHP for Android: Scripting PHP en Android”.

A pesar de que mi conferencia coincidía en el tiempo con otras dos muy interesantes creo que no quedaron sillas vacías y se cumplió el objetivo de generar interés en torno al proyecto.

Ha sido mi primera PBC y mi impresión no ha podido ser más positiva. Desde el nivel de las conferencias hasta la profesionalidad de la organización pasando por la gente tan interesante que asiste y con la cual tienes oportunidad de tratar.

A continuación las transparencias de mi conferencia. Nos vemos en la PBC 11 .

Hoy he aprobado el examen “Zend PHP Certified Engineer – PHP5″ y he pensado que estaría bien un post con mi opinión sobre esta certificación.

Ikuspro es el proyecto de fín de carrera que hice en su día en el que aprendí un montón de cosas sin las cuales no se me habría ocurrido empezar el proyecto PFA.

En su día ya comenté un poco de qué iba el tema . Tras eso la cosa terminó en que el proyecto obtuvo matrícula de honor.

A rasgos generales aprendí lo siguiente y por tanto ahora que está liberado puede que sirva a alguien para indagar en estos aspectos:

• Implementación de un framework MVC para Swing usando genericidad.
• Diseño de interfaces gráficas Swing con soporte para persistencia.
• Buenas prácticas Swing: integración con los OS más utilizados, no recarga del hilo de eventos usando workers etc…
• Programación concurrente en Java, diseño productor-consumidor.
• Separación de una aplicación en dos partes comunicadas mediante sincronización de hilos.
• Implementación con ANTLR de un intérprete de un subconjunto de ANSI-C que se comunica con el GUI mediante mensajes XML.
• Comunicación entre procesos mediante un API XML.
• Dibujado en Canvas con Java2D e integración del mismo con el GUI.

Lo cierto es que fue bastante divertido. Me consta que en EUITI tienen pensado utilizarlo en laboratorios y la idea es que otros alumnos extiendan Ikuspro con nuevas funcionalidades e incluso con nuevos intérpretes.

Gracias a Mikel Villamañe por confiar en mí para implementar la idea.

A continuación el material que usé en la defensa, un pantallazo y el enlace al repositorio en mi github.

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”.

struct _zval_struct {
        /* Variable information */
        zvalue_value value;
        zend_uint refcount;
        zend_uchar type;
        zend_uchar is_ref;
};

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 :

  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 “” 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 “” 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 :

  typedef struct _hashtable {
          uint nTableSize;
          uint nTableMask;
          uint nNumOfElements;
          ulong nNextFreeElement;
          Bucket *pInternalPointer;       /* Used for element traversal */
          Bucket *pListHead;
          Bucket *pListTail;
          Bucket **arBuckets;
          dtor_func_t pDestructor;
          zend_bool persistent;
          unsigned char nApplyCount;
          zend_bool bApplyProtection;
  #if ZEND_DEBUG
          int inconsistent;
  #endif
  } 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:

attr = 25;
ejemplovars_print_type($a);
$a = 4;
ejemplovars_print_type($a);
$a = $a * 1000000000;
ejemplovars_print_type($a);

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

Tipo: IS_BOOL
Tipo : IS_OBJECT
Tipo: IS_LONG
Tipo : IS_DOUBLE

<?php
$a = 5;
$b = &$a;
$c = &$a;
ejemplovars_print_refcount($a);
ejemplovars_print_type($a);

El resultado será:

Referenciado 4 veces.
Tipo: IS_LONG

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.

PHP_FUNCTION(ejemplovars_print_refcount)
{
    zval *arg;
    if (zend_get_parameters(ZEND_NUM_ARGS(), 1, &arg) == FAILURE) {
        RETURN_NULL();
    }
    if (!arg->is_ref) {
        return;
    }

    php_printf("Referenciado %d veces.\n", arg->refcount);
}

PHP_FUNCTION(ejemplovars_print_type)
{
   zval *arg;
   if (zend_get_parameters(ZEND_NUM_ARGS(), 1, &arg) == FAILURE) {
      php_error_docref(NULL TSRMLS_CC, E_WARNING, "Falta el parámetro.");
      RETURN_NULL();
   }
   switch (arg->type) {
      case IS_NULL:
         php_printf("Tipo: IS_NULL\n");
         break;
      case IS_BOOL:
         php_printf("Tipo: IS_BOOL\n");
         break;
      case IS_LONG:
         php_printf("Tipo: IS_LONG\n");
         break;
      case IS_DOUBLE:
         php_printf("Tipo : IS_DOUBLE\n");
         break;
      case IS_STRING:
         php_printf("Tipo : IS_STRING\n");
         break;
      case IS_ARRAY:
         php_printf("Tipo : IS_ARRAY\n");
         break;
      case IS_OBJECT:
         php_printf("Tipo : IS_OBJECT\n");
         break;
      case IS_RESOURCE:
         php_printf("Tipo: IS_RESOURCE\n");
         break;
      default:
         php_printf("Otro tipo\n");
   }

}

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.

<?php
$a = "lala";

function prueba() {
   $b = "jaja";
   print_r($GLOBALS);
}

prueba();

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.

        /* symbol table cache */
        HashTable *symtable_cache[SYMTABLE_CACHE_SIZE];
        HashTable **symtable_cache_limit;
        HashTable **symtable_cache_ptr;

        zend_op **opline_ptr;

        HashTable *active_symbol_table;
        HashTable symbol_table;         /* main symbol table */

        HashTable included_files;       /* files already included */

        jmp_buf *bailout;

        int error_reporting;
        int orig_error_reporting;
        int exit_status;

        zend_op_array *active_op_array;

        HashTable *function_table;      /* function symbol table */
        HashTable *class_table;         /* class table */
        HashTable *zend_constants;      /* constants table */

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:

PHP_FUNCTION(ejemplovars_dump_globalsymtable)
{
      php_printf("Tabla de simbolos global : \n\n");
      php_ejemplovars_print_var_hash(&(EG(symbol_table)));
}

PHP_FUNCTION(ejemplovars_dump_currentsymtable)
{
      php_printf("Tabla de simbolos actualmente activa : \n\n");
      php_ejemplovars_print_var_hash(EG(active_symbol_table));
}

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.

Tabla de simbolos global :

The value of GLOBALS is: Array
The value of _ENV is: Array
The value of HTTP_ENV_VARS is: Array
The value of argv is: Array
The value of argc is: 1
The value of _POST is: Array
The value of HTTP_POST_VARS is: Array
The value of _GET is: Array
The value of HTTP_GET_VARS is: Array
The value of _COOKIE is: Array
The value of HTTP_COOKIE_VARS is: Array
The value of _SERVER is: Array
The value of HTTP_SERVER_VARS is: Array
The value of _FILES is: Array
The value of HTTP_POST_FILES is: Array
The value of _REQUEST is: Array
The value of a is: lala

Tabla de simbolos actualmente activa :

The value of b is: jaja

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:

pear install -f Testing_DocTest

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:”.

<?php
/**
 * 
 * mostrarNumeros(3);
 *
 * // expects:
 * //0
 * //11
 * //222
 * //3333
 * 
 *
 **/
function mostrarNumeros($num) {
   for($i=0;$i<=$num;$i++) {
      for($j=0;$j<=$i;$j++) {
         echo $i;
      }
      echo "\n";
   }
}

Para ejecutar los tests :

phpdt numeros.php.

Dará como resultado:

Processing /tmp/numeros.php
[PASS]  function mostrarNumeros

Total time    : 0.0253 sec.
Passed tests  : 1
Skipped tests : 0
Failed tests  : 0

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.

<?php
/**
 * 
 * // Usamos ELLIPSIS porque hay una parte de la salida que no podemos predecir
 *
 * // flags: ELLIPSIS
 * echo testString();
 * // expects:
 * // Lo siguiente no se puede predecir [...].
 *
 * 
 *
 * 
 * // Este es el mismo test pero lo hacemos para ver que podemos dividir la salida con \
 *
 * // flags: ELLIPSIS
 * echo testString();
 * // expects:
 * // Lo siguiente \
 * // no se puede \
 * // predecir [...].
 *
 * 
 *
 */
function testString()
{
    return sprintf('Lo siguiente no se puede predecir %s', microtime());
}

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:

<?php
/**
 * 
 * mostrarNumeros(3);
 *
 * // expects-file: mostrarNumeros.txt
 *
 * 
 *
 **/
function mostrarNumeros($num) {
   for($i=0;$i<=$num;$i++) {
      for($j=0;$j<=$i;$j++) {
         echo $i;
      }
      echo "\n";
   }
}

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:

 * 
 * // test-file: tests/test1.doctest
 * 

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.

/**
 * This is a file level test.
 *
 * 
 * // setup:
 * // $_ENV['OSTYPE'] = 'linux';
 * echo OS_TYPE;
 * // expects:
 * // linux
 * 
 */
define('OS_TYPE', $_ENV['OSTYPE']);

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)

Sorry this post is only in Spanish :
http://ivanmosquera.files.wordpress.com/2010/02/elephant-php.pngindex.php/2010/02/13/las-referencia…que-no-usarlas/?lang=es
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.

apt-get source php5-cli.

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:

struct _zval_struct {
/* Variable information */
zvalue_value value;             /* value */
zend_uint refcount;
zend_uchar type;        /* active type */
zend_uchar is_ref;
};

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).

typedef union _zvalue_value {
        long lval;                                      /* long value */
        double dval;                            /* double value */
        struct {
                char *val;
                int len;
        } str;
        HashTable *ht;                          /* hash table value */
        zend_object_value obj;
} zvalue_value;

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):

typedef struct _zend_object_value {
        zend_object_handle handle;
        zend_object_handlers *handlers;
} zend_object_value;

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.

typedef struct _zend_object_handlers {
        zend_object_add_ref_t                    add_ref;
        zend_object_del_ref_t                    del_ref;
        zend_object_delete_obj_t                 delete_obj;
        zend_object_clone_obj_t                  clone_obj;
        zend_object_read_property_t              read_property;
        zend_object_write_property_              write_property;
        zend_object_get_property_ptr_t           get_property_ptr;
        zend_object_get_property_zval_ptr_t      get_property_zval_ptr;
        zend_object_get_t                        get;
        zend_object_set_t                        set;
        zend_object_has_property_t               has_property;
        zend_object_unset_property_t             unset_property;
        zend_object_get_properties_t             get_properties;
        zend_object_get_method_t                 get_method;
        zend_object_call_method_t                call_method;
        zend_object_get_constructor_t            get_constructor;
        zend_object_get_class_entry_t            get_class_entry;
        zend_object_get_class_name_t             get_class_name;
        zend_object_compare_t                    compare_objects;
} zend_object_handlers;

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:

$a = "hola/";
echo $a;
{
          $a = "jaja/";
          echo $a;
}
echo $a;

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

En C:

#include
main() {

char *a = "hola/";
printf("%s",a);

{
char *a = "jaja/";
printf("%s",a);
}

printf("%s",a);

}

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

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

<?
$a = "Hola";
echo $a;

if ($a == "Hola") {
        $b = "Adios";
}
echo $b;

Este código en C no tiene sentido.

Podemos ver los zval con xdebug_debug_zval

apt-get install php5-xdebug

Veamos un ejemplo:

atrib1 = "foo";
$obj->atrib2 = "bar";
xdebug_debug_zval('obj');
$obj2 = $obj;
xdebug_debug_zval('obj2');
$obj3 = &$obj;
xdebug_debug_zval('obj3');

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:

$orig = 4;

$a = $orig;
xdebug_debug_zval('a');
$b = &$a;
xdebug_debug_zval('a');
unset($a);
xdebug_debug_zval('b');
echo $b ."\n";
$obj = new stdClass;
$obj->foo = "bar";
$obj2 = &$obj;
xdebug_debug_zval('obj');
unset($obj);
xdebug_debug_zval('obj2');
echo $obj2->foo ."\n";

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):

foo = "bar";
xdebug_debug_zval('a');
lafuncion(&$a);
xdebug_debug_zval('a');

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

flash platform

Veamos a continuación los pasos necesarios para desarrollar en Linux para plataforma Flash con esta herramienta:
Adobe no longer develops Flash/Flex Builder for Linux. I’ve found a promising opensource alternative : Minibuilder. It’s an IDE built with Adobe Air.

flash platform

Let’s see how to install and use this tool:

1. Instalamos Adobe AIR : (Fuente:  http://www.sizlopedia.com/2008/04/06/how-to-install-adobe-air-on-ubuntu/ )

wget http://airdownload.adobe.com/air/lin/download/1.5/AdobeAIRInstaller.bin

chmod +x AdobeAIRInstaller.bin

./AdobeAIRInstaller.bin

Si aún habiendo instalado las dependencias tiene problemas para hacer funcionar Adobe AIR con 64 bits, con un error como el siguiente: Error loading the runtime (libnss3.so: wrong ELF class: ELFCLASS64)
Los pasos que le pueden faltar son:

$ cd /usr/lib32/
$sudo ln -s /emul/ia32-linux/usr/lib/libnss3.so .
$sudo ln -s /emul/ia32-linux/usr/lib/libssl3.so .
$sudo ln -s /emul/ia32-linux/usr/lib/libsmime3.so .
$sudo ln -s /emul/ia32-linux/usr/lib/libnspr4.so .
$sudo ln -s /emul/ia32-linux/usr/lib/libnssutil3.so.1d .
$sudo ln -s /emul/ia32-linux/usr/lib/libplc4.so.0d .
$sudo ln -s /emul/ia32-linux/usr/lib/libplds4.so .
$sudo ln -s /emul/ia32-linux/usr/lib/libplds4.so.0d libplds4.so.0d


2. Instalar Java

apt-get install sun-java-jre

3. Instalar Flex 3.5 ( URL : http://opensource.adobe.com/wiki/display/flexsdk/Download+Flex+3 )

Descomprimir en algún sitio

4. Descargar minibuilder: (URL :  http://minibuilder.googlecode.com/files/AirMiniBuilder-1.0-alpha-3.air )

Adobe\ AIR\ Application\ Installer /$RUTA_ABSOLUTA/AirMiniBuilder-1.0-alpha-3.air

5. Tras la instalación de minibuilder, éste se iniciará. Veremos que nos pide ejecutar un tal MBCompiler, la ruta al script figurará en la última línea de la ventana.
En mi caso : /opt/AirMiniBuilder/share/MBCompiler/start
Supongo que Minibuilder no hace ese trabajo por nosotros debido a algún tipo de limitación del sandbox de Air.

Teniendo ejecutado MBCompiler podemos hacer click en “Check again” y desaparecerá la advertencia.
También tenemos que especificar la ruta  a flex en el cuadro “SDK Path”.

Y ya está. Ya podemos empezar a utilizar de Minibuilder. Empezaremos con un pequeño proyecto para el Flash Player.

Utilizamos la pestaña “Create New Project“:

Minibuilder

Elegimos:
Project target : “Flash Player AS3“

Vemos que soporta dos frameworks : Flex y AsWing. Nosotros por ahora sólo usaremos Flex.
Activamos “Add (some) Flex support“

Como project name lo que queramos, en mi caso “hola mundo”.

Ese texto inicial que veremos se trata de MXML, un lenguaje de marcado que facilita el uso del framework Flex.

Editor Minibuilder

Hacemos click en “Compile and Quickrun”. Veremos que tarda su tiempo en compilar el SWF, años luz de la rapidez de MTASC o Haxe.
No veremos nada cuando no debería ser así. Sospecho que puede ser porque mi distribución Linux utiliza SWFDEC por defecto en lugar del player de flash Adobe. El swf lo podemos encontrar en la carpeta bin-debug, con lo cual podremos ejecutarlo manualmente.

Veremos que aparecen unos botones (“AAA”,”BBB”…) es debido a que se está utilizando la clase “Application.as” predefinida por Minibuilder que incluye esos botones en tabs.

Ahora ya es cuestión de aprender Flex. Como pistas para alguien que venga de MTASC decir que las clases Flash que se solían utilizar anteriormente, en la documentación están en el API de Flash Player.

Así que para jugar por un lado tenemos los controles del framework Flex: http://livedocs.adobe.com/flex/3/html/help.html?content=controls_01.html y por otro lado tenemos el API de Flash Player, el cual ya nos resultará familiar al haberlo utilizado con MTASC , Haxe o Flash Studio:

http://livedocs.adobe.com/flex/3/html/help.html?content=Part3_Flash_Player_APIs_1.html

Podemos utilizar ambas cosas sin problemas. En el siguiente ejemplo, se utiliza NetStream y Netconnection en lugar del control VideoDisplay de Flex, pero eso no quita para que los botones a utilizar puedan ser controles Flex:

http://blog.flexexamples.com/2008/03/01/displaying-a-video-in-flex-using-the-netconnection-netstream-and-video-classes/

Vemos que en ese ejemplo el código Actionscript se encuentra incrustado en el MXML. No tiene porqué ser así y de hecho yo no creo que sea una buena práctica. El ejemplo de Minibuilder utiliza una clase independiente para el código (Application.as). De todos modos, ya hablaremos en otro post sobre buenas prácticas, patrones y otras librerías.

Entonces como conclusión. ¿Qué ofrece Minibuilder en cuanto a facilitar el desarrollo para plataforma Flash?

Resaltado y autocompletado AS3, así como compilación amigable de SWF incluyendo gestión de los namespaces.

<?xml version="1.0" encoding="utf-8"?>
<!-- http://blog.flexexamples.com/2008/03/01/displaying-a-video-in-flex-using-the-netconnection-netstream-and-video-classes/ -->
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml"
        layout="vertical"
        verticalAlign="middle"
        backgroundColor="white"
        creationComplete="init();">

    <mx:Script>
        <![CDATA[
            import mx.utils.ObjectUtil;

            private var nc:NetConnection;
            private var ns:NetStream;
            private var video:Video;
            private var meta:Object;

            private function init():void {
                var nsClient:Object = {};
                nsClient.onMetaData = ns_onMetaData;
                nsClient.onCuePoint = ns_onCuePoint;

                nc = new NetConnection();
                nc.connect(null);

                ns = new NetStream(nc);
                ns.play("http://www.helpexamples.com/flash/video/cuepoints.flv");
                ns.client = nsClient;

                video = new Video();
                video.attachNetStream(ns);
                uic.addChild(video);
            }

            private function ns_onMetaData(item:Object):void {
                trace("meta");
                meta = item;
                // Resize Video object to same size as meta data.
                video.width = item.width;
                video.height = item.height;
                // Resize UIComponent to same size as Video object.
                uic.width = video.width;
                uic.height = video.height;
                panel.title = "framerate: " + item.framerate;
                panel.visible = true;
                trace(ObjectUtil.toString(item));
            }

            private function ns_onCuePoint(item:Object):void {
                trace("cue");
            }
        ]]>
    </mx:Script>

    <mx:Panel id="panel" visible="false">
        <mx:UIComponent id="uic" />
        <mx:ControlBar>
            <mx:Button label="Play/Pause" click="ns.togglePause();" />
            <mx:Button label="Rewind" click="ns.seek(0); ns.pause();" />
        </mx:ControlBar>
    </mx:Panel>

</mx:Application>