Programación

Smarty es un sistema de plantillas diseñado para acelerar la presentación de las páginas html. Para poder emplear la cache simplemente debes instalar smarty en tu frameword de desarrollo e introducir las siguientes líneas:

$plantilla = new Smarty;
$plantilla->caching = 1; //Activa la cache
$plantilla->display('planilla.tpl'); //El fichero planilla.tpl debe contener la planilla a devolver


También es posible llamar a

$html = $plantilla->fetch('planilla.tpl');

Para no volcar al navegador el html y tenerlo almacenado en la variable $html.

Antes de llamar a display o a fetch podemos modificar el comportamiento del sistema de caché de smarty

Por ejemplo:

$plantilla->cache_dir = '/tmp/smarty/';

Grabará las planillas cacheadas en este directorio (smarty cachea el contenido en disco por defecto)

$plantilla->cache_lifetime = 300;

El contenido permanece en cache 5 minutos (300 segundos) antes de ser reemplazado. El valor por defecto es una hora.

$plantilla->compile_check = true;

Verifica si la plantilla ha sido actualizada desde la última vez que se regeneró la caché. Introduce una pequeña sobrecarga al tener que averiguar y comparar la fecha de modificación de la plantilla.

$plantilla->force_compile = true;

Siempre regenerará la cache

$plantilla->is_cached('plantilla.tpl');

Detecta si una plantilla está en el cache o no.

$plantilla->assign('variable',$var);

La plantilla puede ahora leer la variable $var, con el nombre {variable} generando así contenido realmente dinámico

$plantilla->clear_cache('plantilla.tpl');

Elimina la cache para esta plantilla

$plantilla->clear_all_cache();

Elimina todas las caches (en el directorio de cache)

Es posible eliminar el cache por grupos de plantillas. Estos grupos de plantillas se pueden definir de la siguiente manera:

$plantilla->display('index.tpl','sports|basketball');

Y entonces borrar la caché del grupo sports|basketball así:

$smarty->clear_cache(null,'sports|basketball');

o borrar sólo el index.tpl del grupo sports|basketball así:

$smarty->clear_cache('index.tpl','sports|basketball');

Funcionando como una especie de espacio de nombres

Es posible introducir contenido no cacheable dentro de una plantilla cacheada utilizando {insert}.

{insert} funciona de una manera idéntica a {include} con la particularidad de su comportamiento ante el cache.

Veamos como funciona con un ejemplo

