+----+----+--------+
| CS | LF | Locale |
+----+----+--------+
| 0  | 0  | DL_DC  |
| 0  | 1  | LF_DC  |
| 1  | 0  | DL_CS  |
| 1  | 1  | LF_CS  |
+----+----+--------+

Lengend

• CS = Country Supported in the System
• LF = Language Forced in the URL
• DL_DC = Locale for the default country with the default language configured on the DB
• LF_DC = Locale for the default country but with the language forced in the URL
• DL_CS = Locale for the country detected with the default language configured on the DB
• LF_CS = Locale for the country detected with the language forced in the URL

Thinking about how it’s the best approach to solve the problem I found the following solutions.

Which do you think it’s the best approach?

We will try to get the same effect as the image below:

To create this effect you have to add the following lines on the html file:

<div class="background">
   <div class="white">This is an exemple with the CSS opacity property</div>
</div>

The first div have the class “background” to put a standard background and the second div is inside the first div to put another background called “white” over the first background.

Now you can customize the classes with the following attributes and values on your css file:

.background{
 background-image: url(caracol.png);
 width: 300px;
 height: 208px;
 border: 1px solid #000000;
}

.white{
 background-color: #ffffff;
 width: 250px;
 height: 158px;
 border: solid 1px #000000;
 margin: 25px 25px;
 opacity: 0.6;
 filter:alpha(opacity=60);
}

The class “background” contains an image background, the class “white” contains a background color with the opacity property to obtain the transparent effect. The attribute “opacity: 0.6;” is for Firefox and the values can go from 1.0 to 0.0, to be able to show this effect in IE you have to use the following code  “filter:alpha(opacity=60);” and the possible values can go from 100 to 0.

Remember to put the Doctype declaration on your HTML file to avoid the problems with the diferents bowsers and also write a stardard code.

I hope you enjoy it and do not hesitate if you have any doubt.

The tricky point was that the Array could contain more Arrays so we had to write a recursive function to accomplish our objective.

Tudor, at the end, gave the following method to be able to do the conversion.

/**
 * Recursively converts an array to a stdClass object
 *
 * @param array $array
 * @return stdClass
 */
 protected function _convertToStdObject(array $array){
   $obj = new stdClass();
   foreach($array as $key => $value) {
     if(!is_array($value)) {
       $obj->{$key} = $value;
     }else{
       $obj->{$key} = $this->_convertToStdObject($value);
     }
   }

   return $obj;
 }

Maybe, in the next interviews we will do to our PHP Developers candidates, we will ask about this and see how they solve the problem

Para ello, debemos discernir, en primera instancia, entre los datos que conforman el contenido propiamente dicho (normalmente documentos jerarquizados que siguen una estructura) y los llamados metadatos. ¿Y qué son los metadatos? Entendemos por metadatos, los datos que contienen información sobre los propios datos (etiquetas, enlaces, reviews, pageviews, etc.).

Otro aspecto muy a tener en cuenta en el proceso de clasificación de los datos es la privacidad de éstos. Los buscadores utilizan la información para devolver resultados cada vez más adecuados a los usuarios, y parte de ella (como las querys o los clicks) pueden revelar algunos datos personales.

Llegados a este punto se nos formulan algunas preguntas nada despreciables: ¿Cómo podemos utilizar estos datos? ¿Con qué criterio los organizamos? ¿Cuán fiables son los datos que poseemos?

En lo que respecta a la fiabilidad de los datos, podemos hacer una reflexión desde el punto de vista estadístico. Teniendo en cuenta que el conjunto de búsquedas/visitas es muy elevado, y curiosamente la mayoría de ellas son sobre un conjunto de temas comunes (la llamada “long tale” en la representación gráfica), la distribución tenderá a ser una distribución normal o gaussiana. La media de todos los datos será, por lo tanto, un resultado sorprendentemente bueno.

Así, podemos aprovechar que el conocimiento colectivo supera, en la mayor parte de los casos, al conocimiento individual. Toda esta teoría está detallada en profundidad en el libro The Wisdom of Crowds: Why the Many Are Smarter Than the Few and How Collective Wisdom Shapes Business, Economies, Societies and Nations de James Surowiecki.

