Planeta Linux Argentina

Este es un post pagado asi que sino quieren leerlo no hay problema, aunque puede que a muchos les interese.

Hoy les voy a hablar de mercaweb, es una empresa de que brinda alojamiento web, no es el mas economico que he visto pero si esta entre los 10 mas economicos que he visto, el plan mas economico es de 1.99 euros al mes, se llama plan Inicio y creo que es suficiente como para aquellos que quieren comenzar un blog (250mb de espacio y 3Gb de tranferencia) tambien nos da un dominio gratis, que no dice el tipo pero supongo que debe ser un “.es”. Ha, olvide decir que la pagina esta en español y los del soporte tecnico, tanto via email o chat online tambien hablan español y eso es algo bueno

Los planes de hosting corren sobre Linux y usan Cpanel, eso es bueno, Plesk es horrible!

En la pagina tambien se venden dominios, pero eso si estan muy caros, 12 euros al año, es mucho para mi, los he visto mas economicos. Tambien dicen que tienen garantia de 30 dias, pero eso en general yo no lo creo, nunca he probado algo asi, pero no lo creo.

Entre otros servicios en la pagina tambien podran encontrar creadores de sitios, creadores de tiendas virtuales y planes reseller, que estos ultimos si, estan a un precio decente, el mas economico a 15 euros y permite alojar ilimitados dominios, aunque el ancho de banda brindado es poquisimo! solo 30 Gb. Pero para permitir ilimitados dominios esta bueno.

Una cosa buena que le encontre es que permiten el pago por paypal, ademas de por tarjeta y tranferencia bancaria.

Hosting merkaweb.

Ya salio firefox 3.5, entre las novedades podemos citar:

• Mejora en la velocidad de carga
• Soporte para los nuevos elementos de HTML5 (video,audio)
• Navegacion privada
• Navegacion considerando la ubicacion (mas info aqui)
• Mejora en la perfonmance de usando el nuevo motor Tracemonkey para javascript
• Soporte para varias nuevas tecnologias webs

Si quieren leer las notas de lanzamiento click aqui. Yo por mi parte esperare hasta la actualizacion desde los repos, pero si ustedes no quieren esperar pueden bajar firefox 3.5 desde aqui.

Ya les habia hablado de virtualbox 3.0 cuando estaba en su beta 1. Ahora se ha anunciado la version 3.0 final y entre las novedades no hay mucho mas de lo que ya les habia contado:

• Huéspedes con SMP de hasta 32 CPUs virtuales (sólo con Intel VT-x o AMD-V).
• Soporte de Direct3D 8/9 en huéspedes Windows (experimental).
• Soporte de OpenGL 2.0 para huéspedes Windows, Linux y Solaris.

Pero tiene otras mejoras no tan relevantes, que se pueden ver aqui. Yo solo espero que los juegos de mocosoft funcionen bien con el soporte experimental de Direct3D

Me encuetro esto en vivalinux, es un video de un “concepto” que se esta probando para Gnome 3.0, o sea que es solo una prueba, pero viendo el video la verdad me quede con las ganas de que Gnome 3.0 salga ya mismo

En el ejemplo vemos:
* Los encabezados de las ventanas son siempre visibles.
* Solo el botón de cerrar en el encabezado de la ventana.
* Lanzador de aplicaciones con solo hacer doble-click en alguna parte vacía del escritorio.
* Los “dockers” inferiores pueden usarse para minimizar ventanas y moverlas a otro escritorio.

Se liberó ayer la nueva versión del IDE OpenSource de Sun Microsystems, NetBeans.

Si no conocen NetBeans, les comento que es un entorno de desarrollo no solo para aplicaciones Java, también podremos desarrollar en lenguajes como: C/C++, JavaScript, Ruby, Groovy, Phython, y PHP, además de contar con soporte para la sincronización con servidores de aplicaciones como Glassfish, Tomcat y servidores de bases de datos utilizando drivers de conexión, permitiendo fácilmente agregar servidores y administrarlos.

Una excelente innovación que tiene esta nueva versión, es la posibilidad de estar conectado al Project Kenai, el cual es un entorno de colaboración, que le permite a desarrolladores como tu y como yo hospedar tu proyecto opensource en Internet y permitir que esté disponible para todo mundo.

Gracias a esta integración, un equipo de desarrolladores puede usar la misma interfaz para crear proyectos, así como subirlos, editarlos, debuggearlos, construirlos, entre otras cosas.

Si nunca has usado NetBeans, te comento que está disponible para diferentes plataformas:Windows XP/Vista, Linux, Mac OSX y por supuesto para Solaris y OpenSolaris. Y como principal requisito, tener la ultima versión del JDK instalado. Yo lo uso tanto para desarrollar con JavaFX como para desarrollar con KumbiaPHP Framework y es realmente una herramienta genial!

Si quieren mas info aqui tienen las Release Notes y las Installation Instruction. Y para bajarlo van a la pagina de descargas de NetBeans.

Me entere gracias a blogultura.

Bueno, hace un tiempo instalé Pure-FTPd, y hasta ahora anduvo muy bien. Creo que merece la pena probarlo y escribo este artículo con el fin de recomendar su uso, y de paso evitarles algunos de los dolores de cabeza que yo me llevé para hacerlo funcionar.

Pure-FTPd es un servidor FTP muy potente, liviano, fácil de instalar y configurar y por sobre todo, seguro. Es de libre distribución, existe para múltiples plataformas y en muchos idiomas.

En esta guía voy a explicar como instalarlo y configurarlo sobre Debian, pero no creo que tengan problemas para seguir el artículo los que quieran instalarlo en otra distribución.

Algunas de las características más destacadas de Pure-FTPd son:

• Directorios home enjaulados
• Usuarios virtuales
• Cuotas virtuales

Obtener Pure-FTPd

Podemos descargar la última versión estable de http://www.pureftpd.org/.

Una vez descargado lo descomprimimos en algún directorio temporal y procedemos a compilarlo.

cd /usr/local/src
wget http://download.pureftpd.org/pub/pure-ftpd/releases/pure-ftpd-1.0.21.tar.gz
tar xzvf pure-ftpd-1.0.21.tar.gz

Compilación e instalación

Lo compilamos con los siguientes flags:

• –without-inetd: sin inetd (vamos a correr nuestro servidor como demonio aparte, en modo standalone, así que no necesitamos inetd)
• –with-puredb: soporte para usuarios virtuales
• –with-ratios: soporte para ratios de subida/bajada
• –with-quotas: soporte para cuotas
• –with-throttling: soporte para limitar ancho de banda
• –with-language=spanish: soporte para nuestro idioma
• –with-paranoidmsg: sirve para que siempre se muestre el mismo mensaje de error (útil por motivos de seguridad)
• –with-nonroot: para que solo root pueda ejecutar el servidor
• –with-ftpwho: soporte para logs en tiempo real (usuarios conectados, etc.)

NOTA: recomiendo consultar todos los flags disponibles con ./configure –help. Ya que pueden variar según la versión que se instale.

cd /usr/local/src/pure-ftpd-1.0.21 ./configure --without-inetd --with-puredb --with-ratios --with-quotas --with-throttling --with-language=spanish --with-paranoidmsg --with-nonroot --with-ftpwho
make
make install

Configuración

Modo standalone

Si compilamos el servidor con el flag –with-out-inetd, supongo que querrán arrancar el servidor como standalone. Por lo que no deberían saltearse este paso.

Se trata de decirle a inetd que no lo necesitamos, que nuestro servidor va a correr como demonio a parte. Para esto abrimos el archivo de configuración de inetd y comentamos la línea correspondiente al puerto donde corre el FTP. Editamos el fichero vi /etc/inetd.conf.

Comentamos la línea:

#ftp stream tcp nowait root

Usuarios virtuales

NOTA: Para usar usuarios virtuales, necesitamos haber compilado el servidor con el flag –with-puredb.

Los usuarios virtuales son usuarios que no existen en el sistema, sólo pertenecen al Pure-FTPd. Están asociados a un usuario del sistema, pero son virtuales. Por lo tanto, si un usuario “malicioso” lograra conseguir una cuenta FTP en nuestro sistema, no podría hacer mucho…

Estos usuarios virtuales pueden almacenarse en una base de datos MySQL, LDAP, etc. En este caso usamos la que viene por defecto con el Pure-FTPd para no complicarnos la existencia.

Primero que nada creamos un grupo y un usuario en el sistema a los cuales los usuarios virtuales van a estar asociados.

groupadd ftp useradd ftp -g ftp -s /bin/false -d /dev/null

El grupo y el usuario se llaman ftp, le pasamos como argumento -s /bin/false para que no tenga shell y -d /dev/null para que no tenga directorio principal. Es decir, es un usuario sin ningún tipo de privilegio, a un atacante no le serviría de mucho.

Bien, solo nos resta crear los usuarios virtuales:

pure-pw useradd < <nombre_usuario>> -u ftp -g ftp -d /home/ftp/< <nombre_usuario>>; -t 25 -T 25 -c "< <nombre_usuario>>" pure-mkdb

