
Oracle permite gestionar excepciones. Las excepciones suelen producirse cuando hay un error en la ejecución de un bloque PL/SQL, y como en otros lenguajes de programación es posible manipularlas, ya sea interrumpiendo la ejecución o propagando la excepción para que se trate en otra parte del código.

## Sintaxis de excepción en Oracle

Un ejemplo de sintaxis podría ser este.

```sql
WHEN excepcion1 
  OR excepcion2 
THEN
  expression;

WHEN excepcion3 
  THEN expression;
  WHEN OTHERS 
  THEN
  expression;
```

Vemos que podemos especificar la excepción a tratar. WHEN OTHERS sirve para tratar el resto de excepciones sin especificar su nombre.

## Tipos de Excepciones PL/SQL

**Predefinida por Oracle**. Son las que ya vienen predefinidas por el servidor Oracle como por ejemplo.

- **ACCESS_INTO_NULL**. Un programa intenta asignar valores a atributos de un objeto no inicializado.
- **CASE_NOT_FOUND**. Ninguna de las posibilidades en una cláusula WHEN de una expressión CASE está seleccionada y no hay cláusula ELSE.
- **COLLECTION_IS_NULL**. Un programa intenta aplicar otros métodos diferentes de EXISTS a una tabla o array no inicializada.
- **CURSOR_ALREADY_OPEN**. Se intenta abrir un cursor ya abierto. Se debe cerrar siempre los cursores después de usarlos. Un bucle FOR siempre abre los cursores automáticamente.
- **DUP_VAL_ON_INDEX**. Duplicación de valores en una columna que contiene un índice único.
- **INVALID_CURSOR**. Operacion de cursor no permitida, como cerrar un cursor no abierto.
- **INVALID_NUMBER**. Conversion de un caracter a número fallida porque la cadena no representa un número válido.
- **LOGIN_DENIED**. Nombre de usuario y/o contraseñna inválida.
- **NO_DATA_FOUND**. Si un SELECT INTO no devuelve filas
- **NOT_LOGGED_ON**. Si no se está conectado a Oracle.
- **PROGRAM_ERROR**. Error interno de PL/SQL.
- **ROWTYPE_MISTMATCH**. Valores de retorno incompatibles.
- **SELF_IS_NULL**. Llamada al método de un objeto no inicializado.
- **STORAGE_ERROR**. PL/SQL se queda sin memoria, o la memoria se ha corrompido.
- **SUBSCRIPT_BEYOND_COUNT**. Un programa hace referencia a una tabla o array usando un índice mayour que el número de elementos que contiene.
- **SUBSCRIPT_OUTSIDE_LIMIT**. Un programa hace referencia a una tabla o array usando un índice fuera de rango.
- **SYS_INVALID_ROWID**. La conversion de cadena de texto a identificador de fila falla porque no representa un identificador de fila válido.
- **TIMEOUT_ON_RESOURCE**. Se supera el tiempo de espera máximo para el uso de un recurso.
- **TOO_MANY_ROWS**. Demasiadas filas devueltas.
- **VALUE_ERROR**. Error aritmético, de conversión o truncación.
- **ZERO_DIVIDE**. División por zero.

Ejemplo:

```sql
BEGIN
  SELECT ...;
    EXCEPTION
  WHEN ZERO_DIVIDE 
  THEN
    expression;
  DBMS_OUTPUT.PUT_LINE('La operación de ' || TO_CHAR(variable) || ' es inválida');
END
```

**No predefinida por Oracle**. Son las que no tienen un nombre asociado como las anteriores, pero sí un número. Por ejemplo para interrumpir en caso de una violación de integridad:

```sql
DECLARE
  nombreExcepcion EXCEPTION;
  PRAGMA EXCEPTION_INIT(nombreExcepcion, -2292);
  ...
  BEGIN
  ...
  EXCEPTION
  WHEN nombreExcepcion THEN
    DBMS_OUTPUT.PUT_LINE ('Excepción de integridad producida');
  ...
END;
```

**Definida por el programador**. Son las que pueden definir los programadores para gestionar los errores en su código.

```sql
DECLARE
nombreExcepcion EXCEPTION;

...
BEGIN
...
RAISE nombreExcepcion;
...
EXCEPTION
WHEN nombreExcepcion THEN
DBMS_OUTPUT.PUT_LINE('Se ha producido una excepción');
```

Esto son los tipos de excepciones que existen en PLSQL del servidor Oracle.


Tipos de excepciones en Oracle PLSQL y su sintaxis

Gestión de Excepciones en Oracle PL/SQL

gestion-de-excepciones-en-oracle-pl-sql