Aún disponiendo de datos fiables, debemos establecer una organización y clasificación para que resulten realmente útiles al usuario final. Esto requiere determinar unos criterios sobre el conjunto de información (texto, enlaces, etiquetas, queries, etc.) para medir la calidad de cada recurso.

La clasificación por excelencia de la Web 1.0 (PageRank) basa la calidad de los documentos en función de los enlaces que “apuntan” a cada uno de ellos. Este ingenioso modelo funcionaba a la perfección cuando los únicos usuarios que realizaban los enlaces en la red de redes eran los administradores. Hoy por hoy cualquiera tiene la posibilidad de crear enlaces y este sistema para clasificar los contenidos está perdiendo fuerza en la Web 2.0.

Un modelo alternativo que tiene un buen desempeño en la actualidad es el etiquetado, en inglés tagging, de los documentos. El usuario que añade una información en Internet se encarga también de definir un conjunto de etiquetas o palabras claves que ayuden a clasificar dicha información.

El etiquetado tiene aplicaciones muy diversas e interesantes. Una de ellas consiste en la selección de contenido teniendo en cuenta la diversidad de términos (topical diversity). Un ejemplo claro es la consulta “Jaguar”, que puede hacer referencia al animal o a la marca de automóviles.

También son útiles los tags para segregar y descartar algunas imágenes en querys determinadas. Por ejemplo, si un usuario busca “Honda Civic” probablemente no querrá encontrar como resultado un conjunto de imágenes del coche con el mismo ángulo. Un resultado óptimo devolvería imágenes desde todos los ángulos posibles. Es lo que se designa con el término visual diversity.

El tagging en imágenes tiene más aplicaciones útiles, como la navegación a partir de las etiquetas (como en Yahoo! TagExplorer) o las anotaciones visuales (use visual annotations), en las que una etiqueta es representada mediante un rectángulo que encuadra un objeto particular. Sistemas de este tipo se utilizan actualmente en portales como Flickr o Facebook.

Pese a todo, el gran inconveniente de este sistema es la necesidad de que el usuario defina los tags, con lo que ello respecta (errores ortográficos, errores tipográficos, subjetividad, heterogeneidad…). Inmediatamente se nos ocurre la idea de implementar un sistema para sugerir etiquetas, pero la experiencia nos dice que el usuario es propenso a hacer uso de la “ley del mínimo esfuerzo”. Es decir, que en la mayoría de los casos el usuario se limitaría a introducir una única etiqueta y seleccionar el resto de ellas del conjunto propuesto por el algoritmo de sugerencia.

Otro modelo que cabe destacar es el basado en la correlación entre los recursos. El principio de funcionamiento de este método es buscar el conjunto de elementos relacionados con la consulta introducida por el usuario (otros nombres, lugares, eventos, imágenes, etc.). Estas interrelaciones entre las entidades se suelen representar como grafos, y se aplican los algoritmos y técnicas de teoría de grafos para su implementación.

Relacionado con lo anterior está el uso de las consultas como etiquetas implícitas (querys as implicit tags). Esta técnica aprovecha las decisiones que toma el usuario para detectar las relaciones entre las búsquedas y etiquetar los recursos. Un ejemplo podría ser dos usuarios que realizan las consultas “Roma” e “Imperio romano” respectivamente y, no obstante, hacen click en el mismo enlace de todos los presentes en los resultados. El sistema detectaría estos casos y haría patente esa relación mediante nuevas transiciones en el click graph.

Un sistema complementario para mejorar las búsquedas en la Web 2.0 es el uso del conocimiento implícito (implicit knowledge). La mejor manera de entender el funcionamiento de esta técnica es con un caso práctico. Supongamos que un usuario introduce la query “tfcu”. Usando el conocimiento implícito debe obtener todos los documentos relacionados con la teachers federal credit union, dado que tfcu es el acrónimo de ésta. Del mismo modo, el sistema debe guardar una relación entre CEE, UE, Comunidad Económica Europea y Unión Europea.

El objetivo principal de la recuperación de información (information retrieval) es devolver el conjunto óptimo de recursos relacionados con lo que el usuario está buscando, en el menor tiempo posible. Todos los modelos mencionados, y muchos otros que se han quedado en el tintero, sirven para acercarse más al objetivo, y el uso combinado de todos ellos produce mejores resultados.

