Minify es una APP para PHP 5 que nos ayudará a seguir muchas de las reglas SEO de Yahoo!

Combina muchos archivos CSS y JS, elimina espacios en blanco y comentarios innecesarios y los deja en el servidor con compresión gzip y unos headers óptimos para el cliente.

Esto se resume en mayor velocidad de carga y cumplimiento de las reglas SEO de yahoo!

Antes de usar Minify:

El proyecto se publicó recientemente en google code: Minify on google code

Hoy mismo hablé sobre el uso de mysql_connect pero ahora quiero hablaros de la clase MySQLi que un user de CUH (p3ll3) comentó sobre ella y yo no la habia tenido en mente.

Un código básico de MySQLi:

<?php
$con = new MySQLi('host', 'usuario', 'pass', 'db');
$query = $con->Query("SELECT algo, otro FROM tabla WHERE id = 1");

while ($q = $query->fetch_object()) {
    echo "Hola soy ".$q->algo." y ". $q->otro;

}
$query->close(); $con->close();
?>

Como se puede comprobar es bastante sencillo, creamos un objeto con la sentencia new, le decimos que se trata de MySQLi y le pasamos los parámetros de conexión: host, usuario, contraseña y base de datos, aquí ya se nota una mejora por el hecho de no tener que usar mysql_select_db().

Luego para ejecutar una consulta simplemente tomamos el objeto y le indicamos la acción Query seguida de la consulta.

Para accesar a los datos lo hacemos igual que con mysql_query solo que en el while en ves de poner mysql_fetch_array() ponemos la variable y fetch_object().

A la hora de acceder a los datos normalmente lo hariamos como un array $q['algo'] pero con MySQLi se hace así $q->algo.

Eso es todo referente a MySQLi

Ayer hablabamos que el compilador de PHP era un JIT.

Hoy podemos obtener más información gracias a vivaPHP!

Según el ingeniero Haiping Zhao, HipHop for PHP les permitió reducir un 50% el uso de sus CPU lo cual implica un mejor rendimiento en la aplicación Facebook.

Hip Hop for PHP lleva ya 2 años de desarollo, pero reconocen que aún no está finalizado y que la actual versión puede considerarse una beta.
Se ha liberado bajo la misma licencia de PHP lo que permitirá a la comunidad acabar el desarollo de la aplicación dando su punto de vista y sus ideas.

Zhao nos explica que es realmente HipHop:

“HipHop no es técnicamente un compilador. En su lugar es un transformador de código. HipHop transforma tu código fuente PHP en un altamente optimizado código C++ y luego usa g++ (GNU C++) para compilarlo. HipHop ejecuta el código fuente en una manera semánticamente equivalente y sacrifica algunas características raramente usadas -como eval()- a cambio de una performance mejorada. HipHop incluye el transformador de código, una reimplementación del runtime de PHP y una re-escritura de varias extensiones de PHP comunes para aprovechar estas optimizaciones”.

Fuente: vivaPHP!

Luego de mucho tiempo trabajando con la función date(), creando campos INT en MySQL y luego usando una función para calcular a partir de ese INT la fecha que almacena (al mas puro estilo SMF) creo haber dado con la fórmula perfecta, al menos para mi, de trabajar con este dato.

El proceso va orientado a una web con sistema de noticias, comentarios, peticiones y demás por lo que es importante tener un registro de fechas y horas.

Empezamos montando la tabla de ejemplo

mysql> DESCRIBE horas;
+-------+-----------+------+-----+-------------------+--------------------------+
| FIELD | Type      | NULL | KEY | DEFAULT           | Extra
   |
+-------+-----------+------+-----+-------------------+--------------------------+
| hora  | timestamp | NO   |     | CURRENT_TIMESTAMP | ON UPDATE CURRENT_TIMESTA
MP |
+-------+-----------+------+-----+-------------------+--------------------------+
 
mysql> SELECT * FROM horas;
+---------------------+
| hora                |
+---------------------+
| 2010-01-28 15:38:26 |
| 2010-01-28 15:38:49 |
| 2010-01-28 15:38:54 |
+---------------------+
3 rows IN SET (0.00 sec)

