And that’s it for most people, at that point you’re probably a senior developer with good coding practices. But that’s definitely not the end of the road. Depending on your work you may actually have to think a lot on Scalability and that opens up another world of possibilities that still now a days is not “solved”, and everyday there’s a new framework, persistence layer or caching technology seeing the day of light.

But, still, the road continues with what I think are often forgotten or non-priority concerns: Maintainability and Shareability

Maintainability

Hasn’t it happened to you that you look back to code that you wrote a year ago and go: “ok, why did I do this THAT way?”, or even worse, you look at some one else’s code and just don’t get what did they do… This is what I refer to with maintainability: The ability to maintain and evolve an existing code base.

For this I’d stress three good practices that can help keep your code maintainable:

Keep it real: The best way to make your code maintainable is to keep it close to the business needs. In this sense Domain Driven Design is a powerful tool because it creates a common language that enables developers and business experts to communicate effectively, and as a side effect allows the developer (when in doubt) to go ask a business expert what is the code doing and is therefore great for maintenance.

Be verbose: Verbosity goes a long way into helping understand what code does. When I say verbosity, logging is of course the first thing that comes to mind, but the concept expands also to having correctly named variables, methods, classes, etc. But there’s more, in these days where everybody uses IoC and DI frameworks like Spring, sometimes it’s hard to follow how things are wired together; don’t take me wrong, I like the @Autowired annotation, but I don’t like so much @Component/@Service. I prefer to declare beans explicitly in the .xml files.
It’s a bit like the when you’re studying and writing things down actually helps a lot to memorize and understand them.

Refactor: Last, but not least, one the best practices for maintainability of code is to do continuous and incremental refactoring, because honestly it’s not always possible to do it right the first time (because of time constrains, changing business rules, being human, etc).

Shareability

Shareability is the next step. While maintainability allows you to evolve a code base with the business needs, shareability is what allows your code to be able to accommodate not only your specific needs, but other team’s and other businesses’ needs without making the code base a mess.

A great example of this is the Spring framework itself: The way concerns are isolated and interfaces are defined makes the framework amazingly flexible for a very wide range of uses.

This is the most complex level of abstraction to achieve as it implies distilling the essence of each peace of code, carefully designing interconnections and thinking of uses you haven’t thought possible. But it’s also the most “fulfilling” level of coding: If you’ve ever had to implement a new feature and you’re afraid it may be a big change because it deviates a lot from the existing use cases, but it turns out that the solution fits naturally in the existing code, then you’ve just experiences shareability saving the day.

Is this last “level of coding” what has been driving my attention lately, and where I’ve spent some time thinking of alternatives.

In following posts I’ll describe a programming paradigm and framework I’m developing that I think helps you get to this level of coding.

OSGI implementations like Equinox are very well tested and stable, but a hard drive can always go bad, or the cleaning lady could always unplug a network cable, so you’re never really fault tolerant unless you’re able to run your app in more than one machine.

Sometimes it’s as simple as deploying the code to another machine and running it. Sadly, most of the times it’s not that simple.

Creating an OSGI app that will run in several servers is not a trivial task, as I started to do it, I immediately found one typical example of something that’s very simple when done in one machine and rather complex when you need to do it in multiple machines: Configuration.

OSGI already defines a Configuration Admin Service to manage the configuration of your services. Yet it doesn’t say anything about distributed configuration. I started to look around and the best I found was this thread called “Bridge between zookeeper and OSGI configuration admin“.

With that piece of software you’re able to maintain your services configuration in Apache ZooKeeper, and any change in it will be automagically distributed to all servers running your system.

Definitely worth a look.

I find OSGI particularly interesting because it solves one of the big drawbacks I saw to development in Java: deployment and management of component versioning (something that’s not a problem in scripting languages like PHP).