La Web crece en volumen de información y evoluciona a la par que los usuarios requieren disponer de la información más relevante de la forma más rápida posible. ¿Pero, en qué dirección evoluciona la Web? La tendencia marca el progresivo adiós a las búsquedas, dando paso a portales que ofrecerán al usuario justo aquello que desean obtener sin necesidad de que éste lo pida. Dicho así puede sonar bastante utópico. Sin embargo, ¿quién imaginaba hace 20 años que se podría obtener todo tipo de información escribiendo algunas palabras en una caja de texto? ¿Llegará un día en el que abriendo nuestro navegar obtendremos la información que necesitamos sin hacer nada para llegar a ella? Sólo el futuro de la Web tiene la respuesta.

Fuente

Ricardo Baeza – http://www.dcc.uchile.cl/~rbaeza/spanish.html

Antes de nada debo decir que estos son los pasos que he seguido para instalar XDebug para PHP 5.2 usando MAMP Pro 1.8.4 bajo MacOS X Snow Leopard. Es posible que, si tenéis una configuración distinta, los pasos puedan variar un poco.

En primer lugar debemos descargarnos los binarios de XDebug en esta URL: http://aspn.activestate.com/ASPN/Downloads/Komodo/RemoteDebugging.

Descomprimimos el archivo .tgz que nos acabamos de descargar y veremos que hay una estructura de directorios que representa las diferentes versiones de PHP. Yo actualmente estoy utilizando PHP 5.2 (la que en estos momentos incluye por defecto MAMP y MAMP Pro) así que copiaré el fichero xdebug.so que hay dentro de esta carpeta.

Este archivo xdebug.so deberemos copiarlo en el directorio de extensiones de PHP, en MAMP es /Applications/MAMP/bin/php5/lib/php/extensions/no-debug-non-zts-20050922/.

Ahora deberemos añadir algunas líneas a nuestro php.ini para activar y configurar la extensión. La localización habitual del fichero php.ini en MAMP es /Applications/MAMP/conf/php5/php.ini pero (¡OJO!) si utilizáis MAMP Pro las modificaciones en este fichero serán en vano. Esto es debido a que MAMP Pro carga su propia copia del php.ini que se localiza en /Applications/MAMP PRO x.x.x/MAMP PRO.app/Contents/Resources/php5.ini (accediendo haciendo clic con botón derecho sobre la app de MAMP Pro y “Mostrar contenido del paquete“).

Una vez localizado el php.ini adecuado, debemos añadir la siguiente línea:

[xdebug]
zend_extension="/Applications/MAMP/bin/php5/lib/php/extensions/no-debug-non-zts-20060613/xdebug.so"

Si utilizáis el editor TextMate para programar, añadid también esta línea a continuación para que el debugger muestre los errores como enlaces a TextMate en la línea correcta:

xdebug.file_link_format = "txmt://open?url=file://%f&line=%l"

Si además váis a utilizar MacGDBp para debuggar y queréis que se ejecute el debugger por defecto (si lo tenéis abierto) podéis añadir también (sino deberéis añadir ?XDEBUG_SESSION_START=macgdbp a vuestra URL cada vez para iniciar el debugger):

xdebug.remote_enable = On
xdebug.remote_autostart = 1

Para que funcione todo correctamente posiblemente deberemos desactivar el Zend Optimizer, que viene activado por defecto en MAMP.  Para ello, comentamos las siguientes líneas:

;zend_optimizer.optimization_level=15
;zend_extension_manager.optimizer=/Applications/MAMP/bin/php5/zend/lib/Optimizer-3.3.3
;zend_optimizer.version=3.3.3

Ahora debéis reiniciar el servidor Apache y ya podréis comenzar a debuggar vuestras aplicaciones en PHP. Si ha funcionado ya os daréis cuenta de que los errores se muestran en una tabla muy colorida y hay una mejora muy sustancial a la hora de mostrar los resultados de var_dump.

Espero que os sea de utilidad y si tenéis problemas acudid a los comentarios para intentar resolverlos entre todos. ¡Salu2!

Fuentes

debuggable.com – http://debuggable.com/posts/setting-up-xdebug-on-mac-os-x-or-win32-linux:480f4dd6-0240-4a90-8fa1-4e41cbdd56cb

Techno Sophos – http://technosophos.com/content/debugging-your-php-code-xdebug-mamp-textmate-and-macgdbp-support