Hoy en día existe una gran cantidad de software libre para crear y gestionar contenido en internet sin la necesidad de tener grandes conocimientos de programación ni de administración de sistemas. Herramientas para la creación de blogs como [Wordpress](http://www.wordpress.org), o software para la creación de contenidos (CMS - Content Management Systems) como [Drupal](http://drupal.org/) son algunos ejemplos. Estas aplicaciones son altamente personalizables y flexibles y pueden sacarnos de un apuro, aunque como veremos también pueden meternos en algun otro.

Este artículo quiere mostrar las ventajas e inconvenientes que un servidor cree que ofrecen este tipo de soluciones cuando uno mismo es responsable de su creación, implantación y mantenimiento.

## Ventajas de usar Wordpress

**Sencillez de instalación**. Instalar una aplicación como Wordpress és muy sencillo, tan solo subiendo los archivos del programa a nuestro servidor y modificar algunos permisos bastará para que el instalador pueda hacer su trabajo y nos deje el servicio instalado.  
**Actualizaciones a sólo un clic**. Igualmente, hacer un upgrade del software, es decir, actualizarlo a la última versión no tiene dificultad.  
**Personalización**. Podemos bajar temas para Wordpress ya creados e introducirlos en nuestro blog desde el mismo panel de administración.  
**Herramientas extras**. Existen multitud de plugins para ofrecer funcionalidades extras a nuestro blog.

Todas estas posibilidades permiten que nos facilite mucho el trabajo de detrás del telón y nos podamos concentrar en generar contenido para el blog que es lo realmente útil para nuestros visitantes.

También ofrece herramientas como un editor que nos permitirá redactar artículos o entradas sin necesidad de saber HTML. Como si de un documento en Word se tratara podremos maquetarlo a nuestro gusto.

No hay que olvidar que además estos blogs permiten añadir comentarios a la gente. Esto es importante porque el visitante puede participar con el sitio y convertirse en un usuario habitual.

## Inconvenientes

**Riesgos potenciales de seguridad en scripts online**. Crear un servicio de este tipo siempre conlleva situaciones de riesgo si creas el software tu mismo, pero utilizar programas tan extendidos como WordPress o Drupal hace que cuando aparece un bug o vulnerabilidad, éste se extienda por la red en cuestión de horas o días y cualquiera que haya descubierto el error pueda aprovecharse para infiltrarse en tu servidor o causar daño con algun script.  
**Funcionalidades Extra**. Aunque sean aplicaciones que como hemos dicho traen una gran cantidad de plugins, es posible que la funcionalidad que nosotros deseamos no exista, entonces tendremos que adaptarnos a lo que haya o limitar nuestras espectativas. Además, los plugins tienen sus propios ciclos de desarrollo, por lo que también habrá que ir actualizando a distintas versiones de plugins cuando estos tengan bugs conocidos, o mejoras funcionales.  
**Spam en los comentarios**. Es cierto que en este aspecto se ha mejorado bastante. Plugins como Akismet, o sistemas CAPTCHA(escribir los números que aparecen en una imagen) nos permitirán tener a la gran mayoría de bots a raya, sin embargo, si tienes un blog popular siempre tendrás que echarle un ojo a los comentarios enviados por los usuarios. **Recursos del servidor**. Hoy en día Wordpress es una aplicación que ofrece cientos de posibilidades, y si nuestro blog crece es posible que necesitemos servidores dedicados con más RAM, y espacio de disco. Por lo tanto hay que prever también si nos convienen todas las posibilidades que nos ofrece el software o no.

## Conclusión

Utilizar este tipo de software es una buena solución, pero con algunos matices. Mi consejo es que si usáis Wordpress, Drupal o similares, siempre estéis atentos a las actualizaciones ya que los bugs de estos programas son los que habitualmente permiten a gente maliciosa acceder a tu servidor. No abandonéis este tipo de aplicaciones y menos si las hospedáis en servidores con otras webs, ya que puede ser peligroso.


Consejos a tener en cuenta al usar una aplicación para la generación de blogs como Wordpress

Ventajas e Inconvenientes de usar un blog como Wordpress

ventajas-e-inconvenientes-de-usar-un-blog-como-wordpress


En este artículo veremos cómo interactua un programa con dos procesos (threads) independientes que se van intercalando según el procesador los va ejecutando. También introduciremos el concepto de monitor para controlar procesos comunes.

```java
import java.util.logging.Level;
import java.util.logging.Logger;

public class Main {
    public synchronized static void main(String[] args) {
        Mensaje proceso1 = new Mensaje("hola", 100);
        proceso1.start();
        Mensaje proceso2 = new Mensaje("adiós", 100);
        proceso2.start();
    }
}
```

```java
class Mensaje extends Thread {

    private String texto;
    private int tiempo;

    public Mensaje(String texto, int tiempo) {
        this.texto = texto;
        this.tiempo = tiempo;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            try {
                System.out.print(texto + " ");
                sleep(tiempo);
            } catch (InterruptedException ex) {
                Logger.getLogger(PingPong.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }
}
```

Nos aparecerá por pantalla una cadena de texto del tipo: hola adiós hola adiós hola adiós hola adiós hola adiós hola adiós hola adiós adiós hola hola adiós hola adiós, intercalándose cada vez que se ejecute de forma distinta según el procesador vaya ejecutando los hilos. Podéis cambiar el tiempo entre que se lanza cada proceso para observar distintas ejecuciones.

## Monitores

En el caso anterior los dos procesos eran independientes, pero qué pasa si por ejemplo quisieramos que no se escribiera "adiós" si antes no hubiera un "hola" y viceversa? En ese caso habría que crear un Monitor.

Un monitor es una clase externa que sirve para controlar procesos que tienen elementos en común y en cierta forma tener un cierto control sobre qué proceso se puede o no ejecutar.

Para implementar el ejemplo propuesto veamos este ejemplo:

```java
import java.util.logging.Level;
import java.util.logging.Logger;

public class Main {

    public static void main(String args[]) {

        Monitor monitor = new Monitor();
        Escribir hola = new Escribir("hola", 0, monitor);
        hola.start();
        Escribir adios = new Escribir("adiós", 1, monitor);
        adios.start();
    }
}
```

```java
class Escribir extends Thread {

    private Monitor monitor;
    private String texto;
    private int orden;

    public Escribir(String texto, int orden, Monitor monitor) {
        this.texto = texto;
        this.monitor = monitor;
        this.orden = orden;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            try {
                monitor.escribir(texto + " ", orden);
                sleep((int) (Math.random() * 10));
            } catch (InterruptedException ex) {
                Logger.getLogger(PingPong.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }
}
```

```java
class Monitor {

    private int actual = 0;

    public synchronized void escribir(String texto, int orden) {

        while (orden != actual) {
            try {
                wait();
            } catch (InterruptedException ex) {
                Logger.getLogger(ProcesEscriure.class.getName()).log(Level.SEVERE, null, ex);
            }
        }

        System.out.print(texto);
        actual = (actual + 1) % 2;
        notifyAll();
    }
}
```

En este caso creamos la clase **Monitor** que contiene un entero que indica qué proceso se ejecutará. Como los dos procesos manejan datos en común, en este caso Monitor, es imprescindible usar la palabra clave **synchronized** para bloquear las posiciones de memoria que usa el método escribir. Luego dentro del while, pausaremos todos los procesos que no les toque ejecutarse. Y ya fuera del while cuando le toque ejecutarse el proceso correspondiente usaremos el método **notifyAll()** para despertar a todos los threads que estaban em modo espera.

De esta forma conseguimos un intercalamiento de palabras.


Ejemplo de programación concurrente en Java e introducción de cómo controlar procesos con monitores

Programación concurrente. Procesos en Java

programacion-concurrente-procesos-en-java


En este tutorial mostraremos cómo acceder a un archivo remoto en formato CSV extraer los datos y ponerlos en un array para manejarlos como nos convenga.

Los archivos CSV son un tipo de archivo utilizado para guardar información de una forma estructurada de una base de datos en un archivo. Principalmente se utiliza Microsoft Excel para generar estos archivos y es común que nos pasen datos en este tipo de archivo y tengamos que extraerlos.

Para ello PHP tiene funciones que nos facilitarán el trabajo.

## Función fgetcsv()

Lo que haremos será cargar el archivo y luego leer línea a línea para obtener la información.

```php
$archivo = fopen("archivo.csv");
while($linea = fgetcsv($archivo,0,",")){
  $columna1 = $linea[0];
  $columna2 = $linea[1];
  $columna3 = $linea[2];
  $columna4 = $linea[3];
}
fclose($archivo);
```

Es importante que en la función **fgetcsv()** además de pasarle el archivo CSV, le pasemos la cadena de texto que hace de delimitador. En este caso una coma.


Código para extraer información de un archivo CSV en PHP

Cargar archivo CSV con PHP

cargar-archivo-csv-con-php


## Protección de datos personales en las redes sociales online

## Las redes sociales

Desde que Internet se ha convertido en un medio de comunicación masivo utilizado por millones de personas, han aparecido miles de servicios en línea donde los usuarios se pueden registrar, crear un perfil público, plasmar sus datos personales e interactuar con otros usuarios. A estos servicios se les conoce como redes sociales online.

Este concepto de comunicación con otras personas a través de Internet no es nuevo. Servicios como [ClassMates](http://www.classmantes.com) (1995), o [Sixdegrees](http://www.sixdegrees.com) (1997-2001) entre otros fueron de los primeros. Sin embargo, hoy en día, servicios como Facebook (más de 300 millones de usuarios activos), MySpace, Hi5, LinkedIn, Twitter, etc, son de los más populares.

## Riesgos de las redes sociales

El uso de estas redes sociales comporta ciertos riesgos. Es por ello que organizaciones competentes nacionales e internacionales han elaborado normas de uso y recomendaciones para garantizar que el acceso por parte de los usuarios a estos servicios sea seguro.

Hay un conjunto de situaciones en las que se pueden poner en riesgo derechos y valores como la protección al honor, a la intimidad personal y familiar, y hasta a la propia imagen de los usuarios. Por ejemplo, cuando un usuario se da de alta a una red social, ha de prestar atención en configurar correctamente el nivel de privacidad de su perfil. También ha de procurar no publicar contenido que pueda afectar a la privacidad, tanto personal como de terceros.

Dado que un usuario puede publicar una gran cantidad de datos personales, sus perfiles se convierten en "identidades digitales" que podrían ayudar a conocer rápidamente los hábitos y preferencias del individuo. Si un tercero conociera estos datos, el usuario sería susceptible a riesgos como:

**Phishing**. Técnicas usadas para obtener números de tarjetas de crédito de los usuarios.

**Spam**. Envío de correos electrónicos masivos indeseados.

**Indexación no autorizada a los buscadores**. Indexación de datos personales por parte de los buscadores como Google, Yahoo, etc sin conocimiento del usuario.

**Accesos al propio perfil incontrolado**. Control de qué parte del perfil se desea que sea pública y qué parte privada.

**Suplantación de Identidad**. Se ha dado el caso de usuarios que se intentan registrar a redes sociales y observan que su nombre ya está registrado por personas que se hacen pasar por ellas.

**Instalación de cookies**. Inserción de cookies a los navegadores para controlar cómo se mueve el usuario dentro de las redes sociales o por Internet.

## ¿Cómo proteger los datos personales?

En este [documento](http://www.inteco.es/file/1000253719) del Instituto Nacional de Tecnologías de la Comunicación (INTECO) nos muestran detalladamente un conjunto de recomendaciones sobre cómo proteger los datos personales y la imagen individual en las redes sociales. Además de recomendaciones especiales para menores de edad.

## Código de buenas prácticas

Existe un documento llamado **Netiqueta: RFC 1855** que sirve como guía de buena educación en la red (Netiquette). Aun y siendo un poco antiguo (1995), todavía sirve como referente. Este documento detalla las normas básicas del comportamiento que debe adoptar una persona al usar Internet. Está pensado principalmente para introducir a los nuevos usuarios a la cultura de la Red.

La guía se puede dividir, principalmente, en varios apartados entre los que destacan:

1. **El Correo Electrónico.**. Se detallan un conjunto de buenas prácticas para enviar correo electrónicos como: enviar mensajes cortos, con buena presentación, con amabilidad, etc.

2. **Grupos de Noticias y Foros** Al unirte a una comunidad online con foros o grupos de noticias, siempre hay que intentar no publicar o preguntar sobre temas ya discutidos, por lo tanto, se recomienda no escribir mensajes compulsivamente y utilizar el buscador si es posible que la pregunta haya sido respondida con anterioridad. También se recomienda no escribir todo el texto en mayúsculas, no hacer publicidad (ni spam), etc.

3. **Chat (IRC)**. No escribir con colores ni en mayúsculas puesto que resulta molesto para los demás usuarios. Además se recomienda no inundar los canales con texto (lo que en inglés se conoce como flood).


Recomendaciones de seguridad y código de buenas prácticas en el uso de servicios de redes sociales online, foros y chats

Protección de datos en las redes sociales

proteccion-de-datos-en-las-redes-sociales


Este artículo va dirigido a personas que nunca hayan usado ningún lenguaje de programación y quieran aprender cómo se hace para crear un programa en Java. Este mini curso Java nos permitirá conocer los programas necesarios para crear nuestra primera aplicación.

Java es un lenguaje de programación que ha ganado una gran popularidad en la última decada. Sus principales características son que es un lenguaje orientado a objetos, que es multiplataforma (se puede ejecutar en una gran variedad de sistemas operativos como Windows, Linux, Mac's, etc), se aprende fácilmente y se pueden desarrollar grandes aplicaciones. Java puede ser útil para aplicaciones de escritorio, aplicaciones de comunicaciones entre clientes y servidores, etc. Sin embargo es un lenguaje que trabaja a muy alto nivel por lo que actualmente es complicado desarrollar aplicaciones que trabajen con muchos datos como por ejemplo juegos.

## ¿Qué programas se necesitan?

**JAVA JDK** (Java development kit) es un conjunto de programas esencial para desarrolladores que nos permitirán compilar y ejecutar nuestras aplicaciones. Para entendernos, es un KIT de aplicaciones que transformarán nuestro código a un lenguaje que nuestro sistema entienda y pueda ejecutar. Tenemos un tutorial completo sobre cómo [Instalar Java](http://www.webtutoriales.com/tutoriales/programacion/java/descargar-instalar-java.17.html).

**NetBeans** es el entorno de programación que usaremos para codificar nuestros programas. Es común llamar a este tipo de programas IDE (Integrated Development Enviroment) o entorno de desarrollo en español. Son editores que permiten escribir nuestro código y generar la aplicación. Hay bastantes programas de este tipo, algunos gratuitos como el mismo NetBeans y Eclipse y otros de pago IntelliJ. Aunque técnicamente es posible escribir un programa con un editor de texto como por ejemplo el Bloc de Notas de Windows y luego compilarlos y ejecutarlos desde la línea de comandos manualmente, estos IDEs añaden un sinfín de posibilidades como por ejemplo: Compilar y ejecutar el programa solo pulsando un botón, añadir puntos de control del código para debuguear (seguir los pasos del programa para encontrar errores), assistencia al escribir código (autocompletar), generación automática de código, análisis de la sintaxis, formato del texto, etc...

Podemos descargar [NetBeans](http://www.netbeans.org/downloads/) desde su página oficial. Al ser NetBeans un (cada día más) notable entorno de desarrollo, es posible utilizarlo para muchas otras cosas además de Java. Sin embargo, ahora mismo descargaremos la version JAVA SE que es la más básica y sirve sólo para aplicaciones Java de escritorio. En el momento de escribir era la versión Netbeans 6.7.1 y ocupaba sobre 47 MB

Es esencial tener instalado JAVA JDK antes que el editor NetBeans ya que éste requiere del primero para funcionar correctamente. Durante la instalación de NetBeans, este buscará automáticamente la ruta en dónde se ha instalado Java. Normalmente del estio C:\\Program Files\\Java\\jdk1.6.0_13 (o la versión del jdk que tengamos).

## Crear un nuevo proyecto con NetBeans

Netbeans funciona por proyectos. Un proyecto NetBeans es una estructura de archivos y directorios pensados para guardar nuestra aplicación.

Si es la primera vez que abres NetBeans te parecerá un poco complicado y difícil familiarizarte con las posibilidades del editor. Pero para crear un nuevo proyecto simplemente hay que ir a File > New Project. En la ventana que se abre seleccionamos Java Application y le damos a Next. Como ProjectName ponemos el nombre de la aplicación, y podemos cambiar la ruta donde se guardará si lo deseamos. Seleccionamos la opción Create Main Class y Set as Main Project. La Main Class será el archivo principal que se ejecutará cuando abramos la aplicación. Finalmente le damos a finish y se creará el proyecto con el archivo Main.java (si no le hemos cambiado el nombre).

El contenido del archivo Main.java se parecerá a este:

```java
/* *To change this template, choose Tools | Templates* and open the template in the editor.
*/

package javaapplication1;

/** @author
*/
public class Main {
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
    }
}
```
## Compilar la primera aplicación

Tal y como está este código ya se puede compilar y ejecutar la aplicación pulsando el botón con el símbolo de PLAY en la barra de iconos (O pulsando en la barra de herramientas Run > Run Main Project). Si le damos, se ejecutará el programa, sin embargo como es un programa vacío, no veremos nada.

Ahora vamos a hacer que imprima por pantalla la frase "Hola mundo!". Con una instrucción de Java llamada System.out.println(). Volvemos a escribir todo el código para que veas los cambios.

```java
/* *To change this template, choose Tools | Templates* and open the template in the editor.
*/

package javaapplication1;

/** * * @author
*/
public class Main {
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        System.out.println("Hola mundo!");
    }
}
```

Como vemos la estructura de un programa principal siempre empieza dentro del método **public static void main**.

Ahora al ejecutarlo deberías ver por pantalla la frase Hola Mundo.

Bueno esto es todo por el momento. Este tutorial ha pretendido ser muy básico para usuarios no iniciados. Si has tenido algun problema no dudes en usar el formulario de contacto para transmitirnos tus dudas.


Tutorial básico para crear una primera aplicación en Java con NetBeans

Aprender Java

aprender-java


En este tutorial se mostrará cómo se pueden comunicar dos programas executados en distintos equipos mediante sockets utlizando Java.

Un socket (o puerto) es un punto de comunicación entre sistemas que corresponde al dispositivo físico d'entrada/salida de una máquina. Bàsicamente, existen dos tipos de protocolos para establecer conexiones entre varios equipos: TCP y UDP.

TCP, (Transmission Control Protocol) y UDP (User Datagram Protocol). Para entendernos, TCP es un protocolo en el que hay un proceso de negociación (handshaking) entre los afectados cliente y servidor y de cómo se envían los datos, si se han recibido bien, etc. Mientras que UDP es un servicio en el que los datos se van enviando y recibiendo sin ese acuerdo. De forma que UDP es un sistema de comunicación más rápido en una red en la que se pierdan pocos paquetes.

En este caso utilizaremos el protocolo TCP para crear un servidor y un cliente que se comuniquen.

## Cliente

En el código del cliente al crear el socket debemos especificar a qué ip nos conectaremos y a qué puerto. Hay algunos puertos reservados por lo que siempre miraremos de escoger uno bastante alto. En este caso 10831.

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

public class Cliente {

    public static void main(String[] args) {
        try {
            Socket canalComunicacion = null;
            OutputStream bufferSalida;
            DataOutputStream datos;
            canalComunicacion = new Socket("127.0.0.1", 10831);
            bufferSalida = canalComunicacion.getOutputStream();
            datos = new DataOutputStream(bufferSalida);
            String mensaje = "Hola Mundo!\\n";
            for (int i = 0; i < 10; i++) {
                datos.writeUTF(mensaje);
            }
            datos.writeUTF("");
            datos.close();
            bufferSalida.close();
            canalComunicacion.close();
        } catch (UnknownHostException ex) {
            Logger.getLogger(Cliente.class.getName()).log(Level.SEVERE, null, ex);
        } catch (IOException ex) {
            Logger.getLogger(Cliente.class.getName()).log(Level.SEVERE, null, ex);
        }

    }
}
```
## Servidor

Para que el cliente encuentre el servidor hay que especificar el mismo puerto.

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

public class Servidor {

    public static void main(String[] args) {
        try {
            ServerSocket puerto = null;
            Socket canalComunicacion = null;
            InputStream bufferEntrada;
            DataInputStream datos;
            puerto = new ServerSocket(10831);
            canalComunicacion = puerto.accept();
            bufferEntrada = canalComunicacion.getInputStream();
            datos = new DataInputStream(bufferEntrada);
            String cadena = new String(datos.readUTF());
            while (cadena.length() > 0) {
                System.out.print(cadena);
                cadena = datos.readUTF();
            }
            datos.close();
            bufferEntrada.close();
            canalComunicacion.close();
        } catch (IOException ex) {
            Logger.getLogger(Servidor.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
}
```

Finalmente para ver que hay una comunicación procedemos a ejecutar el servidor y luego el cliente. Veremos que se imprimirá por pantalla la cadena pasada por el cliente sólo si el servidor se está ejecutando.


Sencillos pasos para transferir datos entre un cliente y un servidor en Java mediante el protocolo TCP

Comunicación cliente-servidor en Java

comunicacion-cliente-servidor-en-java


En algunas situaciones nos puede interesar que un usuario dentro de nuestro programa pueda escribir código en Java y este se compile y ejecute en tiempo real, sin que el usuario tenga que realizar todos los pasos (algunos sencillos pero farragosos) para poder ejecutar su código, como guardarlo en un archivo compilar y luego ejecutar manualmente.

Java 6 incorpora una API para realizar este tipo de compilaciones dinámicas en tiempo real. Lo que en inglés se conoce con la expresión "on the fly" (al vuelo).

## Janino API

Esta API permite realizar esta tarea, sin embargo con algunos inconvenientes. El principal es que es necesario añadir el archivo tools.jar ya que JRE no viene por defecto con un compilador. Esto añade de golpe 12MB de tamaño más para nuestro proyecto. Además, la API necesita mucho código para lo que en definitiva tendría que ser sencillo para una librería, que es pasarle una String, compilar y ejecutar.

Sin embargo, existe una herramienta llamada [Janino](http://www.janino.net/) que permite hacer esto y mucho más. La API es un jar que actualmente pesa menos de 500kb y además es de código abierto. Esta librería ofrece más ayuda sobre para compilar y ejecutar dinámicamente código Java en tiempo real sin necesidad de implementar más código ni estructuras de datos.

Veamos un ejemplo que nos permite, a partir de un String que contiene una clase, compilarlo y crear una nueva instancia del objeto creado en tiempo real.

```java
public void compilar(String javaSource){
    try {
        SimpleCompiler compiler = new SimpleCompiler();
        compiler.cook(new StringReader(javaSource));
        Class cl = compiler.getClassLoader().loadClass("Nombredelaclase");
        NuestroObjeto objeto = (NuestroObjeto) cl.newInstance();
    } catch (Exception e) {
        System.err.println(e.getMessage());
        e.printStackTrace();
    }

}
```

Por su puesto, en este ejemplo sería necesario que la clase que cargamos extienda la clase NuestroObjeto. Por ejemplo, el contenido de la variable javaSource que le pasamos por parámetro podría ser:

```java
class Nombredelaclase extends NuestroObjeto{
    ...
}
```

Sencillo no?, tan sólo 4 líneas. En este caso hemos compilado una clase entera, pero también podríamos usarlo para evaluar expresiones Java. Podemos encontrar más ejemplos en la página principal de [Janino](http://www.janino.net/download.html#examples).

## Desventajas de Janino

Si hasta ahora hemos defendido esta API, también debemos decir que tiene algunos inconvenientes. Actualmente, la versión 2.5.* sólo es compatible con la versión 1.4 de JDK, es decir, que programas que utilizen funcionalidades de Java 5 y Java 6 no se podrán compilar. Aunque esto puede parecer un gran inconveniente, para la mayoría de casos la simplicidad de uso de la API cubrirá este contratiempo.


API para compilar y ejecutar código Java en tiempo real

Compilar Java en tiempo real

compilar-java-en-tiempo-real


Memcached es una libreria que sirve para guardar en memoria objetos de la base de datos agilizando y reduciendo el número de peticiones que se realizan.

## Instalar Dependencias

Memcached necesita de esta librería que podemos descargar en monkey.org, es posible que haya versiones más actuales. Pero con la 1.3 ya vamos bien.

```bash
wget http://monkey.org/~provos/libevent-1.3e.tar.gz
tar zxpfv libevent-1.3e.tar.gz
cd libevent-1.3e
./configure
make install
```

## Instalar Memcached

```bash
wget http://memcached.googlecode.com/files/memcached-1.2.8.tar.gz
tar zxpfv memcached-1.2.8.tar.gz
cd memcached-1.2.8
./configure
make install
```

Crear el usuario con el que se ejecutará el daemon memcached llamado con el mismo nombre.

```bash
adduser memcached
```

Para acceder a memcached desde cualquier sitio y poder ejecutar luego el daemon.

```bash
ln -s /usr/local/lib/libevent-1.3e.so.1 /lib/
```

Por ejemplo para arrancar una instancia del daemon: En este ejemplo asignamos 50 MB de memoria ram, desde el ip localhost y con el puerto recomendado 11211.

```bash
memcached -u memcached -d -m 50 -l 127.0.0.1 -p 11211
```

Para ver que funciona podemos abrir otra consola y ejecutar un telnet en el puerto 11211.

```bash
telnet 127.0.0.1 11211
```

Por supuesto también podemos ver que se está ejecutando en el sistema.

```bash
ps aux | grep memcached
```

Ahora memcached ya funciona correctamente por si solo. A continuación veremos cómo configurarlo para que funcione en PHP y luego como hacer que se ejecute siempre al arrancar el servidor.

## Instalar la extensión memcache en PHP

No confundir con la extensión memcached que también está en [http://pecl.php.net](http://pecl.php.net). Al momento de escribir esta guía la versión estable era la 2.2.5.

```bash
wget http://pecl.php.net/get/memcache
tar zxvf memcache-2.2.5.tgz

cd memcache-2.2.5

./configure
make
make install
```

En el archivo php.ini debemos habilitar la extension añadiendo la siguiente línea en el apartado de extensiones.

```
extension=memcache.so
```

Luego reiniciamos el servidor Apache

```bash
/etc/init.d/httpd restart
```

Ya podemos ver en el php.ini que aparece la extensión instalada.

## Arrancar memcached cuando inicie el sistema

Hay que crear un script de inicialización en la carpeta /etc/init.d llamado por ejemplo memcached. Este script lo configuraremos para poder configurarlo con el **chkconfig**. Dentro escribimos:

#!/bin/bash

#

# memcached Script de inicio para Memcached

#

# chkconfig: 235 95 16

# description: memcached

# processname: memcached

PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr:bin
memcached -u memcached -d -m 50 -p 11211

Ahora cambiamos los permisos de este archivo para que sea ejecutable.

```bash
chmod 755 memcached
```

Finalmente lo agregamos a la lista de servicios de chkconfig:

```bash
chkconfig --add memcached
chkconfig --list memcached
```

Y ya podemos reiniciar el servidor. Cuando haya reiniciado veremos, utilizando el comando siguiente:

```bash
ps aux | grep memcached
```

que ya se ejecuta por si sola una instancia del demonio.


Instalar Memcached

instalar-memcached


## ¿Qué es un GNA?

Un GNA (Generador de números aleatorios) es un programa que crea números de de forma aleatoria. En informática comúnmente se usan algoritmos pseudoaleatorios, es decir, programas que a partir de una semilla (un número), crea una secuencia de números.

Posiblemente, el algoritmo de números pseudoaleatorios más extendido sea el Congruencial. En este artículo veremos una modificación del mismo. Se generarán 3 congruenciales. El primero servirá para decidir cual de los dos siguientes usar.

## Semillas que pasan los tests

Existen varias pruebas o tests para determinar si un algoritmo es pseudoaleatorio. En nuestro ejemplo se han pasado los tests de Frecuencias, Serie, GAP, Yule-Walker, Distancias, Autocorrelación (casi todas las celdas), Kolmogorov, Maxmin-up y Maxmin-down. Por lo que podemos afirmar que es un algoritmo aceptablemente bueno.

A continuación se muestra un conjunto de 5 semillas que pasaron los tests:

```java
c1 = new congruencial(2147483647,8363,13259,45646);
c2 = new congruencial(2147483647,94781,52859528,4420567);
c3 = new congruencial(2147483647,86341,33107542,33107);

c1 = new congruencial(2147483647,2441,19183,437693);
c2 = new congruencial(2147483647,403681,486641,42773);
c3 = new congruencial(2147483647,449851,611549,14087);

c1 = new congruencial(2147483647,2441,19183,437693);
c2 = new congruencial(2147483647,548489,486641,42773);
c3 = new congruencial(2147483647,562753,611549,611953);

c1 = new congruencial(2147483647,376891,19183,437693);
c2 = new congruencial(2147483647,548489,486641,467353);
c3 = new congruencial(2147483647,562753,611549,611953);

c1 = new congruencial(2147483647,3498013,3552463,437693);
c2 = new congruencial(2147483647,4050589,3938927,3722491);
c3 = new congruencial(2147483647,3621617,3574819,3498419);
```

## Programa generador de números pseudoaleatorios en Java

Este programa genera una secuencia de 3000 números pseudoaleatorios. Para obtener distintas tiras de números basta con cambiar las semillas que se han especificado anteriormente.

```java
public class Composite {

    private congruencial c1;
    private congruencial c2;
    private congruencial c3;

    private double [] vector;
    private int index;

    public Composite() {
        index = 0;
        c1 = new congruencial(2147483647,8363,13259,45646);
        c2 = new congruencial(2147483647,94781,52859528,4420567);
        c3 = new congruencial(2147483647,86341,33107542,33107);

        vector = new double[3000];

        for (int i=0; i < vector.length; i++){
            vector[i] = c1.next();
        }
    }
    public double next(){
        if(vector[index] > 0.5){
            return c2.next();
        } else {
            return c3.next();
        }
    }

    public congruencial getC1() {
        return c1;
    }

    public congruencial getC2() {
        return c2;
    }

    public congruencial getC3() {
        return c3;
    }

    class congruencial{
       private int m;
       private int a;
       private int c;
       private int seed;
       private double prev=0;

       public congruencial(int m, int a, int c, int seed){
           this.m = m;
           this.a = a;
           this.c = c;
           this.seed = seed;
       }

       public double next(){
           prev = (a * prev + c )%m;
           return  prev/m;
       }
    }

    public static void main(String [] args){
        Composite composite = new Composite();
        for (int i=0; i < 3000; i++){
            System.out.println(composite.next());
        }
    }
}
```

Si deseamos usar este algoritmo en otros programas podemos utilizar la función .next() que nos devuelve el siguiente número de la tira generada.


Programa generador de números pseudoaleatorios en Java

Generador de números pseudoaleatorios

generador-de-numeros-pseudoaleatorios


## Descargar CentOS 5.3 Server

Se puede descargar el servidor [CentOS](http://isoredirect.centos.org/centos/5/isos/i386/) en esta url. Algunos mirrors ofrecen la versión completa en DVD "CentOS-5.3-i386-bin-DVD.iso", sino también se pueden descargar los 6 cds (de CentOS-5.3-i386-bin-1of6.iso hasta CentOS-5.3-i386-bin-6of6.iso)

## Configuración de la Instalación de CentOS 5.3 Server

Arrancamos el sistema con el CD 1, o con el DVD y nos aparece la pantalla principal de CentOS. Para instalar pulsamos enter.

A continuación nos pregunta si deseamos testear los CDS, pero podemos pulsar Skip.

Llegamos a la pantalla de instalación de CentOs. Pulsamos Next. Selecionamos el idioma, y después el idioma del teclado.

Ahora nos pide si deseamos borrar la información del disco que estamos instalando. Como es una instalación de 0 pulsamos que si (atención:se borrarán todos los datos si había).

Seguidamente hay que particionar el sistema. Seleccionamos "Suprimir particiones de Linux en dispositivos seleccionados y crear diseño predeterminado". Si nos interesa cambiar las particiones ahora es el momento, pero por las que nos dan por defecto ya van bien. Al pulsar Siguiente nos pide confirmación y seleccionamos si.

En las opciones de configuración de la red usaremos IP's estáticas. Para ello hay que pulsar el botón Modificar en Network Devices y seleccionar dentro de Enable IPv4 support, manual configuration. Dentro de este campo IP Adress ponemos por ejemplo **192.168.0.100** y como máscara de red **255.255.255.0**. Podemos desactivar la opción Enable IPv6 support.

Como nombre de host ponemos un nombre del tipo: **servidor.dominio.com**. Como Gateway 192.168.0.1, como Primary y Secondary DNS por el momento usaremos el mismo ip que el servidor 192.168.0.100

Tras pulsar siguiente, seleccionamos la zona horaria correspondiente y después nos pedirá la root password.

Ahora hay que decirle que aplicaciones queremos que instale. Como en un servidor necesitamos los máximos recursos de memoria y disco disponibles sólo instalaremos lo esencial. No instalaremos ni siquiera entorno de escritorio. Por lo tanto deseleccionamos Desktop - Gnome y pulsamos solamente en la opción de Server. También marcamos la casilla "personalizar ahora" y le damos a siguiente.

Dentro de **Aplicaciones** seleccionamos editores, Internet basada en texto. Dentro de **Desarrollo** Bibliotecas de Desarrollo, Herramientas de Desarrollo. Dentro de **Servidores** seleccionamos Servidor de Nombres DNS, servidor FTP, Servidor de Correo, Base de datos MySQL, Herramientas de Configuración del Servidor, Servidor Web. Dentro de **Sistema Base** seleccionamos Base, Herramientas de Administración y Herramientas del Sistema.

Tras unos segundos de espera en la que el instalador busque dependencias de los programas que instalaremos, pulsamos siguiente y empieza la instalación.

Para finalizar pulsamos reiniciar y quitamos el CD o DVD.


Guía paso a paso para instalar el servidor linux CentOS 5.3

Instalar CentOS 5.3 Server

instalar-centos-5-3-server


## Generar el abecedario en PHP

El siguiente código genera las letras del abecedario en PHP.

```php
for ($i=65; $i <= 90; $i++) {
  echo chr($i);
}
```

El ejemplo es muy sencillo. Lo único que se hace es recorrer los caracteres utilizando el código ASCII de cada letra. Teniendo en cuenta que el número 65 corresponde a la A mayúscula y el 90 a la Z.

## Intercambiar de mayúsculas a minúsculas un caracter

Si se desea modificar el caracter de mayúsculas a minúsculas, se puede utilizar también la numeración de los caracteres ASCII, utilizando la función ord() que devuelve el número entero que identifica el caracter:

```php
$distancia = abs(ord('a')-ord('A'));
for ($i=65;$i<=90;$i++) {
  echo chr($i)." ".chr(abs($i+$distancia))."  ";
}
```

En la variable $distancia guardamos la distancia que hay entre la A mayúscula y minúscula y utilizamos el valor abs para obtener el valor absoluto (sin signo negativo). Tanto la distancia como el orden se pueden consultar en la tabla ascii y poner los números directamente, pero así demostramos que se puede hacer sin tablas.


Ejemplo para generar el abecedario en PHP utilizando el código ASCII

Generar las letras del abecedario en PHP

generar-las-letras-del-abecedario-en-php


## ¿Qué es un cursor?

En el lenguaje SQL existen unos tipos de controles llamados cursores que son útiles para recorrer los registros que devuelve una consulta. Este tipo de estructuras sólo deben utilizarse cuando no haya otra forma de manipular conjuntos de datos en una sola instrucción.

## Ejemplo de cursor en MySQL

Cada base de datos tiene su forma de declarar un cursor e incluso sus propios tipos de cursores (Oracle PL/SQL, Transact, etc). En este caso nos detendremos a ver cómo es la sintaxis para definir un cursor en MySQL.

```sql
DELIMITER ;;
DROP PROCEDURE IF EXISTS `micursor`;;
CREATE PROCEDURE `micursor`()
BEGIN

DECLARE done BOOLEAN DEFAULT FALSE;
DECLARE uid integer;
DECLARE newdate integer;

DECLARE c1 cursor for SELECT id,timestamp from employers ORDER BY id ASC;
DECLARE CONTINUE HANDLER FOR SQLSTATE '02000' SET done = TRUE;

open c1;
c1_loop: LOOP
fetch c1 into uid,newdate;
IF `done` THEN LEAVE c1_loop; END IF;
UPDATE calendar SET timestamp = newdate WHERE id=uid;
END LOOP c1_loop;
CLOSE c1;
END ;;
```

Este cursor en concreto se podría realizar con una única consulta UPDATE, pero sirve para ver cómo se declara en la sintaxis de MySQL.

Como delimitador se ha usado el doble punto y coma (;;), se puede utilizar cualquier otro, pero deberás sustituirlo en todos los sitios.

Básicamente se declaran dos variables uid y newdate que contendrán el valor de cada campo de la fila. Luego se define el cursor mediante una consulta SQL (es como si se creara una tabla temporal). Finalmente, se recorre el cursor y se aplica la operación adecuada según nuestro programa.

## ¿Cómo ejecutar un cursor?

Para ejecutar el cursor podemos usar el método call:

```sql
call timechange();
```

Para guardar el cursor o llamarlo, se puede ejecutar desde el propio programa, utilizando phpMyAdmin, la consola de mysql o MySQL Query Browser por ejemplo.


Ejemplo de cómo se declara un cursor en MySQL

Cursor MySQL

cursor-mysql


En este tutorial veremos cómo crear un formulario de contacto en PHP. Al finalizar, los usuarios podrán rellenarlo y recibiremos sus comentarios por email.

## Formulario HTML

Crearemos un archivo llamado contactar.php que contendrá el formulario de contacto en HTML.

```html
<form action="contactar.php" method="post">
  <p>
    <label for="mensaje">Mensaje</label>
    <textarea name="mensaje"></textarea>
  </p>
  <p>
    <input type="submit" value="Enviar" />
    <input name="accion" type="hidden" value="enviar_comentario" />
  </p>
</form>
```

En el tag form de html definiremos el método de envío del formulario a **POST**. También es importante que en el atributo action escribamos el nombre del archivo que se ejecutará cuando el usuario haga clic en el botón de envío. En este caso llamaremos el mismo archivo en el que estamos **contactar.php** (Aunque no es obligatorio, nuestro script PHP para procesar el formulario también se encontrará en el mismo archivo que el formulario).

Finalmente definiremos un campo invisible "hidden", de nombre accion y valor enviar_comentario que servirá para controlar que el usuario haya ejecutado el formulario.

## Script PHP

Primero comprobaremos que la variable acción (La que habíamos añadido en modo invisible en el formulario HTML) tenga valor. Si lo tiene ya podemos procesar los datos y enviar el comentario a una dirección de correo que queramos.

```php
if(isset($_POST['accion']) && $_POST['accion']=="enviar_comentario"){
  $mensaje = addslashes($_POST['mensaje']);
  if (mail("tuemail@email.com","Formulario de Contacto",$mensaje)) {
    echo "Gracias por enviar el email, pronto lo leeremos.";
  } else {
    echo "No se pudo enviar el email.";
  }
} else {
    // Aquí va el formulario HTML
}
```

## Código Completo

A continuación mostramos el código completo del script para un formulario de contacto.

```php
<?php
if (isset($_POST['accion']) && $_POST['accion']=="enviar_comentario") {
  $mensaje = addslashes($_POST['mensaje']);
  if (mail("tuemail@email.com", "Formulario de Contacto", $mensaje)){
    echo "Gracias por enviar el email, pronto lo leeremos.";
  } else {
    echo "No se pudo enviar el email.";
  }
} else {
?>
  <form action="contactar.php" method="post">
    <div>
      <label for="mensaje">Mensaje</label>
      <textarea name="mensaje"></textarea>
    </div>
    <div>
      <input type="submit" value="Enviar" />
      <input type="hidden" name="accion" value="enviar_comentario">
    </div>
  </form>
<?}?>
```

Si todo ha salido correctamente, se habrá enviado un email a la cuenta correspondiente con el mensaje entrado.


Script en PHP para recibir comentarios de tus visitantes

Formulario de contacto en PHP

formulario-de-contacto-en-php


Uno de los factores más importantes al crear o mantener una web es tener un dominio propio.

## Dominios gratis ¿es una buena idea?

Sin duda, obtener un dominio gratis puede parecer bueno. Sitios como [Dot.tk](http://www.dot.tk/es/index.html?lang=es) te permiten tener tu propio dominio con la extensión **dominio.tk**. Pero dejadme explicaros algunos de los motivos de porqué no es muy buena idea utilizar un dominio grauito para acceder a tu sitio web.

Quizá lo más destacable es que no eres el dueño real del dominio. Es posible que estos servicios realmente sean gratuitos y ofrezcan lo que prometen, pero quien puede estar seguro que mañana seguirán siendo operativos?

Otra razón, también ligada con la anterior, es que puede que el dominio gratuito funcione a la perfección y nuestra web se haga popular. Perder el dominio gratuito también acarrearía perder todas las visitas.

Si eres principiante en la creación de páginas web, o quieres dominios para hacer pruebas, entonces si que es recomendable usar dominios gratis, pero mi recomendación es poseerlos realmente cuanto antes.

## ¿Debería comprar un dominio?

Si con los anteriores argumentos aun no tienes claro si debes o no comprar un dominio, permíteme comentar algunos casos más.

Si eres una empresa, un dominio a tu nombre es "obligatorio" para dar credibilidad a tus clientes sobre tu negocio.

Tener un dominio relacionado con el nombre de tu empresa ayudará a la gente a relacionarlo con los productos que vendas.

Si te planteas hacer una web seriamente, tener un dominio propio es el primer paso fidelizar a tus visitantes.

## Registrar un Dominio

Hay una organización a nivel mundial llamada InterNIC encargada de gestionar los dominios llamados _top level_ (.com, .net, .org, ...). Esta organización otorga permisos a otras empresas para vender los dominios. Para los demás dominios (.es, .co.uk, etc) hay otras organizaciones que se encargan de gestionarlos y a su vez dan permisos a empresas para venderlos. Por ejemplo: el caso de los dominios .es, es gestionado por [red.es](http://www.red.es) mientras que los dominios .cat los gestiona [puntcat](http://www.puntcat.cat/)

Si deseas obtener un dominio, deberás ir a una empresa con permiso de registro, escoger un nombre **unnombrededominiocualquiera.com** y pagar una tasa de registro de unos 8-10$ dólares (8-9€) al año. Los precios pueden variar, según las fluctuaciones del mercado y la empresa donde lo contrates, pero es un precio más que asequible.

Una vez tengas tu dominio, lo más importante es renovarlo antes de que caduque sino podrías perderlo.


Pasos para registrar un dominio (.com, .net, .org,...) en internet

¿Cómo registrar un dominio?

como-registrar-un-dominio


A veces, a partir de un texto normal y corriente queremos pasarlo a HTML. Por ejemplo: Si tenemos un texto que contiene una dirección url del tipo "http://www....", tal vez nos interese modificarlo y convertirlo a HTML válido: <a href="http://www...">http://www...</a>

Con esta sencilla función podemos modificar un texto plano en ASCII:

```php
function ASCIIaHTML($texto) {
$texto = htmlentities($texto);
$partes = split("\\n\\n",$texto);
  for ($i = 0, $j = count($partes); $i < $j; $i++) {
  $partes[$i] = preg_replace("/((http:\\/\\/[^\\s&]+)/", "[$1](<)",$partes[$i]>);
  $partes[$i] = "".$partes[$i].""; } return join("\\n\\n",$partes);
}
```

Básicamente, el código reemplazará urls a html, pero utilizando la función preg_replace, podemos agregar cualquier tag que queramos.


Convertir texto plano ASCII en HTML formateado con PHP

Convertir código ASCII a HTML en PHP

convertir-codigo-ascii-a-html-en-php


En este sencillo tutorial veremos el código necesario para colorear celdas, filas o columnas de una datagridview según sus valores cambiando el color de fondo.

Suponemos que ya tenemos una datagrid con datos obtenidos, por ejemplo, desde una base de datos.

```vb
Private Sub DataGridView_CellFormatting(ByVal sender As Object, ByVal e As System.Windows.Forms.DataGridViewCellFormattingEventArgs) Handles DataGridView.CellFormatting
Try
    If Me.DataGridView.Columns(e.ColumnIndex).Name = "DataGridViewTextBoxColumn7" Then
        If e.Value IsNot Nothing Then
            Dim valor As Integer = CType(e.Value, Integer)
                If (valor >= 100) Then
                    e.CellStyle.BackColor = Color.Yellow
                End If
            End If
        End If
    Catch ex As Exception
        MsgBox(ex.Message)
    End Try
End Sub
```

Si deseamos colorear alguna casilla o celda según su valor, debemos llamar al método CellFormatting del objeto DatagridView. Este método se llama cada vez que se pinta la celda por pantalla.

A continuación, comprobaremos que el nombre de la celda coincide con el nombre de la columna, y si es el caso, procederemos a obtener el valor que hay en ese campo. Es importante convertir el tipo de dato que contiene la celda al tipo que nosotros deseemos con el método **CType("valor", tipo)**, ya que sinó saltará una excepción.

En nuestro ejemplo, se comprobará si la celda contiene un entero mayor o igual a 100. Si es el caso, pintaremos la casilla de color amarillo.


Cómo colorear celdas de una tabla (datagridview) en VB.NET

Colorear celdas de una tabla en VB.NET

colorear-celdas-de-una-tabla-en-vb-net


En el diseño de cualquier web tarde o temprano tendremos que trabajar con imágenes y si eres nuevo en esto, es posible que te hayas preguntado qué es mejor, guardar una imagen en formato .GIF o .JPG (o .jpeg).

Antes que nada, hay que aclarar que hay otros muchos formatos como bitmaps (.bmp), .webp, etc. Sin embargo los más usados son los GIFs y JPGs.

## Diferencia entre GIF y JPG

La principal diferencia entre estos formatos de imagen es el algoritmo de compresión que utilizan, así como el número de colores máximos que pueden usar. De esta forma, una imagen GIF no podrá contener más de 256 colores. El formato JPG permite muchísimos más colores, haciéndolo ideal para mostrar fotografías o imágenes grandes con muchos colores.

## ¿Cuando usar GIFs? y ¿Cuándo usar JPEG?

Es recomendable utilizar imágenes .gif siempre que se pueda antes que .jpg para el diseño de páginas web por los siguientes motivos:  
\- Los .gif siempre ocuparán menos espacio, lo que hará que se carguen muchísimo más rápido y nos ahorrará ancho de banda. - Utilizar .jpg para fotografías en la que no se quiera perder calidad la calidad de la fotografía.


Diferencia entre formatos de imagen GIF y JPG

Utilizar imágenes GIF o JPG

utilizar-imagenes-gif-o-jpg


## Función strtotime

La forma más sencilla de comparar dos fechas es utilizando la función de PHP strtotime que convierte una fecha escrita en una cadena correctamente formateada a un UNIX timestamp, que es como estos sistemas operativos interpretan las fechas (en segundos). Utilizar esta función conlleva un serio problema que veremos más abajo.

$fecha_actual = strtotime(date("d-m-Y H:i:00",time()));
$fecha_entrada = strtotime("19-11-2008 21:00:00");

```php
if( $fecha_actual > $fecha_entrada ){
  echo "La fecha entrada ya ha pasado";
}else{
  echo "Aun falta algun tiempo";
}
```

El problema de trabajar con marcas de tiempo Unix es que el rango de fechas posibles termina sobre el año 2030, es decir que a partir de ese año, como no hay más dígitos para representar una cifra superior se reiniciará a 0 (equivalente al año 1970 aproximadamente). Aunque falte mucho tiempo, es una mala práctica emplear este tipo de factores.

## Comparar Fechas Correctamente

Una forma sencilla de hacerlo sin tener que contar manualmente las fechas, con todo los problemas que esto conlleva: si es año bisiesto o no, si el mes termina en 30 o 31, etc..., lo que se puede hacer es cambiar el sistema de fechas de gregoriano a juliano, para saber la diferencia de días que hay entre dos fechas

```php
function compararFechas($primera, $segunda)
{
  $valoresPrimera = explode ("/", $primera);  
  $valoresSegunda = explode ("/", $segunda);

  $diaPrimera = $valoresPrimera[0];  
  $mesPrimera = $valoresPrimera[1];  
  $anyoPrimera = $valoresPrimera[2];

  $diaSegunda = $valoresSegunda[0];  
  $mesSegunda = $valoresSegunda[1];  
  $anyoSegunda = $valoresSegunda[2];

  $diasPrimeraJuliano = gregoriantojd($mesPrimera, $diaPrimera, $anyoPrimera);  
  $diasSegundaJuliano = gregoriantojd($mesSegunda, $diaSegunda, $anyoSegunda);

  if(!checkdate($mesPrimera, $diaPrimera, $anyoPrimera)){
    // "La fecha ".$primera." no es válida";
    return 0;
  } elseif (!checkdate($mesSegunda, $diaSegunda, $anyoSegunda)){
    // "La fecha ".$segunda." no es válida";
    return 0;
  } else {
    return $diasPrimeraJuliano - $diasSegundaJuliano;
  }
}

$primera = "29/02/2000";
$segunda = "31/01/2000";

echo compararFechas ($primera,$segunda);
```

Este código devuelve el número de días entre dos fechas en caso de que sean válidas (se utiliza la función checkdate de PHP para comprobar que sean fechas válidas).


Distintos métodos para comparar fechas correctamente en PHP

Comparar Fechas en PHP

comparar-fechas-en-php


En este ejemplo veremos cómo crear un thread en vb.net en el que ejecutaremos una función en modo background mientras seguimos con la ejecución principal del programa.

Primero hay que importar la librería System.Threading (antes de iniciar la clase).

Imports System.Threading

Dentro de la clase definimos los atributos que contendrán el Thread y la función que invocará.

```vb
Dim nuestroThread As Thread
Dim nuestroThreadStart As New ThreadStart(AddressOf ActualizacionesBackground)
Dim CallFuncionGenerar As New MethodInvoker(AddressOf Me.FuncionGenerar)
```

Dentro de Form_Load (la función que se llama al cargar la aplicación) podemos asignar el thread en modo background para que no interfiera con el curso principal del programa, e iniciarlo con el método Start.

```vb
nuestroThread = New Thread(nuestroThreadStart)
nuestroThread.IsBackground = True
nuestroThread.Name = "nuestroThread"
nuestroThread.Start()
```

Al iniciar, el thread llamará a una función llamada ActualizacionesBackground creada por nosotros mismos, en dónde, por ejemplo, se puede escribir un bucle que espere cada X tiempo a llamar la función que queramos.

```vb
While True
    Me.BeginInvoke(CallFuncionGenerar)
    Thread.Sleep(15000)
End While
```

## Código Completo

```vb
Imports System.Threading
Public Class Form1
    Dim nuestroThread As Thread
    Dim nuestroThreadStart As New ThreadStart(AddressOf ActualizacionesBackground)
    Dim CallFuncionGenerar As New MethodInvoker(AddressOf Me.FuncionGenerar)
    Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
        Try
            nuestroThread = New Thread(nuestroThreadStart)
            nuestroThread.IsBackground = True
            nuestroThread.Name = "nuestroThread"
            nuestroThread.Start()
        Catch ex As Exception
        End Try
    End Sub

    Public Sub FuncionGenerar()
        Me.Active_guestsTableAdapter.Fill(Me.FontreactorDataSet.active_guests)
    End Sub

    Public Sub ActualizacionesBackground()
        While True
            Me.BeginInvoke(CallFuncionGenerar)
            Thread.Sleep(15000)
        End While
    End Sub

End Class
```

El ejemplo es muy básico. Pero sirve para entender el comportamiento de los threads en vb.net.


Todos los artículos