Yet, the learning curve in OSGI is particularly steep, I guess because it’s really becoming mainstream just recently, so I thought I would share what an OSGI novice has been able to learn about it in a week of development and a lot of reading (and I mean a LOT).

What is OSGI? And what is it for?

OSGI itself is “just” a set of specifications about how you can go about building highly modularized, dynamic applications. That’s why when you got to the OSGI Alliance web site the only download you’ll find are the specs. Take the chance and download them, store them somewhere (you’ll need them… just not now).

So if OSGI is “just” a compendium of specifications, how do I use it?

You need to get your hands on one of the implementations/frameworks. The base for every OSGI App is an OSGI Framework. Its on top of that you build your OSGI Application.

The main open source OSGI Frameworks are:

• Eclipse Equinox: Is Eclipse Foundation’s version of it. It serves as the base for the popular Eclipse IDE, which is in itself an OSGI application.
• Apache Felix: Is Apache Foundation’s implementation. It’s also very used by a lot of people.
• Knoplerfish: Is another Open Source OSGI “service platform”. I think it’s quite used too, but I don’t think you can compare it’s community to any of the previous two.

Once you have one of these up and running you can start bulding/deploying bundles to it… but what is an OSGI bundle?

An OSGI bundle is the main building block of an OSGI application. To better understand it let’s dive deeper into how OSGI works.

How does OSGI works?

In Java, every Class is brought to live by a ClassLoader. Whenever you use a class (whether its one you’ve built or a java.lang one), a ClassLoader is used to fetch it from a directory or JAR in your ClassPath and load it in the JVM.

A ClassLoader can only load a class once, and that’s why when you modify a class in a stand alone app you need to restart the JVM for the changes to take effect. To overcome this “limitation”, the OSGI frameworks create several ClassLoaders (one per bundle), if you need to reload the classes in a bundle, the Framework disposes the ClassLoader associated with the bundle and creates a new one. OSGI Frameworks are not the only ones that use this mechanism, Servlet Containers (like Tomcat or Jetty) do the same, and that’s how you can reload servlets without taking down the web server.

This sounds like a great idea, but it must be handled with a lot of care. For example, when several ClassLoaders are used you could end up with more than one Singleton, and static variables of one class having different values depending on the ClassLoader you use. To make matters even worse, the Java 2 platform silently introduced the concept of Thread Context ClassLoader (A ClassLoader that’s associated with a Thread and not necessarily used to load the classes used in it).

A good article on this topic is: Find a way out of the ClassLoader maze.

But no tool is good or bad in itself, it all depends on how you use it, and this is where the Specs of OSGI come into play establishing a well defined way to manage ClassLoaders. And this is how bundles where born.

What is a bundle?

A bundle is the minimum unit of reloadable content, and “is comprised of Java classes and other resources, which together can provide functions to end users” (OSGI R4 Core Specs, page 27). In practice a bundle is a Jar file with a special META-INF/MANIFEST.MF. In this manifest, the bundle specifies what packages (as  in java.lang) it exposes to other bundles, what packages it needs from other bundles, an optional Activator class (to customize the life cycle of the bundle) and many other things.

But let’s create a simple bundle to understand this better. Our TestBundle is a Jar with this content:

• META-INF/MANIFEST.MF
• com/testbundle/Activator.class
• com/testbundle/exported/Concatenator.class

The manifest contains the following:

Manifest-Version: 1.0
Bnd-LastModified = 1281229346082
Build-Jdk = 1.6.0_20
Built-By = pragone
Bundle-Activator = com.testbundle.Activator
Bundle-ManifestVersion = 2
Bundle-Name = testbundle
Bundle-SymbolicName = com.testbundle.testbundle
Bundle-Version = 0.0.1.SNAPSHOT
Created-By = Apache Maven Bundle Plugin
Export-Package = com.testbundle;uses:="org.osgi.framework",com.testbundle.exported
Import-Package = org.osgi.framework;version="1.2"
Tool = Bnd-0.0.357