Desde la versión 4 de PHP existen dos funciones muy útiles para estos menesteres, fgetcsv y  fputcsv.

Según la documentación PHP la firma de esta función es la siguiente:

array fgetcsv (resource $handle [,int $length [,string $delimiter = ',' [,string $enclosure = '"' [,string $escape = '\\']]]])

Como podemos ver, el primer parámetro a proporcionar es el puntero al fichero que queremos leer y después toda una serie de parámetros opcionales como la dimensión de la cadena a leer, el delimitador de campos, el carácter de envoltorio de campos y el carácter para escapar símbolos poco comunes. Esta función, al ser llamada con los parámetros correctos, devolverá la línea que ha leído en formato de array, donde cada campo será una nueva entrada en el array.

Bien, en este punto y antes de mostrar un trozo de código tengo que hacer mención a un detalle, esta función puede ocasionar algunos problemas dependiendo del sistema operativo en el que estemos corriendo PHP. En mi caso, utilizando Mac OS X Snow Leopard, me he encontrado que la función no detecta bien el final de la línea con lo cuál, y para ahorrarnos problemas, vamos a utilizar también la siguiente instrucción:

ini_set('auto_detect_line_endings', TRUE);

Esta línea lo que hace es forzar a detectar el final de línea, lo que resuelve el problema en dichas plataformas.

Dicho todo esto, voy a mostrar un trozo de código que lo que hace es recorrer el fichero y generar una array de arrays con todo el fichero parseado.

<?php

//Prepare the auto detect line endings for some OS's
ini_set('auto_detect_line_endings', TRUE);

//Save the path to the file we want to open
$file = dirname(__FILE__) . 'test.csv';

//Create a file pointer to de file in read mode
$fp = fopen($file, 'r');

//Setup the result var
$parsedCSV = array();

/* Get the headers of the csv and store it in a special key in the array. Setting the max length to 0 strip the length constrain */
$parsedCSV['headers'] = fgetcsv($fp, 0, ',');

/* Loop to read the entire file, take a look at the comparison and remember that if fgetcsv arrives at the end of the file a FALSE will be returned. We use this to detect the EOF */
while(($line = fgetcsv($fp, 0, ',')) !== FALSE){
    $parsedCSV[] = $line;
}

//Print out the array
die(var_dump($parsedCSV));

Para detectar el final de fichero en este script estamos usando la comparación ($line = fgetcsv($fp, 0, ‘,’)) !== FALSE ya que fgetcsv devuelve FALSE en caso de error o EOF (End Of File).

Espero que este post os sea de ayuda y recordad que podéis preguntarnos mediante el sistema de comentarios.

Si nuestra aplicación sigue el paradigma de la orientación a objetos debemos almacenar el estado del objeto para recuperarlo a posteriori. Un posible enfoque sería almacenar toda esa información en una base de datos y trabajar así con un sistema gestor de base de datos (SGBD) como MySQL. Pero existe un inconveniente en este caso, que la mayoría de SGBD son relacionales y nuestro programa sigue el modelo de la orientación a objetos (OOP) y la conversión entre modelos muchas veces no es obvia.

La alternativa que pretendo explicaros en este post es la serialización de los objetos para que sean almacenados en ficheros de texto, dándo así persistencia a nuestras aplicaciones. Me he decidido a realizar la explicación en Python su excelente mecanismo para la serialización de objetos, Pickle.

Para el post he creado una sencilla clase llamada SFSaludador que se encarga de saludar al usuario imprimiendo un “Hola!” por pantalla. El objeto guardará el total de saludos y esa información se hará persistente en un fichero llamaso “sfsaludador.txt” serializanso mediante Pickle. Os dejo el código a continuación:

import os
import pickle

class SFSaludador(object):
	"""Clase SFSludador"""

	def __init__(self, totalSaludos):
		super(SFSaludador, self).__init__()
		self.__totalSaludos = totalSaludos

	def saluda(self):
		"""Saluda"""
		print "Hola!"
		self.__totalSaludos += 1

	def getTotalSaludos(self):
		"""Devuelve el total de saludos"""
		print "He saludado " + str(self.__totalSaludos) + " veces."

	def load(self):
		"""Obtiene la informacion del archivo"""
		dataFile = open('sfsaludador.txt','r')
		self.__totalSaludos = pickle.load(dataFile)
		dataFile.close()

	def write(self):
		"""Graba los datos en el fichero"""
		dataFile = open('sfsaludador.txt','w')
		pickle.dump( self.__totalSaludos, dataFile)
		dataFile.close()