{insert name="obtenerPublicidad" localizacion=#banner_location_id# id=#site_id#}

Lo que hará a continuación smarty será llamar a la funcion insert_obtenerPublicidad, que debes tener definida en tu código, pasandole como argumento un array asociativo.

Suponiendo que #banner_location_id# valga 5 y #site_id# valga 8. Se ejecutará:

insert_obtenerPublicidad(array('localizacion'= > '5' , 'id'= > '8'));

y lo que devuelva esta función será añadido en la plantilla.

Para saber más sobre smarty y su sistema de cache visita su página oficial.

Otros métodos para acelerar tu servidor web a otros niveles son memcache, x-cache o apc.

Xcache es una librería que sirve para almacenar en cache los códigos de operación de nuestros scripts php. Aunque esta frase pueda parecer algo oscuro y difícil de entender sólo significa que tendremos pre-parseados e interpretados nuestros scripts por el core de php. De manera que en ejecuciones posterires no hará falta pasar por todas las fases de validación, análisis, tratamiento e interpretación del código. Nos encontramos pues ante una especie de compilación de código php. Lo mejor es que el código no está realmente compilado y podemos modificarlo de la forma habitual forzando que se recree el cache sólo para los scripts que hemos modificado.

De esta manera se optimiza el rendimiento de las páginas php en los servidores. Almacenando en RAM (shm) de cache el estado compilado de los scripts php se ahorra tiempo de compilación. Según sus desarrolladores es posible obtener hasta 5 veces más de velocidad en la generación de páginas.

La página oficial de Xcache es la siguiente: Xcache

Actualmente se encuentra en versión estable y sólo disponible para linux. Soporta varias versiones de php desde la 4.3 hasta la 5.3 (e incluso para pre versiones de php6). Extrañamente no es soportado para la versión 5.0.

La optimización de las consultas a la base de datos de tus aplicaciones web es de vital importancia, no sólo ha la hora de medir el tiempo en el que una página se carga sino también cuando el tráfico de tu máquina se incrementa o cuando el hardware tiene trabajo extra debido a un mal diseño de esas consultas.

Incluso aunque tengamos implementadas soluciones de caché (librerías de mysql con cache, memcache o similares) la optimización de las consultas sigue teniendo un relevancia plena. En este artículo resumiremos que herramientas podemos emplear para optimizar, detectar y solucionar problemas en las consultas a tu base de datos que lastran tu aplicación llegando ha hacerla inutilizable o requiriendo una inversión mayor en equipo cuando no debería.

La primera de las herramientas, interna al propio servidor mysql es la sentencia explain, explain también es un alias del comando describe cuando se escribe a continuación un nombre de tabla. Explain o describe devolverá información sobre la estructura de la tabla. La otra sintaxis propia de explain, y la que nos interesa, es la que sirve para analizar como mysql ejecuta una sentencia select.

EXPLAIN [EXTENDED] SELECT select_options

Explain hará que el optimizar de mysql nos devuelva información sobre como se procesará la sentencia SELECT incluyendo información de que tablas usará como utilizará los joins, en que orden y en que modo utilizará los indices que haya definidos en las tablas. Todo esta información se conoce con el nombre de información sobre plan de ejecución de mysql.

Esta información es muy valiosa y se puede emplear para optimizar nuestros selects. Con esta información podremos por ejemplo decidir añadir nuevos índices a nuestras tablas o modificar nuestros selects para que se fuerte un determinado orden para nuestros joins.

Explain devuelve una fila de información por cada tabla empleada en la consulta. Las tablas son listadas en el orden en el que mysql las leerá a la hora de procesar la consulta. Si añadimos EXTENDED mysql nos dará información adicional en forma de warning, para poder verla debemos ejecutar un SHOW WARNINGS. La información extra contiene como el optimizador da
nombre cada una de las tablas y columnas de la sentencia select y puede que otras notas sobre el proceso de optimización.

Veamoslo con un ejemplo bien simple:

mysql> select 1;
+---+
| 1 |
+---+
| 1 |
+---+
1 row in set (0.00 sec)

mysql> explain select 1;
+----+-------------+-------+------+---------------+------+---------+------+------+----------------+
| id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |
+----+-------------+-------+------+---------------+------+---------+------+------+----------------+
| 1 | SIMPLE | NULL | NULL | NULL | NULL | NULL | NULL | NULL | No tables used |
+----+-------------+-------+------+---------------+------+---------+------+------+----------------+
1 row in set (0.00 sec)


Cada columna que devuelve EXPLAIN tiene el siguiente significado:

id - identificador, es sólo una secuencia numérica autoincrementada para cada una de las filas del explain
select_type - Debe ser uno de los siguiente tipos
SIMPLE - No usa subqueries ni UNION
PRIMARY - Último SELECT
UNION - Segunda o última sentencia SELECT en una UNION
DEPENDENT UNION - Segunda o última sentencia SELECT en una UNION, dependiente de otra query
SUBQUERY - Primera SELECT en una subquery
DEPENDENT SUBQUERY - Primera SELECT en una subquery, dependiente de otra query
DERIVED - Tabla SELECT derivada (subquery en una clausula FROM)
UNCACHEABLE SUBQUERY - Una subquery cuyo resultado no puede ser cacheado y debe ser re-evaluado para cada file de la otra query.

table - la tabla a la que se refiere la información
tipo - el tipo de unión empleado, que puede ser:
sytem - SYSTEM SELECT sólo hay una fila en la tabla (tipo especial del tipo const)
const - La tabla tiene como mucho un sola fila resultado, que es leída al principio de la operación convirtiéndose en una constante para el resto de las operaciones del select (operación muy rápida)
eq_ref - Una fila es leída de la tabla por cada combinación de filas en las tablas previas.
ref - Todas las filas con valores de índices validos son leídos de esta tabla por cada combinación de filas de las tablas previas.
fulltext - El join se utiliza mediante un índice FULLTEXT
ref_or_null - Este tipo de join es como el ref, pero además MySQL hace una busqueda extra por filas que contengan valores NULL
index_merge - la columna key en la fila de salida contiene una lista de indices a utilizar, y key_len contiene una lista de las claves más largas para los índices utilizados.
unique_subquery - Este tipo sustituye al ref para algunas subqueries IN de el siguiente tipo de estructuras: value IN (SELECT primary_key FROM single_table WHERE some_expr)
index_subquery - Este tipo join es similar al unique_subquery. Este sustituye subqueries IN, pero funciona para índices no únicos en subqueries del siguiente tipo: value IN (SELECT key_column FROM single_table WHERE some_expr)
range - Solamente las columnas que están en un rango dado son retornadas, empleando un índice para seleccionar las columnas. La columna key indica que índice es utilizado. key_len contiene el índice más largo de la parte del índice más larga utilizada. ref es NULL para este tipo.
index - Este ipo de join es el mismo que el de ALL, con la excepción de que sólo se realiza el escaneado a través de un índice. Esto es mas rápido que ALL ya que los ficheros índice son generalmente más pequeños que el fichero de datos.
all - Se realiza un escaneado de toda la tabla por cada combinación de filas de las tablas anteriores.

Estos tipos están ordenados en cuando a lo mejor o peor en cuanto a optimización. Así un tipo all sería lo peor y un tipo system sería lo mejor. Reducir de un tipo a otro, cambiando o creando índices para una determinada tabla o modificando la estrucutra misma de la petición es la tarea básica que debemos intentar para optimizar nuestra querys.

possible_keys - La columna indica que índices se pueden seleccionar para ser usados a la hora de encontrar filas en la tabla.
key - Índica que índice es empleado finalmente (podría se uno que no estuviera listado en las possible_keys).
key_len - Longitud del índice empleado
ref - Muestra que columnas o constante son empleadas para comparar con el índice
rows - Número de filas que MySQL piensa que debe examinar al ejecutar la petición
extra - Información adicional sobre la consulta.

Cuando modifiques la estructura de una tabla o añadas índices recuerda ejecutar un:

ANALIZE TABLE nombre_tabla;

Esto hará que el optimizador analize adecuadamente la tabla, los datos los usará para ayudarle a determinar la mejor estrategia en consultas posteriores. Tras modificar la tabla ejecuta ANALIZE y vuelve a ejecutar un EXPLAIN para observar las modificaciónes en el plan de ejecución de la consulta.

Firefox, uno de los navegadores más empleados en la actualidad y el más importante de las alternativas "open source" acaba de anunciar la salida de la primera "release candidate".

Este navegador podría ser el primero en desbancar a internet explorer como navegador más empleado.

La versión puede ser descargada directamente desde las páginas de mozilla. Pero se avisa que sólo es válido para realizar pruebas. No presenta muchas características nuevas respecto a las betas anteriores por lo que nos encontramos ante una versión más estable que sólo (esperemos) solucione bugs de las betas anteriores.

En el desarrollo de software la ausencia de errores es una autentica quimera. Tantos son los factores que finalmente pueden alterar el flujo que consideramos "normal" en el programa como los errores propios a cualquier actividad humana.

    Uno de los métodos más utilizados para realizar pruebas a nuestro software es el llamado de pruebas unitarias (unit testing). La base de este método es el hacer pruebas en pequeños fragmentos de nuestro programa. Estos fragmentos deben ser unidades estructurales de nuestro programa encargados de una tarea especifica, en programación procedural u orientada a objetos podemos afirmar que estas unidades son los métodos o las funciones que tenemos definidos.

    Tras realizar estas pruebas sobre los elementos unitarios de nuestro programa podremos eliminar gran parte de los errores de los que podría adolecer. Como ya sabemos cualquier prueba demuestra no la ausencia de errores sino que revela la presencia de ellos. Las pruebas unitarias no revelan errores en la integración de las partes unitarias ni tampoco otros problemas como el bajo rendimiento de las aplicaciones o problemas derivados del sistema sobre el que está ejecutándose nuestro programa.

    El objetivo de las pruebas unitarias es el aislamiento de partes del código y la demostración de que estas partes no contienen errores.

    Una vez creados el conjunto de pruebas unitarias sobre un fragmento de código los beneficios obtenidos, incluso antes de ejecutar ninguna prueba, son múltiples. Pasaré a enumerarlos:

Simplificación de la integración
    Las pruebas unitarias eliminan las posibles incertidumbres y errores en lo que se espera de cada una de las unidades ayudando a entender la integración de cada una de las partes.

Refactorización de código
    Una vez refactorizado el código; las mismas pruebas unitarias nos pueden servir para probar el nuevo código asegurándonos de que este sigue siendo válido bajo la nueva implementación.

Documentación
    Las pruebas unitarias sirven como método de documentación mismo. Los desarrolladores pueden ver a través de las pruebas unitarias cual es el objetivo de las distintas partes del código de una manera básica.

Diseño
    Cuando se desarrolla el software las pruebas unitarias pueden tomar el lugar del diseño formal. Cada prueba unitaria puede ser visto como un elemento de diseños que especifica las clases, los métodos y el comportamiento observable de la aplicación.

Dentro de muy poco tiempo tendremos entre nosotros la próxima versión de php, php6. Esta versión ya está disponible en php.net para su descargar. Aunque la adopción de php5 y desaparición de php4 fue un proceso algo más lento de lo esperado. PHP6 no supone un cambio tan radical como el que sucedió con la versión anterior por lo que es de esperar, si todo va bien, que la adopción de esta versión sea más rápida.

    PHP sigue siendo el lenguaje script para desarrollos web más popular y la lista de nuevas características que vienen con esta nueva versión pueden situarle en posiciones todavía más destacadas.

Estas son las novedades que incorporará el lenguaje:

Soporte para Unicode

    PHP6 soporta Unicode en la mayoría de sus funciones principales. Esta característica tendrá un fuerte impacto ya que permitirá una mayor capacidad de internazionalización al soportar un conjunto de caracteres mucho mayor mediante sus funciones nativas.

Espacios de nombres (Namespaces)

    PHP6 soporta namespaces. Una manera de evitar colisiones entre los nombres que asignemos a las diferentes clases sin tener que estar elaborando notaciones especificas para evitar este problema. De esta manera al crear tu propio espacio de nombres no tienes que preocuparte por si php tiene una clase con el mismo nombre o si una librería externa podría fallar debido a una colisión en los nombres de clase.

    No es obligatorio el uso de namespaces lo que permite que el código de la versión 5 sea compatible con esta nueva caracteristica. Los namespaces aparecen ya soportados en la version php 5.3

Ejemplo:

<php
namespace ACC
class Dummy {}
$dummy = new ACC::Dummy();
?>

SOAP

    SOAP es uno de los protocolos empleados por los servicios web soportado en otros lenguajes como JAVA. SOAP permite la interoperativilidad entre diferentes plataformas.

    PHP6 tendra una extensión SOAP que nos permitirá una manera más sencilla de implementar tanto clientes como servidores SOAP

XML

    A partir de PHP5.1 XMLWriter y XMLReader han formado parte del núcleo de PHP lo que permite construir y leer mensajes XML sin tener que preocuparte de los detalles más complejos de este formato. PHP6 mejora esta funcionalidad

Cosas que se han eliminado en PHP6

    Además de los nuevas características añadidas, PHP 6 no tendrá algunas de las funciones y características propias de versiones anteriores. La mayoría de estas características, como register_globlas y safe_mode, son consideradas negativamente en la versión actual. Los que se oponen ha estas modificaciones arguyen que estos cambios provocará el fallo en los scripts actuales en cuanto se actualize a la nueva versión.

Estas con las características eliminadas en la próxima versión de PHP

magic_quotes
register_globals
register_long_arrays
safe_mode

Magic quotes

    Por razones de portabilidad, rendimiento e inconveniencia se recomienda ya no utilizar esta característica. magic_quotes escapa cadenas que proceden de datos introducidos por el usuario $_POST, $_GET, $_REQUEST y que podrían ser empleados en una sentencia SQL originando fallos en la seguridad de la aplicación si se introducen determinadas secuencias de caracteres. Cuando se elimine esto de PHP también desaparecerá la función get_magic_quotes_gpc(). En su lugar para eliminar este riesgo de seguridad debemos recurrir a funciones del estilo mysql_escape_string para mysql y pg_escape_string para PostgreSQL.

Register globals

    Register globals permitía inicializar variables a partir de datos externos ($_GET,$_POST,$_REQUEST) lo que potencialmente podría producir importantes errores en la aplicación y su seguridad. Register globals paso de estar activo a desactivo por defecto a partir de la versión 4.2

Register long arrays

    Se eliminan los variables superglobales $HTTP_*_VARS se ha mantenido por razones de compatibilidad, aunque se aconsejaba dejar esta característica deshabilitada para mejorar el rendimiento de los scripts.

Safe mode

    Cuando esta habilitada safe mode se aseguraba de que el propietario del fichero que se está ejecutando coincida con el propietario del fichero que se está empleando. Originariamente fue un intento para securizar determinadas operaciones en un entorno en el que el servidor estaba compartido.

Etiquetas PHP

    Ya no se permiten ni etiquetas cortas ni el formato ASP <% %> para encerrar fragmentos de código php

FreeType 1 y GD1

    El soporte para FreeType 1 y GD 1 será eliminado completamente de PHP debido a que ambas librería ya no son mantenidas desde hace bastante tiempo. Las nuevas versiones de ambas librerías si que seguirán en PHP ya que proporcionan mejor funcionalidad.

Ereg

    La extensión ereg también desaparecerá. En su lugar ya tenemos las expresiones regulares compatibles Perl (PCRE - Perl-Compatible Regular Expressions). De esta manera ereg() y eregi() pueden ser sustituidas por preg_match() y ereg_replace() y ereg_replacei() por preg_replace.

PHP 5.3

    Algunas de las características mencionadas previamente para la nueva versión ya han sido portadas a la versión 5.3 de PHP para que el cambio de versión no sea tan violento como son los Namespaces y la inclusión en el núcleo de PHP de XMLReader y XMLWriter.

Las funciones getopt y getopt_long sirven para automatizar el paso de parámetros al programa en linea de comandos. Estas funciones también pertenecen a la librería C de GNU. Sus usos y ejemplos son inmediatos en cuando comenzamos a escribir comandos en nuestra consola.

# ls -la
# find . -name "*.mp3"

    -la y -name son los parámetros que deben ser analizados cuando invocamos estos programas para su correcto funcionamiento. Getopt y getopt_long nos servirán de mucha ayuda para analizar y detectar todos esto parámetros.

    Debemos incluir el archivo de cabecera unistd.h para poder emplear getopt una vez hecho esto la firma de la función es la siguiente:

int getopt(int argc, char * const argv[], const char *optstring);

    Para getopt_long también necesitamos el archivo de cabecera unistd.h:

int getopt_long(int argc, char * const argv[], const char *optstring, const struct option *longopts, int *longindex);

    getopt emplea o fija varias variables, estas son:

int opterr - Si le damos un valor igual a 0 getopt no indicara imprimirá en stderr ningún mensaje de error (por defecto si que lo hará)
int optopt - Si getopt encuentra una opción no reconocida o sin un parámetro necesario, entonces almacena este caracter en esta varible.
int optint - La variable fijada por getopt nos da el indice del parámetro a ser analizado.
char* optarg - Fijada por getopt y que nos da la posición del argumento a analizar.

    La función getopt obtiene el siguiente argumento en la lista de argumentos que se le pasan al programa. Normalmente los argumentos son los pasados a la función main al comienzo de nuestro programa (argc y argv)

    optstring es una cadena que especifica todos los caracteres válidos para nuestro programa. Un carácter seguido de dos puntos ':' indica que esta opción necesita un argumento y si está seguida de dos dobles puntos '::' indicamos que ese argumento es opcional (sólo GNU), por lo tanto la cadena:

"lac:d::"

    Indica que nuestro programa acepta el parametro -l, -a el parámetro -c seguido de un argumento y -d que puede no estar seguido de un argumento esto podría ser:

-l -a -c /tmp/a.txt -d

ó

-la -d -c /tmp/a.txt

etc

    getopt va devolviendo el último parámetro analizado y al final cuando no queda ningúno más por analizar devuelve -1

    Si la opción tiene un argumento este es colocado dentro de optarg

    El argumento especial '--' termina el análisis de opciones posteriores

    Si getopt encuentra una opción que no aparece en la lista de opciones disponibles devuelve '?' e introduce en la variable externa optopt este argumento.

    Este es un ejemplo del uso de getopt:

#include
#include
#include
#include

int main (int argc, char **argv)
{
int aflag = 0;
int bflag = 0;
char *cvalue = NULL;
int index;
int c;

opterr = 0;

while ((c = getopt (argc, argv, "abc:")) != -1)
switch (c)
{
case 'a':
aflag = 1;
break;
case 'b':
bflag = 1;
break;
case 'c':
cvalue = optarg;
break;
case '?':
if (optopt == 'c')
fprintf (stderr, "Option -%c requires an argument.\n", optopt);
else if (isprint (optopt))
fprintf (stderr, "Unknown option `-%c'.\n", optopt);
else
fprintf (stderr,
"Unknown option character `\\x%x'.\n",
optopt);
return 1;
default:
abort ();
}

printf ("aflag = %d, bflag = %d, cvalue = %s\n",
aflag, bflag, cvalue);

for (index = optind; index < argc; index++)
printf ("Non-option argument %s\n", argv[index]);
return 0;
}

La función alloca reserva espacio en la pila de la función que lo llama, devolviendo un puntero ha este espacio reservado. Este espacio temporal es automáticamente liberado cuando la función que llama a alloca retorna.

Esta es la firma o prototipo de la función:

void *alloca(size_t size);

Su declaración está en el archivo de cabecera alloca.h. El parámetro que se le pasa es el número de bytes que se desean reservar. Alloca además devuelve un puntero nulo cuando no tiene éxito al reservar memoria.

Alloca presenta una serie de ventajas con respecto a malloc a la hora de reservar memoria. Alloca no produce segmentación en los bloques de memoria reservados, ya que el espacio se reserva en la pila. Alloca apenas malgasta espacio y es bastante rápido. Cuando la función que llama a alloca es abandonada la memoria es liberada evitando posibles memory leaks. Esto también ocurre en caso de error en la función, la memoria es liberada de inmediato.

Ejemplo de función que emplea alloca:

int open2(char *str1, char *str2, int flags, int mode)
{
char *name = (char *) alloca (strlen (str1) + strlen (str2) + 1);
stpcpy (stpcpy (name, str1), str2);
return open(name, flags, mode);
}

Para tener un código similar empleando sólo malloc y free debemos escribir:

int open2 (char *str1, char *str2, int flags, int mode)
{
char *name = (char *) malloc (strlen (str1) + strlen (str2) + 1);
int desc;
if (name == 0)
fatal ("virtual memory exceeded");
stpcpy (stpcpy (name, str1), str2);
desc = open (name, flags, mode);
free (name);
return desc;
}

Alloca, sin embargo, también tiene algunas desventajas:

Si intentas reservas más memoria de la que la máquina puede reservar no obtendrás un mensaje de error claro. En su lugar tendrás una señal fatal como las obtenidas en un recursion infinita; probablemente una violación de segmento.

Algunos sistemas no-GNU no tienen soporte para alloca, convirtiendo a alloca en menos portable. Sin embargo hay algunas implementaciones en C para solventar estas deficiencias en estos sistemas.

Sigue este link para saber más de reserva de memoria