The important parts here are:

• Import-Package: indicates what packages this bundle needs to function, particularly org.osgi.framework is a package that is always  provided by the OSGI Framework
• Export-Package. indicates what packages owned by this bundle are made available to other bundles. e.g. com.testbundle.exported
• Bundle-Activator: the name of a class that implements org.osgi.framework.BundleActivator

The code of the activator is pretty simple:

package com.testbundle;

import org.osgi.framework.BundleActivator;

import org.osgi.framework.BundleContext;

public class Activator implements BundleActivator {

public void start(BundleContext context) throws Exception {

System.out.println(“Test Bundle starting”);

}

public void stop(BundleContext context) throws Exception {

System.out.println(“Test Bundle stopping”);

}

}

To “execute” this bundle do the following:

1. Download an OSGI framework. Let’s use Equinox for this examples. Get org.eclipse.osgi_<version>.jar from  http://download.eclipse.org/equinox/ (I’m using version 3.6)
2. Save the jar file to a new directory in, say, your desktop. Let’s assume this directory is called “<DESKTOP>/osgi”
3. Download the test bundle source code from here. Untar/Unzip it to a location of your liking.
4. In a terminal/command prompt, go to the folder where the content of the bundle was unpacked and type: “mvn package” (This assumes you have Maven installed. If you don’t… what are you waiting for, go get it)
5. Once Maven has finished execution, a new folder called target will be created and in it a file called: testbundle-<VERSION>.jar, copy this file to the “<DESKTOP>/osgi” folder.
6. Still on the terminal/command prompt go to the “<DESKTOP>/osgi” folder and type:
   java -jar org.eclipse.osgi_<version>.jar -console
7. You should see a “osgi>” prompt. type:
   install file:testbundle-<VERSION>.jar
8. Now type:
   start 1
9. You should see a message indicating: “Test Bundle starting”

That’s it, you just got your first OSGI app up and running.

Now let’s try some Class updating magic. Go into the source code if the TestBundle and modify the source of Activator.java changing the two System.out.println from:

System.out.println("Test Bundle starting"); -- to --> System.out.println("New Test Bundle starting");

and

System.out.println("Test Bundle stopping"); -- to --> System.out.println("New Test Bundle stopping");

repeat steps 4 and 5 from above in a new terminal and then in the terminal running our OSGI app type:

osgi> update 1

You should see:

Test Bundle stopping
New Test Bundle starting

Nice, huh?, the old version was stopped, the new jar loaded and the new version was started. Now that’s what I call a Hot Deployment.

What’s next?

In the next articles, I’ll talk about the BundleContext, bundle Services, Service Trackers, Tools when working with OSGI and resources

Por supuesto, si tu página web sólo sirve unos pocos miles de impresiones al día o a la hora, no tienes grandes problemas y muchas de estas preguntas son simplemente irrelevantes por el bien de un desarrollo ágil, pero si comienzas a hablar de páginas con tráfico considerable es posible que te encuentres con problemas para los que no haya soluciones ampliamente conocidas.

Trataré de escribir algunos artículos más exponiendo mi punto de vista sobre algunas de las tecnologías que ya conocemos y sus alternativas. Por el momento simplemente les dejo con algunos enlaces que pueden resultarles interesantes:

Lenguajes de programación:

• Is the Supremacy of Object-Oriented Programming Over?: [EN] Un artículo realmente interesante que habla sobre las limitación de POO para ciertos problemas y plantea si es la hora de reintroducir lenguajes de programación funcionales por sus mejores condiciones para el manejo concurrente de tareas.
• Erlang [EN] (Wiki [ES]): Un “nuevo” lenguaje de programación creado por Ericsson que es particularmente bueno para el manejo de tareas concurrentes y distribuidas. Es la base para algunos de los proyectos más interesantes que han salido últimamente.
• Clojure [EN]: Otro lenguaje de programación funcional que vive dentro de la JVM

Persistencia / Bases de datos:

• Anti-RDBMS a list of distributed key-value stores [EN]: Un buen artículo en el que se presenta una lista con algunas de las alternativas existentes a bases de datos relacionales. Particularmente interesantes son Project Voldemort y CouchDB.
• BigTable [EN,PDF] y MapReduce [EN]: Desarrollados por Google, conceptualmente la base para la implementación de algunos de los sistemas de persistencia mencionados en el artículo anterior.
• Eventually Consistent [EN]: un artículo interesante en el que se plantea la pregunta de: es necesaria la consistencia de la data siempre? o por razones de performance nos podemos permitir inconsistencias temporales?

• Gigaspaces [EN]: Tecnología muy interesante que se enfoca en mantener todo en memoria y olvidarte de la persistencia (ya se encarga Gigaspaces de ello).
• TokuDB [EN]: Un nuevo storage engine para MySQL, basado en lo que Tokutek llama Fractal Trees ™, o como lo llama el MIT “Cache-Oblivious Trees” [EN]

Búsqueda de texto / Indexación de información:

• Sphinx [EN]: Un FullText Search Engine, con un performance excelente aunque con una lista limitada de funcionalidades.
• Solr [EN]: Un nuevo FullText Search Engine de Apache que encapsula a Lucene y provee algunas funcionalidades extra como el preprocesamiento de la data a indexar.

Espero los enlaces les sean de interés, trataré de escribir algo más de detalle al respecto.

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

El Güero

Hace un par de semanas unos amigos nos invitaron a otro sitio de comida Venezolana, que debo decir ha estado incluso mejor que el anterior: El Güero, comida venezolana en Madrid.

Tienen una carta muy amplia de comida venezolana (y una carta de comida Mexicana que no ha probado pero de seguro que está muy buena).

Lo mejor de todo: Tienen unos quesitos muy buenos: Queso de mano, Guayanés, Telita, etc. Si te quieres tomar una Polar o una Malta lo puedes hacer también… en fin, la verdad es que excelente totalmente. Además de que la atención es muy buena y te hacen sentir en casa

Luego de haber ido un par de veces, mi favorita es la Arepa pelúa: el guiso de carne mechada es genial… sobre todo cuando lo acompañas con la guasacaca que te dan y la salsita picante. Yo que soy de Caracas, me senti en el granjero del este

Merecen una mensión especial también las empanaditas, las cachapas, las tajadas con queso, los tequeños, el papelón con limón, el jugo de parchita… y ahora en época decembrina las hallacas (que no las he probado, pero de seguro lo haré… se pueden encargar).

Tajadas con Queso

La verdad no tomé muchas fotos (estaba muy ocupado comiendo hasta reventar ), pero aquí les dejo un par de joyas que sé que les encantarán (si consigo otras fotos las montaré luego):

Aquí les dejo también el menú de El Güero:

Menú de El Güero

En fin, un sitio que les recomiendo ampliamente.

Asegúrense de fimar el libro de visitas anotando su email y les notificarán de cosas nuevas como por ejemplo cuando salen las hallacas, etc. También pueden visitar su Blog.

La dirección: C/ Emigrantes, 2. 28043, Madrid.

Saludos y disfruten.

Da' Gusto: Comida Venezolana en Madrid

Tenían arepas, patacones, tequeños, unos batidos geniales y malta.

Es dueño es un maracucho muy simpático (aunque no recuerdo el nombre ahora). Nos sentimos como en casa cuando luego de traernos un jugo de Tamarindo, vino con el pote de la licuadora para echar el fondito

Da Gusto: Sentirse como en casa

En fin… muy recomendable. Yo me pedí un de carne mechada y estaba genial.

La dirección es:

Avda. De los Poblados, 131
28025, Madrid

Telef: 913 410 731 / 622 431 583

En fin… muy bueno.

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.