
Las aplicaciones flash normalmente se descargan en el PC del usuario como aplicación cliente. Es posible que a veces nos interese capturar información dinámica y cargarla en la película FLASH para poder usarla.

Con este sencillo código veremos cómo podemos capturar datos de una url externa en AS3.

```js
var cargarPagina:URLLoader = new URLLoader();
cargarPagina.dataFormat = URLLoaderDataFormat.TEXT;
cargarPagina.load(new URLRequest("http://url.com/script.php?variable1=x&variable2=y"));
cargarPagina.addEventListener(Event.COMPLETE, paginaCargada);

function paginaCargada(event:Event){
  trace(event.target.data);
}
```

Como se ve es muy sencillo. Hay varias cosas a notar. Primero que Hay distintos formatos de información que podemos recibir. La usada en el ejemplo es de tipo **URLLoaderDataFormat.TEXT**, para que capturar todo el contenido generado por la url como un solo valor.

Luego también es interesante ver cómo pasarle parámetros al script al que llamamos, podemos modificar estos parámetros desde el mismo código AS3.

Finalmente añadimos un evento para que cuando se haya completado podamos tratar la información, esta se puede obtener dentro de event.target.data.


Código para cargar información de un archivo externo desde AS3

Cargar un archivo externo en AS3

cargar-un-archivo-externo-en-as3


En un entorno de producción siempre será necesario capturar los errores en algun tipo de log. PHP nos lo permite hacer de una forma muy sencilla.

Hay que tener en cuenta que en nuestro entorno de desarrollo nos es más útil que los errores que aparecen al ejecutar una aplicación PHP se muestren por pantalla, sin embargo, esto es peligroso en un entorno real de producción, puesto que estos registros suelen dar información detallada sobre datos de nuestro sistema.

## Capturar todos los registros de errores PHP en un archivo

Para configurar los logs de error de PHP podemos modificar el archivo php.ini que se encarga de configurar opciones de PHP. Normalmente suele estar en /etc/php.ini

```bash
nano /etc/php.ini
```

Podemos usar cualquier editor que nos apetezca (vi, o si estás en entorno gráfico gedit, etc..)

Debemos buscar la línea donde aparezca la variable error_log descomentarla y añadir la ruta donde guardaremos el log. Por ejemplo:

```
error_log = "/var/log/php_errors.log"
```

También hay que asegurarse que la variable log_errors está a On para que registre errores

```
log_errors = On
```

Y finalmente la variable display_errors a Off para que no se muestren los errores por pantalla

```
display_errors = Off
```

Para que apache puedea escribir en ese fichero tiene que tener permisos. Podemos cambiar el owner del fichero /var/log/php_errors.log al usuario apache que suele ser el nombre de usuario que usa el servidor httpd

```bash
chown apache /var/log/php_errors.log
```

O sino, también podemos cambiar los permisos para que se pueda escribir

```bash
chmod 777 /var/log/php_errors.log
```

\* Atención: Hay que ir con cuidado al asignar este último permiso, ya que en un servidor con múltiples usuarios podrían tener acceso.


Configurar PHP para que muestre los errores en un log

Registrar errores PHP en un log

registrar-errores-php-en-un-log


La mejor forma de generar urls amigables y leíbles en Ruby on Rails es utilizando el método **parameterize**.

Este método reemplaza caracteres especiales en una cadena de texto y se usa de la forma siguiente:

```ruby
"El veloz murciélago hindú comía feliz cardillo y kiwi".parameterize
```

El resultado sería:

```
el-veloz-murcielago-hindu-comia-feliz-cardillo-y-kiwi
```

Así de sencillo.

## Transliteraciones

