Novanebula blog - Articulos programación

El cache de Smarty

nospam@example.com (Abraham Covelo) — Mon, 13 Oct 2008 19:51:00 +0200

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.

¿Como medir la complejidad?

nospam@example.com (Abraham Covelo) — Wed, 05 Mar 2008 23:31:00 +0100

    Con este pequeño artículo trataré de explicar como es posible medir la complejidad de algo, computacionalmente hablando. Aunque ciertamente estas ideas podrían ser utilizadas en otras muchas ramas en donde se presenta un problema que debemos resolver y la eficiencia de su resolución (en tiempo) sea un parámetro importante.

    La resolución práctica de un problema computacional exige por una parte un algoritmo o método de resolución y por otra un programa o codificación (implementación) de ese algoritmo en un ordenador real. El algoritmo es esencial a diferencia de la codificación que puede convertirse en anecdótica, aunque lo más normal es que no lo sea, a fin de cuentas los bugs están en la implementación y no en el algoritmo.

    A efectos prácticos además hay que tomar en consideración la cantidad de recursos, tanto de tiempo como de memoria que la implementación de un algoritmo puede precisar. Este suele depender del tamaño del problema pues el algoritmo y la implementación se deban adaptar a diferentes parámetros de entrada, por ejemplo, no es lo mismo ordenar alfabéticamente un array con nombres para un tamaño de array de 100 que para otro de tamaño 100.000 tanto en tiempo como en memoria empleada. El concepto exacto que mide el tamaño del problema depende de la lógica del mismo y es por lo tanto imposible dar una regla para su medición.

    Aunque el tamaño en memoria que una implementación pueda ocupar debe ser tomado en consideración esto ha dejado de ser problemático debido al aumento de la capacidad de memoria de los equipos y aunque puede parecer que a la capacidad de cálculo le pasa lo misma esto no es así. Y es un error común pensar que la optimización del código pueda ser dejada de lado confiando en la potencia de cálculo de nuestros equipos o de equipos futuros. Es pues el tiempo de ejecución el principal baremo a tener en cuenta a la hora de diseñar un algoritmo o afirmar que un algoritmo es "mejor" que otro.

Continua leyendo "¿Como medir la complejidad?"

IPC: Sockets

nospam@example.com (Abraham Covelo) — Wed, 07 Mar 2007 00:48:00 +0100

    Los sockets son una abstraccion que nos proporciona un estructura de direccionamiento y un conjunto de protocolos utilizado para la comunicacion entre procesos. Estos procesos pueden estar en la misma maquina (dominio local) o en distintas maquinas (dominios de internet).

    Los tipos de sockets definen las propiedades de la comunicación que estarán disponibles para la aplicación. Los procesos solamente pueden comunicarse mediante sockets del mismo tipo. Existen 5 tipos diferentes:

    Stream socket - comunicación en dos sentidos, secuenciada y segura (SOCK_STREAM). En el dominio de internet utiliza el protocolo TCP (similar a una conversación telefónica)

    Datagram socket - comunicación en dos sentidos, no asegura la secuencialidad de los mensajes enviados (un mensaje que ha sido enviado después de otro puede llegar antes que este) y tampoco es segura (el equipo de origen no sabe si el mensaje ha alcanzado su objetivo o no) (SOCK_DGRAM). En el dominio de internet utiliza UDP (similar al envío y recepción de correos)

    Secuencial packet socket - comunicación en dos sentidos, secuenciada y segura para datagramas de tamaño fijo (SOCK_SEQPACKET). No existe protocolo en internet que implemente este tipo de socket.

    Raw socket - Proporciona acceso a la capa de comunicaciones.

    Los sockets son orientados a datagramas pero sus características exactas dependen del interfaz proporcionado por el protocolo.

    La utilidad de conocer y poder realizar aplicaciones que utilizen sockets es indiscutible. Si deseas comunicar tu aplicación con otras aplicaciones en otras maquinas o incluso dentro de tu maquina mismo debes conocer a utilizar los sockets.

GTK, desarrollo de interfaces graficas (II)

nospam@example.com (Abraham Covelo) — Tue, 25 Jul 2006 00:03:00 +0200

    Para poder ahondar en la programación de interfaces gráficas con GTK es necesario tener un buen conocimiento de todos los objetos que podemos crear, sus características y todos las señales/eventos ante las cuales pueden reaccionar. Esta lista es muy extensa y únicamente te remito a la referencia de GTK2 para que puedas consultarlo segun tus necesidades.

    Sin embargo hay muchas mas características de las librerías que necesitamos conocer para realizar aplicaciones mas completas. Hare un pequeño resumen algunas de estas funciones.

boolean gtk_init_check(&argc, &argv)

    Te permite verificar antes de ejecutar gtk_init que se va poder inizializar sin problemas GTK, es decir que la llamada a gtk_init no fallara.

g_signal_handler_disconnect( gpointer object, gulong id);

    Elimina el registro de un determinado evento en tu aplicación. g_signal_connect y g_signal_connect_swapped retornan el valor id que se debe utilizar en esta función como parámetro.

    Tambien puedes deshabilitar y habilitar el registro de un evento utilizando estas funciones

g_signal_handler_block (gpointer object, gulong id);

g_signal_handler_block_by_func (gpointer object, GCallback func, gpointer data);

g_signal_handler_unblock (gpointer object, gulong id);

g_signal_handler_unblock_by_func (gpointer object, GCallback func, gpointer data);

    Para poder modificar el titulo de una ventana, suponiendo que window es una ventana:

gtk_window_set_title (GTK_WINDOW (window), "Nuevo titulo");

    Creacion de una caja (elemento invisible que puede contener varios objetos)

GtkWidget box;

    box es ahora un objeto

box = gtk_hbox_new (FALSE,0);

    box es ahora una objeto tipo caja horizontal, los objetos que contendrá se colocaran uno al lado del otro de izquierda a derecha o a la inversa segun los parámetros que se le pasen o:

gtk_vbox_new (FALSE,0);

    La caja vertical con los objetos uno encima del otro, de arriba a abajo o a la inversa.

    Siendo window un objeto ventana incluimos la caja en la ventana como siempre con:

gtk_container_add(GTK_CONTAINER (window,box);

    ahora creamos y asignamos las señales a los objetos que deseamos añadir a la caja cuando tengamos listo CADA objeto ejecutamos esto

gtk_box_pack_start (GTK_BOX(box), button, TRUE, TRUE, 0);

    suponindo que button es un objeto claro y:

gtk_widget_show(button);

    Atencion: Podemos reutilizar la variable button después de esto para definir otros objetos.

    Finalmente ejecutamos

gtk_windget_show(box);

    y

gtk_widget_show(window);

    Aqui tenemos un ejemplo completo:

#include

/ Our new improved callback. The data passed to this function
is printed to stdout. /
static void callback( GtkWidget widget,
gpointer data )
{
g_print ("Hello again - %s was pressed\n", (gchar ) data);
}

/ another callback /
static gboolean delete_event( GtkWidget *widget,
GdkEvent *event,
gpointer data )
{
gtk_main_quit ();
return FALSE;
}

int main( int argc,
char argv[] )
{
/ GtkWidget is the storage type for widgets */
GtkWidget *window;
GtkWidget *button;
GtkWidget box1;

/ This is called in all GTK applications. Arguments are parsed
from the command line and are returned to the application. /
gtk_init (&argc, &argv);

/ Create a new window /
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);

/ This is a new call, which just sets the title of our
new window to "Hello Buttons!" /
gtk_window_set_title (GTK_WINDOW (window), "Hello Buttons!");

/ Here we just set a handler for delete_event that immediately
exits GTK. /
g_signal_connect (G_OBJECT (window), "delete_event",
G_CALLBACK (delete_event), NULL);

/ Sets the border width of the window. /
gtk_container_set_border_width (GTK_CONTAINER (window), 10);

/ We create a box to pack widgets into. This is described in detail
in the "packing" section. The box is not really visible, it
is just used as a tool to arrange widgets. /
box1 = gtk_hbox_new (FALSE, 0);

/ Put the box into the main window. /
gtk_container_add (GTK_CONTAINER (window), box1);

/ Creates a new button with the label "Button 1". /
button = gtk_button_new_with_label ("Button 1");

/ Now when the button is clicked, we call the "callback" function
with a pointer to "button 1" as its argument /
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (callback), (gpointer) "button 1");

/ Instead of gtk_container_add, we pack this button into the invisible
box, which has been packed into the window. /
gtk_box_pack_start (GTK_BOX(box1), button, TRUE, TRUE, 0);

/ Always remember this step, this tells GTK that our preparation for
this button is complete, and it can now be displayed. /
gtk_widget_show (button);

/ Do these same steps again to create a second button /
button = gtk_button_new_with_label ("Button 2");

/ Call the same callback function with a different argument,
passing a pointer to "button 2" instead. /
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (callback), (gpointer) "button 2");

gtk_box_pack_start(GTK_BOX (box1), button, TRUE, TRUE, 0);

/ The order in which we show the buttons is not really important, but I
recommend showing the window last, so it all pops up at once. /
gtk_widget_show (button);

gtk_widget_show (box1);

gtk_widget_show (window);

/ Rest in gtk_main and wait for the fun to begin! */
gtk_main ();

return 0;
}

Nos vemos ...

GTK, desarrollo de interfaces graficas (I)

nospam@example.com (Abraham Covelo) — Mon, 24 Jul 2006 00:36:00 +0200

    Este tutorial se basa en el que esta disponible en la pagina oficial de la GTK. Esta dedicado a la versión 2 de GTK+ que es la mas actual en el momento que escribo este mensaje (si lees esto después del 2010 no te olvides de actualizar tus conocimientos).

    Bueno para todos aquellos que nunca han programado en entorno gráfico les dedico el siguiente párrafo.

    Los sistemas gráficos están plagados de ventanas con botones, menús, imágenes, barras de scroll y demas objetos (en GTK todos estos elementos se llaman widgets -traduccion cacharro, atilugio. Si, utilizare el termino ingles o la termino objeto) que pueden ser activados/utilizados en cualquier momento. Para poder tratar estos elementos GTK (y otros sistemas para la creación de interfaces gráficas) utiliza un sistema basados en señales/eventos que llaman a funciones que son los que realizan el comportamiento asociado a cada objeto (widget).

    Basicamente una aplicacion grafica en GTK inizializa el sistema, crea cada uno de los objetos
que requiere la aplicacion (ventanas, botones, etc), asigna los eventos asociados a cada objeto, los muestra por pantalla y deja la aplicacion es estado de espera a la llegada de cada uno de esos eventos (tambien llamados señales aunque no tienen relacion alguna con el sistema de señales de Unix).

    Veamos un ejemplo sencillo

#include

static void hello( GtkWidget *widget, gpointer data )
{
g_print ("¡Hola mundo!\n");
}

static gboolean delete_event(GtkWidget *widget, GdkEvent *event, gpointer data )
{
g_print ("Evento de borrado detectado\n");
return TRUE;
}

static void destroy(GtkWidget *widget, gpointer data)
{
gtk_main_quit ();
}

int main( int argc, char *argv[] )
{
GtkWidget *window;
GtkWidget *button;

gtk_init (&argc, &argv);

window = gtk_window_new (GTK_WINDOW_TOPLEVEL);

g_signal_connect (G_OBJECT (window), "delete_event", G_CALLBACK (delete_event), NULL);

g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (destroy), NULL);

gtk_container_set_border_width (GTK_CONTAINER (window), 10);

button = gtk_button_new_with_label ("Hello World");

g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (hello), NULL);

g_signal_connect_swapped (G_OBJECT (button), "clicked", G_CALLBACK (gtk_widget_destroy), G_OBJECT (window));

gtk_container_add (GTK_CONTAINER (window), button);

gtk_widget_show (button);

gtk_widget_show (window);

gtk_main ();

return 0;
}

    Para compilarlo en linux con gcc instalado ejecuta esto en una shell. Debes tener instaladas las librerias GTK+-2.0

# gcc hello_world.c `pkg-config --cflags --libs gtk+-2.0`

    Con el sistema X en ejecucion puedes ver tu aplicacion ejecutando:

#./a.out

    pkg-config es una herramienta que sirve para localizar los directorios donde estan situados las librerias y los archivos necesarios para la compilacion.

    El programa define 4 funciones, 3 de ellas hello, delete_event y destroy son las funciones que se llamaran cuando se dispare un evento dentro de nuestra ventana. Main es la cuarta funcion. Dentro de ella se crean los objetos (ventana y boton), se inicializa el sistema (con gtk_init). GtkWidget declara las variables como objetos (widgets). gtk_window_new y gtk_button_new_with_label crean la ventana y el boton respectivamente.

    Las funciones g_signal_connect y g_signal_connect_swapped registran cada uno de los eventos que deseemos implementar e informan de cual es la funcion que se ejecutara en cada caso.

    Ademas debemos incluir el boton dentro de la ventana con:

gtk_container_add (GTK_CONTAINER (window), button);

Finalmente se muestra los objetos utilizando gtk_widget_show

gtk_widget_show (button);

gtk_widget_show (window);

La aplicacion queda a la espera de los eventos con la linea

gtk_main ();

Las señales que se registran son las siguientes

g_signal_connect (G_OBJECT (window), "delete_event", G_CALLBACK (delete_event), NULL);

delete_event (ventana) -- Se dispara cuando intentamos cerrar la ventana utilizando los controles que estan en la barra de titulo de la ventana (o el botón x de la esquina derecha o en el menú la opción cerrar). En nuestro programa se ejecuta la función "delete_event" que simplemente imprime en consola "Evento de borrado detectado". En la función delete_event el return TRUE; informa que el evento no precisa llamar a otras funciones para completar su funcionalidad.

El sistema GTK tiene una implementación por defecto para cada una de las señales/eventos que detecta. Si deseamos que ejecute su implementación por defecto tenemos que o bien no registrar en nuestro programa la señal o si lo hacemos debemos hacer que la función asignada a la señal devuelva TRUE para indicar que no deseamos ejecutar la implementación por defecto. FALSE en caso contrario.

destroy (ventana) -- Se llama cuando se destruye el objeto, en nuestro caso la ventana. La función asociada ejecuta simplemente un:

gtk_main_quit ();

    que termina la ejecucion de espera de gtk_main ();

    clicked (botón) -- Se ejecuta cuando se hace clic sobre el botón (obviamente) llama a la function hello que imprime el mensaje hola mundo por consola y ademas llama a la función gtk_widget_destroy de la ventana y no del boton, por eso utilizamos la funcion g_signal_connect_swapped en lugar de g_signal_connect ya que el objeto sobre el que actua el evento no es el mismo que el que lo recibe.

    La función gtk_widget_destroy destruye el objeto ventana y emite la señal "destroy" que llama a nuestra función destroy que a su vez llama a gtk_main_quit (); que termina la ejecución del gtk_main(); en la función main.

    Bueno a partir de aquí y con alguna documentacion de referencia sobre los objetos y los eventos que tenemos a nuestra disposición ya podemos empezar a crear nuestras propias pequeñas aplicaciones.

    Animo y en breve seguire con la saga...

GTK, desarrollo de interfaces graficas - Presentacion

nospam@example.com (Abraham Covelo) — Sun, 23 Jul 2006 00:26:00 +0200

    Bueno este interesante proyecto de libreria grafica de codigo abierto te permite desarrollar interfaces en una buena cantidad de lenguages entre los que se incluyen C/C++, perl y python aunque hay muchos mas como por ejemplo el php o C#. El siguiente enlace contine una lista completa de lenguajes soportados por GTK.

    Su licencia es la LGPL ya que es un proyecto de la GNU (estos chicos son increíbles :D, no os olvideis de llamar GNU/Linux al sistema operativo y Linux al kernel que tiene). En principio GTK se diseño para el desarrollo de aplicaciones/plugins para el GIMP de hay la G que aparece en su nombre (GTK - GIMP toolkit).

    Ademas de para el GIMP GTK es utilizado por una gran cantidad de proyectos, sobre todo para aplicaciones a ejecutar en GNOME, si quieres saber de que es capaz mira una lista de proyectos que utilizan GTK. Aunque GTK también puede desarrollar aplicaciones gráficas para otros sistemas operativos (MAC, Windows ...) e interfaces graficas (como KDE).

    Bueno seguro que estas deseando aprenderlo todo (¡pues vete al siguiente post! ¡a que esperas!).