def main():
	"""Main function"""

	miSaludador = SFSaludador(0)

	if (os.path.exists('sfsaludador.txt')):
		print("Archivos encontrados. Cargando...")
		miSaludador.load()
	else:
		print("Archivos no encontrados...")

	miSaludador.getTotalSaludos()
	miSaludador.saluda()
	miSaludador.getTotalSaludos()

	miSaludador.write()

if __name__ == '__main__':
	main()

Para ejecutar el programa utilizaremos el intérprete de Python por consola de la siguiente forma (en entornos UNIX):

python SFSaludador.py

Dónde SFSaluadador.py es el fichero con el código de nuestro programa de ejemplo.

La primera vez que ejecutamos el programa no encontrará ningún fichero (así nos lo comunicará nuestra aplicación) y será al final de esta ejecución cuando creará el fichero con el estado del objeto para cargarlo en siguiente ejecuciones. Si volvemos a ejecutarlo vemos como esta vez si encuentra el fichero y el total de saludos tiene en cuenta los saludos de ejecuciones anteriores.

A veces Pickle puede llegar a ser un poco lento si necesitamos serializar muchos ficheros. Para solucionar esto existe una implentación de la librería realizada en el lenguaje de programación C, llamada cPickle. Si queremos hacer uso de ella sin tener que realizar modificaciones en nuestro código solo debemos sustituir el import de la librería por:

import cPickle as pickle

Espero que con este breve post haya podido haceros llegar la idea de la persistencia de datos en ficheros y su implementación en el potente lenguaje Python. Como siempre, ¡os espero en los comentarios!

En este tutorial vamos a ver como instalar el servidor de subversion en una maquina ubuntu.

Para ello el primer paso es instalar los paquetes necesarios

sudo apt-get install subversion libapache2-svn subversion-tools

Creamos la carpeta para guardar los ficheros

sudo mkdir /home/<user>/svn

Editamos el fichero de configuración

sudo nano /etc/apache2/mods-enabled/dav_svn.conf

Hay que modificar el archivo hasta que se parezca a esto

# dav_svn.conf - Example Subversion/Apache configuration
#
# For details and further options see the Apache user manual and
# the Subversion book.# <location URL> ... </location>
# URL controls how the repository appears to the outside world.
# In this example clients access the repository as http://hostname/svn/
<location /svn>
# Uncomment this to enable the repository,
DAV svn
# Set this to the path to your repository
SVNParentPath /home/<user>/svn

# The following allows for basic http authentication.  Basic authentication
# should not be considered secure for any particularly rigorous definition of
# secure.
# to create a passwd file
# # rm -f /etc/apache2/dav_svn.passwd
# # htpasswd2 -c /etc/apache2/dav_svn.passwd dwhedon
# New password:
# Re-type new password:
# Adding password for user dwhedon
# #
# Uncomment the following 3 lines to enable Basic Authentication
 AuthType Basic
 AuthName "Subversion Repository Access"
 AuthUserFile /etc/apache2/dav_svn.passwd
 Require valid-user
# Uncomment the following line to enable Authz Authentication
# AuthzSVNAccessFile /etc/apache2/dav_svn.authz
# The following three lines allow anonymous read, but make
# committers authenticate themselves.
#<limitexcept GET PROPFIND OPTIONS REPORT>
#Require valid-user
#</limitexcept>
</location>

Creamos el fichero de usuarios y claves

sudo htpasswd -cm /etc/apache2/dav_svn.passwd <username>

Usamos este comando si queremos añadir mas usuarios

sudo htpasswd /etc/apache2/dav_svn.passwd <another username>

Reiniciamos apache

sudo /etc/init.d/apache2 restart

Creamos la carpeta que contendrá el proyecto

sudo mkdir -p /home/<user>/svn/<project>

Creamos el repositorio

sudo svnadmin create /home/<user>/svn/<project>

Conectamos al subversion localmente y creamos las carpetas Trunk, Tags y Branches