Sin embargo, si deseamos hacer una url amigable a partir de caracteres Unicode como los usados por el alfabeto Chino, Ruso, etc el método parameterize no sería útil. Existen gems que nos lo ponen igual de fácil. Por ejemplo la [Unidecode gem](http://rubyforge.org/projects/unidecode/)


Urls amigables en Ruby on Rails

urls-amigables-en-ruby-on-rails


## Listado de Comandos para Windows 7

Microsoft Windows 7 también se puede administrar desde la línea de comandos. Para acceder a la línea de comandos de Windows 7, se pulsa en el Menú Inicio y en el campo de Buscar Programas y Archivos (o la tecla de Windows + r) se escribe el comando **cmd** y se pulsa enter. De esta forma se abre la consola del sistema donde se podrá entrar los comandos.

A continuación se muestra una lista con algunos de los comandos de Windows 7 ordenados alfabéticamente: (esta misma lista aparece usando el comando help)

ASSOC - Muestra o modifica las asociaciones de las extensiones de archivos.  
ATTRIB - Muestra o cambia los atributos del archivo.  
BREAK - Establece o elimina la comprobación extendida de Ctrl+C.  
BCDEDIT - Establece propiedades en la base de datos de arranque para controlar la carga del arranque.  
CACLS - Muestra o modifica las listas de control de acceso (ACLs) de archivos.  
CALL - Llama a un programa por lotes desde otro.  
CD - Muestra el nombre del directorio actual o cambia a otro directorio.  
CHCP - Muestra o establece el número de página de códigos activa.  
CHDIR - Muestra el nombre del directorio actual o cambia a otro directorio.  
CHKDSK - Comprueba un disco y muestra un informe de su estado.  
CHKNTFS - Muestra o modifica la comprobación de disco al arrancar.  
CLS - Borra la pantalla.  
CMD - Inicia una nueva instancia del intérprete de comandos de Windows COLOR - Establece los colores de primer plano y fondo predeterminados de la consola.  
COMP - Compara el contenido de dos archivos o un conjunto de archivos.  
COMPACT - Muestra o cambia el estado de compresión de archivos en particiones NTFS.  
CONVERT - Convierte volúmenes FAT a volúmenes NTFS.  
No puede convertir la unidad actual.  
COPY - Copia uno o más archivos en otra ubicación.  
DATE - Muestra o establece la fecha.  
DEL - Elimina uno o más archivos.  
DIR - Muestra una lista de archivos y subdirectorios en un directorio.  
DISKCOMP - Compara el contenido de dos disquetes.  
DISKCOPY - Copia el contenido de un disquete en otro.  
DISKPART - Muestra o configura las propiedades de partición de disco.  
DOSKEY - Edita líneas de comando, memoriza comandos de Windows y crea macros.  
DRIVERQUERY - Muestra el estado y las propiedades actuales del controlador de dispositivo.  
ECHO - Muestra mensajes, o activa y desactiva el eco.  
ENDLOCAL - Termina la búsqueda de variables de entorno del archivo por lotes.  
ERASE - Elimina uno o más archivos.  
EXIT - Sale del programa CMD.  
EXE (interfaz de comandos).  
FC - Compara dos archivos o conjunto de archivos y muestra las diferencias entre ellos.  
FIND - Busca una cadena de texto en uno o más archivos.  
FINDSTR - Busca cadenas de texto en archivos.  
FOR - Ejecuta un comando para cada archivo en un conjunto de archivos.  
FORMAT - Formatea un disco para usarse con Windows.  
FSUTIL - Muestra o configura las propiedades de sistema de archivos.  
FTYPE - Muestra o modifica los tipos de archivo usados en una asociación de extensión de archivo.  
GOTO - Direcciona el intérprete de comandos de Windows a una línea en un programa por lotes.  
GPRESULT - Muestra información de directivas de grupo por equipo o usuario.  
GRAFTABL - Permite a Windows mostrar un juego de caracteres extendidos en modo gráfico.  
HELP - Proporciona información de ayuda para los comandos de Windows.  
ICACLS - Muestra, modifica, hace copias de seguridad o restaura listas de control de acceso (ACL) para archivos y directorios.  
IF - Ejecuta procesos condicionales en programas por lotes.  
LABEL - Crea, cambia o elimina la etiqueta del volumen de un disco.  
MD - Crea un directorio.  
MKDIR - Crea un directorio.  
MKLINK - Crea vínculos simbólicos y vínculos físicos MODE - Configura un dispositivo de sistema.  
MORE - Muestra la información pantalla por pantalla.  
MOVE - Mueve uno o más archivos de un directorio a otro en la misma unidad.  
OPENFILES - Muestra archivos compartidos abiertos por usuarios remotos.  
PATH - Muestra o establece una ruta de búsqueda para archivos ejecutables.  
PAUSE - Suspende el proceso de un archivo por lotes y muestra un mensaje.  
POPD - Restaura el valor anterior del directorio actual guardado por PUSHD.  
PRINT - Imprime un archivo de texto.  
PROMPT - Cambia el símbolo de comandos de Windows.  
PUSHD - Guarda el directorio actual y después lo cambia.  
RD - Quita un directorio.  
RECOVER - Recupera la información legible de un disco dañado o defectuoso.  
REM - Marca comentarios en archivos por lotes o CONFIG.  
SYS.  
REN - Cambia el nombre de uno o más archivos.  
RENAME - Cambia el nombre de uno o más archivos.  
REPLACE - Reemplaza archivos.  
RMDIR - Quita un directorio.  
ROBOCOPY - Utilidad avanzada para copiar árboles de archivos y directorios SET - Muestra, establece o quita variables de entorno de Windows.  
SETLOCAL - Comienza la sección de cambios locales de entorno en un archivo por lotes.  
SC - Muestra o configura servicios (procesos en segundo plano).  
SCHTASKS - Programa comandos y programas para ejecutarse en un equipo.  
SHIFT - Cambia posición de modificadores reemplazables en archivos por lotes.  
SHUTDOWN - Permite el apagado local o remoto de un equipo.  
SORT - Ordena la salida.  
START - Inicia otra ventana para ejecutar un programa o comando.  
SUBST - Asocia una ruta de acceso con una letra de unidad.  
SYSTEMINFO - Muestra las propiedades y la configuración específicas del equipo.  
TASKLIST - Muestra todas las tareas en ejecución, incluidos los servicios.  
TASKKILL - Termina o interrumpe un proceso o aplicación que se está ejecutando.  
TIME - Muestra o establece la hora del sistema.  
TITLE - Establece el título de la ventana de una sesión de CMD.  
EXE.  
TREE - Muestra gráficamente la estructura de directorios de una unidad o ruta de acceso.  
TYPE - Muestra el contenido de un archivo de texto.  
VER - Muestra la versión de Windows.  
VERIFY - Comunica a Windows si debe comprobar que los archivos se escriben de forma correcta en un disco.  
VOL - Muestra la etiqueta del volumen y el número de serie del disco.  
XCOPY - Copia archivos y árboles de directorios.  
WMIC - Muestra información de WMI en el shell de comandos interactivo.


Comandos Windows 7

comandos-windows-7


En muchas bases de datos como MySQL, PostgreSQL, etc que usan el lenguaje SQL permiten usar una instrucción llamada UNION, que permite unir los resultados de varias consultas. El problema que me encontré es que los resultados que devuelve unidos sólo se pueden ordenar de forma general, no por cada consulta individual. Veamos un ejemplo práctico.

Imaginad que queremos hacer una consulta que nos devuelva un conjunto de elementos ordenados por fecha, de modo que nos muestre los x primeros elementos ordenados de una forma y los y siguientes de otra.

```sql
SELECT title, IFNULL(eventos_proximos,eventos_pasados)
FROM (
  (
    SELECT title, begin_at as eventos_proximos,null as eventos_pasados FROM eventos
    WHERE begin_at >= NOW()
  )
  UNION
  (
    SELECT title, null, begin_at FROM eventos AND begin_at < NOW()
  )
) t2
ORDER BY eventos_proximos, eventos_pasados DESC;
```

En PostgreSQL podemos usar COALESCE en vez de IFNULL para comprobar que si el valor es nulo, y en Oracle podríamos usar la funcion NVL.


Ejemplo práctico de la instrucción UNION para obtener una lista de elementos ordenados

Consulta avanzada de SQL usando UNION

consulta-avanzada-de-sql-usando-union


No es ninguna novedad el uso de máquinas virtuales en el mundo de la programación. En este artículo repasaremos qué es una máquina virtual y como darle un buen uso para crear un entorno de trabajo.

## Máquina Virtual

Una máquina virtual es un programa que emula el comportamiento de un PC y actúa como si fuera otra computadora. Lo bueno es que en un mismo PC se pueden ejecutar tantas máquinas virtuales como capacidad tenga nuestro sistema.

Las ventajas que esto supone son muchísimas: desde empresas de hosting que en un solo servidor albergan varias máquinas virtuales, hasta para crear máquinas independientes sin afectar al sistema operativo instalado en el propio PC.

## Virtual Box

Existen varias aplicaciones que permiten crear máquinas virtuales, Virtual PC 2007 de Microsoft (un poco anticuada), KVM, Xen, Virtuozzo, VMWare y Virtual Box entre muchísimas otras.

Destacamos entre ellas **Virtual Box**. Esta aplicación es de Sun Microsystems y puede descargarse de forma gratuita ([http://www.virtualbox.org/wiki/Downloads](http://www.virtualbox.org/wiki/Downloads)).

Soporta una gran cantidad de sistemas operativos a virtualizar entre los que destacan Windows, GNU/Linux, FreeBSD, MS-DOS, OpenBSD, OS/2 Warp y Solaris entre otros.

Otro uso muy común de las máquinas virtuales es usarlas para recrear un qualquier entorno. Por ejemplo, si desarrollamos una web y lo hospedamos en un servidor dedicado, podemos recrear este servidor en una máquina virtual para realizar prueba instalar nuevo software y probar cosas antes de hacerlo en el entorno de producción.

## Crear una Máquina Virtual

Para crear una nueva máquina virtual sólo necesitamos una imagen (iso, etc) o un cd/dvd del sistema operativo que deseemos instalar. El asistente nos ayudará preguntándonos sobre cuanta memoria de disco deseamos usar y cuanta RAM. Una vez creada la máquina virtual, al iniciziarla arrancará el sistema y debemos capturar la imagen para empezar a instalar el sistema operativo. A partir de este momento ya es como si se tratara de un PC corriente.


Usar máquinas virtuales para recrear entornos de trabajo

Virtual Box

virtual-box


GIT es un sistema de control de versiones, gratuito y de código abierto, está diseñado para trabajar con todo tipo de proyectos de forma eficiente y rápida.

Es una herramienta para controlar versiones de ficheros, muy útil para trabajar en equipos de desarrollo y es similar a otros sistemas conocidos como Mercurial, Subversion, Bazaar, CVS o Preforce. Hay una gran multitud de proyectos que lo utilizan, algunos tan importantes como el Kernel de Linux, Perl, Gnome, Ruby on Rails, QT, etc.

## Instalar GIT

Podemos usar nuestro gestor de paquetes como apt-get, yum, etc. Por ejemplo en Debian o Ubuntu

```bash
apt-get install git-core
```

si preferimos compilar el código fuente, lo podemos descargar de la página oficial de [GIT](http://git-scm.com/) y lo descomprimimos:

```bash
wget http://kernel.org/pub/software/scm/git/git-1.7.0.3.tar.gz
tar -xf git-1.7.0.3.tar.gz
```

Seguidamente lo compilamos e instalamos:

```bash
cd git-1.7.0.3
./configure --prefix=/usr/local/ && make && sudo make install
```

En principio si no falta ninguna dependencia, el programa se habrá instalado correctamente. Podemos usar el comando git para ver que funciona.

\*En algunos casos puede faltar la librería zlib, podemos instalar el paquete zlib-devel-1.2.3-3.i386 por ejemplo.

## Crear un nuevo proyecto o repositorio

Supongamos que tenemos el proyecto sobre el que trabajaremos en nuestra carpeta de usuario llamado proyecto1

```bash
cd proyecto1
git init
```

Así de simple. Con este comando se crea una carpeta oculta .git.

Por lo tanto se deseamos dejar de usar git en este proyecto basta con borrar esta carpeta

```bash
rm -rf .git/
```

\*Antención: Siempre hay que ir con cuidado al eliminar. En este caso no borraremos el código del proyecto pero sí todo lo que se ha echo con GIT.

Hasta aquí hemos visto como instalar y crear un repositorio. Esta carpeta deberá ser accesible desde la red para que un tercero pueda acceder a ella, descargarse la versión del proyecto y aplicar futuros cambios.


GIT. Control de versiones

git-control-de-versiones


Hay diversas formas de hacer un seguimiento de los clics que se generan en nuestro sitio web. Quizá la más segura y fiable sea hacer un script propio almacenado en nuestro servidor que cuente el número de veces que se hace un clic sobre un enlace. Sin embargo, podemos usar el poder de Google Analytics para obtener toda la información sobre clics a enlaces externos con una mínima pérdida de información.

Supongamos que queremos saber cúantas veces se hace clic sobre un link externo del tipo

```html
<a href="http://sitioexterno.com"></a>
```

Tan sólo añadiendo una simple instrucción en el evento **onclick** google analytics ya registrará los clics:

```html
<a href="http://sitioexterno.com" onClick="javascript: pageTracker._trackPageview('/enlace_externo/nombredescriptivo');"></a>
```

En la función **_trackPageview** es recomendable poner una etiqueta descriptiva que podemos cambiar a nuestro gusto para diferenciarlas de nuestras otras páginas.

* Atención: Es importante actualizar el código de Google Analytics a la última versión para que la función **_trackPageview** tenga efecto.

## Ver las estadísticas de los enlaces externos

Al cabo de unas 24/48 horas ya podremos ver las estadísticas de nuestro sitio en la página de Google Analytics en el apartado de **Contenido** > **Contenido Principal**. Ahí podemos filtrar por las palabras clave (en el caso del ejemplo anterior '/enlace_externo/nombredescriptivo') y veremos toda la información relacionada sobre las visitas efectuadas a ese enlace por parte de nuestros visitantes.


Uso de la función _trackPageview() de Google Analytics para contar enlaces externos

Google Analytics. Seguimiento de clics externos

google-analytics-seguimiento-de-clics-externos


Para iterar sobre arrays (estructuras de datos de tipo tabla o vector) en PHP podemos usar la instrucción **foreach**

Su uso es muy simple y nos permite recorrer estas estructuras de datos de una forma alternativa a la forma clásica de declarar una variable como contador e ir incrementándola a medida que recorremos los índices.

Existen dos tipos de sintaxis para la instrucción foreach:

```php
foreach (array as $valor){
    instruccion;
}

foreach (array as $clave => $valor){
    instruccion;
}
```

La primera se utiliza cuando solo nos interesa el contenido de una posición concreta de vector.

La segunda se usa si también deseamos usar el valor de $clave, por ejemplo si los índices no son numéricos.

## Ejemplo funcional de foreach en PHP

```php
$datos = array("69878754-E" => "Julián", "32684574-F" => "Paula", "44580546-P" => "Marta");
foreach ($datos as $clave => $valor) {
    echo "dni: $clave Nombre: $valor";
}
```

En este ejemplo tenemos un conjunto de personas en una tabla cuya identificación es su DNI.


Método foreach() para recorrer estructuras de tipo vector o tabla en PHP

Foreach PHP

foreach-php


## ¿Qué es Java Web Start?

Java Web Start es una aplicación que permite descargar y ejecutar aplicaciones Java directamente desde la Web con un solo click, evitando así procedimientos farragosos de instalación.

Java Web Start viene por defecto en el entorno de ejecución JRE. Cuando se descarga y ejecuta un programa con este método, éste se guarda en la memoria caché y si volvemos a intentar descargar la aplicación sólo se descargará si ya no está en la cache o hay una nueva versión.

## Desplegar una aplicación con Java WebStart y NetBeans

Netbeans nos permite desplegar (deploy en inglés) aplicaciones Java WebStart de una forma sencilla. En la lista de proyectos abiertos, pulsamos sobre el botón derecho del ratón sobre el proyecto que queramos desplegar y pulsamos sobre Properties.

En la pantalla de propiedades nos dirigimos en la sección Application > **Web Start** .

Ahí activamos la casilla Enable Web Start. Ahora hay que tener en cuenta si deseamos desplegar la aplicación para que pueda ser descargada desde el servidor web o para uso local. Si deseamos testearlo en nuestra propia máquina podemos seleccionar "Local Execution" en el campo CodeBase. Si por el contrario lo queremos subir a un servidor Web seleccionamos "User defined (e.g. HTTP deployment)".

En el siguiente campo Codebase Preview debemos escribir la ruta de acceso donde reside el jar principal de nuestra aplicación. O una dirección url si hemos seleccionado desplegamiento web en el paso anterior.

Activamos la casilla "Allow Offline" para permitir la ejecución sin conexión

Seleccionamos la casilla Self-signed para assignar un certificado propio a nuestro programa. Si usamos otras librerías estas no deberán estar signadas de forma que cuando compilemos se signe toda la aplicación y sus librerías con el mismo certificado, sino no se podrá ejecutar.

Finlamente le damos a OK y hacemos un build del proyecto (Mayúsculas+F11).

Al construir el proyecto se crean, entre otros archivos, un archivo HTML desde donde se podrá llamar al archivo JNLP que invoca a nuestra aplicación. Estos archivos se encuentran por defecto en la carpeta **dist** de nuestro proyecto.


Qué es Java WebStart y cómo desplegar una aplicación en NetBeans con este método

Java WebStart con NetBeans

java-webstart-con-netbeans


En muchos lenguajes de programación existen excepciones. Las excepciones sirven para controlar varios tipos de errores que pueden suceder durante la execución de un programa. Cuando ocurre el error, con las excepciones se puede capturar para tratarlo en vez de terminar el programa por completo.

En Ruby on Rails, el tratamiento de excepciones se encapsula entre cláusulas **begin** y **end** de la siguiente forma:

```ruby
begin # codigo...
  rescue TIPO_EXCEPCION_1
  STDERR.puts "Ha ocurrido un problema de tipo 1"
  rescue TIPO_EXCEPCION_2
  STDERR.puts "Ha ocurrido un problema de tipo 2"
  else
  STDERR.puts "Ha ocurrido otro problema"
  ensure # se ejecuta siempre haya o no excepción
end
```

## Tipos de excepciones

A continuación mostramos los tipos de excepciones de Ruby:

- Exception
  - fatal
  - NoMemoryError
  - ScriptError
    - LoadError
    - NotImplementedError
    - SyntaxError
  - SignalException
    - Interrupt
  - StandardError
    - ArgumentError
    - IOError
      - EOFError
    - IndexError
    - LocalJumpError
    - NameError
      - NoMethodError
    - RangeError
      - FloatDomainError
    - RegexpError
    - RuntimeError
    - SecurityError
    - SystemCallError
      - _Errorno::___ (ENOENT, etc.) (system-dependent)
    - ThreadError
    - TypeError
    - ZeroDivisionError
  - SystemExit
  - SystemStackError

## Alzar excepciones

Podemos lanzar excepciones propias usando la palabra raise:

```ruby
def metodo_que_lanza_excepcion
  raise "error 1"
end
```

metodo_que_lanza_excepcion rescue puts $!

El código anterior definimos un método y luego fuera de este método definimos qué pasará cuando se lanze la excepción. En este ejemplo imprimimos con el comando puts el mensaje que se passa por parámetro: "error 1"


Declaración y captura de excepciones en Ruby

Tratamiento de excepciones en Ruby

tratamiento-de-excepciones-en-ruby


En este tutorial mostraremos como con unos pocos pasos podemos reemplazar una versión antigua de Java en CentOs por la que nos interese.

En realidad esto puede servir para reemplazar cualquier aplicación o comando porque lo que se trata es de modificar, usando el comando **alternatives** de linux, la aplicación que se ejecuta al llamar a ese comando. Veamos detalladamente este ejemplo donde reemplazaremos la aplicación que se ejecuta al usar el comando java:

Primero podemos usar el comando

```bash
java -version
```

que sirve para conocer cúal es la última versión de java instalada de nuestro servidor antes de hacer ningun cambio.

Ahora descargaremos la última versión de Java de la [página oficial](http://java.sun.com/javase/downloads/index.jsp). Tenéis que cambiar la url de este ejemplo por la verdadera.

```bash
curl -L -O http://....jdk-6u18-linux-i586.bin
```

Se descargará el archivo empaquetado bin. Podemos cambiarle los permisos de ejecución y ejecutarlo:

```bash
chmod +x jdk-6u18-linux-i586.bin
./jdk-6u18-linux-i586.bin
```

Tras ejecutar el comando anterior, el programa se desempaqueta en la misma carpeta. Podemos moverlo donde nos plazca, un buen sitio puede ser

```bash
mv jdkxxx /usr/local
```

Ahora viene lo interesante:

```bash
alternatives --install /usr/bin/java java /usr/jdkxxx/java 2
```

Lo que hace este comando es agregar una alternativa para este comando. Finalmente llamamos otra vez a este comando para asignar el comando java a la ruta de la nueva instalación.

```bash
alternatives --config java
```

y podemos seleccionar el comando que queremos ejecutar.

Efectivamente, este método sólo modifica el comando java, de forma que el resto de comandos (javac, etc) deberíamos reemplazarlos manualmente de la misma forma.

En general es un buen recurso para reemplazar comandos si creemos que alguna vez deberemos necesitar el antiguo, puesto que en otros casos quizá nos interese desinstalar la aplicación anterior e instalar la nueva versión.


Cómo usar una versión actualizada de Java sin desinstalar la antigua en CentOS server

Upgrade de Java en CentOS

upgrade-de-java-en-centos


## ¿Qué es Struts 2?

Struts, cuya primera versión fue lanzada en el 2001, es un framework para desarrollar aplicaciones web en Java que sigue el patrón de diseño Modelo Vista Controlador MVC. Este tipo de herramienta se utiliza sobretodo para separar el código HTML del código Java en las páginas JSP y para reutilizar la mayor parte de código posible para poder mantenerlo fácilmente.

## Propiedades y características de Struts 2.0

Así pues, Struts 2.0 nos ayudará a construir y desarrollar aplicaciones web de forma más sencilla y rápida. Estas son algunas de las cualidades de este framework:

**Java**. Java es un lenguaje tipado, es decir, al declarar variables hay que definir de qué tipo son (int, String, boolean, etc). Además de ser un lenguaje orientado a objetos ofrece muchas otras ventajas, como librerías con miles de funciones ya creadas que podremos usar en nuestras aplicaciones reduciendo el tiempo de diseño y desarrollo. Además también hay gran cantidad de IDE's preparados para programar en JAVA con funcionalidades a tener en cuenta como autocompletar o generar código.

**Convenciones por encima de la configuración**. Igual que el framework de Ruby llamado Ruby on Rails, Struts está pensado para que una vez instalado funcione. Aun así, podremos modificar cualquier configuración manualmente si nos interesa.

**MVC**. Struts2 sigue el patrón de diseño modelo vista controlador, tan usado hoy en día por la gran mayoría de frameworks para crear aplicaciones web. El mismo Ruby on Rails mencionado anteriormente lo hace, también frameworks como CakePHP y codeIgniter en PHP siguen este patrón.

**Anotaciones**. Con JDK 5 se introdujeron las anotaciones, lo que hace reducir drásticamente el uso de XML

## Struts 2 vs Ruby on Rails

Productivamente hablando el framework de Ruby on Rails está por encima del framework Struts 2. La eficiencia que permite Ruby on Rails en la rapidez de crear aplicaciones web es actualmente superior y algunas de sus características nunca se podrán realizar en Struts debido principalmente a restricciones del mismo lenguaje Java. De todas formas, esto no quiere decir que no se puedan desarrollar aplicaciones Web potentes. Sitios como [cj.com](http://www.cj.com) uno de los sitios de afiliados ecommerce más conocido del mundo o infinidad de periódicos digitales como [Boston.com](http://www.boston.com/) están creados con Struts 2.


Descripción y cualidades del framework Struts 2 de Java

Struts 2

struts-2


## Clases y objetos

Una clase es una definición de un objeto que contiene atributos a los que representa y métodos que puede ejecutar. En Ruby una clase se define de la siguiente forma:

```ruby
class Coche
    def initialize(color, puertas)
        @color = color
        @puertas = puertas
    end
end
```

El método initialize es un método especial de Ruby que se utiliza como constructor cada vez que se crea una nueva instancia del objeto.

En Ruby todas las classes deben empezar con letra mayúscula.

## Public, private, protected

Los métodos de una clase por defecto, y si no se indica lo contrario, son públicos. Además de público, un método puede ser protected o private.

Para determinar de qué tipo es basta con añadir la palabra clave private al principio de los métodos privados por ejemplo:

```ruby
class coche
    def abrirPuertas
    end

    def cerrarPuertas
    end

    private
    	def abrirGuantera
    	end
    end
end
```

La palabra clave protected se usa de la misma forma que private con la diferencia que un si una clase hereda el método también puede usarla como si fuera público, mientras que si se llama desde el exterior se comporta como un método privado.

## Herencia

Otra de las particularidades de cualquier lenguaje orientado a objetos es sin duda la herencia. En Ruby se define la herencia de la siguiente manera:

```ruby
class Vehiculo
    def initialize()
    end
end

class Coche < Vehiculo
end
```

La clase coche hereda todos los métodos públicos o protegidos de vehículo.

Al igual que Java por ejemplo, Ruby tampoco soporta la herencia múltiple, es decir, una clase sólo puede heredar de otra clase y no de varias.

## Poliformismo

El poliformismo sirve para dar genericidad a un método de una clase. Por ejemplo: Supongamos que tenemos dos tipos de objetos un triangulo y un círculo que heredan la clase forma. La clase forma tiene un método que se llama devolverPerimetro

```ruby
class Forma
    def devolverPerimetro()
    end
end

class Circulo < Forma
    def devolverPerimetro()
    ...
    end

end

class Triangulo < Forma
    def devolverPerimetro()
    ...
    end

end
```

Está claro que no se calcula de la misma forma el perímetro de un círculo que el de un triangulo, por ello cada objeto lo definirá de una forma distinta.

El poliformismo nos da la posibilidad de que si tenemos un objeto forma pero no sabemos si es triangulo o circulo, podamos llamar al método devolverPerimetro y nos devolverá el perímetro correcto.


Introducción a Ruby y a la programación orientada a objetos

Ruby. Programación orientada a objetos

ruby-programacion-orientada-a-objetos


Ruby es un lenguaje interpretado orientado a objetos creado por Yukihiro Matsumoto. Lo creó basándose en otros lenguajes como perl y python en referencia sobretodo a la sintaxis y también en smalltalk por su orientación a objetos.

Una de las mejores cualidades de este lenguaje es su sencillez para leerlo.

En Ruby, todos los tipos de datos son considerados objetos, incluso lo que otros lenguajes como Java consideran tipos primitivos (enteros, booleanos, NULL, etc). Además, es importante saber que Ruby no necesita definir de qué tipo es una variable antes de inicializarla.

A continuación se muestran ejemplos básicos de programación como la sintaxis de las variables, las estructuras de control y algunas particularidades más que utiliza Ruby.

## Ejemplos de sintaxis

Veamos la sintaxis para crear un método. En este ejemplo se le pasa una cadena de texto por parámetro y se devuelve otra cadena de texto modificada.

```ruby
def mifuncion(texto)
  cadena = texto + " y adiós."
  return cadena
end

puts mifuncion("Hola")
```

La función **puts** imprime por pantalla el resultado del método llamado.

Para ejecutar el código basta guardar el código en un archivo llamado, por ejemplo, hola.rb y desde la línea de comandos ejecutar:

```bash
ruby hola.rb
```

## Diferencia entre métodos que acaban en ? o !

A veces nos interesará saber si un atributo o variable está definida. Podemos usar la expressión:

```ruby
atributo.nil?
```

Que devolverá cierto o falso según si está definida o no.

En cambio si una variable está seguida de el símbolo !, indica que se modifica el contenido de la variable. Mientras que si no lo lleva devuelve una copia modificada del contenido de la variable.

## Variables

Hay diferentes tipos de variables: Las locales, las globales y las de instancia de un objeto.

Una variable local es una variable como la usada en el ejemplo anterior llamada "cadena".

Las variables globales son las que se pueden acceder desde cualquier sitio y se escriben con el símbolo $ delante.

Las variables para instanciar un objeto se escriben con una arroba @ delante:

```ruby
@coche = Coche.new
```

Y para acceder a cualquier atributo de un objeto:

```ruby
@coche.color = "verde"
```

## Estructuras de control

Las estructuras de control que más usaremos son la condicional **if** y el **while**.

```ruby
dinero = 40

if dinero < 10
  puts "Tienes menos de 10"
elsif dinero > 10
  puts "Tienes mas de 10"
else
  puts "Tienes 10"
end
```

El bucle while se escribe de la siguiente forma:

```ruby
total = 10
while total>0
  puts total
  total -= 1
end
```

## Arrays y Hashes

Ruby permite crear estructuras de datos de tipo Array y de tipo Hash. Un array tiene como índice un entero mientras que un hash tiene como índice una cadena de texto.

Un ejemplo de array y como se recorre con un iterador:

```ruby
muebles = ['Silla', 'Mesa', 'Armario']
  muebles.each do |m|
  puts "#{m}"
end
```

Ahora un ejemplo de hash y como se recorre con un iterador:

```ruby
muebles = {
  :silla => 'salón',
  :mesa => 'salón,'
  :armario => 'dormitorio'
}

muebles.each_with_index do |m,i|
  puts "indice: #{i} contenido:#{m}"
end
```

También es posible recorrer un array pasando por todos los indices numéricos con un for

```ruby
muebles = ['Silla', 'Mesa', 'Armario']
for i in 0..muebles.length
  puts muebles[i]
end
```

Tenemos así una gran variedad de formas de recorrer las estructuras de datos.


Introducción básica a la sintaxis del lenguaje interpretado Ruby

Introducción a Ruby

introduccion-a-ruby


Hay distintas formas de descargar y extraer el audio y la música o canciones que aparecen en los videos de YouTube. Una de ellas es usar la herramienta [Listen To YouTube](http://www.listentoyoutube.com/). Este sitio nos facilita la labor y con tan sólo pasarle la url de la película flash es suficiente. La herramienta se encarga de extraer el sonido y reconvertirlo en formato mp3 listo para descargar.

La web está algo cargada de publicidad, pero se le perdona por el magnífico servicio que ofrece. Tan solo hay que escribir la url de la pelicula flash en el campo con título "Enter Youtube URL" de la página principal y pulsar GO. Las urls de los videos son del tipo:**http://www.youtube.com/watch?v=p2hNhM3dHB4**. Podeis copiarlo de la barra de direcciones url de la página de Youtube.

Tras pulsar GO, vemos una animación en estado "trabajando" más abajo de la página que convierte el video y extrae el MP3. El proceso puede tardar un poco según la duración del video. Una vez finalizado, aparece un enlace con el texto Download MP3. Lo pulsamos, nos lleva a otra página y pulsamos el enlace "Download MP3" (Debajo de Click button below...)


Herramienta para extraer audio de videos de YouTube

Cómo extraer música y sonido de YouTube

como-extraer-musica-y-sonido-de-youtube


Hoy veremos cómo hacer lo mismo pero dando soporte a muchos clientes al mismo tiempo utilizando para cada uno de ellos un Thread.

La estructura cliente-servidor es bastante similar, sin embargo, introducimos el concepto de Receptor. Para cada cliente que se conecte al servidor crearemos un nuevo hilo en el mismo que se encargará de gestionar el cliente.

Este receptor lo representamos con la clase Java: **ServidorHilo.java**

```java
import java.io.*;
import java.net.*;
import java.util.logging.*;

public class ServidorHilo extends Thread {

    private Socket socket;
    private DataOutputStream dos;
    private DataInputStream dis;
    private int idSessio;

    public ServidorHilo(Socket socket, int id) {
        this.socket = socket;
        this.idSessio = id;
        try {
            dos = new DataOutputStream(socket.getOutputStream());
            dis = new DataInputStream(socket.getInputStream());
        } catch (IOException ex) {
            Logger.getLogger(ServidorHilo.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    public void desconnectar() {
        try {
            socket.close();
        } catch (IOException ex) {
            Logger.getLogger(ServidorHilo.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    @Override
    public void run() {
        String accion = "";
        try {
            accion = dis.readUTF();
            if(accion.equals("hola")){
                System.out.println("El cliente con idSesion "+this.idSessio+" saluda");
                dos.writeUTF("adios");
            }

        } catch (IOException ex) {
            Logger.getLogger(ServidorHilo.class.getName()).log(Level.SEVERE, null, ex);
        }

        desconnectar();
    }
}
```
En el constructor creamos dos buffers (uno de entrada y otro de salida) para gestionar los envíos y recibos del cliente, y dentro del método RUN gestionamos qué hacer cuando recibamos un mensaje del cliente.

## Servidor

La clase **Servidor.java** se encarga de asignar un nuevo Thread a cada nueva conexión.

```java
import java.io.*;
import java.net.*;
import java.util.logging.*;

public class Servidor {

    public static void main(String args[]) throws IOException {

        ServerSocket ss;
        System.out.print("Inicializando servidor... ");
        try {
            ss = new ServerSocket(10578);
            System.out.println("\\t[OK]");
            int idSession = 0;
            while (true) {
                Socket socket;
                socket = ss.accept();
                System.out.println("Nueva conexión entrante: "+socket);
                ((ServidorHilo) new ServidorHilo(socket, idSession)).start();
                idSession++;
            }

        } catch (IOException ex) {
            Logger.getLogger(Servidor.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
}
```

## Cliente

El **Cliente.java** lo representamos mediante otra clase llamada Persona que se encarga de enviar y recibir los mesnajes que vienen y van del servidor.

```java
import java.io.*;
import java.net.Socket;
import java.util.*;
import java.util.logging.*;

class Persona extends Thread {

    protected Socket sk;
    protected DataOutputStream dos;
    protected DataInputStream dis;
    private int id;

    public Persona(int id) {
        this.id = id;
    }

    @Override
    public void run() {
        try {
            sk = new Socket("127.0.0.1", 10578);
            dos = new DataOutputStream(sk.getOutputStream());
            dis = new DataInputStream(sk.getInputStream());

            System.out.println(id + " envía saludo");
            dos.writeUTF("hola");
            String respuesta="";
            respuesta = dis.readUTF();
            System.out.println(id + " Servidor devuelve saludo: " + respuesta);
            dis.close();
            dos.close();
            sk.close();
        } catch (IOException ex) {
            Logger.getLogger(Persona.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
}

public class Cliente {

    public static void main(String[] args) {
        ArrayList clients = new ArrayList();
        for (int i = 0; i < 5; i++) {
            clients.add(new Persona(i));
        }
        for (Thread thread : clients) {
            thread.start();
        }
    }

}
```

Como ejemplo, se crean 5 clientes que se conectan al servidor.


Creación de un servidor en Java que soporte varios clientes al mismo tiempo con el uso de threads

Comunicación entre un servidor y múltiples clientes

comunicacion-entre-un-servidor-y-multiples-clientes


Como ya sabréis, la marca de tiempo de UNIX empieza en 1970 y tiene caducidad en 2037. Aunque es posible que cualquier aplicación que desarrollemos ya no esté operativa para esas fechas, ¿por qué usar UNIX_TIMESTAMP? Hasta no hace demasiado un servidor lo usaba, pero al tratar con otros lenguajes de programación he visto que no tiene demasiado sentido, y aunque puede ser más cómodo en algunos casos usarlo (como en PHP), finalmente cada vez que desarrollo una nueva aplicación utilizo el tipo de dato DATE de MySQL.

Si tenéis tablas de MySQL con un campo definido como INT 11 que guarda esta marca de tiempo, os recomiendo pasaros a DATE con estas sencillas instrucciones.

```sql
ALTER TABLE `horario` ADD `fecha2` DATETIME NULL AFTER `fecha`;
UPDATE horario SET fecha2 = FROM_UNIXTIME(fecha);
```

Simplemente añadir un nuevo campo al lado del campo que queremos cambiar y luego utilizar la función **FROM_UNIXTIME**

```sql
ALTER TABLE `horario` DROP `fecha`;
```

Finalmente podemos borrar el campo antiguo si estamos seguros del cambio.


Usar la función de MYSQL FROM_UNIXTIME para convertir la fecha UNIX_TIMESTAMP a Date

Convertir fecha UNIX_TIMESTAMP a fecha DATE

convertir-fecha-unix_timestamp-a-fecha-date


El siguiente código puede ser útil si por ejemplo tenemos una aplicación gráfica con un lienzo donde se pintan figuras y queremos exportar toda la imagen a un archivo externo como un PNG.

La función crea un buffer donde se almacena la imagen.

Los atributos **getWidth()** y **getHeight()** son el tamaño de la imagen. Pintamos un rectángulo en blanco del mismo tamaño que el lienzo, que será el color de fondo por defecto.

```java
public BufferedImage crearPNG() {
    BufferedImage bufferedImage = new BufferedImage(this.getWidth(), this.getHeight(), BufferedImage.TYPE_INT_RGB);
    Graphics2D g2 = bufferedImage.createGraphics();
    g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    g2.setColor(Color.white);
    g2.fillRect(0, 0, this.getWidth(), this.getHeight());
    // Aquí deberíamos introducir el código que queramos pintar.
    g2.dispose();
    return bufferedImage;
}
```

Una posible forma de exportar la imagen PNG sería utilizar la función write en un archivo file ya definido.

```java
try {
    ImageIO.write(crearPNG(), "png", file);
} catch (IOException ex) {
    
}
```

Estos sencillos pasos nos pueden ayudar a exportar imágenes creadas desde nuestros programas.


Código para crear una imagen PNG en un buffer para exportarla a un archivo

Crear imagen PNG para exportar con Java

crear-imagen-png-para-exportar-con-java


Netbeans es un editor para desarrollar aplicaciones Java y nos permite generar código de forma sencilla y rápida con unos simples clics.

## Generar código para atributos y métodos

En la programación orientada a objetos es común declarar variables de classe (también conocidas como atributos) como privadas y utilizar métodos públicos para tener acceso a estas variables desde otro contexto. A esto se le llama encapsulación de datos y es lo que en Java se conoce como la metodología "getter and setter".

Supongamos que tenemos una clase que representa a un objeto Mesa y tenemos algunos atributos a declarar como por ejemplo el color, la altura, el ancho de la mesa, etc. Con NetBeans sólo es necesario crear una nueva clase como esta:

```java
public class Mesa {

}
```

Luego pulsamos con el botón derecho dentro de la clase Mesa entre las llaves {} y pulsamos sobre Insert Code. Nos aparece otro menú y seleccionamos Add Property. Ahí ya podemos rellenar todos los datos del atributo como el nombre, el valor inicial, el tipo, si deseamos que sea public, private o protected, static o final. Seleccionamos también "Generate getter and setter". Y si queremos Javadoc también para que nos genere la documentación básica de los métodos.

Hemos usado como ejemplo el atributo ancho. Por defecto hemos puesto que valga 2.5 y de tipo double, privada y que genere los métodos de acceso. También hemos seleccionado que genere el código Javadoc. Podemos ver en la vista previa el resultado de nuestras modificaciones:

    private double ancho = 2.5;

    /**
     * Get the value of ancho
     *
     * @return the value of ancho
     */
    public double getAncho() {
        return ancho;
    }

    /**
     * Set the value of ancho
     *
     * @param ancho new value of ancho
     */
    public void setAncho(double ancho) {
        this.ancho = ancho;
    }

## Otras formas de generar código Java

Netbeans ofrece más posibilidades. Podemos por ejemplo seleccionar un bloque de código y en el margen del documento vemos como aparece una bombilla. Si pulsamos en ella nos aparece un conjunto de posibilidades que podemos seleccionar para alterar o generar código.


Cómo crear rápidamente código Java en Netbeans sin ningún esfuerzo

Todos los artículos