• pure-pw useradd: es el comando que nos ofrece Pure-FTPd para crear usuarios virtuales
• >: el nombre del usuario virtual
• -u y -g: el usuario y el grupo del sistema al cual vamos a asociarnos
• -d: el directorio principal del usuario (esta opción hace chroot en el directorio a diferencia de -D)
• -t y -T: el grupo del sistema al cual vamos a asociarnos (para usar estos parámetros debió haberse compilado el servidor el flag –with-throttling
• -c: el nombre “real” del usuario virtual
• pure-mkdb: es el comando que sirve para actualizar la base de datos de usuarios virtuales, hay que usarlo cada vez agregamos/eliminamos/modificamos usuarios virtuales, o en su defecto utilizar el parámetro -m

CONSEJO: podemos hacernos un script para crear usuarios virtuales, así no tenemos que escribir “semejante línea” cada vez que queramos crear un usuario:

nano /usr/sbin/userftpaddc

Escribimos el siguiente script dentro:

pure-pw useradd $1 -u ftp -g ftp -d /home/ftp/$1 -t 25 -T 25 -c $2 -m

Y le damos permisos de ejecución:

chmod a+x /usr/sbin/userftpadd

Ahora cada vez que queramos crear un usuario hacemos:

userftpadd < <nombre_usuario>> "< <nombre_usuario>>"

El primer parámetro es el nombre del usuario virtual y el segundo es el nombre “real” del mismo.

Script de inicio

Nos falta crear el script de arranque en /etc/init.d y configurar los niveles de ejecución para iniciar el servidor.

nano /etc/init.d/pure-ftpd

/usr/local/sbin/pure-ftpd -j -B -lpuredb:/etc/pureftpd.pdb -A -c 10 -C 2 -d -E -k 90 -u 100

Le damos permisos de ejecución:

chmod a+x pure-ftpd

Y creamos los niveles de ejecución (los de defecto).:

update-rc.d pure-ftpd defaults

De esta manera el servidor se va a iniciar cada vez que inicie el sistema, con lo siguientes flags:

• -j: si al arrancar, el directorio raíz de un usuario no existe, lo crea
• -B: corre en background
• -lpuredb:/etc/pureftpd.pdb: indica el fichero donde se almacenan los usuarios virtuales (no olvidar verificar que este sea correcto)
• -A: hace chroot (así nadie sale de su directorio principal)
• -c 10: 10 conexiones simultanes máximo (depende de tu servidor)
• -C 2: cantidad de conexiones por IP (nadie debería conectarse más de dos veces simultaneamente desde una misma IP, por cuestiones de seguridad)
• -d: log verboso
• -E: no se permiten usuarios anónimos
• -k 80: se podrá ocupar como máximo el 80% de la partición
• -u 100: UID mínimo 100 (para que nadie se loguee como root ni nada parecido)

Firewall

Si están bajo un router o tienen algún iptables corriendo por ahí, no olvidar abrir los puertos 20 y 21.

Otra cosa, como montamos el servidor en modo pasivo, si intentan conectarse a la IP pública pero desde su misma IP, no van a poder. Tienen que conectarse desde una IP diferente.

Conectándonos y probando el servidor

Primero de manera local:

ftp localhost

Debería pedirles que se logueen con un usuario y conectarlos al directorio principal de dicho usuario.

Después intenten de manera remota (repito, háganlo desde otra IP que no sea la del servidor, ya que está en modo pasivo):

ftp tudominio.com

Problemas frecuentes

“No puedo loguearme como usuario virtual”

¿Compilaste el servidor con el flag –with-puredb?

¿Iniciaste el servidor con el parámetro -lpuredb:/etc/pure-ftpd.pdb?

¿Existe el fichero /etc/pure-ftpd.pdb? si no existe hay dos opciones:

1. no compilaste con la opción –with-puredb, SOLUCION: volvé a compilar el servidor con el flag –with-puredb

2. estás usando otra versión y el fichero se encuentra en otra ruta, como por ejemplo en /etc/pure-ftpd/pure-ftpd.pdb, SOLUCIÓN: cambiá el flag de inicio -lpuredb

“No inicia el servidor”

¿Compilaste con –without-inetd?

¿Deshabilitaste FTP en inetd.conf?

¿Revisaste que todos los parámetros de inicio sean correctos?

“Tengo que arrancar el servidor manualmente, yo quiero que arranque al iniciar”

Tenés que configurar los niveles de ejecución, en esta misma guía explico como.

“Me puedo conectar localmente pero remotamente no”

Revisá el router/firewall, que tengas abiertos los puertos 20 y 21.

“Me puedo conectar, pero los comandos no responden”

Repito por tercera vez: si te estás conectando desde la misma IP donde está el servidor, no vas a poder, ya que está en modo pasivo. Intentá desde otra IP.

Para dar acceso remoto a MySQL tienen que hacer un pequeño cambio en el fichero de configuración my.cnf.

El archivo my.cnf dentro del directorio de instalación de MySQL, probablemente /etc/mysql/my.cnf.

Busquen por la línea:

bind-address            = 127.0.0.1

Como pueden ver, actualmente solo permite que se ingrese localmente. Vamos a cambiarla para que nos permita ingresar desde cualquier lado:

bind-address            = 0.0.0.0

O también podemos optar por comentarla, es igual:

#bind-address            = 127.0.0.1

Ahora reiniciamos el servicio:

/etc/init.d/mysql restart

Bueno, no olviden tampoco abrir el puerto que usa MySQL (3306 por default) en el firewall/router.

A la hora de monetizar nuestro blog, o sea sacarle provecho economico, son pocas las opciones que realmente funcionan, incluso adsense esta dando muy poco ultimamente y la venta de enlaces pasa a ser algo a tener en cuenta.

Con TNX la venta de enlaces se vuelve algo mas real que con los otros sistemas que he probado. Explicare un poco el funcionamiento.

Los primero es crearnos una cuenta aqui. La creacion de cuentas no esta abierta a todo el mundo, solo se puede entrar por invitacion, por eso veran en la pagina de registro que les pide un “Invitation code” sin el cual no pueden avanzar en el registro. Eso no es mucho problema, simplemente dejenme un comentario y yo les paso una invitacion.

Luego de registrados damos de alta nuestro blog y colocamos el codigo en el mismo(esto lo explicare al final).

Al cabo de unos dias veremos que el sistema nos empieza a indexar paginas y a asignarnos enlaces. Nosotros tendremos un control total sobre los enlaces que queremos que aparezcan y aquellos que no, incluso podremos excluir paginas para que en ellas no aparezca ningun enlace.

Por defecto solo se nos agregara un enlace por pagina, pero si hacen click donde dice “Show Site Options” podran aumentar este numero a 4 por pagina.

Como podran ver nos muestra ademas los yahoo backlinks que tiene nuestro blog. Esa es una caracteristica interesante de TNX, ya que a la hora de darle un valor a los enlaces no solo se base en el PageRank sino tambien el los BackLinks de Yahoo.

El sistema que usa tnx para la monetizacion es simple, cada enlace vendido tiene un valor de puntos que se sumaran dia a dia en nuestra cuenta. Esos puntos pueden ser canjeados por dinero que se entrega via paypal, pueden ser vendidos a otro usuario de TNX o pueden ser usados para comprar nuestras propias campañas de venta de enlaces. El limite minimo para transferir dinero a nuestra cuenta de paypal son $5 dolares. Bastante bajo si lo comparamos con otros sistemas que nos piden llegar a los 50 o 100 dolares para recien entregarnos el dinero. La relacion que existe entre los puntos TNX y el dinero en dolares es la siguiente: 1000 puntos=$0.96 dolares

Ademas de ganar por vender enlaces tambien se puede ganar por un sistema de afiliados, TNX nos regalara un porcentaje de lo que ganen nuestros afiliados.

Creo que no me ha quedado nada por explicar sobre el funcionamiento. Solo quiero decirles que este es el mejor sistema de venta de enlaces que me he encotrado hasta el momento. Ahora voy a explicarles como instalarlo en un blog de Wordpress.

Instalacion en Wordpress

TNX usa PHP para insertar sus enlaces dinamicamente, por lo que no puede ser usado en blog que esten alojados en wordpress.org. La instalacion del codigo es super sencilla:

1. Descargar este plugin que nos permite insertar codigo PHP en nuestro sidebar y activarlo.
2. En nuestra cuenta de TNX ir a donde dice “Get Code”, el mismo codigo vale para todos nuestros blogs que queramos agregar al sistema.
3. Luego pegar el codigo en un widget de texto de Wordpress y listo, nuestras paginas se empezaran a indexar y los enlaces se asiganaran solos.

Lo ultimo que quiero decirles es que el sistema solo tiene un requerimiento y es que el sitio este indexado por google, pero no tiene requerimiento minimo de PageRank. Asi que ya saben, si quieren usar este sistema me dejan un comentario para que les pase el codigo Invitacion.

Get-You (click para agrandar)

Get-You es una aplicacion que nos permite buscar videos en los sitios de videos mas famosos, como Youtube, DailyMotion, Google-Videos, y varios mas. Podemos hacer las busquedas por palabra clave, lo cual es muy bueno y verlos sin salir del programa ya que incorpora un visor de videos simple. Ademas de verlos nos da la posibilidad de bajarlos.

El programa esta hecho en java por lo que es multiplataforma, su uso es super sencillo e intuitivo.

Los detalles de la instalacion se encuentran en su pagina oficial. Yo les mostrare como instalarlo en Ubuntu Hardy, aclaro que funciona tambien perfectamente en Ubuntu 9.04 Jaunty.

Vamos a una consola y escribimos

sudo gedit /etc/apt/sources.list

Al final del archivo agregamos lo siguiente:

deb http://ppa.launchpad.net/get-you-development/ubuntu hardy main

Luego lo clasico

sudo apt-get update

seguido de un

sudo apt-get install get-you

Les recomiendo que usen este programita ya que es la manera mas sencilla que he encontrado hasta ahora de buscar y bajar videos de internet

En este artículo voy a explicar, a modo de introducción, que son las inyecciones SQL, como funcionan, y como evitarlas. Además vamos a ver un caso práctico sobre SQL Injection, para poder comprender mejor en que consiste esta vulnerabilidad.

Que es SQL Injection

Se define como SQL Injection (o Inyección SQL en español) el insertar código SQL dentro de otro código SQL, para alterar su funcionamiento normal. Esto sucede gracias a un malo o inexistente filtrado en el nivel de validación de una aplicación, que permite a un atacante, insertar (o mejor dicho “inyectar”) código SQL dentro de variables que son utilizadas por la aplicación para realizar consultas SQL. Veamos mejor esto con un ejemplo…

Un caso práctico de SQL Injection

Imaginemos que tenemos un sistema de noticias. El mismo dispone de una base de datos donde almacena las noticias, los rubros de las mismas, los usuarios registrados al sistema, etc.

Para mostrar las noticias, la aplicación hace una consulta SQL pidiéndole a la base de datos las noticias correspondientes al día de hoy, y finalmente se las presenta al usuario.

Sería una consulta SQL como esta:

SELECT * FROM news WHERE date='$today';

Donde la variable $today, sería la que almacena la fecha actual.

Perfecto, tenemos un gran sistema de noticias. Ahora imaginemos que además de por fecha, queremos ordenar las noticias por rubros. Es decir, queremos ofrecerle al usuario, la posibilidad de elegir el rubro que quiere ver, y mostrarle las noticias sólo de ese rubro.

Se trata de una aplicación web, en la que tenemos una página que le devuelve al usuario todas las noticias del rubro elegido. Para esto el usuario hace una petición HTTP a la página, pasándole por GET el rubro que quiere ver, así:

http://sistemanoticiasejemplo.com/show_notes.php?item=economy

(Esto obviamente lo hace a través de una interfaz que le permite elegir el rubro que quiere ver).

Entonces, la página en cuestión toma el parámetro item pasado por el usuario, y lo usa para hacer la consulta SQL:

SELECT * FROM news WHERE date='$today' AND item='$selected_item';

Siendo $selected_item, en este caso, la variable que tiene el rubro pedido por el usuario. Es decir, que a la base de datos le llegaría algo así:

SELECT * FROM news WHERE date='03-03-2008' AND item='economy';

Entonces la base de datos le devolvería a la página todas las noticias correspondientes al día de hoy que pertenezcan al rubro de economía.

Lo que tenemos que entender de esto, es que la consulta SQL depende de un dato pasado por el usuario, en este caso, el rubro.

Es decir, si de pronto al usuario se le ocurre pasarnos el valor “jsdkafjsdfk” como rubro, nada se lo impediría, y la aplicación haría una consulta así:

SELECT * FROM news WHERE date='03-03-2008' AND item='jsdkafjsdfk';

Ahora bien… ¿en que nos puede perjudicar esto? en nada… porque el rubro “jsdkafjsdfk” no existe… Pero, ¿qué pasaría ahora si en vez de ingresar un valor sin sentido, al usuario se le ocurriera ingresar como rubro un trozo de código SQL?

Es decir, imaginemos que el usuario ingresara esto:

http://sistemanoticiasejemplo.com/show_news.php?item=’ OR ”=’

Ahora la aplicación haría la siguiente consulta SQL:

SELECT * FROM news WHERE date='03-03-2008' AND item='' OR ''='';

¡El usuario estaría alterando la consulta SQL! estaría diciéndole a la base de datos algo así como: “dame todas las noticias pertenecientes al día de hoy y cuyo rubro sea igual a ” o la expresión ”=” sea verdadera”, que si lo resumiéramos a sería algo como “dame las noticias de hoy sin importar cual sea el rubro”.

Como podemos ver, el usuario (a partir de ahora, el atacante) estaría alterando la consulta para lograr un resultado no esperado por la aplicación. En este caso, mostrar todas las noticias juntas sin importar el rubro.

Bueno, señores, a esto se le llama SQL Injection. Si bien el ataque anterior no tiene mucho “peligro” para la aplicación, no podemos pasar por alto que hay una vulnerabilidad grave en el sistema, que podría permitir a un atacante con un poco más de conocimiento hacer otro tipo de inyecciones más perjudiciales para la aplicación.

Siguiendo con el mismo ejemplo, veamos algunos ejemplos de como un atacante podría jugar un poco con nuestro bug…

Bien, ahora nuestro atacante estuvo leyendo un libro de SQL, y quiere poner en práctica sus nuevos conocimientos con nuestra aplicación. Entonces se le ocurre esta vez, alterar la consulta de manera que devuelva los datos de otra tabla, como por ejemplo la tabla users que contiene toda la información de los usuarios registrados al sistema de noticias (sus mails, contraseñas encriptadas, etc.).

Entonces, esta vez hace lo siguiente:

http://sistemanoticiasejemplo.com/show_notes.php?item=’ UNION SELECT * FROM users WHERE ”=’

Lo cual va a provocar que nuestra aplicación haga la siguiente consulta a la base de datos:

SELECT * FROM news WHERE date='03-03-2008' AND item='' UNION SELECT * FROM users WHERE ''='';

Ahora si estamos en problemas, nuestro ya no tan inofensivo atacante acaba de obtener con esa consulta todos los datos de nuestros usuarios registrados.

¿Pueden ver ahora lo grave que es un bug de este tipo? dejaría prácticamente la base de datos en las manos de la creatividad y conocimiento de cualquier atacante.

Como evitar SQL Injection

Bien, ahora que sabemos lo que son esencialmente las inyecciones SQL, veamos como podemos hacer para proteger nuestras aplicaciones de ellas.

A ver, pensemos… ¿dónde está el error en el ejemplo del sistema de noticias?

En la base de datos? NO, la base de datos simplemente nos devuelve lo que le pedimos, no tiene la culpa de que alguien altere nuestra aplicación para que la consulta cambie.

Y entonces quién tiene la culpa? el atacante? el atacante no tiene la culpa de que nuestra aplicación sea vulnerable, a lo sumo tendrá que lidiar con su conciencia por las noches, pero no lo podemos culpar por nuestro bug.

Y bien… dónde está el error entonces? pensemos… qué pasa entre la petición del usuario y el procesamiento de la consulta? o mejor dicho… qué es lo que NO pasa? UNA VERIFICACIÓN! así es señores, en nuestra aplicación en ningún momento hacemos una verificación de los datos ingresados por el usuario antes de realizar la consulta. Eso es terrible, deberíamos estar avergonzados de nuestra existencia.

A qué nos referimos con “verificación”? bueno, simplemente a verificar que dentro de los datos ingresados por el usuario no haya código SQL que pueda alterar nuestra consulta. Veamos un poco más sobre esto…

Siguiendo con el mismo ejemplo del sistema de noticias. El dato que habría que verificar sería el rubro, es decir, verificar que el usuario no nos haya pasado como rubro caracteres especiales como comillas que puedan servir para inyectar código SQL en la consulta.

En este caso, nos bastaría con verificar que el rubro pasado por el usuario sólo tenga letras y/o números, sin ningún caracter especial.

Bien, en este caso con eso sería suficiente. Pero imaginemos que por alguna razón el usuario tenga que ingresar comillas o algún otro caracter especial porque la aplicación lo solicita… ¿cómo hacemos para que esta entrada no sea tomada como parte de la consulta?

En ese caso tendríamos que escapar este tipo de caracteres, para que sean tomados simplemente como caracteres y no como parte de la consulta SQL. En PHP tenemos la función mysql_escape_string().

Bueno, lo que tenemos que entender de todo esto. Es que cuando una aplicación es vulnerable a SQL Injection, el problema está en el nivel de verificación de datos de la apicación. Por lo que la solución es filtrar siempre la entrada del usuario, de manera que nunca un atacante pueda inyectar código SQL en ningún lado de la aplicación. A continuación voy a poner algunas de las técnicas más comunes de filtrado:

• Limitar, siempre que se pueda, el tamaño del dato ingresado: de esta manera limitamos la cantidad de código SQL que un atacante puede inyectar. En especial si se trata de una consulta anidada.
• No permitir, o en su defecto escapar, todos los caracteres que puedan llegar a ser usados como parte de una inyección SQL: comilla simple (’), punto y coma (;) y caracteres de comentario (/* */ y –).
• Filtrar con expresiones regulares todo lo que ingrese el usuario. Por ejemplo en un formulario de registro, el campo mail sólo debería aceptar letras en minúsculas, números y un arroba. Al igual que en un número de teléfono sólo deberían aceptarse números. Etc…

Otros consejos que no tienen que ver con la verificación de datos, son:

• Realizar las consultas de la aplicación con un usuario con la menor cantidad de privilegios posible en la base de datos. De modo que si un atacante, pudiera saltearse de algún modo la verificación de datos e inyectar código en alguna de nuestras consultas, los daños se reduzcan al no tener suficientes privilegios.
• Realizar la verificación de los datos ingresados por el usuario en todas las capas de la aplicación. Algunos desarrolladores por ejemplo, hacen una sola verificación con JavaScript en la capa de presentación. Que puede ser fácilmente obviada por un atacante, enviando por ejemplo los datos directamente a la capa de negocio de la aplicación.
• No mostrar los mensajes de error devueltos por la base de datos. Un atacante podría serle muy útil esta información, en especial para hacer Blind Injection.
• Usar Prepared Statements: es lo mejor que podés hacer, ya que prácticamente son inmunes a las inyecciones SQL. Si quieren más info. sobre ellos, acá escribí un artículo sobre Prepared Statements.

Bueno, eso es todo por hoy. Como pueden ver, esto es una especie de introducción a lo que es SQL Injection. El tema es tan amplio y complejo como interesante, y no me alcanzarían ni el tiempo ni los conocimientos para cubrirlo todo. Más adelante, vamos a ver otros casos avanzados de SQL Injection como Blind Injection.

Prepared Statements es una nueva característica a partir de MySQL 4.1, que permite separar de una manera segura, los datos pasados en una consulta SQL de la consulta en si. En este artículo voy a explicar como funciona y como se usa.

Entendiendo Prepared Statements

Generalmente cuando hacemos una consulta, hacemos lo siguiente:

SELECT * FROM table WHERE field='Data';

Es decir, tenemos todo junto, tanto la consulta, como los datos (en este caso ‘Data’).

¿Cuál es el problema de esto?

Bueno, que alguien podría inyectar código SQL en nuestra consulta si no tuviéramos un buen filtrado de los datos. (Si necesitan información sobre inyecciones SQL, acá tienen un artículo de introducción a SQL Injection).

Prepared Statements consiste en pasarle a MySQL, la consulta por un lado, y los datos por otro. De manera que MySQL sabe perfectamente que pertenece a la consulta y que no. Y así nunca nadie puede inyectar código SQL dentro de los datos para alterar la consulta.

Como usar Prepared Statements

Creamos un nuevo Prepared Statement:

PREPARE stmt FROM "SELECT * FROM table WHERE field = ?";

Como podemos ver, al crear el nuevo Prepare Statement, le estamos pasando solo la consulta (sin el dato).

Ahora creamos, por otra parte, el dato:

SET @data = "Data";

Perfecto, tenemos por una parte al consulta, y por otra el dato. Lo único que tenemos que hacer es decirle MySQL que ejecute la consulta usando ese dato.

EXECUTE stmt USING @data;

Fácil cierto? y seguro además…

Bueno, si quisiéramos hacer otra consulta con el mismo dato, o la misma consulta con otro dato, también sería muy sencillo hacerlo:

SET @other_data = "Other data";
PREPARE other_stmt FROM "INSERT INTO table (field) VALUES (?)";
EXECUTE stmt USING @other_data;
EXECUTE other_stmt USING @data;

Como pueden ver estamos reutilizando la consulta anterior con otro dato. Y además estamos reutilizando el dato anterior con una nueva consulta.

Si quisiéramos borrar un Prepared Statement, haríamos lo siguiente:

DROP PREPARE stmt;

O así:

DEALLOCATE PREPARE stmt;

Para usar más de un dato en una consulta, usan varios signos de pregunta (?), y después al ejecutar el Prepared Statement, tienen que pasarle la cantidad de parámetros como datos en la consulta. Ejemplo:

PREPARE stmt FROM "SELECT * FROM table WHERE field = ? OR field = ?";
SET @data_1 = "Data 1";
SET @data_2 = "Data 2";
EXECUTE stmt USING @data_1, @data_2;

Bueno, esto va a ser lo ultimo que voy a publicar de JavaFX por unos dias porque tengo que estudiar para los examenes de la facu.
Hoy vamos a ver como permitirle al usuario interactuar con nuestro programa, es decir, los eventos. Los eventos tambien se pueden agregar arrastrando desde la barra de herramientas de NetBeans.

Actions en NetBeans

Todos los objetos que conforman la GUI que vimos hasta ahora tienen los eventos correspondientes al mouse y el teclado.

Vamos a ver un par de ejemplos.

onMouseEntered y onMouseExited

Primero que nada creamos una variable llamada “miFigura” antes del contendo(content) del escenario(Scene). Nos quedaria asi:

scene: Scene {
var miFigura:Rectangle = Rectangle {
x: 20, y: 10
width: 150, height: 70
arcWidth: 50, arcHeight: 50
fill: Color.LIGHTBLUE
stroke: Color.ROYALBLUE
strokeWidth: 3
}
content: [ ]
}

Como veran es una objeto literal comun como el que ya hemos usado muchas veces. Pero veamos un par de cosas que tendremos que tener en cuenta:

• Por que lo asignamos a una variable? Para poder operar con sus atributos de manera mas sencilla.
• Por que lo creamos fuera de “content”? Porque no pueden declararse variables dentro del content, solo usarse.
• Que es arcWidth y arcHeight? Es para darle bordes redondeados al rectangulo.

Ahora le agregaremos las acciones de onMouseEntered y onMouseExited desde el panel lateral derecho. Esto lo hacemos dentro de la variable miFigura, el codigo nos quedara asi:

scene: Scene {
var miFigura:Rectangle = Rectangle {
x: 20, y: 10
width: 150, height: 70
arcWidth: 50, arcHeight: 50
fill: Color.LIGHTBLUE
stroke: Color.ROYALBLUE
strokeWidth: 3
onMouseEntered: function( e: MouseEvent ):Void {
miFigura.fill = Color.LIGHTGREEN;
}
onMouseExited: function( e: MouseEvent ):Void {
miFigura.fill = Color.LIGHTBLUE;
}
}

content: [
miFigura
]
}

Lo que agregamos es lo que esta en rojo. En los eventos veran que lo que hacemos es cambiar la propiedad fill (relleno) de el rectangulo, que se llama miFigura. El evento onMouseEntered se lanza cuando el puntero del mouse entra en la figura, y onMouseExited cuando la deja. El ultimo cambio que pueden ver con rojo es cargar dentro de content la variable que contiene nuestro rectangulo, sino colocan nada dentro de content solo les aparecera una ventana vacia.

Este mismo concepto vale para todas las acciones o eventos que podemos ver en el panel lateral del NetBeans, no vale la pena verlas todas ahora ya que con solo leer el nombre nos damos una idea de para que sirve cada accion. Ademas en las subsiguientes partes de este tutorial seguramente las usaremos todas.

Transformaciones

Este es otro tema que no es de gran importancia si queremos hacer aplicaciones llamativas y vistosas y con lindos efectos. Las transformaciones nos permiten transformar de una u otra manera nuestros objetos visibles. Vamos a ver 3 tipos de transformacionesm que, obviamente, el NetBeans nos la provee en su barrita listas para arrastrarlas a nuestro codigo. Al final del esta parte del tutorial les dejare un video para que vean las transformaciones en accion. Para todos los ejemplos usaremos el mismo codigo del primer ejemplo (onMouseEntered y onMouseExited)

Rotate

Esta tranformacion nos permite rotar un objeto visible sobre un pivote. Nosotros podremos espedificar la ubicacion de dicho pivote y el angulo de inclinacion. Su uso basico es el siguiente:

transforms: Rotate {
angle: 30 // angulo de inclinacion
pivotX: 10 //punto pivote X
pivotY: 10 //punto pivote Y
}

Pero eso es muy sencillo, nosotros lo daremos un mejor uso con nuestro anterior codigo asi:

scene: Scene {
var miFigura:Rectangle = Rectangle {
…
var angulo = 0
transforms: Rotate {
angle: bind angulo
pivotX: 10
pivotY: 10
}
onMouseEntered: function( e: MouseEvent ):Void {
angulo = 10
}
onMouseExited: function( e: MouseEvent ):Void {
angulo = 0
}
}

content: [
miFigura
]
}

Como podran observar en rojo lo que hacemos es solo cambiar el valor del angulo segun si el puntero del mouse esta dentro o fuera de la figura. Pueden ver el ejemplo en accion en el video del final.

Traslate

Lo que hace esta transformacion es super sencillo, simplemente traslada nuestro objeto a otra posicion, como parametros requiere una posicion X y una posicion Y. Su uso basico es como sigue:

transforms: Translate {
x: 50 //posicion X
y: 40 //posicion Y
}

Por supuesto nosotros haremos algo mas lindo agregando esto a nuestro primer ejemplo. El codigo queda como sigue:

var miFigura:Rectangle = Rectangle {
…
var PosX = 20
var PosY=10
transforms: Translate {
x: bind PosX
y: bind PosY
}
onMouseEntered: function( e: MouseEvent ):Void {
PosX = 20; PosY=50
}
onMouseExited: function( e: MouseEvent ):Void {
PosX = 20; PosY=10
}
}

Nada que explicar, esta muy sencillo.

Scale

Hace falta decir que hace este? Bueno lo digo, esta tranformacion lo que hace es cambiar la escala de un objeto. Su uso basico es:

transforms: Scale {
x : 2 //escala en ancho
y : 3 //escala en largo
}

El numero que se le asigna a cada atributo representa porcentaje. Colocar 2 en “x” significa que se duplicara el ancho del objeto, 3 en “y” significa que se triplicara el lardo del objeto.

En nuestro ejemplo:

var miFigura:Rectangle = Rectangle {
…
var tamX=1
var tamY=1
transforms: Scale {
x : bind tamX
y : bind tamY
}
onMouseEntered: function( e: MouseEvent ):Void {
tamX = 1; tamY=2
}
onMouseExited: function( e: MouseEvent ):Void {
tamX = 1; tamY=1
}
}

Cambiamos solo el valor de la escala en Y para que aumente o disminuya el largo del objeto. El video al final.

Bind

Como veran en los ejemplos hice uso de la palabra clave “bind”, esta es muy importante para en el desarrollo de GUIs con JavaFX. Basicamente lo que hace es enlazar u obligar a las variables a tomar valores que cambian a lo largo de la aplicacion. No voy a dar muchas vueltas con esto porque creo que con los ejemplos dados esta mas que claro su usp.

El video

Espero que les sea util esta cuarta parte del tutorial, como les dije al principio el tutorial continuara pero despues que rinda los examenes en la facu

Saludos

A la hora de hacer interfaces graficas JavaFX y NetBeans nos brindas varias facilidades, y entre ellas estan las formas basicas predefinidas que pueden ser agregadas al codigo con simplemente arrastrar y soltar.

Formas Basicas de JavaFX

Pero tambien nos permite crear nuestras propias formas y darle efectos. Eso es lo que tratare de explicar en esta parte del tutorial.

Crear nuestras propias formas es sencillo con JavaFX. Basicamente tenemos 2 maneras de hacer una nueva figura o forma:

• Combinar formas basicas existentes
• Crear formas totalmente nuevas desde 0

Lo primero es sencillo, lo segundo no lo es tanto pero no lo vamos a ver porque al menos por ahora no lo vamos a necesitar, eso lo veremos mucho mas adelante cuando hagamos nuestro primer juego con JavaFX. Asi que ahora vamos a ver como crear una nueva forma combinando otras existentes.

Supongamos que nuestro programa tiene un cuadrado y un rectangulo, simplemente colocados sin hacerles ningun cambio, quedarian asi:

El codigo para eso seria el siguiente:

Stage {
title: “Graficos”
width: 200
height: 200
scene: Scene {
content: [
Rectangle {
x: 10, y: 10
width: 140, height: 90
fill: Color.BLUE
}
Circle {
centerX: 100, centerY: 100
radius: 40
fill: Color.RED
}
]
}
}

Ahora vamos a ver como combinarlos para crear formas nuevas usando ShapeIntersect y ShapeSubtract.

ShapeIntersect

Esto nos permitira dibujar en pantalla todo aquello que forme parte parte de ambas formas basicas, es decir que dibujara su interseccion.

Nos quedaria algo asi:

El codigo:

scene: Scene {
content: [
ShapeIntersect {
fill: Color.LIGHTGREEN
stroke: Color.GREEN //esto es el color del borde
strokeWidth: 3 //esto determina el ancho de la linea
a:Rectangle {
x: 10, y: 10
width: 140, height: 90
fill: Color.BLACK
}
b:Circle {
centerX: 100, centerY: 100
radius: 40
fill: Color.BLACK
}
}
]
}

Veran que he agregado algunos detalles como un borde para que vayamos viendo de a poco todas las opciones que tenemos en JavaFX.

ShapeSubtract

Esto nos permitira hacer lo contrario, en vez de dibujar la insterseccion de ambos objetos nos dibujara aquellas partes de la primer forma y que no pertenezcan a la segunda. Con lo que nos quedaria algo asi:

Se entiende verdad? Bueno el codigo es el mismo que el anterior nada mas que en vez de usar ShapeIntersect se usa ShapeSubtract

Imagenes

Tambien podemos de manera super sencilla tener un control que muestre una imagen. Pueden usarlo para mostrar imagenes que esten en su disco duro asi:

ImageView {
image: Image {
url: “file:///home/usuario/fotos/rayo.jpg”
}
}

O pueden usarlo para mostrar fotos que esten en internet asi:

ImageView {
image: Image {
url: “http://paginaweb.com.xx/avatar.gif”
}
}

Ahora empecemos a ver algo que seguramente usaran mucho, los efectos.

Sombra (DropShadow)

Lo que hace es obvio y lo veremos mejor con un ejemplo:

Rectangle {
x: 10, y: 10
width: 140, height: 90
fill: Color.BLACK
effect: DropShadow {
offsetX: 10 //pixeles en la direccion X
offsetY: 20 //pixeles en la direccion Y
color: Color.RED //Color de sombra
radius: 30.0 //Radio del difuminado
}
}

Sombra JavaFX

Otros efectos

Supongamos que tenemos la siguiente figura:

Imagen Original

Estos son algunos efectos que podremos usar con esa imagen:

effect: SepiaTone { level: 0.5 }

Sepia

effect: Glow { level: 0.7 }

Glow

effect: GaussianBlur {
input: SepiaTone {
level: 0.5 }
radius: 10.0
}

Blur

effect: Reflection {
fraction: 0.7 }

Reflection

Como veran todo se vuelve facil en JavaFX, estas cosas no tengo ni idea como hacerlas con otro lenguaje sin usar librerias especializadas. Vimos desde como crear nuestras propias formas hasta como darle efectos, pero como se podran dar cuenta hasta ahora nuestros programas no hacen nada, solo dibujar en pantalla, en la proxima parte de este tutorial veremos como hacer que nuestros programas empiecen a hacer algo y que permitan la interaccion con el usuario Saludos

Bueno como estoy aburrido y no tengo nada mejor que hacer vamos a continuar con el tutorial de JavaFX. Bueno entonces lo primero sera ver que es lo que podemos crear con JavaFX en termino de interfaces graficas. Esto es solo de manera informativa para que se den una idea de los componentes que existen asi que vean esta pagina (muy recomendable). No es muy dificil de entender, solo vean los dibujos de esa pagina y podemos seguir.

Antes de empezar han de recordar esto: “El orden en que declaran los elementos en el codigo coincide con el orden en que apareceran en la aplicacion”

Paso a Paso para crear una Interfaz Sencilla

Lo que haremos sera crear algo sencillo, como lo siguiente:

GUI basica con JavaFX

Pasos:

1. Crear la ventana
2. Incluir un escenario
3. Insertar un rectangulo
4. Insertar un circulo

Existe un paso previo que seria colocar los “imports” necesarios, pero si estan usando NetBeans para desarrollar eso no tiene mucha importancia ya que lo hace solo.

Crear la ventana

La ventana sera obviamente un objeto literal(si no saben lo que es revisen la parte 1 del tutorial) llamado Stage. Esta ventana o Stage en general es inicializado con ciertos parametros, como el titulo de la ventana y el tamaño. Hacemos asi:

Stage {
title: “Graficos”
width: 200
height: 200

}

Con eso hemos creado una ventana con el titulo “Graficos” y de tamaño igual a 200×200 pixeles.

Incluir un Escenario

Dentro de un Stage se debe incluir un Scene que nos servira para contener los objetos nodos como el circulo y el rectangulo. Este Escenario o Scene es una area maestra donde seran colocados otro objetos graficos. Todos los objetos que contendra estaran dentro de la variable content. Entenderan mejor con un ejemplo:

Stage {
…
scene: Scene {
content: [ //aqui estaran los otro objetos graficos]
}
}

Insertar un rectangulo

Se puede incluir un rectangulo de manera super sencilla arrastrandolo desde la barra Palette->Basic Shapes que esta a la derecha. Esto es un objeto con algunos parametros que nosotros modificaremos a gusto. En mi caso quedo asi:

Stage {
…
scene: Scene {
content: [
Rectangle {
x: 10, y: 10
width: 120, height: 120
fill: Color.GREEN
}
]
}
}

Un rectangulo cuya esquina superior  izquierda esta a 10 pixeles del borde superior y del borde izquierdo de la ventana (Stage), que tiene un tamaño de 120×120 pixeles y que esta relleno con color verde. Sencillo verdad?

Insertar un circulo

Se puede hacer arrastrando desde la paleta de Formas Basicas (Basics Shapes) igual que el rectangulo o escribiendo:

Stage {
…
scene: Scene {
content: [
Rectangle {
x: 10, y: 10
width: 120, height: 120
fill: Color.GREEN
}
Circle {
centerX: 100, centerY: 100
radius: 60
fill: Color.LIGHTBLUE
}
]
}
}

Como veran en el caso del circulo lo que se indica es el punto medio y el radio, y con fill establecemos el color de relleno.

Con eso ya tiene su primer aplicacion grafica creada, obviamente que no hace nada Ahora solo hagan click en Run en NetBeans y proban ver lo que han creado. Aqui les dejo un video que dura menos de 2 minutos que va desde el comienzo(crear el proyecto) hasta el final(ejecutarlo) y veran como hacer este ejemplo en NetBeans.

Creo que seria mejor si lo bajan, click aqui para bajar.

Bueno por ahora eso es todo, en la proxima parte de este tutorial seguiremos aprendiendo mas sobre las interfaces graficas.

Log4j es una API open source desarrollada por Apache Software Foundation, para manejar el registro de logs en aplicaciones Java. Provee un framework robusto, extendible, configurable y sencillo para loguear aplicaciones Java, puede ser utilizado tanto en entornos de producción para monitoreo, o en entornos de desarrollo para debug. Básicamente le permite a los desarrolladores insertar sentencias de log en el código y configurarlas externamente. En este artículo vamos a ver como funciona esta API, sus ventajas/desventajas, y como configurarla e implementarla en nuestras aplicaciones Java.

Que es Log4j

La importancia de los logs

Las tareas de logging juegan un papel muy importante tanto en el desarrollo como en la ejecución de una aplicación.

• En entornos de desarrollo, no siempre se tiene disponible un debuguer (como ocurre en el caso de las aplicaciones distribuidas) por lo que debuguear generando trazas de ejecución mediante la inserción de sentencias de log en el código, es un método de bajo nivel muy utilizado por los desarrolladores.
• En cuanto a los entornos de producción, es donde más se utilizan los logs, ya que son una herramienta fundamental para la auditoría. Pueden ser almacenados en un medio de persistencia, como ser ficheros de log, transferirse a otros servidores, enviarse por mail, etcétera. Y de esta manera ser analizarlos más tarde, incluso con herramientas específicas que los usen como fuente de información, permitiéndole a por ejemplo un administrador monitorear la aplicación fácilmente.

El problema

El proceso de logging tiene también sus inconvenientes.

• Puede afectar el rendimiento de la aplicación.
• Si es demasiado verbose puede causar scrolling blindness, es decir que el desarrollador se le dificulte la tarea de encontrar cierta información relevante en interminables ficheros de logs que muestran cada ínfimo cambio de bit que ocurre.
• Si no están bien implementados pueden ser un dolor de cabeza para el programador (ejemplo: los System.out.println() hardcodeados por toda la aplicación).

La solución

Log4j es una API de logging open source basada en Java, desarrollada por Apache Software Foundation, que nos provee todo lo necesario para el registro de logs de nuestras aplicaciones. Inicialmente fue creado para entornos Java, pero luego se implementó para otros lenguajes como C/C++, Perl, Python, Ruby, entre otros.

Las características fundamentales de Log4j:

• Optimizar el proceso de logging.
• Permite configurar el proceso de logging en tiempo de ejecución mediante ficheros de propiedades o XML externos.
• Permite cambiar el formato de los logs fácilmente mediante layouts.
• Ofrece diferentes tipos de salida, como consola, ficheros, servidores remotos por TCP, por mail, JMS, o hasta el envío al Unix Syslog.
• Diferentes niveles de detalle de los logs.
• Se agrupan logs por categorías que se pueden configurar independientemente.
• Es thread-safe.
• Soporta internacionalización.

Obtener Log4j

Podemos obtener la última versión, el código fuente y la documentación, de Log4j, del sitio oficial del proyecto http://logging.apache.org/log4j/. En cuanto a la instalación, simplemente incluímos el JAR en el classpath de nuestra aplicación como siempre, nada raro.

Fundamentos de Log4j

Categorías

Tenemos la clase Logger, que vendría a ser la clase principal de la API. Esta clase tiene un método getLogger() que nos devuelve un objeto Logger. A este método le tenemos que pasar como parámetro un string con el nombre de una categoría (ya que como vamos a ver en un momento, Log4j nos permite clasificar los logs por categorías). Habitualmente esta categoría se trata del nombre del paquete/clase en que estamos.

Logger logger = Logger.getLogger("com.foo.Bar");

Las categorías funcionan igual que los paquetes en Java. Es decir, “com.foo”, tendría una categoría “com”, y una subcategoría dentro llamada “foo”. Además, hay una categoría root, que siempre está, y se obtiene así:

Logger logger = Logger.getRootLogger();

Fichero de configuración

Le especificamos al objeto Logger que fichero de configuración usar mediante su método configure() pasándole como parámetro un string con la ruta del XML o el fichero de propiedades. En un rato vamos a ver para que sirve este fichero de configuración.

logger.configure("log4j.properties");

Niveles de detalle

Bueno, este objeto Logger, que representa una categoría, es el que vamos a utilizar para registrar los logs. Mediante sus métodos warn(), info(), error(), etcétera (según el nivel de detalle).

logger.warn("This is a warning");
logger.error("This is an error");
logger.debug("I'm so creative...");

Tipos de salida / formato

En teoría, eso es todo lo que tenemos hacer programáticamente para registrar los logs. El resto lo podemos configurar declarativamente mediante ficheros externos sin tocar nada del código. Estos ficheros externos pueden ser documentos XML o bien ficheros en formato de Java Properties (propiedad=valor) que vamos a utilizar en este ejemplo.

Así que ahora vamos a configurar los logs mediante un fichero de propiedades. Básicamente lo que hacemos es a cada categoría configurarle: un nivel de detalle (si queremos que sólo se muestren los warnings, o errores, etc.), un tipo de salida (si queremos mandarlo a un fichero, a otro servidor, etc.), y un formato (como queremos que se muestre el log).

Para las dos últimas cosas (tipo de salida y formato) se definen mediante en lo que Log4j denomina appenders. En un fichero de propiedades sería así:

log4j.appender.myAppender=org.apache.log4j.RollingFileAppender
log4j.appender.myAppender.File=file.log
log4j.appender.myAppender.layout=org.apache.log4j.PatternLayout
log4j.appender.myAppender.layout.ConversionPattern=%-5p [%t]: %m%n

Como pueden ver, definimos un appender llamado myAppender, le definimos el tipo de salida (un fichero de log) y el formato mediante un layout.

El formato como pueden ver, utiliza la clase PatternLayout, y le tenemos que asignar un conversion pattern (similar al de printf() en C). Pueden consultar la documentación de la clase para saber como crearlo.

Ahora, a la categoría le asignamos el nivel de detalle, y el appender, en este caso myAppender:

log4j.logger.com.foo.Bar=WARN, myAppender

Una categoría puede tener más de un appender. Es decir, una categoría puede tener diferentes tipos de salida con diferentes formatos.

Todo esto, también se puede configurar programáticamente, pero la gracia de Log4j está en hacerlo en tiempo de ejecución, ya que nos permite más flexibilidad. Por ejemplo, si queremos desactivar los logs, o simplemente mostrar los warnings, o en vez de almacenarlos en un fichero mandarlos al Syslog o a otro servidor, o cambiar el formato en que son almacenados, etcétera, podemos hacerlo sin tener que modificar el código.

Bueno, esta sería la salida del log:

   WARN  [main]: I'm a warning
   ERROR [main]: I'm an error
   DEBUG [main]: I'm so creative

Buenas prácticas con Log4j

• Logs “greppeables”: es decir, que se puedan analizar mediante grep. Para esto cada registro de log debe consistir en una sóla línea, nunca en más de una línea (excepto por los stack traces). Y no debe faltar información, todas las preguntas que uno pueda llegar a querer responder mediante los logs deben poder ser respondidas mediante un simple grep.
• Categorización de logs: es recomendable crear diferentes categorías para los logs. Por ejemplo, un log de mensajes, otro de stack traces, etc. Una misma línea puede quedar en más de un log, pero está bien, ya que depende de como quiera ser consultada. De esta manera si queremos por ejemplo debuguear una excepción, podemos usar el log de stack traces, o si en cambio queremos ver las HTTP requests de una aplicación web podemos usar el log correspondiente.
• Loguear excepciones: cuando se lanza una excepción, no importa si no le notificamos nada al usuario y seguimos normalmente con la ejecución o bien hacemos caer el sistema, siempre deberíamos loguear las excepciones.

  
  try {
     // risky code
  } catch (Exception e) {
    stacktraceLog.error(e);
  }
  

• Cuidar performance: dado que podemos configurar diferentes niveles de detalle en tiempo de ejecución. A veces hay código que se termina ejecutando en vano. Por ejemplo, si seteamos para una cierta categoría el nivel de detalle de errores, ¿para qué deberían ejecutarse las sentencias que loguean warnings? para nada… así que no viene de más hacer verificaciones del nivel de detalle en que nos encontramos.

if (log.isDebugEnabled()) {
  log.debug("Debugging...");
}

log4j.appender.myAppender=org.apache.log4j.DailyRollingFileAppender
log4j.appender.myAppender.DatePattern=.yyyy-MM-dd.HH

Estuve buscando horas por google por un buen tutorial o manual de JavaFX pero no encontre ni uno solo, pero en serio no encontre ni uno!

Asi que me decidi a hacer yo uno. Ya les he contado de que se trata JavaFX y como instalar JavaFX asi que ahora vamos a empezar a aprender a usar el lenguaje.

En esta primera parte del tutorial vamos a ver:

• Objetos Literales
• Tipos de datos

Esto es un poco de teoria que a muchos nos aburre pero a veces es necesario verla. Quiero aclarar que todo esto lo hago basandome en el curso de javapassion que por supuesto esta en ingles y no a todo el mundo le gusta leer las cosas en ingles. (es mi caso :P) Tambien he de aclarar que el curso de javapassion esta mucho mas completo pero yo omitire aquellas cosas que considere poco importantes. Por ejemplo los operadores, son los mismos en todos los lenguajes y a nadie le gusta tener que releer eso todas las veces.

Entenderan que yo recien estoy aprendiendo y espero que si alguien ve errores a lo lardo del tutorial me lo diga.

Antes de empezar con el tutorial quiero aclarar que JavaFX corre sobre la maquina virtual de Java y ademas en JavaFX pueden usar las mismas clases y funciones que usaban en Java para programar, por ejemplo en JavaFX puede usar JDBC para conectarse a las bases de datos, etc etc. Esto lo digo porque siempre hay algunos apresurados que no van a seguir el tutorial sino que quieren avanzar mas rapido

Bueno, con eso dicho empecemos.

Objetos Literales

Todos sabemos conceptualmente que es un objeto verdad? Un objeto nos sirve para modelar cualquier cosa, desde compenentes de la GUI (Graphic User Interface) hasta abstracciones no visuales como datos de temperatura, registros financieros, etc.

En JavaFX un objeto puede ser creado con un Objeto Literal. Lo que significa una sintaxis declarativa consisa parecida a javascript.

Ejemplo:

// Creando un Rectangle (rectangulo)
Rectangle {
x: 10 y: 10
width: 100
height: 100
}

Como veran la primer palabra “Rectangle” especifica el tipo de objeto, o sea la clase, que estas creando. Las variables en su interior no son asignaciones, son inicializaciones de los atributos del objeto.

Algo que me gusta de JavaFX es la manera en que se pueden colocar los atributos de un objeto. En el ejemplo anterior veran que no hay comas(”,”), ni puntos y comas(”;”) sino que estan separadas por un espacio(” “),pero, si se pueden usar. Por ejemplo podria ser asi:

// Creando un Rectangle (rectangulo)
Rectangle {
x: 10, y: 10,
width: 100,
height: 100,
}

O con putos y comas.

Objetos Anidados

Otra cosa que se puede hacer y en general lo van a hacer mucho en javaFX es anidar objetos. Esto es usar un objeto dentro de otro, normalmente como asignacion a uno de los atributos del objeto padre. Por ejemplo:

Rectangle {
x: 10
y: 10
width: 100 height: 100
fill: Color {
red: 1
green: 0
blue: 0
}
}

Como pueden ver, lo que hicimos fue usar el objeto Color dentro del objeto Rectangle para establecer el valor del atributo fill.

Asignando Objetos Literales a una variable

Otra cosa muy util que deberemos saber es a utilizar variables para asignar a ellas Objetos Literales. Esto es super sencillo y lo entenderan con el siguiente ejemplo.

var miColor:Color=Color{
red: 1
green: 0
blue: 0
}

Rectangle {
x: 10, y: 10
width: 140, height: 90
fill: miColor
}

En el ejemplo lo que hacemos es asignar un objeto de tipo “Color” a la variable “miColor” y luego cuando creamos un Rectangle solo usamos la variable “miColor”. He marcado con colores algunas partes para que entiendan mejor, pero luego esto lo explicare mejor. Lo que esta en rojo es el nombre de la variable, lo que esta en azul es el tipo y lo que esta en gris es el tipo de objeto o clase.

Tipo de datos

Esto es otra de las cosas que me gusto de JavaFX, en vez de tener muchos tipos de datos que al final nunca utilizamos, aqui tenemos solo 5.

• Boolean
• Integer
• Number
• String
• Duration

Strings

Un tipo string puede ser declarado usando comillas simples o comillas dobles indistintamente ya que no hay diferencias entre estas.

var s1 = ‘Hello’
var s2 = “Hello”

Puedes embeber variables dentro de un string usando llaves “{}”. Por ejemplo:

var nombre=”Perro”

var s=”Hola {nombre}”

Esto producira que la variable “s” sea igual a “Hola Perro”

Integer y Number

Estos son sencillos. Integer representa numeros enteros y Number representa numeros con punto flotante. En este caso se recomienda usar el tipo Number solo cuando es absolutamente necesario.

Boolean

Este tipo de datos representa 1 de 2 valores, o True o False. Ejemplo:

var cansado= True

Duration

El tipo de dato Duration representa una unidad fija de tiempo, por ejemplo.

5ms //representa 5 milisengundos

10s //representa 10 segundos

20m //representa 20 minutos

2h //representa 2 horas

Este tipo de datos lo usaremos cuando veamos animaciones.

Por hoy terminamos, en el proximo post de este tutorial haremos unos cuantos ejemplos para ejecutar en netbeans. Que les parece? Tambien estaba pensando que podiamos hacer mini test, para ver quien los resuelve mas rapido

Yo ya les habia hablado de esta aplicacion en otro post. Pero ahora gracias a ubunlog me entero de una actualizacion.
juancarlospaco ha liberado una versión de su programa RadioGUI, para escuchar las radios de Argentina on-line en Ubuntu, las novedades de esta versión son:

* Bug del Uso de procesador arreglado.(Upgrade muy Recomendado!)
* Soporte para Skins.
* Todas las radios solicitadas agregadas.
* Si se sale de escuchar una Radio, se vuelve al Menu de Emisoras, por si se quiere escuchar otra, sino Cancelar se cierra.
* Zenity como paquete requerido.
* Libnotify como paquete sugerido (necesario para la integracion con las notificaciones de Ubuntu)

Descarga RadioGUI 1.6.deb
Más información en este thread de Ubuntu-Ar

Hola gente, queria contarles de algunos cambios que acabo de realizar en el blog. Lo primero que seguramente NO notaran es que faltan 2 paginas, la de publicidad del blog y la de stickers, no las visitaba nadie asi que decidi eliminarlas. De todas maneras habia lindos stickers para los usuarios linux y si los quieren los pueden bajar desde aqui.

Ademas de eso notaran como he cambiado el gadget de google friend connect un poco mas arriba, creo que ahi queda mejor :P. Ya les hable de friendconnect hace mucho, pueden revisar esa entrada aqui y esta otra si quieren implementarlo en wordpress.

Veran que tambien agregado otro gadget de friendconnect mas abajo, este sirve para que cualquiera haga preguntas y cualquiera pueda responder. Yo lo veo como un mini foro

A la vez he puesto todos los directorios en los que estoy anotado en la segunda pestaña para que no molesten tanto ya que casi no tenian ninguna utilidad.

Espero que les gusten estos pequeños cambios Saludos

Bueno, tengo un par de horas de descanso asi que voy a explicar como instalar JavaFX en Ubuntu/Linux. para aquellos que no leyeron que es javaFX les recomiendo que lo hagan. Basicamente existen 2 formas, la rapida y la no tan rapida.
Primero vemos la rapida.

Instalar NetBenas con el complemento incluido.

Es realmente sencillo, primero vamos a esta pagina, alli seleccionamos NetBeans IDE 6.5.1 for JavaFX 1.2 y luego le damos al boton Download. Al terminar de bajarse abrimos una consola, nos vamos a la carpeta donde se bajo y escribimos

sudo ./netbeans-6_5_1-javafx_sdk-1_2-linux-i586.sh

Obviamente el nombre puede variar con el tiempo a medida que salgan nuevas versiones.

Agregar el plugin de javaFX a NetBeans

1-Seguramente muchos ya tienen netbeans instalado y personalizado y no quieren desinstalarlo solo para instalar JavaFX, obviamente existe una solucion. Esta solucion no es para Linux sino que funciona para cualquier SO.

2-Asegurarse que tienen lo necesario para instalar javaFX, eso lo pueden ver en esta pagina.

3-Inicien su NetBeans

4-En el menu principal elijan Tools->Plugins

5-En la ventana que les aparecera seleccionen la pestaña Settings y activen todos los centros de Updates que tengan disponibles. Elijimos todos porque los otros centros pueden tener algunas de las dependencias que necesitamos.

Click para agrandar

6-Ahora seleccionamos la pestaña de Available Plugins y hacemos click en el boton Reload Catalog para que actualize la lista.

7-Ahora en el campo de busqueda que dice Search escriban “javafx”

8- Marquen para instalar todos los plugins que digan JavaFX que encuentren, en general solo aparecen 3 y despues hagan click en el boton Install

9-Les apareceran unas cuantas ventanas mas en las que solo deberan poner Continue o Next.

10-Despues de que se terminan de bajar e instalar los plugins les pedira reiniciar el NetBeans IDE y listo. Ya tendran instalado JavaFX.

En el proximo post sobre este tema les mostrare como hacer su primer aplicacion. Espero que todos los que no saben programar en ningun lenguaje se animen y empicen con algo. Saludos.

Les vengo hablando de cambios que se esperan para Ubuntu 9.10 Karmic Koala hace tiempo pero aqui les dejo un resumen.

1. PulseAudio sin fallos: el polémico sistema de gestión de sonido de Ubuntu y otras muchas distros podría aparecer por fin en una versión completamente libre de fallos y que no de conflictos con ciertas tarjetas y configuraciones hardware. Todos se quejan de este pero la verdad para mi fue la solucion a todos mis problemas de audio, creo que es genial.
2. Firefox 3.5: el nuevo navegador de Mozilla está al caer, y Ubuntu 9.10 lo integrará por defecto.
3. Mejores tiempos de arranque: Ya les habia hablado de esto. Es uno de los esfuerzos más importantes que se están realizando en el desarrollo de la próxima versión de Ubuntu, esperemos que logren el objetivo de un arranque en 10 segundos.
4. Ext4 por defecto: Esta es otra de las mejoras que muchos ya estamos disfrutando. Hasta la fecha era una opción de la instalación se convertirá en la elección de serie en Ubuntu 9.10.
5. GRUB 2: el nuevo gestor de arranque permitirá entre otras cosas dar soporte completo a particiones de arranque ext4, pero además ofrece mayores opciones visuales y de configuración y control de un sistema con varios SSOO instalados.
6. Nuevo kernel: como mínimo tendremos el 2.6.31 que entre otras cosas mejorará el soporte KMS. Un mejor kernel implica muchas mejoras.
7. PackageKit: el soporte de este sistema de gestión de paquetes permitirá más facilidades frente al actual Update Manager + PolicyKit, como ya se ha visto en otras distros.
8. Empathy: Probablemente el más controvertido de los cambios de Ubuntu al sustituir al venerado Pidgin. Este cliente de mensajería instantánea y de videoconferencia tiene un gran futuro por delante, pero tendrá que demostrarlo en Ubuntu 9.10.
9. Banshee podría reemplazar a Rythmbox: Esta decisión fue originalmente impulsada por los propios desarrolladores basada en el deseo de abandonar el el proyecto.

En lo que a mi respecta queria usar empathy hace mucho, solo necesitaba una escusa y ahora la tengo. Tambien probare Banshee ya que he escuchado muy buenos comentarios de este.

Si, asi como leen, acabo de entrar y veo carteles raros en mi blog de los cuales la unica conclusion que puedo sacar es que el blog ha sido hackeado. Solo miren las imagenes y se daran cuenta.

En el panel de administracion

En el primer post

En el titulo del blog

Como veran solo cambiaron pocas cosas, al menos de las visibles a simple vista, pero tendre que ponerme a investigar mas y ver como paso. En google no sale ninguna info, aunque si salen muchos mas sitios hackeados. Espero que no vuelva a pasar

Tal vez algunos recuerden que ya les habia contado sobre pwsafe, que es un programa en consola para guardar y administrar nuestras contraseñas. Y queria mostrarles programas que hagan lo mismo pero que tengan GUI, o sea interface grafica. Me fui a synaptic, en el buscador puse la palabra password y me salieron un monton de programas para el proposito, asi que solo les voy a dar una breve descripcion de algunos, ya que todos son faciles de usar y hacen casi lo mismo.

KeepassX

KeepassX

Keepassx es multiplataforma y su funcionamiento es tanto util como sencillo. En su pantalla nos permite a la izquierda administrar los grupos, por ejemplo: web, mails, etc y a la derecha muestra las entradas, que pueden ser varias por grupo. Al igual que la mayoria copia las contraseñas en el clipboard del sistema y por lo tanto es seguro usarlo frente a otra persona ya que la password no se muestra sino que se copia en el portapapeles. Tambien permite hacer abrir directamente la pagina web y “tratara” de hacer el login automatico.

Todo se administra con una contraseña maestra que no deben olvidar y la base de datos se guarda encriptada donde ustedes deseen, util para llevar a donde se desee.

Instalacion

sudo apt-get install keepassx

Revelation

Revelation

Revelation es ese programa que cuando lo usas durante un tiempo te preguntas, como no lo había encontrado antes?, en lo que respecta al uso es bastante intuitivo y simple, no requiere conocimientos metafísicos, sólo basta ser ordenados al momento de ordenar nuestras contraseñas e incluir una buena descripción de ellas, para poder llegar a ellas y si no encontramos la password que estamos buscando el programa trae incorporado un buscador, además permite ordenar la información bajo carpetas que puedes ir creando según el tema de las contraseñas ( yo tengo una carpeta llamada Cactus Digital). Trae la posibilidad de importar y exportar base de datos cifradas en varios formatos tales como: Figaro Password Manager, GPass, MyPasswordSafe, netrc, Password Gorilla, Password Safe, Plaint Text, XHTML / CSS, XML.

Instalacion

sudo apt-get install revelation

Figaro’s Password Manager

Figaro's Password Manager

Este otro es uno que yo recomendaria, hace lo mismo que todos los otros, super basico, en vez de organizar todo en carpetas lo hace en categorias, que es lo mismo Tambien se maneja con una contraseña global o principal. No se donde guarda la password porque no pide una ubiacion especifica como los 2 anteriores pero si permite exportar e importar passwords. Lo que mas rescato de este el su ligereza, me refiero a la consumision de recursos obviamente.

Instalacion

sudo apt-get fpm2

Otros

Probe otros tambien (gpass, password-gorilla) pero su funcionamiento era similar y hacen lo mismo con algun detalle mas o menos asi que no voy a alargar el post con esos. Pero como les dije al principio todo dependera de ustedes porque hay mucho de donde elegir.

No me gusta esto de estar escribiendo a las apresuradas ni tampoco esto de estar escribiendo noticias como esta que son super cortitas rozando lo que es el micro blogging, pero es necesaria ya que tengo que aclarar unas cosas.

1- El post anterior por si no se dieron cuenta en un post pagado, estoy probando que tal van las ganancias con los post patrocinados y ademas estoy intentando validar mi cuenta de paypal. Obviamente que si lo logro compartire el proceso con todos ustedes

2- Mi blog de humorperruno fue banneado o algo asi por google hace ya varios meses y me canse de actualizarlo y no recibir visitas… mi solucion? hacer otro, que no este baneado por google y comenzar de 0
Ahora es este zapatomojado.com.ar

Espero que me disculpen por haber mermado el ritmo de las publicaciones pero no sera por mucho mas tiempo, solo me quedan unos pocos examenes y “si me va bien” voy a tener la suficiente tranquilidad para seguir posteando como siempre….seguro que muchos estudiantes universitarios saben como se debe sentir en estas fechas

La mayoría de los lectores de mi blog son españoles así que hoy les traigo una buena noticia.
Te gusta viajar? Eres de madrid? Viajas seguido a Palma de Mallorca?
Madrid y Palma de Mallorca están separados por 549 kilómetros y el estimando de tiempo aproximado de vuelo es de 00:47 horas. Y eso como? Fácil, la empresa que se los brinda es Destinia, esta les ofrece precios súper económicos a la hora de hacer viajes. Ese es el caso de los vuelos Madrid - Palma de Mallorca
En su pagina pueden encontrar un buscador que les permitira seleccionar si van de ida, vuelta o ida-vuelta, podran elegir la fecha de viaje asi como tambien la hora. La cantidad de adultos que viajaran, niños y/o bebes.

En realidad destinia no ofrece los viajes sino que mas bien buscara las mejores ofertas por ustedes, asi no tienen que estar abriendo las paginas de cada empresa por separado o estar llamando a cada una por aparte.

Ademas de todo eso en la pagina se muestra el estado del tiempo en cada destino asi no tendran que ir a buscar el estado del tiempo en otro lugar. Y tambien veran un mapa de google maps para guiarse donde estan y a donde van.

Entre las cosas que encontraran entre otras cosas, traduccion a otros idiomas e incluso un feed para recibir por email las mejores ofertas.

Haaa…ahora seguramente todos mis lectores habituales se estaran pregutando porque escribi un post tan fuera de lugar a lo que escribo siempre? Pues simple….se los dire proximamente, es todo parte de un plan estrategico. Fuera de eso es algo util para aquellos que viajen seguido. No habra alguien por ahi que me pague un viajecito a España?

Se anunció así en sus foros el lanzamiento de la primera versión preliminar Beta del próximo VirtualBox 3.0, la siguiente gran actualización del software de virtualización de Sun Oracle que traerá importantes novedades como por ejemplo:

• Huéspedes con SMP de hasta 32 CPUs virtuales (sólo con Intel VT-x o AMD-V).
• Soporte de Direct3D 8/9 en huéspedes Windows (experimental).
• Soporte de OpenGL 2.0 para huéspedes Windows, Linux y Solaris.

Obviamente, esta versión no es recomendada todavía no está lista para reemplazar a ninguna instalación en ambientes de producción, sino solo para fines de evaluación y reporte de errores iniciales.

Porque puse esta noticia? Facil, si leen bien dice que se esta experimentando con el soporte Direct3D en huespedes mocosoft. Eso significa que se eliminara la unica razon que tienen los windowseros para no pasarse a Linux. Estuve buscando algunos videos en youtube para mostrarles pero los que encontre no estaban muy buenos.

via vivalinux

Check out what happened when AJAX bug tags editing landed in April:

Note that since Launchpad has the edge/production split, so the changes in the graphs are less drastic since a set of users start interacting with new code before others.

Y otro video mas de blogubuntu. En la web del Laboratorio de Informática Interactiva del ENAC, en Toulouse, han publicado un vídeo que demuestra las capacidades multi-touch soportadas en el nuevo kernel Linux 2.6.30.

Genial no? No habra alguien que me done unos cuantos miles para que me compre una pantalla touch?

Como sabran yo no uso KDE pero estos videos me parecieron sumamente interesantes, en especial el primero que es Plasma(la herramienta del entorno KDE 4,) corriendo en un SmartPhone. Estaria genial tener un movil asi aunque como veran todavia no esta maduro todo, pero avanza bien.

Este otro es de plasma en una netbook, no tengo netbook ni esta en mis planes tener, pero si tuviera seguro le pongo KDE4

via blogubuntu

Me dieron ganas de aprender javaFX, lamentablemente estoy en epoca de examenes y me falta un poco el tiempo, pero de a poco voy a ir escribiendo sobre esta tecnologia. Como siempre espero que aprendamos entre todos.

JavaFX nacio para competir con Flash de Adobe y SilverLight de Mocosoft.

JavaFX Script es un lenguaje de scripting declarativo estáticamente tipado, llamado anteriormente F3 (Form Follows Function) que fue desarrollado en su mayoría por Chris Oliver, quien trabaja para Sun microsystems desde la adquisición de SeeBeyond Technology por parte de esta a fines de 2005.

El compilador de JavaFX, así como gran parte de las bibliotecas gráficas y herramientas se encuentran liberadas con la licencia GPL2, a través del proyecto OpenJFX.

JavaFX tiene el propósito de facilitar la creación de Rich Internet Applications (RIAs) con gran cantidad de contenido multimedia, respetando siempre la idea de Java de poder luego ejecutarlas en forma independiente de la plataforma.

¿Lenguaje declarativo?, ¿Estáticamente tipado?

Para comenzar, la característica principal de JFXS es que es un lenguaje de tipo declarativo, esto significa que, en vez de explicar  “como” realizar algo (el algoritmo, en los lenguajes imperativos), deberemos describir “que” es ese algo. Por ejemplo, en HTML, se declara el contenido de la pagina, pero no se explica como este será mostrado en la pantalla.

Lo poco que probado del lenguaje me resulta bastante similar a la sintaxis que usamos en css, y puede resultar algo dificil para los que estan acostumbrados a lenguajes como python, ruby o basic ya que se contrasta bastante. Pero solo es cuestion de acostumbrarse

De las primeras cosas que me llamo la atencion sobre JavaFX es la que los programas funcionan en el navegador y esos mismos programas pueden funcionar en el escritorio, solo arrastrandolos y soltandolos fuera del navegador, incluso nos crea un enlace en el escritorio para ejecutar la aplicacion la proxima vez.

Hay miles de videos en internet sobre el funcionamiento de JavaFX, con el tiempo pondre varios, segun vaya realizando los tutoriales, pero por ahora vean estos.

En el siguiene video Danny Coward (chief arquitect de aplicaciones cliente en Sun) y Ken Russell (miembro del JavaSE deployment team) nos muestran una serie de applets funcionando en el browser, siendo quizás el más interesante el que localiza a nuestros amigos utilizando el servicio World Wind de la NASA, nuevamente vemos el drag and drop al escritorio, y adicionalmente veremos como luego de cerrar la aplicación se crea un icono en el mismo para reutilizar la aplicación en un futuro que es justamente lo que les explicaba antes

El siguiente video muestra las capacidades multimedia de JavaFX en dos aplicaciones: Photo Flocker y Movie Cloud. El primero busca imágenes por tags con una interfaz muy sencilla y el segundo muestra hasta 200 vídeos en alta definición a la par dentro de la aplicación.

Hay muchos mas, pero como ya les dije, aprenderemos entre todos y en los siguiente post seguiremos con mas ejemplos. En el proximo post les enseñare a instalar las herramientas de desarrollo en Ubuntu Jaunty 9.04 y en el siguiente a ese nuestro primer ejemplo

Los que tienen blogs hechos con wordpress seguramente se han encontrado con texto codificado en sus themes varias veces. Ese codigo lo ponen los diseñadores de los themes para que uno no los pueda cambiar, por ejemplo en los enlaces al sitio del diseñador que por lo general esta en el pie de pagina (footer.php)

Da la casualidad que los mejores themes que uno encuentra siempre tienen ese feo codigo y cuando uno quiere personalizar algo no puede. Pero por suerte existen formas de volver ese codigo a su forma original, entra esas formas esta que les comento ahora es la mas facil que encontre.

Solo deben ir a esta pagina y copiar el texto codificado y con un solo click les devolvera el texto original

Bueno fue un post cortito pero creo que es bastante util

Esta es una introducción a la ampliamente utilizada herramienta para construir aplicaciones para entornos Java: Ant. En este artículo vamos a ver como se compone un build file, algunas buenas prácticas que es muy recomendable seguir a la hora de construir uno, y algunos ejemplos de build files para determinados tipos de aplicaciones.

Que es Ant

Es similar a GNU Make

Ant es una herramienta basada en Java que sirve para construir aplicaciones, permitiéndonos automatizar tareas mecánicas y repetitivas como las de compilación, empaquetado, deploy, etc. Es muy similar la conocida herramienta GNU Make pero con la notable diferencia de que Ant es portable y no depende del sistema operativo, por lo que es ideal para entornos Java.

Es portable

La característica principal de Ant, que lo diferencia de otras herramientas como GNU Make, es que es cross-plataform.

Cualquiera que haya programado bajo plataforma Linux, probablemente haya utilizado GNU Make. Y como ya sabrán, esta herramienta se basa en órdenes de shell, obviamente dependientes del sistema operativo. Esta es una gran limitación para el entorno Java, que es multiplataforma.

A diferencia de GNU Make, Ant nos provee de una gran rama de tareas core que podemos configurar mediante build files, que vendrían a ser lo equivalente a los make files de GNU Make, pero escritos en XML.

Está ampliamente difundido

Ant es un proyecto open source mantenido por Apache Software Foundation, y actualmente está ampliamente difundido. Prácticamente todos los IDEs para entornos Java ofrecen integración con Ant, incluso algunos lo utilizan internamente.

Instalación de Ant

Podemos obtener la última versión de Ant de la página del proyecto. Están disponibles las distribuciones binarias y las distribuciones de código fuente, ambas con sus respectivas firmas digitales y documentación de instalación. Por lo que no debería presentarles ningún inconveniente la instalación.

Uso de Ant

Terminología

Ant agrupa las tareas (o tasks) en targets, todo proyecto suele tener varios targets, generalmente uno para compilar, otro para empaquetar, etc. Por ejemplo, un target para compilar, llamémoslo compile, tendría varias tareas, una que verifica las dependencias, otra que crea los directorios donde se van a guardar los binarios, otra que invoca al compilador, etc.

Es decir, en Ant, a diferencia de otras herramientas, las órdenes de shell para copiar ficheros, compilar código, ejecutar aplicaciones, etc. están “encapsuladas” en tareas/tasks. Y estas tareas están agrupadas en targets.

Todos estos targets, con sus tasks, etc. se definen en un build file, llamado build.xml, que no es más que un documento XML mediante el cual le indicamos a Ant que hacer.

Ejemplo

Este es un ejemplo de build.xml:

<project>

    <target name="clean">
        <delete dir="build"/>
    </target>

    <target name="compile">
        <mkdir dir="build/classes"/>
        <javac srcdir="src" destdir="build/classes"/>
    </target>

    <target name="jar">
        <mkdir dir="build/jar"/>
        <jar destfile="build/jar/HelloWorld.jar" basedir="build/classes">
            <manifest>
                <attribute name="Main-Class" value="oata.HelloWorld"/>
            </manifest>
        </jar>
    </target>

    <target name="run">
        <java jar="build/jar/HelloWorld.jar" fork="true"/>
    </target>

</project>

Como podrán ver, es bastante intuitivo, hay 4 targets (clean, compile, jar y run). El target clean tiene una tarea delete para eliminar el directorio build, el target compile tiene dos tareas, una que crea el directorio build/classes y otra para invocar al compilador, el target jar tiene una tarea para crear el directorio build/jar y otra para crear el fichero JAR, y finalmente el target run tiene una tarea que ejecuta la aplicación.

Para que Ant procese el build file, simplemente lo invocamos así:

ant [target]

Siendo [target] un argumento opcional, para indicarle a Ant que target ejecutar. En caso de no especificar ninguno se ejecuta el target por default (que en un momento vamos a ver como configurar).

Build files

Ahora vamos a ver como se compone un build file en un poco más de detalle, pero no demasiado (para eso existe la documentación).

Projects

Cada build file debe tener al menos un tag project. Este tag tiene 3 atributos opcionales:

• name: el nombre del proyecto.
• default: el target por default, que se va a ejecutar en caso de que no se especifique ningún target.
• basedir: el path que se va a usar como basedir para todos los paths a lo largo del build file. (Puede sobreescribirse más adelante).

Targets

Dentro de cada tag project, puede haber cero o más tags target. Los targets como ya dijimos agrupan tareas, y se definen mediante tags target. Este tag tiene un atributo requerido:

• name: el nombre del target, debe ser único ya que sirve para identificarlo y referirse a él más tarde.

Y también tiene otros atributos opcionales que suelen ser útiles:

• description: una breve descripción de lo que hace el target. (Es buena práctica colocarla).
• depends: los targets de los cuales depende el target, Ant se encarga de resolver las dependencias ejecutando esos targets antes de ejecutar el target. (Se indican los nombres separados por coma).
• if: se ejecuta sólo si está seteada una determinada propiedad (en un rato vamos a ver lo que son las propiedades, pero mientras tanto ya se lo pueden ir imaginando).
• unless: lo mismo que el anterior pero al revés (sólo si la propiedad no está seteada).

Tasks

Dentro de los targets se encuentran las tareas o tasks, estas como ya dijimos, a diferencia de otras herramientas como GNU Make, donde se crean mediante shell scripting, en Ant en cambio existe una gran cantidad de core tasks, que generalmente nos serán más que suficientes para lo que necesitamos, y como Ant está 100% basado en Java están garantizadas para hacer exactamente lo mismo sin importar el sistema operativo donde se ejecuten. Igualmente, en caso de que estas tareas core no sean suficientes, Ant nos permite crear nuestras propias tareas usando shell scripting, de hecho existen muchas tareas third party dando vueltas. Claro que estas no cuentan con la ventaja de la portabilidad.

Las tareas se definen así:

<nombre_tarea atributo1="valor1" atributo2="valor2" ... />

En la documentación oficial de Ant, podemos encontrar esta lista de core tasks, que como podrán ver es bastante completa y detallada. En este artículo sólo vamos a ver algunas, sólo las más comunes.

• javac: sirve para compilar utilizando el compilador javac. Tiene varios atributos, la mayoría mapeados con los argumentos que acepta javac:
  • srcdir: el path donde está el código fuente a compilar.
  • destdir: el path donde se van a guardar los binarios.
  • classpath: el classpath.

  
  <javac srcdir="src"
               destdir="bin"
               classpath="lib/mycommons.jar"
  />
  

• mkdir, delete, copy: sirven para crear, eliminar y copiar directorios y ficheros. No necesitan demasiada explicación, veamos algunos ejemplos:

  
  <delete dir="build/bin" />
  <mkdir dir="build/bin" />
  <copy file="myfile.xml" todir="../some/other/dir" />
  

• jar: sirve para crear ficheros JAR, tiene dos atributos:
  • jarfile: el nombre del fichero JAR a crear.
  • basedir: el path donde están los ficheros a comprimir en el JAR.

  
  <jar jarfile="build/dist/myapp.jar"
          basedir="build/bin" />
  

Bueno, hay muchas más tareas que vienen como core en Ant, esas sólo son las más utilizadas. Pero hay muchas más para trabajar con el sistema de ficheros (mover ficheros, cambiar permisos, etc.), obtener revisiones de repositorios SVN, CVS… deployar aplicaciones en contenedores J2EE, correr tests unitarios con JUnit, etc.

Properties

Es una buena práctica definir ciertas propiedades, que contengan paths y otros valores que se puedan reutilizar a lo largo del build file. Estas propiedades se definen mediante el tag propoerty, así:

<property name="dir.bin" value="dist/bin" />

Se puede acceder a estas propiedades desde cualquier lugar del build file mediante:

${nombre_propiedad}

También es útil poder acceder a variables de entorno del sistema, esto se hace así:

${env.nombre_variable}

Podemos asignarle a una propiedad el valor de una variable de entorno, así:

<property name="JAVA_HOME" value="${env.JAVA_HOME}" />

Buenas prácticas

Hay ciertas prácticas recomendables para construir build files que deberíamos siempre tener en cuenta:

• Un sólo build file: algunas personas prefieren partir el build file en varios pequeños build files, esto si está bien hecho puede ser útil, pero hay veces que termina agregando complejidad innecesaria. De cualquier manera, siempre es recomendable tener un build file en el root directory que delegue el trabajo a los demás build files.
• Colocar build file en el directorio raíz: aunque el build file puede colocarse en cualquier lugar, es recomendable colocarlo en el directorio raíz del proyecto. Es una convención bastante común, ya que los paths relativos son más fáciles de entender, y además así no hace falta cambiar el working directory para invocar a ant, pudiendo hacer esto:

  ant -find compile
  

  El argumento find le dice a Ant que busque el build file en los directorios padre.

• Proveer ayuda útil: hay tres cosas que deberían utilizarse para proveer buena ayuda:
  • Especificar atributos description para los targets.
  • Proveer un target help para los desarrolladores.
  • Escribir XML comments en el build file.
• Proveer target clean: es recomendable crear un target clean que se encargue de eliminar todos los ficheros y directorios generados. (Volviendo todo a su estado original, tal como estaba en el repositorio antes de invocar ningún target).
  

  NOTA: no es recomendable autoinvocar este target, sino que es preferible que el desarrollador lo invoque cuando lo crea conveniente.

• Manejar dependencias con Ant: una aplicación Java lo considerablemente compleja, podría consistir por ejemplo en una interfaz web, una capa EJB, una GUI y algo de utility code. A medida que el sistema crece, hay que compilar más ficheros cada vez que se cambia algo. Imagínense que no tiene mucho sentido recompilar los componentes EJB y los servlets cada vez que se cambia algo de la GUI.

  Para evitar esto, se debe hacer un manejo consistente de las dependencias y Ant simplifica bastante esta tarea. Por un lado, mediante un buen uso del atributo depends de los targets, se puede lograr que los desarrolladores no tengan que ejecutar los targets en un orden específico. Por otro lado, se debe diseñar el build file para que se compile la aplicación por partes, separando bien por ejemplo el utility code de los componentes de la GUI.

• Definir paths como propiedades: para favorecer la reutilización de paths, es una buena práctica definir propiedades que guarden todos estos paths al principio del build file.
• Mantener el build file self contained: es preferible no referirse a paths y librerías externas si se quiere mantener la portabilidad. Y en caso de ser necesario hacerlo, se deberían utilizar propiedades para que estos paths puedan configurarse fácilmente.
• Usar propiedades para la configuración: todo lo que necesite ser configurado dentro del build file, debería ser definido con propiedades. Generalmente se colocan al principio del fichero, o bien en un fichero aparte que se incluye mediante:

  
  <property file="myproject.properties"/>
  

• Mantener build file bajo control de versiones: es importante que el build file sea versionado al igual que el resto de los ficheros, ya que esto permite que si se vuelve a una revisión anterior, se pueda construir la aplicación sin problemas de dependencias, etc.

Integración de IDEs con Ant

Hoy en día casi todos los IDEs para entornos Java se integran con Ant, ofreciéndonos editores, generadores automáticos de build files con targets plantilla, entre otras cosas bastante útiles como debuggers para Ant, etc.

Una de las ventajas de esta integración, es que en un equipo de desarrollo, cada desarrollador puede utilizar su IDE preferido, ya que Ant actúa como denominador común.

Ejemplos con Ant

Veamos un ejemplo de build file para un proyecto web con Tomcat:

<project name="My Project" default="all" basedir=".">

  	<property name="app.name"        value="myapp"/>
  	<property name="app.path"           value="/${app.name}"/>
  	<property name="app.version"      value="0.1-dev"/>
  	<property name="build.home"       value="${basedir}/build"/>
  	<property name="catalina.home"  value="${env.CATALINA_HOME}"/>
  	<property name="dist.home"          value="${basedir}/dist"/>
  	<property name="docs.home"        value="${basedir}/docs"/>
  	<property name="manager.url"      value="http://localhost:8080/manager"/>
  	<property name="src.home"           value="${basedir}/src"/>
  	<property name="web.home"         value="${basedir}/web"/>

	<path id="compile.classpath">
  		<pathelement location="${catalina.home}/common/classes"/>
		<fileset dir="${catalina.home}/common/endorsed">
			<include name="*.jar"/>
		</fileset>
		<fileset dir="${catalina.home}/common/lib">
			<include name="*.jar"/>
		</fileset>
		<pathelement location="${catalina.home}/shared/classes"/>
		<fileset dir="${catalina.home}/shared/lib">
			<include name="*.jar"/>
		</fileset>
		<fileset dir="${catalina.home}/shared/lib">
			<include name="*.jar"/>
	    </fileset>
	</path>

	<target name="all"
	        depends="clean,compile"
	        description="Clean build and dist directories, then compile"/>

	<target name="clean"
	        description="Delete old build and dist directories">
		<delete dir="${build.home}"/>
		<delete dir="${dist.home}"/>
	</target>

	<target name="compile"
	        depends="prepare"
	        description="Compile Java sources">
		<mkdir    dir="${build.home}/WEB-INF/classes"/>
	    <javac srcdir="${src.home}"
	           destdir="${build.home}/WEB-INF/classes"
	           debug="${compile.debug}"
	           deprecation="${compile.deprecation}"
	           optimize="${compile.optimize}">
	    	<classpath refid="compile.classpath"/>
	    </javac>
	    <copy  todir="${build.home}/WEB-INF/classes">
	    	<fileset dir="${src.home}" excludes="**/*.java"/>
	    </copy>
	</target>

	<target name="dist"
	        depends="compile,javadoc"
	        description="Create binary distribution">
		<mkdir dir="${dist.home}/docs"/>
	    <copy todir="${dist.home}/docs">
	   		<fileset dir="${docs.home}"/>
	    </copy>
	    <jar jarfile="${dist.home}/${app.name}-${app.version}.war"
	         basedir="${build.home}"/>
	</target>

	<target name="install"
	          depends="compile"
	   		  description="Install application to servlet container">

		<install url="${manager.url}"
	             username="${manager.username}"
	             password="${manager.password}"
	             path="${app.path}"
	             war="file://${build.home}"/>
	</target>

	<target name="javadoc" depends="compile"
	        description="Create Javadoc API documentation">
		<mkdir          dir="${dist.home}/docs/api"/>
	    <javadoc sourcepath="${src.home}"
	             destdir="${dist.home}/docs/api"
	             packagenames="*">
	    	<classpath refid="compile.classpath"/>
	    </javadoc>
	</target>

	<target name="list"
	        description="List installed applications on servlet container">
		<list url="${manager.url}"
	          username="${manager.username}"
	          password="${manager.password}"/>
	</target>

	<target name="prepare">
		<mkdir  dir="${build.home}"/>
	    <mkdir  dir="${build.home}/WEB-INF"/>
	    <mkdir  dir="${build.home}/WEB-INF/classes"/>
	    <copy todir="${build.home}">
	    	<fileset dir="${web.home}"/>
	    </copy>
	    <mkdir  dir="${build.home}/WEB-INF/lib"/>
	</target>

	<target name="reload"
	        depends="compile"
	        description="Reload application on servlet container">
		<reload url="${manager.url}"
	            username="${manager.username}"
	            password="${manager.password}"
	            path="${app.path}"/>
	</target>

	<target name="remove"
	        description="Remove application on servlet container">
		<remove url="${manager.url}"
	            username="${manager.username}"
	            password="${manager.password}"
	            path="${app.path}"/>
	</target>

</project>

Otro ejemplo. Este es un build file para un proyecto EJB con JBoss:

<project name="ejb3-project" default="jar" basedir=".">

	<property environment="env" />
	<property name="src.dir" value="${basedir}/src/main" />
	<property name="src.resources" value="${basedir}/src/main/resources" />
	<property file="${user.home}/.ant.properties"/>
	<property name="jboss.home" value="${env.JBOSS_HOME}" />
	<property name="jboss.server" value="default"/>
	<property name="build.dir" value="${basedir}/target" />
	<property name="build.classes.dir" value="${build.dir}/classes" />
	<property name="jboss.base" value="${jboss.home}/server/${jboss.server}"/>
	<property name="deploy.dir" value="${jboss.base}/deploy"/>

	<path id="classpath">
		<fileset dir="${jboss.base}/lib">
			<include name="*.jar" />
		</fileset>
		<fileset dir="${deploy.dir}/ejb3.deployer">
			<include name="*.jar" />
		</fileset>
		<fileset dir="${deploy.dir}/jboss-aop-jdk50.deployer">
			<include name="*.jar" />
		</fileset>
		<fileset dir="${jboss.home}/lib">
			<include name="*.jar" />
		</fileset>
		<pathelement location="${build.classes.dir}" />
	</path>

	<property name="build.classpath" refid="classpath" />

	<target name="prepare">
		<mkdir dir="${build.dir}" />
		<mkdir dir="${build.classes.dir}" />
	</target>

	<target name="compile" depends="prepare">
		<javac srcdir="${src.dir}" destdir="${build.classes.dir}" debug="on" deprecation="on" optimize="off" includes="**">
			<classpath refid="classpath" />
		</javac>
	</target>

	<target name="jar" depends="compile">
		<jar jarfile="${build.dir}/${ant.project.name}.jar">
			<fileset dir="${build.classes.dir}">
				<include name="**/*.class" />
			</fileset>
			<fileset dir="${src.resources}/">
				<include name="META-INF/persistence.xml" />
			</fileset>
		</jar>
	</target>

	<target name="deploy" depends="jar">
		<copy file="${build.dir}/${ant.project.name}.jar" todir="${deploy.dir}" />
	</target>

	<target name="run.client" depends="deploy">
		<java classname="com.uberdose.Client" fork="yes" dir=".">
			<classpath refid="classpath" />
		</java>
	</target>

	<target name="clean.db">
		<delete dir="${jboss.base}/data/hypersonic" />
	</target>

	<target name="clean">
		<delete dir="${build.dir}" />
		<delete file="${deploy.dir}/${ant.project.name}.jar" />
	</target>

</project>

Una imagen vale mas que mil palabras….

Click para agrandar

via pinguinosycia

Ahora que ya sabemos exactamente lo que es el nofollow les quiero dar unos cuantos consejos de como usarlo especialmente en sus blogs. Voy a usar como ejemplo el mio.

Seguramente todos tenemos un blogroll o una lista de blogs y paginas amigas, en general yo NO recomendaria usar el nofollow en esos casos, tambien seguramente tenemos una lista con enlaces a otros de nuestros blogs, NO deberian usar nofollow en esos casos porque justamente queremos que el pagerank si se transmita hacia esas paginas. Por ejemplo en este blog podran ver claros ejemplos de los que les acabo de decir.

Pero tambien podran ver en este blog que tengo enlaces hacia los principales servicios y redes sociales como twitter y facebook, en estos casos SI usar el nofollow.

Por ejemplo veran que en este blog tambien estan los enlaces para ver el blog en varios idiomas, SI usar nofollow en esos casos porque de nada nos sirve que google siga esos enlaces o que les de nuestro pagerank.

Otro lugar donde SI nos conviene usar el nofollow es en los enlaces del theme que casi todos tenemos en el pie de pagina. No nos sirve que google les de nuestro pagerank pero tampoco podemos sacar esos enlaces porque estariamos inclumpliendo con la licencia del theme.

Y el ultimo gran uso que podemos darle es en los mismos post, cuando enlaces a otros blogs yo NO recomendaria usar el nofollow pero a veces en nuestro post ponemos enlaces a sitios que no necesitan mas pagerank y sitios como google, facebook, twitter y miles mas, enlaces que en general son sitios muy grandes y conocidos, en esos enlaces SI usar nofollow.

Bueno esta fue mi pequeña ayuda para que mejoren un poco el SEO todos. Esperemos que la forma de trabajar del nofollow no cambie

Bueno gente, despues de estar toda la semana estudiando me alegra poder volver a escribir es en situaciones como esta donde me doy cuenta que realmente me gusta compartir y escribir….y espero que a ustedes les guste leer lo que escribo. Buenos vamos a lo que nos concierne….

Yo he tratado de explicarlo muchas veces y en realidad no es algo dificil de entender todo este tema del nofollow o dofollow, pero hay algunos a los que les cuesta entender, como a mi amigo hyuuga, por suerte la gente de obux ha escrito un tutorial muy bueno sobre lo que es el nofollow y a continuacion el copy+paste:

El Nofollow es un atributo utilizado en los enlaces web. Fue popularizado por Google y su algoritmo de posicionamiento en buscadores. Por ejemplo al revisar el código fuente de varios encontraran que los enlaces están de la siguiente manera:

<a rel="nofollow" href="http://www.otro-website.org">

La histórica necesidad del No-follow

La implementación del Nofollow nace como solución de la problemática que era y es generada por los spammers.  En todo website que contenga un formulario (blogs y foros regularmente) cualquier spammer es capaz de colocar comentarios con enlaces hacia sitios web de Spam (los famosos enlaces de Viagra). Esto afectaba de forma directa al buscador de Google. ¿Pero como es eso?

Recordemos que Google funciona como una gran red de nodos interconectados a través de los enlaces web. Si en tu sitio existen tres enlaces, Google navegara por tu sitio, visitará secuencialmente el destino de esos tres enlaces y verificara si ya ha agregado esas paginas a su buscador o si han cambiado desde la ultima vez que fueron visitadas.

Ahora imagínate que en tu sitio existan 50 comentarios con enlaces Spam, Google seguiría a través de esos enlaces y estaría indexando ese contenido de tal manera que su funcionamiento se haría lento y sobrecargado ¿La solución? El atributo Nofollow.

Cuando le añadimos Nofollow al enlace, le estamos diciendo literalmente a Google “No sigas este enlace, no es importante para la arquitectura de mi sitio web, no le debes de trasmitir la popularidad del home y si el enlace es Nofollow en todo el sitio no debes indexar esa pagina“. Es por esto que la mayoría de sitios web que cuentan con la opción de dejar comentarios agregan este atributo de forma automática, así Google solamente seguirá los enlaces definidos por el administrador web y haría caso omiso de todos los que tuvieran Nofollow. No es que sea un duro golpe para los spammers, sin embargo al menos las Serps (paginas de resultados en los motores de búsqueda) son más limpias.

Pero el asunto no queda ahí, a Google también se le ocurrió hacer otro invento: El pageRank.

El PageRank y su relación con el atributo No-follow

El Pagerank es un sistema de valoración (entre 1 y 10) definido por Google a través de más de 200 variables el cual se distribuye entre todas las paginas web de un sitio. Mientras más pageRank tenga un sitio web, más importante es ante los ojos de Google.

Las maneras en que un sitio va ganando pageRank van desde el número de enlaces que el sitio recibe hasta la antigüedad del dominio, actualización del website, etc.

Continuando con el ejemplo del website con tres enlaces. Supongamos que ha pasado el tiempo y Google le ha asignado pageRank 3 , este pageRank se dividirá entre los enlaces a través de una variable llamada Link-Juice de tal forma que las paginas recibirán parte de ese PageRank lo que les ira generando a su vez su propio Pagerank.  Por cierto cuando un enlace no lleva la etiqueta Nofollow recibe el nombre de Enlace Dofollow.

Si no se utiliza el atributo No-follow, el Link-Juice se distribuye entre todas las paginas que estemos enlazando desde nuestro website.

Pero ahora imaginemos que al webmaster se le ha ocurrido que debe agregar más contenido y añade tres paginas de chistes (para aumentar el tiempo de las visitas) pero no quiere que se les traspase el Link-Juice ¿Que se puede hacer? Nuevamente aquí entra en acción el Nofollow.  Si el sitio tiene pageRank 3 y cuenta con seis enlaces, el Link-Juice que se traspasará a esos enlaces será de 0.5, sin embargo si a los últimos tres enlaces se les agrega el atributo Nofollow el link-Juice solo se distribuirá entre los enlaces naturales asignándoles 1 de Link-Juice a cada uno.

Lo anterior vendría a darle mucha más fuerza a los primeros tres enlaces y haría invisible (hacia Google) los últimos hacia las paginas de chistes.

Al utilizar el atributo Nofollow, le estamos indicando a Google que a esas paginas no se les debe transmitir el Link-Juice.

El atributo Nofollow es algo que actualmente se utiliza casi en el 70% de websites y muchas veces no se sabe porque existe ni como funciona realmente

Hasta ahi fue la genial explicacion de la gente de obux. Pero revisando me he encontrado con otro post en otro blog donde en resumidas palabras nos cuenta que el nofollow pronto dejara de tener esta utilidad, ya veremos, si algo sucede yo les aviso

Acabo de enterarme (y de probar con todo éxito) de un nuevo ataque de denegación de servicio (DoS) para servidores web. Lamentablemente, hasta este momento, todas las versiones de Apache son vulnerables

Realmente, es un ataque muy simple y que prácticamente no consume ancho de banda en el atacante, por lo que en este momento cualquiera puede (con un mínimo esfuerzo) dejar totalmente inaccesible cualquier sitio web que esté alojado en un servidor vulnerable.

Para probar la vulnerabilidad

slowloris.pl

Requerimientos:

• perl
• IO::Socket::INET (perl -MCPAN -e 'install IO::Socket::INET')
• IO::Socket::SSL (perl -MCPAN -e 'install IO::Socket::SSL')
• GetOpt::Long (perl -MCPAN -e 'install GetOpt::Long')

Nos interesa la línea var _download = ‘http\x3a\x2f\x2f8fg7rq.blu.livefilestore.com\x2fy1pX-xLeP5hg1gK-JoGR0gzsocnqKUTcX7AQ8K-Yboe-Xn9MvVAJ72VtmEnn_u7wVgyzHYFX0qyVow6NZiQo9STrPm7VRq8lWax\x2f08-Vivir\x2520sin\x2520ella.mp3\x3fdownload’;

Como verán se trata de la dirección del archivo. Bien, ¿ven ese \x3a luego del http? eso significa : (dos puntos). Dicho eso se podrán imaginar como modificar la URL, pero yo se las doy directamente :

http://8fg7rq.blu.livefilestore.com/y1pX-xLeP5hg1gK-JoGR0gzsocnqKUTcX7AQ8K-Yboe-Xn9MvVAJ72VtmEnn_u7wVgyzHYFX0qyVow6NZiQo9STrPm7VRq8lWax/08-Vivir sin ella.mp3-download

Si ingresan con su navegador a esa dirección, hará una de dos cosas: 1. Tratará de descargar el archivo; ó 2. Tratará de reproducirlo (como Chrome). En fin, es esa la url que deben usar para incrustar el audio en WordPress, lo cual se hace de la siguiente forma:

[audio=URL-que-conseguimos]

¡Y listo! Disfruten de la canción .