sudo svn mkdir file:///home/<user>/svn/<project>/trunk -m "Trunk"
sudo svn mkdir file:///home/<user>/svn/<project>/tags -m "Tags"
sudo svn mkdir file:///home/<user>/svn/<project>/branches -m "Branches"

Otorgamos permisos a apache

sudo chown -R www-data.www-data /home/<user>/svn

Navegamos a la carpeta /etc/init.d, creamos un fichero llamado init-svnserve y lo abrimos con nano para editarlo

cd /etc/init.d/
sudo touch init-svnserve
sudo nano init-svnserve

En el fichero añadimos esta linea

svnserve -d -r /home/<user>/svn

Damos permisos de ejecución al fichero

sudo chmod +x init-svnserve

Actualizamos el arranque del sistema para que detecte el nuevo fichero

sudo update-rc.d init-svnserve defaults

Reiniciamos el servidor y todo funcionando!

sudo shutdown -r now

• Ubuntu Software Center →Substituye a la aplicación “Agregar y quitar” del menú Aplicaciones.
• Gnome 2.28 → Nueva versión del entorno de escritorio.
• Empathy → El cliente de mensajería Empathy substituye a Pidgin.
• Quickly → Permite a los desarrolladores más facilidades para la creación de aplicaciones en Ubuntu y compartir los archivos a través de paquetes .deb entre otros.
• Kernel → 2.6.31-14.48 kernel basado en 2.6.31.1.
• Grub 2 → El gestor de arranque substituye a Grub Legacy. Sólo podremos hacer uso de él desde Karmic Koala y no podremos actualizar desde otras versiones al tratarse de una operación arriesgada.
• Ubuntu One → 2Gb de almacenamiento gratuito online y la facilidad de compartir archivos ya sea con ordenadores propios o con los de otros. Por un precio a bajo costo podemos ampliar esta capacidad.

Para más información acerca del Ubuntu 9.10 ir a: http://www.ubuntu.com/products/whatisubuntu/910features

Podemos obtener Ubuntu desde: http://www.ubuntu.com/getubuntu

Uno de esos widgets es el acordeón. Al clicar en los títulos se extienden mostrando el contenido de estos.

Para realizar este efecto nos basaremos en el ejemplo de la propia web de jQuery UI dónde podréis comprobar otros efectos muy interesantes.

En primer lugar crearemos un documento html en el que añadiremos las diferentes secciones con sus correspondientes títulos y contenidos, nosotros en este ejemplo utilizaremos 3 secciones:

<div id="accordion">
 <h3><a href="#">Section 1</a></h3>
 <div>
 <p>
 Content
 </p>
 </div>
 <h3><a href="#">Section 2</a></h3>
 <div>
 <p>
 Content
 </p>
 </div>
 <h3><a href="#">Section 3</a></h3>
 <div>
 <p>
 Content
 </p>
 </div>
</div>

Hemos asignado la id “accordion” al div principal porque será el que le diremos a JQuery UI que utilice para montar el acordeón.

Para poder hacer uso de las librerías de jQuery el procedimiento es como el que utilizamos en otro post para incluir Prototype y Scriptaculous, la primera es descargarnos las librerías desde la web y llamarlas desde nuestro html y la segunda es incluirlas directamente desde la web oficial. Nosotros las incluiremos directamente desde la web oficial.

Para ello hay que añadir las siguientes líneas de código:

<link rel="stylesheet" href="http://ajax.googleapis.com/ajax/libs/jqueryui/1.7.2/themes/redmond/jquery-ui.css" type="text/css" media="all" />
<script type="text/javascript" charset="utf-8" src="http://ajax.googleapis.com/ajax/libs/jquery/1.3.2/jquery.min.js"></script>
<script type="text/javascript" charset="utf-8" src="http://ajax.googleapis.com/ajax/libs/jqueryui/1.7.2/jquery-ui.min.js"></script>

La primera línea incluye el estilo visual. En este caso hemos utilizado el estilo “Redmond” pero ya veréis que en la web de jQuery UI tenéis mucha variedad y con la posibilidad de modificarlos desde la misma web con una interfaz gráfica.

Por último añadimos el script que coge el div “accordion” y llama al método accordion() que es el que monta el acordeón propiamente dicho:

<script type="text/javascript">
$(function() {
$("#accordion").accordion();
});
</script>

Y este es un ejemplo del resultado final: