Novanebula blog

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.

Losantos no tiene desperdicio con una camara delante y alguien que le ria las "gracias".
Sin lugar a dudas vomitivo... Habría que explicarle lo que es un dictador (FRANCISCO FRANCO) y lo que no (Evo Morales, Hugo Chavez, ...)



Una persona que desea la enfermedad y la muerte a sus iguales creo que se define por sí misma.

Este comando linux tiene ciertas peculiariedades que lo alejan de su utilización en consola y lo hacen realmente útil para el programación de scripts. Seguramente el hecho más relevante que reafirma lo que acabamos de decir en la manera en la que test devuelve la información; simplemente a través de su código de retorno. O sea que después de ejecutarlo por consola no veremos absolutamente nada sólo el prompt de nuestro terminal pidiendonos que introduzcamos la siguiente orden.

Tes es un comando para evaluar expresiones devolviendo 0 (cómo código de retornos) en el caso de que la expresión evaluada sea verdadera o un valor distinto de 0 en el caso de ser falso. Esto es la manera habitual para la shell, completamente diferente a la programación en C donde 0 es evaluado como falso y diferente de 0 como verdadero (aunque C no tiene tipos booleanos). Bueno que me estoy liando.

El caso es que test es capaz de analizar cadenas de texto, enteros y ficheros evaluando sus propiedades para analizar lo que más nos interese de estos elementos. Así por ejemplo para cadenas es capaz de determinar si estamos ante una cadana vacia o no (-n), si su longitud es cero (-z) si es igual a otro cadena (=). Para enteros puede determinar si son iguales, mayores o menores que otro dado y para ficheros que en mi modesta opinion es donde radica uno de sus puntos puede determinar un montón de cosas como:

FILE1 -ef FILE2
FILE1 y FILE2 son el mismo fichero en realidad (mismo inodo y dispositivo)

FILE1 -nt FILE2
FILE1 es más reciente que el FILE2 (por la fecha de modificación)

FILE1 -ot FILE2
FILE1 es más antiguo que FILE2

-b FILE
FILE existe y es un fichero de bloque especial (no un fichero regular, ver mknod)

-c FILE
FILE existe y es un dispositivo de tipo caracter (ver mknod)

-d FILE
FILE existe y es un directorio

-e FILE
FILE exite (sin entrar en otras consideraciones como en el caso de los otros parámetros)

-f FILE
FILE existe y es un fichero regular

-g FILE
FILE existe y tiene marcado el bit de GUID (id de grupo)

-G FILE
FILE existe y es poseido por el EGUID (id de grupo efectivo)

-h FILE
FILE existe y es un enlace simbólico (igual que el modificador -L)

-k FILE
FILE existe y tiene marcado el bit sticky

-L FILE
FILE existe y es un enlace simbólico (igual que el modificador -h)

-O FILE
FILE existe y es poseido por el EUID (id de usuario efectivo)

-p FILE
FILE existe y es una tuberia con nombre (ver FIFOs)

-r FILE
FILE existe y el usuario actual tiene permiso de lectura sobre él

-s FILE
FILE existe y tiene un tamaño mayor que cero

-S FILE
FILE existe y es un fichero tipo socket

-t FD
el descriptor de fichero FD esta abierto en una terminal

-u FILE
FILE exite y su SUID está marcado

-w FILE
FILE existe y el usuario actual tiene permiso de escritura sobre él

-x FILE
FILE existe y el usuario actual tiene permiso de ejecución (o busqueda) sobre él

Además test es capaz de concatenar varias expresiones empleando AND o OR lógicos con los siguientes modificadores:

EXPRESSION1 -a EXPRESSION2 (AND lógico)


EXPRESSION1 -o EXPRESSION2 (OR lógico)



Como ya he comentado antes test se emplea sobre todo en programación bash en instrucciones condicionales por acabar el articulo con un par de ejemplos que ilustraran claramente su utilización:

file="/tmp"
if [ -k $file ]
then
echo "El directorio /tmp tiene el bit sticky marcado";
fi


Otro ejemplo

cadena="hola"
if [ $cadena = "hola" ]
then
echo "Hola mundo!";
fi


Observad que en los ejemplos no hemos puesto ningún test pero es que en programación en bash y en este tipo de construcciones el corchete abierto [ es sinónimo de test (y por razones de eficiencia en un builtin (bash lo tiene incluido internamente y no llama al comando test al que emula)

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.