Se puede apreciar claramente que estamos utilizando el tipo timestamp y como valor por defecto CURRENT_TIMESTAMP.
Podemos apreciar que estas funciones guardan los datos en formato EEUU (2010-01-28 15:38:54), cosa que no nos interesa y por la cual normalmente buscariamos otro método, pero aquí viene lo interesante.

La función DATE_FORMAT

Con esta función nos podemos permitir el lujo de formatear las fechas a nuestro anotjo a la hora de hacer las consultas.

Un ejemplo:

mysql> SELECT DATE_FORMAT(hora, '%H:%i:%s %e/%m/%y') AS hora FROM horas;
+-------------------+
| hora              |
+-------------------+
| 15:38:26 28/01/10 |
| 15:38:49 28/01/10 |
| 15:38:54 28/01/10 |
+-------------------+

Como se aprecia en el ejemplo tenemos una hora y fechas perfectamente formatadas.

Tratando las fechas en PHP

Ahora ya solo importa como vayamos a utilizar esta información, para el ejemplo yo voy a comprobar que se haya escrito hace menos de una hora, hoy o ayer, en caso de no ser ninguno de estos casos muestro la fecha mas no la hora.

He agregado un valor y modificado dos para que se produzca cada caso, así que ahora tenemos:

mysql> SELECT DATE_FORMAT(hora, '%H:%i:%s %e/%m/%y') AS hora FROM horas;
+-------------------+
| hora              |
+-------------------+
| 15:38:26 28/01/10 |
| 13:38:49 28/01/10 |
| 22:38:54 27/01/10 |
| 22:38:54 25/01/10 |
+-------------------+
4 rows IN SET (0.01 sec)
 

El código encargado de tratar con las fechas es:

<?php

$con = mysql_connect('localhost','root','') or die(mysql_error());
mysql_select_db('z_test',$con) or die(mysql_error());

$query = mysql_query("SELECT DATE_FORMAT(hora, '%H:%i:%s %e/%m/%y') 
                     AS hora FROM horas;",$con);

while ($list = mysql_fetch_array($query)) {
   $all = explode(' ', $list['hora']);
   $data = explode('/', $all[1]);
   $time = explode(':', $all[0]);

   echo '<br />Publicado: ';
   
   if (date('H') - $time[0] <= 1 && date('d') == $data[0])
      echo 'Hace una hora';
   else if (date('d') == $data[0])
      echo 'Hoy';
   else if (date('d') - $data[0] == 1)
      echo 'Ayer';
   else
      echo $all[1];
}

?> 


Y para finalizar la salida de la página:

Publicado: Hace una hora
Publicado: Hoy
Publicado: Ayer
Publicado: 25/01/10

Espero que os sirva para un futuro.

Me encuentro diseñando un par de aplicaciones y este es un tema que siempre te planteas, cual tengo que utilizar?

Una forera de elhacker.net (^Tifa^) me recomendó un servidor con InnoDB para consultas Insert y Update y otro con Myisam para Select, pero claro... no todos podemos permitirnos tal cosa, y yo menos.

Así que en base a ciertos valor tendremos que "jugarnosla" por uno de ellos.
Vamos a exponer los principales puntos que se comentan en la red, que no todos, pues no soy ningún experto.

InnoDB:
- En general se recomienda para consultas Insert y Update por su integridad a la hora de guardar datos
- Lo que lo convierte en mas lento
- Pero mas seguro (bajo cortes de luz, por ejemplo, si la consulta no se ejecutó completamente no se guarda y así no recibimos la mitad de los datos corruptos)
- También tiene las Foreng Keys (FK), lo cual lo hace muy util para una base de datos optimizada

Myisam:
- Se recomenda para aquellos diseños en los que suele haber mas SELECT que no Insert o Update
- No garantiza la integridad de nuestros datos,
- lo cual lo convierte en mas rapido
- pero menos seguro a lo que datos se refiere
- Quizá su mayor desventaja es que no tiene las preciadas FK
- Los Text se indexan con mayor desempeño, lo cual permite crear una "specie de buscador" mas eficiente que en InnoDB

A grandes rasgos quizá esto sea lo mas importante a destacar

Conclusión propia:

Mi conclusión es siempre decantarme por InnoDB (si necesito FK), soy un negado del SQL si algún dia le meto mas tiempo y aprendo a usar los TRIGGERS quizá mi visión del mundo cambie. De momento prefiero utilizar InnoDB y sus amadas FK para mis base de datos relacionales.

Conclusión de otras entidades:
Otros blogs, web, docuemntos, dicen que si tu sitio es mas propenso a recibir datos que no a mostrarlos, tu motor es InnoDB, como el caso no se suele producir frecuentemente, por regla general el motor a usar es myisam.
Quizá lo lógico, bajo esa perspectiva, es tener alguna tabla tipo un log de acciones con un motor InnoDB y el resto usando myisam.

En definitiva, cada uno escoja lo que mas le convenga de acuerdo a su necesidad o gustos. El post pretende ser una guia para empezar a tomar conciencia de que es cada motor y en que se diferencian. A partir de este punto queda investigarlos un poco mas y tomar la decisión de cual de ambos necesita nuestra aplicación.

PHP Benchmark nace como un sitio en el cual su único objetivo es demostrar que no todos los procesos similares de PHP funcionan a la misma velocidad, podeis visitar la página, pero para aquellos que no les gusta el inglés dejo las partes que me parecieron mas curiosas:



+ 105 % comillas simples (') en una string vacia: $tmp[] = ''';
+ 102 % comillas dobles (") en una string vacia: $tmp[] = "";
+ 100 % simples ('). 20 bytes de texto: $tmp[] = 'aaaaaaaaaaaaaaaaaaaa';
+ 103 % dobles ("). 20 bytes de texto: $tmp[] = "aaaaaaaaaaaaaaaaaaaa";
+ 102 % simples ('). 20 bytes de teto y 3 $: $tmp[] = 'aa $ aaaa $ aaaa $ a';
+ 106 % dobles ("). 20 bytes de teto y 3 $: $tmp[] = "aa $ aaaa $ aaaa $ a";
+ 100 % dobles ("). . 20 bytes de teto y 3 \$: $tmp[] = 'aa \$ aaaa \$ aaaa \$ a';

Conclusión: en este caso podemos llegar a la conclusión de que ambas formas no suponen una gran diferencia de velocidades y que con las comillas dobles, escapar los carácteres como $ (\$) supone un ahorro de tiempo, mínimo eso si.


+ 100 % foreach($aHash as $val);
+ 657 % while(list($val)) = each($aHash);
+ 119 % foreach($aHash as $key => $val);
+ 688 % while(list($key,$val)) = each($aHash));
+ 238 % foreach($aHash as $key => $val) $tmp[] = $aHash[$key];
+ 757 % while(list($key)) = each($aHash)) $tmp[] = $aHash[$key];
+ 300 % Get Key-/value-array: foreach($aHash as $key[]=>$val[]);
+ 329 % Get Key-/value-array: array_keys() / array_values()
+ 381 % $key = array_keys($aHash);
$size = sizeOf($key);
for($i=0; $i < $size; $i++) $tmp[] = $aHash[$key[$i]];

Conclusión: La conclusión mas obvia que podemos sacar es que foreach() es mas rapido que while() y for()


acabo con este que me pareció muy muy curioso:


El test se orienta a, si el rendimiento cambia al calcular el tamaño de una variable antes del for o en el momento que declaramos el for.

Ejemplos:
antes del for: "for ($i=0; $i 'menor que' $tamaño; $i++)"
en el for: "for ($i=0; $i 'menor que' sizeof($x); $i++)"


+ 100 % Antes del for con count()
+ 50058 % En el for con count()
+ 100 % Antes del for con sizeof()
+ 50421 % En el for con sizeof()

Conclusión: este es quizá el ejemplo mas claro a la hora de programar nuestras aplicaciones, hemos de tener muy en cuenta que el tamaño deveriamos calcularlo antes de declarar el for() para así agilizar sustancialmente nuestra aplicación.


Sin mas os animos a visitar la página del autor: http://www.phpbench.com/