Lo que haremos es modificar php.ini para que Xdebug envíe el tráfico al propio servidor remoto (xdebug.remote_host = localhost) y lanzar un SSH desde nuestra máquina indicando al cliente que redireccione el tráfico del puerto 9000 del servidor (puerto por defecto de Xdebug) a un puerto de nuestra máquina donde nuestro IDE esté a la espera del depurador:

ssh -R 9000:localhost:9000 usuario@servidor.com

Si utilizas Windows y prefieres las aplicaciones gráficas, puedes utilizar indistintamente el cliente de SSH y telnet PuTTY, o cualquiera de sus alternativas, como mi favorito, KiTTy. Sólo tenemos que introducir el servidor y el puerto al que queremos conectarnos en Session, y configurar el túnel en Connection -> SSH -> Tunnels. En Source port (puerto de orígen) introduciremos el puerto al que está enviando la información Xdebug en el servidor y en Destination (destino) la máquina y el puerto al que queremos redireccionarlo. Por último, marcaremos la casilla Remote (remoto) y, muy importante, pulsaremos el botón Add (Añadir) para confirmar la redirección.

Una vez hecho esto, ya podremos depurar el código con Xdebug aunque nos encontremos detrás de un firewall. Si no es así, activa la opción de registro de Xdebug (xdebug.remote_log = /ruta/archivo/log) y comprueba que tu cliente SSH esté efectivamente escuchando en el puerto 9000 del servidor

netstat -an | grep 9000

Para crear nuestro iterador en PHP tenemos que / podemos implementar la interfaz Iterator. Esto nos permitirá recorrer nuestra colección utilizando un foreach, por ejemplo. La interfaz Iterator declara los siguientes métodos:

• abstract public void rewind(void): debe mover el puntero al primer elemento, sin devolver ningún valor
• abstract public mixed current(void): debe devolver el valor actual
• abstract public scalar key(void): devuelve la clave actual
• abstract public void next(void): mueve el puntero al siguiente elemento
• abstract public boolean valid(void): devuelve true si el iterador sigue siendo válido (no se ha alcanzado el final de la colección) y false en caso contrario

Como ejemplo de iterador en PHP, vamos a implementar algo parecido a la clase DatePeriod de PHP 5.3, que permite iterar sobre los días de un periodo de fechas

<?php
class Intervalo {
    public $inicio;
    public $fin;

    function __construct($inicio, $fin) {
        $this->inicio = strtotime($inicio);
        $this->fin = strtotime($fin);
    }
}

<?php
class IteradorPorDia implements Iterator {
	private $intervalo;

	function __construct(Intervalo $intervalo) {
		$this->intervalo = $intervalo;
	}

    function rewind() {
        $this->claveActual = 1;
        $this->fechaActual = $this->intervalo->inicio;
    }

    function key() {
        return $this->claveActual;
    }

    function current() {
        return date('Y-m-d', $this->fechaActual);
    }

    function next() {
        $this->claveActual++;
        $this->fechaActual = strtotime('+1 day', $this->fechaActual);
    }

    function valid() {
        return ($this->fechaActual <= $this->intervalo->fin);
    }
}

<?php
require_once 'Intervalo.php';
require_once 'IteradorPorDia.php';

$intervalo = new Intervalo('2012-12-24', '2013-01-08');
$iterador = new IteradorPorDia($intervalo);
foreach($iterador as $num => $fecha)
	echo "El día $num del intervalo es $fecha<br/>";

Si queremos seguir el patrón Iterador al pie de la letra (recomendado), haciendo que sea el agregado el que cree el iterador y lo devuelva, nuestra colección tendrá que implementar la interfaz IteratorAggregate y su método abstract public Traversable getIterator(void). Si hacemos esto podremos pasar la colección al foreach directamente, haciendo nuestro código cliente más sencillo y claro.

<?php
require_once 'IteradorPorDia.php';

class Intervalo implements IteratorAggregate {
    public $inicio;
    public $fin;

    function __construct($inicio, $fin) {
        $this->inicio = strtotime($inicio);
        $this->fin = strtotime($fin);
    }

    public function getIterator() {
        return new IteradorPorDia($this);
    }
}

<?php
require_once 'Intervalo.php';

$intervalo = new Intervalo('2012-12-24', '2013-01-08');
foreach($intervalo as $num => $fecha)
	echo "El día $num del intervalo es $fecha
";

La librería estándar de PHP (SPL) también cuenta con varios iteradores predefinidos que pueden ser interesantes, además de una serie de clases que permiten encadenar varios iteradores (AppendIterator), filtrar valores no deseados (FilterIterator), iterar indefinidamente (InfiniteIterator), iterar sobre un subgrupo de elementos (LimitIterator) o iterar de forma recursiva (RecursiveIteratorIterator).

Las dos formas más comunes de proporcionar una dependencia a una función son, por un lado, los parámetros de la función:

function insertarItem($db, $item) {
	// Haz algo
	// ...

	$db->insertar($item);

	// Haz más algo
	// ...
}

y por otra parte, cualquier tipo de mecanismo de acceso global con el que contemos en el lenguaje (variables globales, patrón Singleton, etc). En este ejemplo en PHP utilizamos la palabra clave global para crear una variable local con una referencia a la variable global.

function insertarItem($item) {
	// Haz algo
	// ...

	global $db;
	$db->insertar($item);

	// Haz más algo
	// ...
}

En principio podría parecer que no hay mucha diferencia entre ambos ejemplos. Nada más lejos de la realidad.

El primer problema con el que nos encontramos es que las variables globales ocultan las dependencias, y transportan la información de un lado a otro por arte de magia. Imagina que quieres utilizar la función insertarItem dentro de un año. Podrías pensar que puedes usarla de esta forma:

insertarItem($item);

cuando, de hecho, la función puede estar esperando que hagas esto:

$GLOBALS['db'] = new Db('localhost', 'mibbdd', 'usuario', 'pass');
$_SESSION['permisos'] = new Usuario()-<permisos();
insertarItem($item);

¿Cómo podrías saberlo sin tener que leer todo el código?

Otro problema es que es terriblemente difícil seguir sus cambios. Es posible que en algún momento crees otra variable global con el mismo nombre, y termines sobre escribiendo su valor sin percatarte, lo cuál generaría errores de lo más esotérico y de lo más difícil de depurar.

Las variables globales son malvadas por, al menos, 6 razones relacionadas:

1. El código es más difícil de entender
2. El código es más difícil de depurar
3. El código es más difícil de testear
4. El código es más difícil de mantener
5. El código es más difícil de reutilizar
6. Las variables globales matan gatitos

A pesar de todo puede tentarte usar variables globales para no tener que pasar el objeto $db a todas y cada una de las funciones que puedan necesitarlo, por ejemplo, y todas las funciones que llamen a funciones que puedan necesitarlo. En ese caso, en lugar de una colección de funciones con usos relacionados, puedes utilizar clases, y pasar la dependencia al objeto utilizando el constructor. Otras opciones son el uso de los patrones Abstract Factory, Service Locator o, mucho mejor, la inyección de dependencias (Dependency Injection, también llamado Inversion of Control).

Ojo, porque el patrón Singleton NO es una solución adecuada a este problema. Sí, es uno de los patrones explicados en Design patterns: elements of reusable object-oriented software, uno de los 10 libros míticos que todo programador debería leer, pero se suele abusar de él utilizándolo simplemente como una especie de variable global glorificada. Así las cosas, existen multitud de artículos que desaconsejan su utilización, e incluso Google desarrolló en su día un pequeño script para detectar el uso de singletons y poder eliminarlos.

Esto, unido a otros pecados como las inconsistencias en el nombrado de las funciones y el orden de los parámetros, ha convertido a PHP en un lenguaje con no muy buena fama. Seguramente, esto cambiaría drásticamente si más personas leyeran y aplicasen los conceptos que se explican en este PHP in Action.

PHP in Action es un compendio de técnicas modernas, conceptos, principios y consejos dirigidos a los profesionales que están interesados en convertirse en mejores programadores. No puede convertirte en un gran programador por sí sólo, pero puede sentar las bases.

El libro está dividido en 4 grandes partes claramente diferenciadas. Comienza con un repaso básico de la orientación a objetos, explicando los 5 principios SOLID y algunos patrones de diseño clásicos como Strategy, Decorator o Composite; continúa con pruebas unitarias y funcionales, desarrollo guiado por pruebas (TDD) y refactorización; pasa a describir conceptos como el patrón MVC, el patrón Front controller o las plantillas, y termina con todo lo relacionado con bases de datos, desde cómo tener disponible la conexión en cualquier rincón del código sin usar globales o Singleton, a patrones comunes para CRUD, como Row Data Gateway o Active Record.

Si ya has leído “Agile Software Development, Principles, Patterns, and Practices”, “Design Patterns: Elements of Reusable Object-Oriented Software”, “Refactoring: Improving the Design of Existing Code” y “Patterns of Enterprise Application Architecture”, puede ser un buen repaso. Si todavía no has leído ninguno de estos libros, puedes empezar por este.

Primero necesitamos descargar los archivos de la API de Facebook para PHP, así como obtener el id y el secreto de aplicación, tal como explicamos anteriormente.

Una vez hecho esto, para obtener el número de fans que tenemos en Facebook, utilizaremos el siguiente código, sustituyendo, respectivamente, ID_APP por el id de aplicación, SECRETO por el secreto de aplicación, e ID_USUARIO por nuestro id de usuario.

<?php
require 'php-sdk/facebook.php';

$fb = new Facebook(array(
  'appId'  => 'ID_APP',
  'secret' => 'SECRETO',
  'cookie' => true
));

$res = $fb->api('/ID_USUARIO');
echo "Tienes {$res['likes']} fans";

El array asociativo $res, que devuelve esta consulta, incluye además el id de la cuenta (clave id), el nombre (name), la imagen (picture), la URL de nuestra página en Facebook (link), la categoría (category), la URL de nuestra página web (website), el nombre de usuario (username) y la descripción (description).

Empecemos con los lenguajes más utilizados. Estos podrían ser los lenguajes cuyas sintaxis y características gustan más, o, simplemente, aquellos con los que están más familiarizados los participantes. Como vemos, C++ es, con mucha diferencia, el lenguaje más popular, seguido a larga distancia de Java y Python.

Pasamos a continuación a los lenguajes con mayor porcentaje de programadores capaces. Vemos que el porcentaje de programadores que consiguieron la puntuación suficiente para pasar de fase es altísimo en el caso de C++ y Haskell (90,8% y 90,68%), mientras que el porcentaje de programadores aprobados en el caso de PHP (lenguaje con el que yo me gano las lentejas actualmente) es alarmantemente bajo en comparación (76,5%).

Por último, veamos el porcentaje de programadores que consiguieron la puntuación perfecta, agrupados por lenguaje de programación. Aquí Haskell se distancia bastante de C++, y mucho más del resto de lenguajes, quizás por la llamada paradoja Python. PHP, por su parte, se mantiene con el dudoso honor de ser el lenguaje con peor porcentaje de programadores con puntuaciones perfectas.

Lo primero que necesitaremos, evidentemente, es la API oficial de Facebook, que podemos descargar desde GitHub. Descomprimimos el archivo y lo subimos a nuestro servidor.

También necesitamos crear una aplicación, que será la encargada de llevar a cabo estas operaciones sobre nuestra cuenta de usuario o de marca. Para ello os podéis dirigir al sitio web de desarrolladores de Facebook, donde os pedirán amablemente que validéis vuestra cuenta, bien introduciendo vuestro teléfono móvil, para que os envíen un código de confirmación, o bien introduciendo vuestro número de cuenta. En serio, es escalofriante, pero ya sabemos todos como es Facebook.

Una vez hayáis creado la aplicación, podréis consultar el id de la aplicación y la clave secreta de aplicación en esa misma página. Estos son dos de los datos que vamos a necesitar, así que tenerlos a mano.

Lo siguiente que necesitamos es que nuestro usuario dé permisos a nuestra aplicación para poder interactuar con nuestra cuenta. Esto lo podemos hacer de forma sencilla utilizando una URL especialmente diseñada a tal efecto, que tendrá el siguiente aspecto:

https://graph.facebook.com/oauth/authorize?type=user_agent&
client_id=ID_APLICACION&
redirect_uri=http://www.facebook.com/connect/login_success.html&
scope=offline_access,manage_pages,publish_stream,create_event

donde:

• client_id es el id de la aplicación, que habíamos apuntado en el paso anterior
• redirect_uri es la página a la que redireccionar el navegador una vez hayamos dado los permisos a la aplicación
• y scope es una lista de permisos, cuyos posibles valores podemos consultar en la documentación al respecto. El permiso offline_access es uno de los más importantes: permite que el token que nos va a pasar Facebook para autenticarnos no caduque, incluso cuando el usuario esté desconectado. Si quieres interactuar con las páginas que gestiona tu usuario, en lugar, o además de con tu propia cuenta personal, necesitarás requerir también el permiso manage_pages

Al cargar la URL en tu navegador y pulsar ‘Permitir’, si no ha pasado nada raro, Facebook debería redirigirte a la página que indicaste como valor de redirect_uri, añadiendo a esta un parámetro access_token, que es el que utilizaremos para identificarnos, y otro expires_in, que nos informa de que el token de acceso no va a caducar.

Para comprobar que todo funciona correctamente puedes intentar cargar la siguiente URL:

https://graph.facebook.com/me?access_token=ACCESS_TOKEN

Si el token de acceso es el adecuado, Facebook nos mostrará un objeto JSON con la información de nuestra cuenta de usuario. En caso contrario, mostrará un objeto JSON informando del error.

Ahora bien, si queremos interactuar con las páginas de marca que administremos, en lugar de con nuestra página personal, necesitaremos un access token distinto. Para obtenerlo preguntaremos a Facebook por la información de las distintas páginas y aplicaciones que administramos utilizando la URL:

https://graph.facebook.com/me/accounts?access_token=ACCESS_TOKEN

Listo. Ahora sí, ya estamos preparados para empezar a jugar con la API de Facebook. Para publicar en el muro, crear eventos y subir imágenes en Facebook utilizaremos la clase del mismo nombre, a cuyo constructor le pasamos un array con el identificador de nuestra aplicación y su secreto:

$fb = new Facebook(array(
  'appId'  => 'ID_APP',
  'secret' => 'SECRETO',
  'cookie' => true
));

El método que nos interesa de esta clase es api, que normalmente tendrá como primer parámetro una cadena del tipo "/ID_USUARIO/SERVICIO" o "/ID_PAGINA/SERVICIO". El segundo parámetro es siempre el método a utilizar (POST o GET), y el tercero, un array con los argumentos necesarios para ese servicio.

Para publicar algo en el muro, por ejemplo, utilizaríamos como primer parámetro una cadena "/ID_USUARIO/feed" y como tercer parámetro, un array con claves message (el mensaje a publicar) y access_token, siendo este último el valor que obtuvimos anteriormente para identificar a nuestro usuario o alguna de las páginas de marca que administramos (OJO: el token de acceso del usuario no sirve para identificar a la página, evidentemente, y viceversa).

$fb = new Facebook(array(
  'appId'  => 'ID APLICACION',
  'secret' => 'SECRETO',
  'cookie' => true
));

$params = array(
    'access_token' => 'TOKEN ACCESO',
    'message' => 'Hola mundo'
);
$res = $fb->api('/ID_USUARIO/feed', 'POST', $params);
if(!$res)
    echo 'Ha ocurrido un error indeterminado';
elseif($res->error)
    echo "Ha ocurrido un error: {$res->error}";
else
    echo "OK";

Para terminar, os dejo una pequeña clase con la que podréis publicar en el muro, subir una imagen o crear un evento fácilmente:

<?php
require_once 'facebook.php';

/**
 * Clase para facilitar el trabajo con Facebook. Proporciona métodos para
 * publicar imágenes en un álbum, notas en el muro, y eventos
 *
 * Ejemplos de uso:
 * $fb = new Fb();
 * $fb->publicarNota('Prueba');
 * $fb->publicarImagen('/home/zootropo/html/imagenes/mi-imagen.jpg');
 * $fb-gt;publicarEvento('Prueba de evento', 'Descripción del evento', '2011-03-08');
 */
class Fb {
    const ID_APP = 'ID APLICACION';
    const SECRETO = 'SECRETO APLICACION';
    const ACCESS_TOKEN = 'TOKEN ACCESO';
    const ID_ALBUM = 'ID ALBUM';
    const ID_PAGINA = 'ID PAGINA';
    private $fb;

    /**
     * Constructor de la clase. Crea el objeto Facebook que utilizaremos
     * en los métodos que interactúan con la red social
     */
    function __construct() {
        $this->fb = new Facebook(array(
          'appId'  => self::ID_APP,
          'secret' => self::SECRETO,
          'cookie' => true
        ));
    }

    /**
     * Publica un evento
     * @param string $titulo Título del evento
     * @param string $descripcion Descripción del evento
     * @param string $inicio Fecha o fecha y hora de inicio del evento, en formato ISO-8601 o timestamp UNIX
     * @return bool Indica si la acción se llevó a cabo con éxito
     */
    function publicarEvento($titulo, $descripcion, $inicio) {
        $params = array(
            'access_token' => self::ACCESS_TOKEN,
            'name' => $titulo,
            'description' => $descripcion,
            'start_time' => $inicio,
        );
        $res = $this->fb->api('/'.self::ID_PAGINA.'/events', 'POST', $params);
        if(!$res or $res->error)
            return false;

        return true;
    }

    /**
     * Publica una nota en el muro de la página
     * @param string $mensaje
     * @return bool Indica si la acción se llevó a cabo con éxito
     */
    function publicarNota($mensaje) {
        $params = array(
            'access_token' => self::ACCESS_TOKEN,
            'message' => $mensaje
        );
        $res = $this->fb->api('/'.self::ID_PAGINA.'/feed', 'POST', $params);
        if(!$res or $res->error)
            return false;

        return true;
    }

    /**
     * Publica una imagen en el álbum de la página
     * @param string $ruta Ruta absoluta a la imagen en nuestro servidor
     * @param string $mensaje Mensaje a mostrar en el muro, si queremos avisar
     * de la subida de la imagen
     * @return bool Indica si la acción se llevó a cabo con éxito
     */
    function publicarImagen($ruta, $mensaje='') {
        $this->fb->setFileUploadSupport(true);

        $params = array(
            'access_token' => self::ACCESS_TOKEN,
            'source' => "@$ruta"
        );
        if($mensaje) $params['message'] = $mensaje;

        $res = $this->fb->api('/'.self::ID_ALBUM.'/photos', 'POST', $params);
        if(!$res or $res->error)
            return false;

        return true;
    }
}

“¿Y por qué hebreo?”, se preguntará alguno. El motivo es sencillo, y es que, como ya vimos en Una no tan breve historia de PHP, Zeev Suraski y Andi Gutmans, los dos programadores que crearon el Zend Engine, son ambos israelíes.

Os podéis encontrar con este nombre tan críptico, por ejemplo, al utilizar el operador condicional ternario y repetir el carácter de dos puntos por accidente. Si probáis a ejecutar el siguiente código:

<?php
$modo = $_SERVER['SERVER_NAME']!=='localhost'?'Debug'::'Producción';

PHP os responderá con un mensaje parecido a este:

Parse error: syntax error, unexpected T_PAAMAYIM_NEKUDOTAYIM in /usr/local/apache/htdocs/ejemplo.php on line 2

A principios de los años 90 Tim Berners-Lee estableció las bases de la World Wide Web cuando desarrolló, mientras trabajaba en el CERN, el primer servidor web (CERN httpd) y el primer navegador de la historia (WorldWideWeb, más tarde rebautizado como Nexus). Durante los primeros meses, la web consistió en una pequeña gran colección de documentos estáticos escritos en HTML, pero no pasó mucho tiempo antes de que Robert McCool y su equipo del NCSA pensaran en la posibilidad de poder responder a las peticiones del navegador con el resultado de la ejecución de pequeños programas, permitiendo así al servidor web una mayor interacción con el usuario.

Así nació en 1993 CGI (Common Gateway Interface), como parte del servidor NCSA HTTPd, que más tarde daría origen al famoso Apache. Esta tecnología, que aún se utiliza ampliamente en los servidores web debido a su sencillez, definía una interfaz común mediante la cuál el servidor web, y por tanto el cliente, podía comunicarse con un programa situado en el servidor, utilizando para ello variables de entorno predefinidas, argumentos de línea de comandos, y la entrada y salida estándar. La mayoría de estos programas estaban escritos en C o en Perl.

El nacimiento de PHP

Y así llegamos a una tarde de otoño de 1994, en la que un programador danés en paro afincado en Toronto (Canadá), Rasmus Lerdof, se pone manos a la obra para escribir un pequeño CGI en Perl que le ayude a contabilizar las visitas que llegan a su currículum vitae, guardando este valor en una base de datos mSQL. Más tarde, como el servidor web en el que se alojaba tenía algún problema de rendimiento, Rasmus decide reescribir su script en C, para ahorrarse la carga de tener que crear un nuevo proceso de Perl cada vez que alguien visitara su web.

El pequeño script de Rasmus llama la atención de otras personas alojadas en su mismo servidor, que le piden poder utilizarlo, y van sugiriendo cada vez más y más funcionalidades. De esta forma, acaba con una pequeña colección de 30 scripts distintos, que decide combinar en una única librería C.

El siguiente paso es escribir un sencillo analizador sintáctico que busque etiquetas en el código HTML y las reemplace con la salida de las funciones correspondientes de su pequeña librería. Este analizador sintáctico va aumentando en complejidad, y Rasmus añade etiquetas condicionales, etiquetas de bucles y funciones. El danés bautizó este paquete de software, junto con algunas utilidades de uso común por esas fechas, como un libro de visitas y un contador, con el nombre de Personal Home Page Tools (Herramientas para Página de Inicio Personal) o PHP Tools.

Además, de forma paralela, Rasmus empieza a desarrollar otro CGI que analizaría consultas SQL, y facilitaría crear los formularios y las tablas correspondientes. Esta herramienta se llamó FI (Form Interpreter), y al conjunto de ambos paquetes PHP/FI.

Con todo ya listo, y tras crear una lista de correo y un pequeño FAQ, el 8 de Junio de 1995, Rasmus anuncia la primera versión oficial de PHP en los grupos de noticias. Esta primera versión, publicada bajo la licencia GPL, sólo corría en servidores UNIX y carecía de características tan básicas como el bucle for.

No obstante, el número de usuarios comienza a crecer, y algunos programadores empiezan a ayudar en el proyecto. PHP y FI se combinan creando un único binario, se reescribe el analizador sintáctico, y el paquete se renombra a Personal Home Page Construction Kit (Kit de Construcción de Páginas Personales). Con esto llegamos a la publicación de PHP/FI 2.0, el 1 de Noviembre de 1997, con una base de usuarios de unas 50.000 personas.

La contribución de Zend

Con la versión 3.0, lanzada el 6 de Junio de 1998, bajo una licencia dual GPL – PHP License, el lenguaje daría un salto de gigante en cuanto a rendimiento, funcionalidad y popularidad, alcanzando el millón de usuarios. Esto fue posible en gran parte gracias a la colaboración de Zeev Suraski y Andi Gutmans, dos programadores israelíes que descubrieron PHP/FI 2.0 cuando buscaban una herramienta para desarrollar una aplicación de comercio electrónico para la universidad, y que más tarde fundarían la famosa Zend Technologies, llamada así por la contracción de sus nombres de pila.

Zeev y Andi volvieron a reescribir el analizador sintáctico de PHP y contribuyeron en la reescritura de buena parte del resto de su código. También diseñaron una nueva API que permitía crear extensiones para PHP, atrayendo así la atención de un gran número de programadores.

Otras novedades de esta versión, lanzada para Windows 95, Windows NT, Macintosh y varias versiones de UNIX, fue la introducción de una muy básica orientación a objetos, el soporte para los sistemas de bases de datos más populares, como MySQL y PostgreSQL, y la creación de un módulo nativo para Apache. Fue también en esta versión en la que el nombre del lenguaje perdió el sufijo /FI, quedando sólo en PHP, y en la que el acrónimo cambió su significado por el que conocemos hoy en día, ‘PHP Hypertext Pre-processor’ (Pre-procesador de hipertexto PHP), tras una votación de los desarrolladores, y después de un breve periodo de tiempo en que se utilizó como nombre ‘Professional Home Pages’ (Páginas de Inicio Profesionales).

El 22 de Mayo de 2000 se lanza PHP 4, basado en el Zend Engine 1.0, una máquina virtual de código abierto, bajo licencia PHP, desarrollada también por Zeev y Andi. Desde esta versión el código fuente se compila primero a un código máquina intermedio llamado bytecode, y el Zend Engine se encarga después de ejecutar este código, al estilo Java. Esto mejoró considerablemente la velocidad de ejecución respecto de la versión anterior.

Entre las novedades introducidas en PHP 4.0 también encontramos mejoras de rendimiento en la API de extensiones, una capa de abstracción que permitía a PHP ejecutarse en la mayoría de los servidores web más populares, sesiones HTTP, control de buffer de salida, el tipo booleano, mejoras en la orientación a objetos y varias construcciones nuevas. También se pasó de usar una licencia dual GPL – PHP License, a utilizar exclusivamente la licencia PHP, lo que causó un pequeño revuelo entre la comunidad open source. Y es que Rasmus y el resto de desarrolladores no veían sentido a utilizar una licencia dual, teniendo en cuenta que los usuarios solían siempre utilizar la menos restrictiva de las dos.

Las revisiones menores de PHP 4 también introdujeron mejoras interesantes, como la inclusión de las variables superglobales en PHP 4.1.0, la desactivación por defecto de la opción register_globals en PHP 4.2.0, o la posibilidad de ejecutar los scripts desde la línea de comandos y la capa de acceso a ficheros y recursos de red a través de flujos o streams en PHP 4.3.0.

Presente y futuro de PHP

El 13 de Julio de 2004, por fin, contando el lenguaje con una base de usuarios de 15 millones de dominios, se lanza PHP 5, basado en el Zend Engine 2.0, versión que haría que PHP entrara en su madurez, y lo convertiría en un lenguaje muy agradable de utilizar. El esfuerzo principal a la hora de desarrollar esta versión se centró en una muy necesaria mejora en el soporte de la orientación a objetos, muy pobre y discutida hasta ese momento, aunque también se añadieron otras características igual de importantes, como la capa de abstracción de acceso a bases de datos PDO (PHP Data Objects u Objetos de Datos PHP), SQLite por defecto, manejo de excepciones con bloques try-catch, iteradores, mejoras en el manejo de XML gracias a la extensión SimpleXML, mejoras en la velocidad y el rendimiento, y muchas cosas más.

La versión 5.3.x, la actual a la hora de escribir estas líneas, y que fue lanzada inicialmente el 30 de Junio de 2009, introdujo también características muy interesantes, inicialmente pensadas para PHP 6, como los espacios de nombres, el late static binding (enlace estático en tiempo de ejecución), closures o funciones anónimas.

Y es que la futura sexta versión del lenguaje, que venía planeándose desde mediados de 2005, viene sufriendo retrasos desde hace un tiempo, principalmente, debido a lo ambicioso del proyecto y los problemas con el soporte completo de Unicode. Tanto es así, que el desarrollo de PHP 6 se movió a una rama en Marzo de 2010, y el desarrollo continúa en el trunk, en un código basado en la versión 5.3.

Pero el futuro de PHP se presenta más brillante que nunca, no obstante, con millones de usuarios en todo el mundo y siendo utilizado en un 75% de los servidores, alcanzando el puesto de cuarto lenguaje más utilizado del mercado según TIOBE; con novedades tan útiles en un futuro próximo como los traits y con frameworks que nada tienen que envidiar a Django o Ruby on Rails, como Yii, y a Struts o Spring MVC, como Zend o Symfony.