Ha sido un proyecto como ninguno en mi carrera profesional. El día 2 de Enero de este año empezó su vida como proyecto y cerca del 14 de Enero empezó de forma oficial su desarrollo. En poco menos de dos meses hemos construido una nueva plataforma desde cero (pues no hemos podido aprovechar prácticamente nada del código de Loquo).

Esta nueva plataforma resuelve la mayoría de las limitaciones que Loquo tiene: Un excelente motor de búsquedas; Soporte para atributos flexibles; Mejor soporte para I18N y muchos más.

De aquí mis felicitaciones, no sólo a mi equipo de desarrollo que ha respondido de una forma excelente frente a la presión con un constante buen ánimo y energía, sino a todos los integrantes del equipo: CS, OM/DM, SEO/SEM, al equipo de Liderago  y al equipo de Site Operations de Marktplaats.

Todas las partes han desempeñado su papel de forma magistral… y, debo decirlo, haber tenido una team-meeting el 3 de Marzo a las 2:00 (a.m.) cuando el sitio empezó a estar “live”, y que prácticamente todo el equipo estuviera ahí asegurándose de que su parte estuviera bien ha sido una experiencia genial de integración

Me siento honrado de trabajar con este equipo.

Es un momento excelente y un proyecto muy especial.

Gracias a todos

Este proceso consiste de dos partes:

1. La creación de un LSH (Locality Sensitive Hash), es decir, crear una especie de “firma” que tenga la propiedad de que dos imágenes que se parezcan tengan dos firmas parecidas y que dos imágenes que no se parezcan tengan firmas diferentes.
2. Tener estas firmas en una base de datos para dada una “firma” buscar si hay alguna otra imagen cuya firma se parezca lo suficiente.

Existen muchas formas de crear la firma, por ejemplo con el uso de Haar Wavelet, Histogramas de colores, etc. Sin embargo, la parte de la búsqueda es la realmente complicada.

Una firma, puede consistir de 128, 200 o más números enteros. Estas firmas pueden ser vistas como un vector de tantas dimensiones como números la compongan, y de ahí que el título del artículo se refiera a espacios de alta dimensionalidad.

Debido a que buscar los duplicados de una imagen particular (imagen query) es encontrar algún otro “vector” en una base de datos cuya distancia a la imagen query sea menor a cierto umbral, estas búsquedas no son manejables con un sistema de base de datos convencional (No sin recorrer toda la base de datos a cada consulta y calcular la distancia de la imagen query con todas las imágenes de la BBDD).

Sin embargo, hay alternativas. La mayoría de ellas tienen que ver con reducciones dimensionales, es decir tratar de representar en menos dimensiones (con menos números) los mismos datos. Esto resulta bastante bien cuando la data es dispersa, ya que probablemente muchas dimensiones no aporten casi información (por ejemplo, en las estructuras de datos utilizadas para la detección de Spam con SVM (Support Vector Machines) en la que cada palabra es una dimensión y el valor de esa dimensión es la cantidad de veces que aparece la palabra en el texto.

Pero cuando la data no es esparcida, los métodos que se basan exclusivamente en reducciones dimensionales no son tan atractivos.

Es por esto que la propuesta descrita en: Indexing High-Dimensional Data for Efficient In-Memory Similarity Search resulta muy interesante.

En este paper se propone la creación de una estructura llamada un delta-tree, en el que los niveles superiores (más cercanos a la raíz) son de dimensiones menores que los inferiores (de hecho las “hojas” del árbol son los datos sin ninguna reducción dimensional).

Lo que más me llamó la atención fue la forma en la que se realiza la reducción dimensional: SVD:  Singular Value Decomposition. Esta técnica te permite reducir la dimensionalidad de la data con una propiedad interesante:

Dados dos puntos x1 y x2 en el espacio m-dimensional de origen, y dados y1 y y2 sus “versiones reducidas”  en el espacio n-dimensional (con n < m),

d(x1,x2) ≤ d(y1,y2), donde d(a,b) es la distancia que hay entre a y b.

De esta forma se puede recorrer el árbol, descartando las ramas que ya se encuentran muy lejos (por encima del umbral) con menos dimensiones (y por lo tanto menos cálculos) y centrar la búsqueda en las dimensiones superiores en un espacio mucho menor.

Esto me parecía muy bueno para ser verdad, así que me instalé SciLab que es un excelente reemplazo gratis de Matlab (as in beer and in speech), hice una prueba de esta reducción dimensional y comprobé la regla de las distancias empíricamente.

Creé de forma aleatoria una matriz de datos (50 puntos), cada uno de ellos en un espacio de 20 dimensiones, la reduje a 15, 10 y 5 dimensiones y comparé las distancias entre los puntos entre las distintas dimensiones y obtuve gráficos como este:

Correlación con una reducción a 15 dimensiones

Un punto de este gráfico se obtiene de la siguiente forma:

Coordenada x = distancia entre los puntos xi y xj en el espacio original (20 dimensiones)

Coordenada y = distancia entre los puntos xi y xj en el espacio reducido (15 dimensiones en este caso)

Como se puede ver existe una gran cercanía de estos puntos a la recta y=x (la correlación de los puntos en la gráfica de 15 dimensiones es de 0.95), con lo que se puede ver que hay una correlación entre las distancias en el espacio original y el espacio reducido.

Haciendo lo mismo con 10 y luego 5 dimensiones obtuve:

Correlación con una reducción a 10 dimensiones

Como es lógico se redujo más la correlación pues se pierde más información en la reducción dimensional, pero sigue habiendo una fuerte relación entre las distancias en ambos espacios.

Y, finalmente, con una reducción a 5 dimensiones obtuve:

Correlación con una reducción a 5 dimensiones

En el que la correlación si bien existe es bastante débil.

Sin embargo, incluso en este escenario en el que se pierde tanta información por la reducción dimensional, logré verificar que se mantiene la asumpción sobre que las distancias en menores dimensiones son menores que en mayores dimensiones, y por lo tanto el esquema propuesto sirve.

No conozco ningún manejador de base de datos que pudiere utilizar para representar esto… así que supongo que tendré que crear uno

En Loquo, buena parte de mi labor se centra no solo en el desarrollo de producto, sino en la investigación e innovación en la plataforma.

El primer fruto que logramos fue la creación del sistema de detección de duplicados. Este sistema ha tenido un impacto muy positivo en el sitio, logrando mejorar la calidad del contenido y por lo tanto la experiencia del usuario.

Claro está, los spammers no se iban a quedar de brazos cruzados y, como era lógico, han evolucionado sus técnicas.

Primero, se fueron por la ruta de colocar texto oculto (cuyo color se parece mucho al color de fondo), así que sacamos un sistema que elimina el texto oculto (utilizando un cálculo que toma en consideración la percepción de los colores para el ojo humano). Luego, colocaron texto muy pequeño… y también lo eliminamos.

Ahora, simplemente colocan textos aleatorios de forma visible y colocan toda la información “de verdad” en imágenes.

Por supuesto, colocar esta información en las imágenes las hace prácticamente indetectables… ¿o no?

Pues es en eso en lo que estoy trabajando ahora. En luchar contra el Spam en Imágenes.

Problemas para la detección de Spam en Imágenes

La detección de Spam en imágenes es particularmente retadora porque una imágen no es más que un conjunto de pixels, cada uno de un color. A diferencia del texto en el que cada palabra tiene un sentido particular, un pixel o linea no tiene ningún significado como tal.Además, las imágenes son información bidimensional, mientras que el texto es de una sola dimensión…

En fin, es un problema mucho más complicado, así que..

¿Cómo afrontar el problema de detección de Spam en Imágenes?

Como siempre, en problemas complejos, no hay una solución sencilla. El sistema que tengo en mente tiene dos módulos principales:

• Análisis de la imagen: En este se busca extraer información de la imagen para tratar de reconocer si una imágen particular es Spam o no.
• Detección de imágenes duplicadas: En este otro, lo que se busca es saber si una imagen se parece a otra que ya se encuentre en el sistema y que haya sido identificada como Spam.

Cada una de estas tareas es todo un reto pues consisten de procesamientos altamente complicados, con lo cual escalarlo a una plataforma con tantos visitantes como lo es Loquo (más de 5.5 millones de Usuarios únicos al mes) es un problema doblemente complicado.

Análisis de la Imagen

Este sistema consiste en la extracción de información a partir de una imágen.

Evidentemente, la información más “sencilla” de extraer son los textos que se encuentren embebidos en la imágen a través de uso de un software OCR (Optical Character Recognition).

Para esto se deben hacer dos pasos:

1. Document Layout Analysis: Este primer paso consiste en identificar en una imagen las áreas que probablemente contienen texto.
2. OCR: Luego, las áreas con alta probabilidad de contener texto son pasadas al software OCR para ver qué es capaz de reconocer.

Otra forma de analizar la imagen sería intentar extraer información sobre los objetos que componen la imagen. Este es un proceso aún más complicado, pero podría servir, para, por ejemplo, reconocer si en una imagen hay una pistola o algún otro elemento prohibido.

Detección de imágenes duplicadas

Este sistema busca identificar si una imagen dada se parece lo suficiente a alguna otra imagen de una base de datos.

Evidentemente la forma trivial es simplemente compara los hashes de los archivos (MD5 o SHA1). Pero esto sólo sirve para reconocer que se trata del mismo archivo. Basta cambiar un pixel en la imagen y este sistema sería inválido. Por esto, la forma correcta de atajar este problema es con “Near-Duplicate Image Detection”.

El sistema de Near-Duplicate Image Detection consiste en crear una especie de Hash a partir de la imagen, pero de tal forma que si dos imágenes se parecen, sus respectivos Hashes también se parezcan. (Esto se conoce como LSH: Locality Sensitive Hashing.

En próximos artículos comentaré un poco sobre los avances logrados en cada una de estas áreas.

Este es el segundo artículo o tutorial de la serie sobre cómo integrar phpBB3 con tu sitio.

phpBB3 es un excelente paquete de foros gratuito, escrito en PHP+MySQL. Debido a su gran utilidad y al hecho de que es de código abierto (free as in beer and speech), una de las cosas que muchos queremos hacer es integrarlo con algún otro sistema que tengamos, para poder ofrecer la excelente funcionalidad del foro, sin que esto complique la experiencia del usuario en el sitio.

En este artículo se trata la segunda integración descrita en el artículo: cómo integrar phpBB3 con tu sitio:

Al crear un usuario en el otro sistema, automáticamente se crea un usuario en phpBB3 y hacer login en uno de ellos automáticamente te loguea en el otro.

Esta es una integración un poco más compleja que la anterior y por lo tanto la divido en dos partes. En esta hablo sobre cómo hacer para que al registrar a un usuario en “el otro sistema” (el que no es phpBB3), automáticamente quede registrado en el foro. La segunda parte la dejo para otro artículo por ser un poco más compleja y depender de la configuración de los dos sitios (si están o no en el mismo dominio o subdominio).

La idea básica

phpBB3 está muy bien hecho, el código es muy modular y es fácil de navegar. Por esto, cuando estudiamos cómo hace phpBB3 la creación de un nuevo usuario nos encontramos con lo que buscamos en el archivo includes/ucp/ucp_register.php [code] (luego de sortear mucho código de validación).

Para crear un nuevo usuario nos bastaría con este código:

<?php
 
	/* GetUserIp: 
	 *
	 * Taken from: http://forums.whirlpool.net.au/forum-replies-archive.cfm/976380.html
	 *
	 */
 
	define('IN_PHPBB', true);
	$phpbb_root_path = (defined('PHPBB_ROOT_PATH')) ? PHPBB_ROOT_PATH : './';
	$phpEx = substr(strrchr(__FILE__, '.'), 1);
	require($phpbb_root_path . 'common.' . $phpEx);
	require($phpbb_root_path . 'includes/functions_user.' . $phpEx);
	require($phpbb_root_path . 'includes/functions_module.' . $phpEx);
 
	function GetUserIP() {
		if (isset($_SERVER)) {
			if (isset($_SERVER['HTTP_X_FORWARDED_FOR'])) return $_SERVER['HTTP_X_FORWARDED_FOR'];
			if (isset($_SERVER['HTTP_CLIENT_IP'])) return $_SERVER['HTTP_CLIENT_IP'];
			return $_SERVER['REMOTE_ADDR'];
		}
		if (getenv('HTTP_X_FORWARDED_FOR')) return getenv('HTTP_X_FORWARDED_FOR');
		if (getenv('HTTP_CLIENT_IP')) return getenv('HTTP_CLIENT_IP');
		return getenv('REMOTE_ADDR');
	}
 
	$user_name = 'paolo123';
	$user_pass = 'shh123';
	$user_email = 'usuario@servidor.de.correo';
	$user_lang = 'es';
	$user_ip = GetUserIP();
 
	$sql = 'SELECT group_id
		FROM ' . GROUPS_TABLE . "
		WHERE group_name = 'REGISTERED'
			AND group_type = " . GROUP_SPECIAL;
	$result = $db->sql_query($sql);
	$row = $db->sql_fetchrow($result);
	$db->sql_freeresult($result);
 
	if (!$row)
	{
		trigger_error('NO_GROUP');
	}
 
	$group_id = $row['group_id'];
 
	// Utilizamos el uso horario del foro
	$is_dst = $config['board_dst'];	
	$timezone = $config['board_timezone'];
 
	// Reunimos toda la data del nuevo usuario
	$user_row = array(
		'username'		=> $user_name,
		'user_password'		=> phpbb_hash($user_pass),
		'user_email'		=> $user_email,
		'group_id'		=> (int) $group_id,
		'user_timezone'		=> (float) $timezone,
		'user_dst'		=> $is_dst,
		'user_lang'		=> $user_lang,
		'user_type'		=> USER_NORMAL,
		'user_actkey'		=> '',
		'user_ip'		=> $user_ip,
		'user_regdate'		=> time(),
		'user_inactive_reason'	=> 0,
		'user_inactive_time'	=> 0,
	);
 
	// Register user...
	$user_id = user_add($user_row, $cp_data);
 
	// This should not happen, because the required variables are listed above...
	if ($user_id === false)
	{
		trigger_error('NO_USER', E_USER_ERROR);
	}
 
?>

Este código crea un usuario con nombre ‘paolo123′ y clave ‘shh123′. Este será un usuario idéntico a cualquier otro usuario que se haya registrado siguiendo el proceso normal del foro.

Consideraciones finales

Importante indicar que este código está pensado para ejecutar en un archivo que estuviera en la carpeta raíz del foro, por lo que si no es este el caso, habría que modificar la declaración del principio que dice: $phpbb_root_path = (defined('PHPBB_ROOT_PATH')) ? PHPBB_ROOT_PATH : './'; cambiando el ‘./’ por la ruta relativa o absoluta de la carpeta raíz del foro.

Importante: Crear el usuario de esta forma, salta todas las verificaciones que hay normalmente en el foro, por lo que es importante asegurarse de que todos los datos son válidos.

La forma de integrar este código con tu sistema la dejo a discreción del usuario, ya que variaría mucho dependiendo del sistema desde el que se invoque… lo único que hay que tener presente son los datos que necesita este código para ejecutar: $user_name, $user_pass, $user_email, $user_lang y $user_ip.

En el próximo artículo de esta “serie” trataré el tema de la segunda parte de esta integración: el manejo de sesiones… Cómo hacer que cuando un usuario se identifique en uno de los sistemas, quede identificado en el otro también.

Espero les sirva.

Este post ha tenido bastantes visitas, lo que me lleva a pensar que no hay mucha literatura en español al respecto y que sí hay mucho interés…. por lo que he decidido que escribiré un conjunto de artículos sobre cómo hacer las integraciones.

Lo primero, es que hay muchas formas de integrar phpBB3 con otro sitio web. Las cosas que necesitas hacer dependen de cómo desees que sea esa integración, y por eso el primer paso es tener claro cómo quieres integrar phpBB3 a tu sitio.

Primero que nada, definamos una “nomenclatura” para entender bien las distintas formas de integración:

Partes de los sistemas

Registro de usuarios

Es el conjunto de páginas y el código que se encarga de crear un nuevo usuario en el sistema.

Identificación

Una vez creado el usuario, este es el conjunto de páginas y código que se encarga de verificar la información de usuario/clave contra la base de datos de usuarios y que da acceso a un usuario registrado al sitio.

Manejo de sesión

Son las porciones de código (nada visible para el usuario) que le indican al sistema si quien está solicitando una página específica es un usuario registrado que ya se ha identificado en la página. Por lo general se maneja a través de Cookies en el navegador del usuario.

Mis Datos

Son las páginas en las que el usuario puede entrar para modificar su información (cambio de clave, email, etc).

Información del sistema

Con información del sistema me refiero a distintos datos de uno de los sistemas que se podría querer mostrar. Por ejemplo: Número de usuarios registrados en el foro, número de hilos del foro, etc.

Lo mismo para el otro sistema (si por ejemplo el otro sistema es un blog, último post, número de comentarios de un post particular, etc).

Ya habiéndole dado nombre a todo esto, el escenario que nos encontramos al iniciar la integración es este:

Leyenda:

- Cada columna es un módulo.
- La primera fila es la capa de presentación, es decir, las páginas que se le muestra al usuario.
- La segunda fila es la capa de lógica o aplicación, es decir, el código que se ejecuta para realizar la acción solicitada en la página.

Formas de Integración

Ya teniendo un estándar para definir las distintas partes, una integración no es más que sustituir o modificar algunas de estas partes en uno de los sistemas por la misma parte en el otro (probablemente con nuevo código).

Algo importante al decidir cómo hacer la integración es que, por más que se deseen integrar los sistemas, siempre se deberá preservar la base de datos de usuarios de cada uno de ellos. Esto es así porque de lo contrario la cantidad de cambios sería muy grande y haría muy difícil que en el futuro se puedan actualizar los sistemas.

Hay muchas formas de realizar la integración entre el phpBB3 y el otro sistema. Lo que haré será escribir distintos artículos explicando cada una de las formas de integración, e iré enlazándolos desde este post a medida que vayan saliendo.

Integración 1: phpBB3 usa la base de datos de usuario del otro sistema para autenticar a los usuarios. Los usuarios de phpBB3 se crean de forma pasiva.

[Ir directamente al artículo]

Esta es la integración más sencilla (gracias a que phpBB3 implementa módulos de autenticación).

Estas son las características de esta integración:

• El registro de usuarios está completamente deshabilitado en el phpBB3
• No se puede alterar la información del usuario en phpBB3.
• Al realizar el login en phpBB3, la información del usuario es contrastada con la base de datos de usuario del otro sistema
• En caso de que sea la primera vez que un usuario válido del otro sistema entra al phpBB3, un nuevo usuario es creado de forma “automágica” en el phpBB3.
• Cada sistema maneja sus sesiones de forma independiente.
• No se muestra información de un sistema en el otro

Gráficamente sería así:

Aquí está el post en el que se explica cómo hacer esta integración de phpBB3.

Integración 2: Al crear un usuario en el otro sistema, automáticamente se crea un usuario en phpBB3 y hacer login en uno de ellos automáticamente te loguea en el otro.

[Ir directamente a la primera parte artículo]

Esta integración es diferente de la anterior porque los usuario son creados en phpBB3 de forma activa, es decir, aunque el usuario no haya entrado en el phpBB3 ya su usuario existe.

Estas son las características de esta integración:

• El registro de usuarios está deshabilitado en uno de los sistemas (aquí se explica con el registro de usuarios deshabilitado en el phpBB3, aunque podría ser en el otro sentido).
• Cuando un usuario se registra en el otro sistema, se crea un nuevo usuario tanto en la base de datos del otro sistema como en la de phpBB3
• No se puede alterar la información del usuario en el sistema en el que el registro esté deshabilitado (en este caso, no se puede alterar la información en phpBB3).
• Al realizar el login en cualquiera de los dos sistemas, la información del usuario es contrastada con la base de datos de dicho sistema, pero se inician las sesiones en ambos, de forma de que basta un login en alguno de ellos para estar logueado en ambos.
• No se muestra información de un sistema en el otro

Gráficamente sería así:

He dividido este artículo en dos partes:

1. Creación del usuario: Ver artículo
2. Manejo de sesiones: [pronto estará disponible]

Más integraciones

Hay muchas formas de hacer las integraciones. Estaré describiendo las distintas formas dependiendo de lo que sea más solicitado. Deja un comentario solicitando la explicación de una integración si no la ves aquí.

Algunas integraciones ya han sido solicitadas y estoy trabajando en nuevos posts para explicarlas.

También son bienvenidos comentarios en los que me indiques si te sirvió o no alguna integración en particular. Estos comentarios hazlos, por favor, en el post específico de esa forma de integración.

phpBB3 es un excelente paquete de foros gratuito y escrito en PHP+MySQL.

Particularmente phpBB3 promete muchas mejoras interesantes sobre la versión anterior, por lo que he decidido utilizarlo para el foro del nuevo proyecto en el que estoy trabajando (jugar-fútbol.com).

Sin embargo, ya me había currado un proceso de registro y prefería evitar que un usuario registrado tuviera que registrarse nuevamente para poder acceder a los foros… y por otro lado, la experiencia me ha dicho que permitir la publicación sin registro en un foro es invitar al desastre y a la llegada de Spambots.

Así que me puse a investigar y una de las cosas interesantes del phpBB3 es que tiene módulos de identificación. El phpBB viene de base con 3: DB (el módulo por defecto en el que verifica la información de los usuarios en su propia BD), Apache (con htaccess y cosas por el estilo) y LDAP (contra un directorio LDAP).

Basándome en el de LDAP pude construir de forma muy rápida un proceso que te permitiera identificarte en el foro. Esto es lo que hay que hacer:

En la carpeta phpbb/includes/auth/ creas un nuevo archivo llamado auth_<algo>.php donde ese <algo> será el nombre de tu módulo. En mi caso fue auth_jugar.php.

En ese archivo debes implementar una funcion llamada: login_<algo> que recibe como parámetros el username y el password indicados en el formulario de identificación de un usuario.

PHPBB espera como respuesta de esta función un arreglo asociativo con tres elementos: ‘status’, ‘error_msg’ y ‘user_row’.

Los posibled valores para status (que yo haya utilizado) son:

• LOGIN_ERROR_PASSWORD: Error en el password (por ejemplo, el password ha venido vacío)
• LOGIN_ERROR_USERNAME: Indica que el login o la combinación login/clave son inválidos
• LOGIN_ERROR_ACTIVE: El usuario no se encuentra activo
• LOGIN_SUCCESS: Todo bien… debemos dejar entrar al usuario
• LOGIN_SUCCESS_CREATE_PROFILE: Este es muy interesante… Indica que los datos son correctos y que debemos crear al usuario en PHPBB y permitirle el acceso.

Es este último status el que es más útil para la integración, pues la primera vez que un usuario ya registrado en mi sistema de registro vaya al foro, creará su usuario del foro de forma transparente.

Los valores de error_msg y user_row dependen del status de respuesta y me parece que lo más fácil será colocar el código que he utilizado. Siéntanse libres de hacer Copy&Paste y ajustar a sus necesidades.

Ya para terminar recomendaría que impidieran que estos usuarios puedan modificar su información de email y clave y que lo deban hacer desde tu sistema actual de registro.

Espero sea de utilidad.

<?php
/**
*
* Jugar auth plug-in for phpBB3
*
* Authentication plug-ins is largely down to Sergey Kanareykin, our thanks to him.
*
* @package login
*
*/
 
/**
* @ignore
*/
if (!defined('IN_PHPBB'))
{
	exit;
}
 
// Aquí cargo cosas que necesito para verificar los datos del usuario
require_once '/forum_env.php';
 
/**
* Login function
*/
function login_jugar(&$username, &$password)
{
	global $db, $config, $user;
 
	// do not allow empty password
	if (!$password)
	{
		return array(
			'status'	=> LOGIN_ERROR_PASSWORD,
			'error_msg'	=> 'NO_PASSWORD_SUPPLIED',
			'user_row'	=> array('user_id' => ANONYMOUS),
		);
	}
 
	if (!$username)
	{
		return array(
			'status'	=> LOGIN_ERROR_USERNAME,
			'error_msg'	=> 'LOGIN_ERROR_USERNAME',
			'user_row'	=> array('user_id' => ANONYMOUS),
		);
	}
 
	// Aquí es donde verifico los datos en mi registro existente
	$jugar_user = ForumUser::validateCredentials($username, $password);
 
	if ($jugar_user instanceOf ForumUser) {
		$sql ='SELECT user_id, username, user_password, user_passchg, user_email, user_type
			FROM ' . USERS_TABLE . "
			WHERE username_clean = '" . $db->sql_escape(utf8_clean_string($username)) . "'";
		$result = $db->sql_query($sql);
		$row = $db->sql_fetchrow($result);
		$db->sql_freeresult($result);
 
		if ($row) {
			// User inactive...
			if ($row['user_type'] == USER_INACTIVE || $row['user_type'] == USER_IGNORE)
			{
				return array(
					'status'		=> LOGIN_ERROR_ACTIVE,
					'error_msg'		=> 'ACTIVE_ERROR',
					'user_row'		=> $row,
				);
			}
 
			// Successful login... set user_login_attempts to zero...
			return array(
				'status'		=> LOGIN_SUCCESS,
				'error_msg'		=> false,
				'user_row'		=> $row,
			);
		}
		else
		{
			// retrieve default group id
			$sql = 'SELECT group_id
				FROM ' . GROUPS_TABLE . "
				WHERE group_name = '" . $db->sql_escape('REGISTERED') . "'
					AND group_type = " . GROUP_SPECIAL;
			$result = $db->sql_query($sql);
			$row = $db->sql_fetchrow($result);
			$db->sql_freeresult($result);
 
			if (!$row)
			{
				trigger_error('NO_GROUP');
			}
 
			// generate user account data
			$user_row = array(
				'username'		=> $username,
				'user_password'	=> phpbb_hash($password),
				'user_email'	=> $jugar_user->email,
				'group_id'		=> (int) $row['group_id'],
				'user_type'		=> USER_NORMAL,
				'user_ip'		=> $user->ip,
			);
 
			// this is the user's first login so create an empty profile
			return array(
				'status'		=> LOGIN_SUCCESS_CREATE_PROFILE,
				'error_msg'		=> false,
				'user_row'		=> $user_row,
			);
		}
	}
 
	return array(
		'status'	=> LOGIN_ERROR_USERNAME,
		'error_msg'	=> 'LOGIN_ERROR_USERNAME',
		'user_row'	=> array('user_id' => ANONYMOUS),
	);
}
 
 
?>

Es un sistema avanzado de detección de duplicados. Aunque apenas ha comenzado su vida, los resultados resultan prometedores.

La idea básica es que si cada anuncio “diferente” puede ser publicado sólo una vez al día (esto podría cambiar en el futuro), entonces el trabajo de los Spammers se vuelve mucho más complicado pues ya no pueden depender de un “simple” sistema automátizado para la publicación masiva de anuncios.

Creo que todos los usuarios de Loquo, estarán de acuerdo conmigo en que la calidad de los anuncios había caído considerablemente en los últimos meses. Y en buena parte esto se debe a que no tenemos la capacidad de revisar cada uno de los anuncios que es publicado, y si bien la comunidad hace un trabajo excelente a la hora de marcar los anuncios, no resultaba suficiente.

El problema resulta muy complicado de atacar y estamos conscientes de que de esta forma estamos alterando todo un ecosistema que gira al rededor de la página. Sin embargo, esperamos que el cambio sea a positivo. Digo esto por varias razones:

Revisión de todos los anuncios… ¿cómo?

Uno de los principales problemas para garantizar la calidad de los anuncios es poder revisar la mayor cantidad posible de ellos. Sin embargo, esto es una tarea imposible. Sólo tomando Barcelona como muestra, antes de la implementación de este sistema, la media de nuevos anuncios era de más de 24 por minuto, sin embargo, no es algo estable a lo largo del día. Aproximadamente el 30% era fuera de horario de oficina, y además en horas pico, el promedio (de nuevo, sólo en Barcelona) era de 1.3 anuncios por segundo!!

No existen recursos suficientes para revisar todos estos anuncios en ninguna empresa. Claro está, portales de menor dimensión, o en los que se cobre por la publicación se pueden dar este lujo o costear la externalización… pero ese no es nuestro caso.

La regla del 1%

Como sucede con casi todas las cosas en Internet, Loquo también se ciñe con precisión casi matemática a esta regla de facto del 1% que viene a reemplazar a la regla de Pareto del 80-20 en el mundo offline y que definen así en Microsiervos:

Está empezando a hablarse de una regla que sugiere que si pones a 100 personas en línea entonces una creará contenido, 10 interactuarán con este, ya sea comentando u ofreciendo mejoras, y los otros 89 simplemente lo mirarán.

Esta regla también se ajusta al comportamiento de los usuarios a la hora de publicar en una versión un tanto modificada: el 1% (o incluso menos) representa a los spammers más fuertes. un 10% serán usuarios “muy activos” que si bien publican muchos anuncios (más de los que sería ideal) por lo menos publican anuncios válidos, y el resto 89% son los usuarios como tu y yo que publican un piso en alquiler o algún producto de segunda mano para vender o fotografías para la home

El principal problema con esto es que la mayor parte del tiempo del equipo de soporte se estaba dedicando a responder a las preguntas, comentarios, quejas, etc de los usuarios y a tratar de paliar el efecto destructivo de ese 1% de spammers “heavy-duty”.

Dicho esto, con este sistema esperamos poder deshacernos lo máximo posible de ese 1% y mantener bajo control al segundo grupo del 10%. El 89% de los usuarios simplemente nunca se verán afectados por este cambio pues para ellos publicar un anuncio al día es más que suficiente para promocionar su oferta.

Más aún, ese 89% (e incluso el 10% de usuarios “muy activos”) se verá beneficiado por este cambio pues su anuncio tendrá más visibilidad al eliminar la basura que lo desplaza hacia abajo en el listado. Así, que el resultado esperado es: mayor satisfacción y efectividad para la mayoría de los usuarios que publican anuncios y una mejor experiencia para los visitantes que encontrarán un contenido de mayor calidad.

¿Y qué pasa con ese 10%?

Este es el grupo que más afectado se siente por la implantación del nuevo sistema, pero lo cierto es que el mayor cambio será en sus costumbres y no en sus resultados.

Por ejemplo, en las secciones de contacto de Loquo, existen sólo en Barcelona unos 472.154 anuncios activos… y esta sección tiene una duración de apenas 30 días. En esta sección (que es donde la mayor parte de ese 10% publica) se podrían reducir los anuncios a una décima parte o a un veinteavo sin afectar la experiencia del visitante. ¿Por qué?… saquemos unas cuentas: si hubiera sólo un veinteavo de los anuncios, todavía habría unos 23.600 anuncios, es decir, un promedio de casi 800 por día, a 75 anuncios por página, esto significaría que un usuario debería navegar por 11 páginas antes de llegar al siguiente día!, me parece que sigue habiendo una gran abundancia de contenido.

Igualmente, si un usuario que publica en esta sección se está “viendo obligado” a publicar hasta 20 veces el mismo anuncio en un día porque bajan demasiado rápido (el orden de los anuncios es cronológico), ahora su anuncio bajará a un veinteavo de la velocidad, con lo que efectivamente publicar un anuncio le bastaría para obtener la misma visibilidad y por lo tanto los mismos contactos.

Sin embargo, estoy seguro de que será un cambio complicado de asimilar al principio, no será sino hasta que vean que no se reduce la efectividad de sus anuncios que se sientan tranquilos con este sistema. Llevan mucho tiempo haciéndolo de la forma actual y éste como cualquier otro cambio generará incertidumbre.

Beneficios para el equipo de Loquo (y para los usuarios)

Lógicamente, contar con una base de anuncios menor y más limpia permitirá al equipo de soporte revisar una mayor cantidad de los anuncios y poder tomar medidas más correctivas que punitivas. Mejorando en todos los sentidos la experiencia de los usuarios

Otros beneficios del sistema

Búsquedas

La implantación de este sistema tiene otros beneficios para los visitantes, si ahora realizas una búsqueda en Loquo, es posible que consigas en algunas secciones el mismo anuncio repetido varias veces. Esto representa una pérdida de tiempo para el visitante que debe navegar e invertir más tiempo en encontrar más anuncios diferentes.

Sistemas

Se los digo por experiencia, manejar un sitio con más de 4MM de visitantes al mes no es sencillo, desde un punto de vista de sistemas es todo un reto mantener la disponibilidad del sitio en todo momento.

Uno de los principales inconvenientes es precisamente el crecimiento de la Base de Datos de anuncios. Contar con un sistema que permita reducir la cantidad de anuncios reales será un alivio al igual que permitirá mejorar el tiempo de respuesta de la página.

Finalmente..

Este es uno de los proyectos más importantes y con mayor impacto que hemos realizado en Loquo. Tenemos muchas esperanzas en él y estaremos todo lo atentos que podamos a los comentarios de los usuarios (más de lo habitual) para poder ajustarlo de la mejor forma posible.

Deseadnos suerte!

Pues escribo luego de un extendido período de silencio para comentarles por primera vez sobre un nuevo proyecto en el que estoy trabajando: jugar-futbol.com

Este proyecto busca ofrecer en un solo sitio las cosas que los entusiastas de este deporte necesitamos para poder practicarlo. Eso sí… en el mundo real… offline.

No es un sitio de juego online, ni es un directorio de sitios de fútbol. Busca ser una comunidad en la que encuentres las herramientas que buscas para poder practicar este deporte.

El sitio todavía no se encuentra público (aunque espero poder terminar las primeras funcionalidades este puente y sacarlo a producción). La primera etapa servirá para resolver uno de los problemas que tenemos cuando queremos jugar fútbol: ¿Dónde?.

Esta primera etapa consta de un directorio de campos de fútbol en toda España… claro está no sería capaz de rellenar toda la información por lo que cuento con que a los visitantes le mole el sitio y ayuden agregando un par de sitios que conozcan.

Muy pronto estará al aire… así que si te da curiosidad espera un próximo post en el que colocaré la dirección… o déjame un comentario aquí y te mandaré un correo cuando el gran momento llegue.

Esto es despreciable en el caso de los Plugins de compilación, pues sólo se utilizan una vez y luego se dejan de lado (de hecho, las funcionalidades que busques agregar a la compilación es bueno hacerlas como plugins).

Pero para las funciones y los modificadores pueden ser un gran problema.

Esto hay dos formas de resolverlo:

La forma simple

Smarty permite a través de los métodos register_function y register_modifier la inclusión de estos “plugins” sin tener que cargar un archivo adicional. Para este caso, de nuevo resulta muy útil el haber creado una función propia que extienda al Smarty, pues simplemente podemos colocar las definiciones de estas funciones en nuestra clase hija de Smarty y cargarlas en el constructor.

La forma no tan simple… pero mejor

Otra forma de lograr mejores resultados es modificar las funciones de Smarty cambiándolas de funciones de tiempo de ejecución a funciones de compilación.

Este es un procedimiento que no es tan trivial, pues hay que tener en cuenta que en tiempo de compilación no tenemos certeza de los valores que tienen las variables.

Para esto veamos un ejemplo.

Veamos este template sencillo que hace uso del tag {counter}. Este es un tag relativamente simple, sin embargo ofrece varios parámetros que modifican su comportamiento.

Este es el template:

Archivo: DOCROOT/templates/ejemplo3.tpl

<br>
<table cellpadding="5" cellspacing="0" border="1">
<tr>
<TD>up:1</TD>
<TD>up:1</TD>
<TD>start:3; up:1</TD>
<TD>up:2</TD>
<TD>down:1</TD>
<TD>up:1 on >=fifth down:1</TD>
<TD>up:1;no-print;using assign</TD>
</tr>
{counter name="third" start="3" print=false}
{section name="myloop" loop=11}
<TR>
<TD>{counter}</TD>
<TD>{counter name="second"}</TD>
<TD>{counter name="third"}</TD>
<TD>{counter name="fourth" skip=2}</TD>
<TD>{counter name="fifth" direction="down"}</TD>
<TD>{counter name="sixth" print=true}{if $smarty.section.myloop.index == 5}{counter name="sixth" direction="down" print=false}{/if}</TD>
<TD>{counter name="seventh" print=false assign="counter6"}{$counter6}</TD>
</TR>
{/section}
</table>

y este el resultado de su ejecución:

Ahora bien, ¿cómo compila Smarty este template?

Archivo: DOCROOT/smartystuff/compile/%%64^64F^64F63ED0%%ejemplo3.tpl.php

<?php /* Smarty version 2.6.19, created on 2008-03-15 14:59:55
         compiled from ejemplo3.tpl */ ?>
<?php require_once(SMARTY_CORE_DIR . 'core.load_plugins.php');
smarty_core_load_plugins(array('plugins' => array(array('function', 'counter', 'ejemplo3.tpl', 12, false),)), $this); ?>
<br>
<table cellpadding="5" cellspacing="0" border="1">
<tr>
<TD>up:1</TD>
<TD>up:1</TD>
<TD>start:3; up:1</TD>
<TD>up:2</TD>
<TD>down:1</TD>
<TD>up:1 on >=fifth down:1</TD>
<TD>up:1;no-print;using assign</TD>
</tr>
<?php echo smarty_function_counter(array('name' => 'third','start' => '3','print' => false), $this);?>
 
<?php unset($this->_sections['myloop']);
$this->_sections['myloop']['name'] = 'myloop';
$this->_sections['myloop']['loop'] = is_array($_loop=11) ? count($_loop) : max(0, (int)$_loop); unset($_loop);
$this->_sections['myloop']['show'] = true;
$this->_sections['myloop']['max'] = $this->_sections['myloop']['loop'];
$this->_sections['myloop']['step'] = 1;
$this->_sections['myloop']['start'] = $this->_sections['myloop']['step'] > 0 ? 0 : $this->_sections['myloop']['loop']-1;
if ($this->_sections['myloop']['show']) {
    $this->_sections['myloop']['total'] = $this->_sections['myloop']['loop'];
    if ($this->_sections['myloop']['total'] == 0)
        $this->_sections['myloop']['show'] = false;
} else
    $this->_sections['myloop']['total'] = 0;
if ($this->_sections['myloop']['show']):
 
            for ($this->_sections['myloop']['index'] = $this->_sections['myloop']['start'], $this->_sections['myloop']['iteration'] = 1;
                 $this->_sections['myloop']['iteration'] <= $this->_sections['myloop']['total'];
                 $this->_sections['myloop']['index'] += $this->_sections['myloop']['step'], $this->_sections['myloop']['iteration']++):
$this->_sections['myloop']['rownum'] = $this->_sections['myloop']['iteration'];
$this->_sections['myloop']['index_prev'] = $this->_sections['myloop']['index'] - $this->_sections['myloop']['step'];
$this->_sections['myloop']['index_next'] = $this->_sections['myloop']['index'] + $this->_sections['myloop']['step'];
$this->_sections['myloop']['first']      = ($this->_sections['myloop']['iteration'] == 1);
$this->_sections['myloop']['last']       = ($this->_sections['myloop']['iteration'] == $this->_sections['myloop']['total']);
?>
<TR>
<TD><?php echo smarty_function_counter(array(), $this);?>
</TD>
<TD><?php echo smarty_function_counter(array('name' => 'second'), $this);?>
</TD>
<TD><?php echo smarty_function_counter(array('name' => 'third'), $this);?>
</TD>
<TD><?php echo smarty_function_counter(array('name' => 'fourth','skip' => 2), $this);?>
</TD>
<TD><?php echo smarty_function_counter(array('name' => 'fifth','direction' => 'down'), $this);?>
</TD>
<TD><?php echo smarty_function_counter(array('name' => 'sixth','print' => true), $this);?>
<?php if ($this->_sections['myloop']['index'] == 5): ?><?php echo smarty_function_counter(array('name' => 'sixth','direction' => 'down','print' => false), $this);?>
<?php endif; ?></TD>
<TD><?php echo smarty_function_counter(array('name' => 'seventh','print' => false,'assign' => 'counter6'), $this);?>
<?php echo $this->_tpl_vars['counter6']; ?>
</TD>
</TR>
<?php endfor; endif; ?>
</table>

El código no es del todo limpio (de hecho es bastante sucio), sin embargo , obviando la parte del {section} es bastante comprensible… y quisiera presta atención a dos cosas: La primera parte precisamente carga el plugin que implementa el tag {counter}; y las distintas invocaciones al plugin que lucen más o menos así: echo smarty_function_counter(array(), $this);

Parece un poco inútil que para un simple counter se cargue un archivo adicional y se invoque a una funcion. Cuando, en su caso más sencillo, eso es algo que se podría lograr con un: $i = 1; echo $i++;

Aquí es donde entra el beneficio de los plugins de compilación de Smarty.

Vamos a reemplazar la función por un plugin de compilación.

El plugin que necesitamos sería este:

Archivo: DOCROOT/classes/smarty/libs/plugins/compiler.counter_compile.php

<?php
/**
 * Smarty plugin
 * @package Smarty
 * @subpackage plugins
 */
 
/**
 * Smarty {compiler} compiler function plugin
 *
 * Type:     compiler function<br>
 * Name:     counter<br>
 * Purpose:  print out a counter value
 * @author Paolo Ragone <pragone at gmail dot com> (initial author)
 * @param string containing name, start, skip, direction, print and assign attributes
 * @param Smarty_Compiler
 */
function smarty_compiler_counter_compile($tag_attrs, &$compiler)
{
	$_params = $compiler->_parse_attrs($tag_attrs);
	$_confvar_prefix = '$this->_tpl_vars[\'__counters_conf__\']';
 
	if (isset($_params['name'])) $name = $_params['name'];
	else $name = '\'default\'';
 
	$myconf = $_confvar_prefix . '[' . $name . ']';
	$myskip = '$_counter[\'skip\']';
	$mydir = '$_counter[\'direction\']';
	$myassign = '$_counter[\'assign\']';
	$myval = '$_counter[\'val\']';
 
	$r = '$_counter =& ' . $myconf .';' ."\n";
 
	if (isset($_params['start'])) $r .= $myval . ' = (int)' . $_params['start'] . '; ';
	else $r .= ' if (!isset(' . $myval . ')) {' . $myval . ' = 1;} ' ."\n";
 
	if (isset($_params['skip'])) $r .= $myskip . ' = ' . $_params['skip'] . '; ';
	else $r .= ' if (!isset(' . $myskip . ')) {' . $myskip . ' = 1;} ' ."\n";
 
	if (isset($_params['direction'])) $r .= $mydir . ' = ' . $_params['direction'] . '; ';
	else $r .= ' if (!isset(' . $mydir . ')) {' . $mydir . ' = \'up\';} ' ."\n";
 
	if (isset($_params['assign'])) $r .= $myassign . ' = ' . $_params['assign'] . '; ' ."\n";
 
	if (!isset($_params['print']) || $_params['print'] != 'false') {
		$r .= 'if (empty(' . $myassign . ')) { print ' . $myval  . ';} ' ."\n";
	}
 
	$r .= 'if (!empty(' . $myassign . ')) { $this->assign(' . $myassign . ',' . $myval . '); } ' ."\n";
 
	$r .= 'if (' . $mydir . ' == \'down\') {'  ."\n" . 
				$myval . '-= ' . $myskip . '; ' ."\n" . 
				'} else {'  ."\n" .
				$myval . '+= ' . $myskip . '; } ' ."\n";
 
	$r .= 'unset($_counter);' ."\n";
	return $r;
}
 
?>

Y el código del template compilado (una vez cambiados los tags de {counter} por {counter_compile} es (he creado una copia del template):

Archivo: DOCROOT/smartystuff/compile/%%C3^C34^C34FA758%%ejemplo3.1.tpl.php

<?php /* Smarty version 2.6.19, created on 2008-03-15 14:59:56
         compiled from ejemplo3.1.tpl */ ?>
<br>
<table cellpadding="5" cellspacing="0" border="1">
<tr>
<TD>up:1</TD>
<TD>up:1</TD>
<TD>start:3; up:1</TD>
<TD>up:2</TD>
<TD>down:1</TD>
<TD>up:1 on >=fifth down:1</TD>
<TD>up:1;no-print;using assign</TD>
</tr>
<?php $_counter =& $this->_tpl_vars['__counters_conf__']['third'];
$_counter['val'] = (int)'3';  if (!isset($_counter['skip'])) {$_counter['skip'] = 1;} 
 if (!isset($_counter['direction'])) {$_counter['direction'] = 'up';} 
if (!empty($_counter['assign'])) { $this->assign($_counter['assign'],$_counter['val']); } 
if ($_counter['direction'] == 'down') {
$_counter['val']-= $_counter['skip']; 
} else {
$_counter['val']+= $_counter['skip']; } 
unset($_counter);
 ?>
<?php unset($this->_sections['myloop']);
$this->_sections['myloop']['name'] = 'myloop';
$this->_sections['myloop']['loop'] = is_array($_loop=11) ? count($_loop) : max(0, (int)$_loop); unset($_loop);
$this->_sections['myloop']['show'] = true;
$this->_sections['myloop']['max'] = $this->_sections['myloop']['loop'];
$this->_sections['myloop']['step'] = 1;
$this->_sections['myloop']['start'] = $this->_sections['myloop']['step'] > 0 ? 0 : $this->_sections['myloop']['loop']-1;
if ($this->_sections['myloop']['show']) {
    $this->_sections['myloop']['total'] = $this->_sections['myloop']['loop'];
    if ($this->_sections['myloop']['total'] == 0)
        $this->_sections['myloop']['show'] = false;
} else
    $this->_sections['myloop']['total'] = 0;
if ($this->_sections['myloop']['show']):
 
            for ($this->_sections['myloop']['index'] = $this->_sections['myloop']['start'], $this->_sections['myloop']['iteration'] = 1;
                 $this->_sections['myloop']['iteration'] <= $this->_sections['myloop']['total'];
                 $this->_sections['myloop']['index'] += $this->_sections['myloop']['step'], $this->_sections['myloop']['iteration']++):
$this->_sections['myloop']['rownum'] = $this->_sections['myloop']['iteration'];
$this->_sections['myloop']['index_prev'] = $this->_sections['myloop']['index'] - $this->_sections['myloop']['step'];
$this->_sections['myloop']['index_next'] = $this->_sections['myloop']['index'] + $this->_sections['myloop']['step'];
$this->_sections['myloop']['first']      = ($this->_sections['myloop']['iteration'] == 1);
$this->_sections['myloop']['last']       = ($this->_sections['myloop']['iteration'] == $this->_sections['myloop']['total']);
?>
<TR>
<TD><?php $_counter =& $this->_tpl_vars['__counters_conf__']['default'];
 if (!isset($_counter['val'])) {$_counter['val'] = 1;} 
 if (!isset($_counter['skip'])) {$_counter['skip'] = 1;} 
 if (!isset($_counter['direction'])) {$_counter['direction'] = 'up';} 
if (empty($_counter['assign'])) { print $_counter['val'];} 
if (!empty($_counter['assign'])) { $this->assign($_counter['assign'],$_counter['val']); } 
if ($_counter['direction'] == 'down') {
$_counter['val']-= $_counter['skip']; 
} else {
$_counter['val']+= $_counter['skip']; } 
unset($_counter);
 ?></TD>
<TD><?php $_counter =& $this->_tpl_vars['__counters_conf__']['second'];
 if (!isset($_counter['val'])) {$_counter['val'] = 1;} 
 if (!isset($_counter['skip'])) {$_counter['skip'] = 1;} 
 if (!isset($_counter['direction'])) {$_counter['direction'] = 'up';} 
if (empty($_counter['assign'])) { print $_counter['val'];} 
if (!empty($_counter['assign'])) { $this->assign($_counter['assign'],$_counter['val']); } 
if ($_counter['direction'] == 'down') {
$_counter['val']-= $_counter['skip']; 
} else {
$_counter['val']+= $_counter['skip']; } 
unset($_counter);
 ?></TD>
<TD><?php $_counter =& $this->_tpl_vars['__counters_conf__']['third'];
 if (!isset($_counter['val'])) {$_counter['val'] = 1;} 
 if (!isset($_counter['skip'])) {$_counter['skip'] = 1;} 
 if (!isset($_counter['direction'])) {$_counter['direction'] = 'up';} 
if (empty($_counter['assign'])) { print $_counter['val'];} 
if (!empty($_counter['assign'])) { $this->assign($_counter['assign'],$_counter['val']); } 
if ($_counter['direction'] == 'down') {
$_counter['val']-= $_counter['skip']; 
} else {
$_counter['val']+= $_counter['skip']; } 
unset($_counter);
 ?></TD>
<TD><?php $_counter =& $this->_tpl_vars['__counters_conf__']['fourth'];
 if (!isset($_counter['val'])) {$_counter['val'] = 1;} 
$_counter['skip'] = 2;  if (!isset($_counter['direction'])) {$_counter['direction'] = 'up';} 
if (empty($_counter['assign'])) { print $_counter['val'];} 
if (!empty($_counter['assign'])) { $this->assign($_counter['assign'],$_counter['val']); } 
if ($_counter['direction'] == 'down') {
$_counter['val']-= $_counter['skip']; 
} else {
$_counter['val']+= $_counter['skip']; } 
unset($_counter);
 ?></TD>
<TD><?php $_counter =& $this->_tpl_vars['__counters_conf__']['fifth'];
 if (!isset($_counter['val'])) {$_counter['val'] = 1;} 
 if (!isset($_counter['skip'])) {$_counter['skip'] = 1;} 
$_counter['direction'] = 'down'; if (empty($_counter['assign'])) { print $_counter['val'];} 
if (!empty($_counter['assign'])) { $this->assign($_counter['assign'],$_counter['val']); } 
if ($_counter['direction'] == 'down') {
$_counter['val']-= $_counter['skip']; 
} else {
$_counter['val']+= $_counter['skip']; } 
unset($_counter);
 ?></TD>
<TD><?php $_counter =& $this->_tpl_vars['__counters_conf__']['sixth'];
 if (!isset($_counter['val'])) {$_counter['val'] = 1;} 
 if (!isset($_counter['skip'])) {$_counter['skip'] = 1;} 
 if (!isset($_counter['direction'])) {$_counter['direction'] = 'up';} 
if (empty($_counter['assign'])) { print $_counter['val'];} 
if (!empty($_counter['assign'])) { $this->assign($_counter['assign'],$_counter['val']); } 
if ($_counter['direction'] == 'down') {
$_counter['val']-= $_counter['skip']; 
} else {
$_counter['val']+= $_counter['skip']; } 
unset($_counter);
 ?><?php if ($this->_sections['myloop']['index'] == 5): ?><?php $_counter =& $this->_tpl_vars['__counters_conf__']['sixth'];
 if (!isset($_counter['val'])) {$_counter['val'] = 1;} 
 if (!isset($_counter['skip'])) {$_counter['skip'] = 1;} 
$_counter['direction'] = 'down'; if (!empty($_counter['assign'])) { $this->assign($_counter['assign'],$_counter['val']); } 
if ($_counter['direction'] == 'down') {
$_counter['val']-= $_counter['skip']; 
} else {
$_counter['val']+= $_counter['skip']; } 
unset($_counter);
 ?><?php endif; ?></TD>
<TD><?php $_counter =& $this->_tpl_vars['__counters_conf__']['seventh'];
 if (!isset($_counter['val'])) {$_counter['val'] = 1;} 
 if (!isset($_counter['skip'])) {$_counter['skip'] = 1;} 
 if (!isset($_counter['direction'])) {$_counter['direction'] = 'up';} 
$_counter['assign'] = 'counter6'; 
if (!empty($_counter['assign'])) { $this->assign($_counter['assign'],$_counter['val']); } 
if ($_counter['direction'] == 'down') {
$_counter['val']-= $_counter['skip']; 
} else {
$_counter['val']+= $_counter['skip']; } 
unset($_counter);
 ?><?php echo $this->_tpl_vars['counter6']; ?>
</TD>
</TR>
<?php endfor; endif; ?>
</table>

Sé lo que están pensando… esto en vez de mejorar empeora. Pero no es así. Hemos eliminado la carga de un archivo adicional (el del plugin del counter) y aunque el template sea más grande, hemos reducido el número total de líneas de código a ejecutar (contando las que se ejecutarían al invocar la función del counter).

Ya para terminar (y para quitarnos el mal sabor de boca de haber tenido que mirar código de este tipo), les propongo una versión alternativa.

Para un caso más simple en el que los valores que le pasamos a al tag {counter} son estáticos y no varían durante la ejecución del tpl (por ejemplo, no cambiamos el sentido o incrementamos el skip basándonos en una variable de tiempo de ejecución… vamos, el caso típico. Podemos utilizar esta otra versión del counter compilado:

Archivo: DOCROOT/classes/smarty/libs/plugins/compiler.simple_counter_compile.php

<?php
/**
 * Smarty plugin
 * @package Smarty
 * @subpackage plugins
 */
 
/**
 * Smarty {compiler} compiler function plugin
 *
 * Type:     compiler function<br>
 * Name:     counter<br>
 * Purpose:  print out a counter value
 * @author Paolo Ragone <pragone at gmail dot com> (initial author)
 * @param string containing name, start, skip, direction, print and assign attributes
 * @param Smarty_Compiler
 */
function smarty_compiler_simple_counter_compile($tag_attrs, &$compiler)
{
	$_params = $compiler->_parse_attrs($tag_attrs);
 
	if (isset($_params['name'])) $name = $compiler->_dequote($_params['name']);
	else $name = 'default';
 
	$myvar = '$_counter_' . $name;
 
	if (isset($_params['start'])) $r .= $myvar . ' = (int) ' . $compiler->_dequote($_params['start']) . '; ';
	else $r .= ' if (!isset(' . $myvar . ')) {' . $myvar . ' = 1;} ' ."\n";
 
	if (isset($_params['direction'])) $mydir  = $compiler->_dequote($_params['direction']);
	else $mydir = 'up';
 
	if (isset($_params['assign'])) $r .= '$this->assign(' . $_params['assign'] . ',' . $myvar . '); ' ."\n";
	elseif (!isset($_params['print']) || $compiler->_dequote($_params['print']) != 'false') {
		$r .= 'print ' . $myvar  . ';' ."\n";
	}
 
	if (isset($_params['skip'])) {
		$myskip = $compiler->_dequote($_params['skip']);
	} else {
		$myskip = 1;
	}
 
	if ($mydir == 'down') {
		$r .= $myvar . '-= ' . $myskip . '; ' ."\n";
	} else {
		$r .= $myvar . '+= ' . $myskip . '; ' ."\n";
	}
	return $r;
}
 
?>

Luego de reemplazar las invocaciones de {counter_compile} por {simple_counter_compile} el código compilado es MUCHO mejor:

Archivo:DOCROOT/smartystuff/compile/%%84^84E^84EFDD88%%ejemplo3.2.tpl.php

<?php /* Smarty version 2.6.19, created on 2008-03-15 15:01:09
         compiled from ejemplo3.2.tpl */ ?>
<br>
<table cellpadding="5" cellspacing="0" border="1">
<tr>
<TD>up:1</TD>
<TD>up:1</TD>
<TD>start:3; up:1</TD>
<TD>up:2</TD>
<TD>down:1</TD>
<TD>up:1 on >=fifth down:1</TD>
<TD>up:1;no-print;using assign</TD>
</tr>
<?php $_counter_third = (int) 3; $_counter_third+= 1; 
 ?>
<?php unset($this->_sections['myloop']);
$this->_sections['myloop']['name'] = 'myloop';
$this->_sections['myloop']['loop'] = is_array($_loop=11) ? count($_loop) : max(0, (int)$_loop); unset($_loop);
$this->_sections['myloop']['show'] = true;
$this->_sections['myloop']['max'] = $this->_sections['myloop']['loop'];
$this->_sections['myloop']['step'] = 1;
$this->_sections['myloop']['start'] = $this->_sections['myloop']['step'] > 0 ? 0 : $this->_sections['myloop']['loop']-1;
if ($this->_sections['myloop']['show']) {
    $this->_sections['myloop']['total'] = $this->_sections['myloop']['loop'];
    if ($this->_sections['myloop']['total'] == 0)
        $this->_sections['myloop']['show'] = false;
} else
    $this->_sections['myloop']['total'] = 0;
if ($this->_sections['myloop']['show']):
 
            for ($this->_sections['myloop']['index'] = $this->_sections['myloop']['start'], $this->_sections['myloop']['iteration'] = 1;
                 $this->_sections['myloop']['iteration'] <= $this->_sections['myloop']['total'];
                 $this->_sections['myloop']['index'] += $this->_sections['myloop']['step'], $this->_sections['myloop']['iteration']++):
$this->_sections['myloop']['rownum'] = $this->_sections['myloop']['iteration'];
$this->_sections['myloop']['index_prev'] = $this->_sections['myloop']['index'] - $this->_sections['myloop']['step'];
$this->_sections['myloop']['index_next'] = $this->_sections['myloop']['index'] + $this->_sections['myloop']['step'];
$this->_sections['myloop']['first']      = ($this->_sections['myloop']['iteration'] == 1);
$this->_sections['myloop']['last']       = ($this->_sections['myloop']['iteration'] == $this->_sections['myloop']['total']);
?>
<TR>
<TD><?php  if (!isset($_counter_default)) {$_counter_default = 1;} 
print $_counter_default;
$_counter_default+= 1; 
 ?></TD>
<TD><?php  if (!isset($_counter_second)) {$_counter_second = 1;} 
print $_counter_second;
$_counter_second+= 1; 
 ?></TD>
<TD><?php  if (!isset($_counter_third)) {$_counter_third = 1;} 
print $_counter_third;
$_counter_third+= 1; 
 ?></TD>
<TD><?php  if (!isset($_counter_fourth)) {$_counter_fourth = 1;} 
print $_counter_fourth;
$_counter_fourth+= 2; 
 ?></TD>
<TD><?php  if (!isset($_counter_fifth)) {$_counter_fifth = 1;} 
print $_counter_fifth;
$_counter_fifth-= 1; 
 ?></TD>
<TD><strong><?php  if (!isset($_counter_sixth)) {$_counter_sixth = 1;} 
print $_counter_sixth;
$_counter_sixth+= 1; 
 ?><?php if ($this->_sections['myloop']['index'] == 5): ?><?php  if (!isset($_counter_sixth)) {$_counter_sixth = 1;} 
$_counter_sixth-= 1; 
 ?><?php endif; ?></strong></TD>
<TD><?php  if (!isset($_counter_seventh)) {$_counter_seventh = 1;} 
$this->assign('counter6',$_counter_seventh); 
$_counter_seventh+= 1; 
 ?><?php echo $this->_tpl_vars['counter6']; ?>
</TD>
</TR>
<?php endfor; endif; ?>
</table>

Pero cuidado, no funciona como la versión anterior o como la versión función. Fíjense en la columna: “up:1 on >=fifth down:1″

Eso es todo por ahora. Este tip lo he utilizado de otras formas también. Colocaré otras mejoras en los próximos artículos.

1. Servidor Web: Smarty es muy extensible, pero afrontémoslo… no es ligero. Las grandes libertades que te ofrece vienen con un coste: CPU, memoria y acceso a disco (por lo general carga muchos archivos, sobre todo en la etapa de compilación).
2. Bases de Datos: Suelo ser un cuello de botella, y si tienes algunos procesos que sean intensivos en datos puede hacer que tus servidores se arrodillen pidiendo perdón.

Para esto existe el Cache.

El uso del Cache es bastante claro para páginas que no cambien con frecuencia, de hecho con la clase que creamos en el artículo anterior, es muy sencillo, ya que es un parámetro a la hora de instanciar la clase.

Sin embargo, el uso del Cache no sólo se limita a páginas estáticas o casi estáticas. Hay un par más de casos (entre otros que ahora no se me ocurren) en el que es útil:

• Si la información no debe ser “real time”
• Para hacer que páginas estáticas se vuelvan estáticas.

Una buena opción para el uso del cache es cuando tienes una página cuyo contenido es dinámico, pero que no importa si tiene un par de minutos de “retraso. Por ejemplo, un listado de noticias, etc.

En este caso, nos basta con indicarle al Smarty que sí deseamos utilizar el cache y decirle cada cuánto queremos que refresque el contenido.

Por ejemplo, supongamos que tenemos un PHP que saca el listado de las últimas noticias y lo muestra. Sin el caché sería así (simplificando un poco el código):

Archivo: DOCROOT/pubs/ejemplo2.php

<?php
 
require_once 'classes/db/News.php';
require_once 'classes/template/MySmartyBasic.php';
 
$news = News::getLatestNews();
 
$tpl = new MySmarty();
$tpl->assign('news', $news);
$tpl->display('ejemplo2.tpl');
 
?>

Archivo: DOCROOT/confs/ejemplo2.conf

latest_news=Últimas Noticias

Archivo: DOCROOT/templates/ejemplo2.tpl

{config_load file="ejemplo2.conf"}
<html>
<head>
<title>{#lates_news#}</title>
<style>
{literal}
BODY {
	font-family:Arial, sans;
}
h1 {
	border: 1px black solid;
	background-color:#dddddd;
	margin:5px;
	padding:6px;
}
div, div.dark {
	white-space:nowrap;
	overflow:hidden;
	padding:5px;
	margin: 5px 10px 0px 10px;
}
div.dark {
	background-color:#eeeeee;
}
{/literal}
</style>
</head>
<body>
<h1>{#latest_news#}</h1>
{foreach from=$news item="new"}
<div {cycle values=",class='dark'"}>
<a href="{$new.url}">{$new.title}</a>: {$new.description}
</div>
{/foreach}
</body>
</html>

Para utilizar el caché, basta con modificar el php de la siguiente forma:

Archivo: DOCROOT/pubs/ejemplo2.1.php

<?php
 
require_once 'classes/db/News.php';
require_once 'classes/template/MySmartyBasic.php';
 
$tpl = new MySmarty(2); // Para asegurarnos de usar el cache.
$tpl->cache_lifetime = 5*60*60; // Regenerar cada 5 minutos
 
if (!$tpl->is_cached('ejemplo2.tpl', 'latest_news')) {
	// Colocamos el acceso a la BD dentro del if para evitarlo
	$news = News::getLatestNews();
	$tpl->assign('news', $news);
}
 
$tpl->display('ejemplo2.tpl', 'latest_news');
 
?>

y listo, el caché se refrescará cada 5 minutos.

Un ejemplo de hacer que el contenido dinámico se vuelva estático sería en este caso apropiado para la página que muestra la noticia. En este caso nos basta con modificar el PHP que muestra la noticia para que utilice el caché (como hicimos en el caso anterior), pero incluyendo el identificador de la noticia como parte del “cache_id”. Podría quedar así:

Archivo: DOCROOT/pubs/ejemplo2.2.php

<?php
 
require_once 'classes/db/News.php';
require_once 'classes/template/MySmartyBasic.php';
 
$new_id = $_GET['id'];
 
if (!is_numeric($new_id)) die("new_id debe ser un número");
 
// Para asegurarnos de usar el cache y que nunca expire
$tpl = new MySmarty(-1);
 
$cache_id = 'news' . $new_id;
if (!$tpl->is_cached('ejemplo2.2.tpl', $cache_id)) {
	// Colocamos el acceso a la BD dentro del if para evitarlo
	$the_news = News::getNews($new_id);
	if ($the_news === false) die("News id $new_id doesn't exist");
	$tpl->assign('the_news', $the_news);
}
 
$tpl->display('ejemplo2.2.tpl', $cache_id);
 
?>

Y listo!

Recuerda con el uso del cache algunas cosas importantes:

• No lo uses en desarrollo, te ahorrarás muchos dolores de cabeza.
• Ten cuidado con el manejo de errores, no quieres que si al generar la página ocurre algún error, ese error quede perpetuado en la versión cacheada. Tip: si detectas un error deshabilita el cache.
• Si necesitas forzar que una versión en caché sea regenerada tienes dos opciones: eliminar el archivo de la carpeta cache (el nombre del archivo incluye el cache_id); o utiliza la función clear_cache recordando de indicarle el cache_id.
• Si realizas algún cambio en el .tpl en el que se basa un cache, automáticamente todas las versiones cache-adas de ese .tpl quedan invalidadas y deberán ser regeneradas.
• Si debes cambiar el tpl y temes el impacto que regenerar el cache pueda tener en tu servidor, puedes regenerar las versiones cache en un ambiente anterior al de producción (stage) y subirlas junto con el tpl cuando estés publicando el cambio. En este caso ten mucho cuidado con las fechas de modificación de los archivos, las versiones cache deben ser posteriores al tpl o serán inválidas (un touch puede servir, o simplemente usa rsync).