En ocasiones por comodidad, y sobre todo para ahorrarnos dar más información de la cuenta de cara a la seguridad y a que aparezcan mensajes de errores en la pantalla del cliente, es preferible ocultar la información de depuración que nos devuelve el intérprete PHP mediante las típicas líneas de error y warning.

La forma más cómoda para hacerlo instrucción a instrucción es el uso del prefijo @ delante de la misma. El error o warning seguirá existiendo pero no se generará una salida HTML describiéndola.

Por ejemplo, intentaremos borrar el fichero contenido en la variable $fichero

unlink($fichero);

Si el fichero no existe, aparecería un error por pantalla que si ponemos esto:

@unlink($fichero);

No aparecerá. Si la operación de borrado del fichero es para asegurarnos y si no existe hemos conseguido lo que queríamos, nos ahorraremos unas cuantas líneas de código que escribir.

Quickly es un framework que nos ayuda a crear programas de software (y otras cosas) de forma rápida. Dispone de soporte para un gran conjunto de plantillas y la opción de utilizar algunos comandos simples para crear, editar el código y la interfaz.

¿Qué hace Quickly para ayudarnos? Pues básicamente ese tipo de tareas pesadas como son gestionar los archivos, llevar el control de versiones, compilar, empaquetar e incluso publicar nuestro producto final para que sea accesible al resto de la comunidad open source. Me parece una buena idea de concepto, algo que debería de tener en cuenta todos los IDEs actuales, ya que existe mucha gente que quiere aprender a programar pero se sorprende y descontrola por los tantísimos detalles a controlar.

La plantilla para programar en Ubuntu Linux nos permite crear una aplicación usando el lenguaje de programación Python, con la GUI a través de Glade, control de versiones en Bazaar y LaunchPad como plataforma de publicación, preocupándonos únicamente de lo que importa, programar.

Sitio oficial.

Las palabras clave son: #region y #endregion para indicar el comienzo y el fin de la región, respectivamente. Podéis ver el resultado en las siguientes imágenes, como podéis apreciar MonoDevelop te genera un extracto del contenido de la región:

Aunque en la entrada de la presentación de Django se habla de la instalación del framework, a través de dos métodos: script install.py e instalación de paquete desde el repositorio; vamos a explicar otro método más, algo más largo pero a la vez más compatible. Nos quita la limitación del paquete de que la versión no sea la más reciente (limitación que no tiene el método de instalación con install.py).

Doy por supuesto que tenéis instalado Python en vuestro equipo.

1. Nos dirigimos a nuestro directorio $HOME
2. Descargamos la última revisión del proyecto: svn co http://code.djangoproject.com/svn/django/trunk/ djtrunk
3. Averiguamos cuál es el directorio en el que Python guarda los paquetes:  python -c “from distutils.sysconfig import get_python_lib; print get_python_lib()”
4. Nos dirigimos al directorio que nos indique y creamos un fichero de nombre django.pth (el fichero podéis crearlo con nano mismo nano django.pth).
5. En dicho fichero indicamos sólo una línea con el directorio en el que hemos descargado el código de Django (en nuestro caso será /home/miusuario/djtrunk).
6. Añadimos a la variable PATH la ruta de los binarios de Django:
   1. Editamos el fichero con las variables de entorno /etc/environment
   2. Añadimos a la variable PATH la ruta: PATH=”lo_que_haya_antes: $HOME/djtrunk/djtrunk/django/bin”

Ya podemos probar la instalación de Django. Podéis probar a importar el módulo Django desde Python o podéis probar a crear un sitio y lanzar el servidor de prueba:

1. django-admin.py startproject misitio
2. python manage.py runserver
3. Lanzamos el navegador para escuchar el puerto 8000 del host local: http://localhost:8000

Deberías ver algo así:

Y a partir de aquí seguid leyendo el ejemplo que colgamos ayer.

A lo largo de la presentación que adjuntamos en este enlace y con motivo del trabajo voluntario planteado en las prácticas de Programación Avanzada, José Antonio Sánchez Pallero y yo, hemos tratado de transmitir una idea general acerca de Django, el framework libre basado en Python orientado a la creación rápida de aplicaciones web. Al final del mismo y para completar la explicación, presentamos un pequeño ejemplo de desarrollo haciendo uso de esta herramienta.

Toda persona que haya tenido contacto con el desarrollo web, sabrá de los inconvenientes que crean temas como: el control de las entradas del usuario, la interacción con la base de datos, la creación de direcciones amigables para los buscadores (tan necesario para el SEO), la modificación de las estructuras de datos una vez creadas o la definición de distintos roles de permisos para los usuarios del sistema.

Todo este tipo de problemas los soluciona Django de una manera muy intuitiva, con la potencia añadida de un lenguaje tan amable y completo como Python.

A continuación os dejo la presentación y adjunto también capturas de pantalla del ejemplo desarrollado y el código fuente del ejemplo para descargar. Los objetivos y la funcionalidad del ejemplo están comentados en la presentación; la implementación en sí explicada está comentado directamente sobre el código.

Django – Plataforma de sitios web

• Descargar: ejemploDjango.tar.gz (código fuente del ejemplo)

Los datos personales que aparecen en los ejemplos son inventados. Algunos datos sobre grupos y centros de investigación sí son reales.

Vista índice

Vista Instituto

Vista grupo

Esta entrada también ha sido publicada en un blog sobre Python que ha creado un compañero de la clase. Desde aquí darle la enhorabuena y recomendároslo a todos: Aprende Python como si estuvieras en primero.

¿Por qué escoger este binomio en lugar de XSP? La respuesta es fácil: XSP es un servidor de pruebas, no de producción y si queremos tener un servicio o aplicación web ejecutando de forma decente en producción, mejor utilizar Apache y mod_mono. Las razones no son sólo por la escalabilidad y eficiencia que permite Apache, sino que están relacionadas por la seguridad que provee el servidor más utilizado a nivel mundial y por la gran variedad de opciones que nos ofrece.

De todas maneras sigo pensando que al igual que el servidor de pruebas de Django es útil para las pruebas, XSP es un buen servidor de pruebas para practicar con nuestro PC cuando estemos aprendiendo ASP.NET. Cuando la aplicación se hace compleja y sobre todo queramos pasarla a producción, Apache.

Instalación y configuración

A través de esta entrada vamos a introducirnos en el mundo del desarrollo de aplicaciones gráficas usando una librería llamada pygame que nos proporciona las herramientas necesarias para crear de forma relativamente sencilla nuestros juegos en el lenguaje de programación Python.

¿Qué es Pygame?

Pygame es un conjunto de módulos que nos ayudan a crear videojuegos o aplicaciones gráficas (no necesariamente videojuegos) en dos dimensiones. Pygame incluye gráficos y bibliotecas de sonido diseñados para ser utilizados directamente bajo Python. Está construido bajo Simple DirectMedia Layer (SDL), que a su vez son un conjunto de bibliotecas desarrolladas en lenguaje C, proporcionando las funciones básicas para realizar operaciones de dibujado 2D, gestión de efectos de sonido y música, y carga y gestión de imágenes. De esta manera, a través de Pygame podemos abstraernos de la lógica del juego (o aplicación) en si mismo, haciendo posible el uso de un lenguaje de alto nivel como Python para estructurar el juego.

Pygame fue contruido como sustituto de pySDL, después del poco éxito del mismo, ya que la forma de interactuar no llegó a recoger tantas opciones y tan simples como las del entorno de Pygame.

Escrito originalmente por Shinners Pete se distribuye bajo la GNU Lesser General Public License. Desde 2004 se trata de un proyecto de código abierto de la comunidad de software libre.

Instalando Pygame y el entorno

Antes de comenzar a ver una serie de ejemplos generales a modo de introducción en el mundo de Pygame vamos a configurar nuestro sistema para poder importar los módulos de Pygame desde Python, como cualquier otra librería.

La instalación es bastante simple. Suponiendo que nuestro sistema corre una distribución basada en Debian y que ya corre la versión más reciente de Python, de tal forma bastará con usar un gestor de paquetes e instalar el paquete python-pygame y satisfacer todas sus dependencias. Así, y de la forma más intuitiva usaremos las dos vías principales, usando el adminstrador de paquetes en modo texto APT y su versión gráfica Synaptic.

En el primero de los casos la instalación es bastante sencilla, abrimos un terminal y ejecutando como superusuario (root) lanzamos la herramienta apt-get como se indica a continuación y cómo se observa en la figura 1.

$ sudo apt-get install python-pygame

Y nos preguntará si deseamos instalar todos los paquetes anexos y dependencias, a lo que responderemos afirmativamente.

Figura 1 Instalación mediante el gestor de paquetes APT

Usando el gestor de paquetes Synaptic la operación es similar, nos dirigimos a System → Administration → Synaptic Package Manager, localizamos el paquete python-pygame y lo marcamos para instalar, cómo se muestra en la figura 2. Aplicamos los cambios aceptando todas las dependencias y listo, ya tenemos nuestro entorno preparado nuestro entornor para empezar a trabajar con Pygame.

Figura 2 Instalación mediante el gestor de paquetes Synaptic

Uno de mis entornos de programación preferidos es Geany, un IDE desarrollado en GTK y que se define así mismo como: A fast and lightweight IDE. Aconsejo su uso ya que nos resultará bastante sencillo probar los ejemplos planteados.

Para su instalación, y de forma análoga a Pygame, localizaremos el paquete geany y satisfaceremos sus dependencias si se precisan, así con APT y cómo se muestra en la figura 3:

$ sudo apt-get install geany

Figura 3: Instalación del IDE Geany

Nuestro primer programa…

Vamos a proceder con un ejemplo muy básico de uso. Abrimos nuestro IDE de Python (Geany) y probamos con el siguiente código, en este se dibujará un fondo sobre una ventana y dos lineas diagonales que cruzarán los extremos de izquierdas a derechas y de arriba a abajo y al contrario. Así, el código comentado:

# -*- coding: utf-8 -*-

# Importamos las librería de Pygame y las del sistema, necesarias para forzar el cierre
import pygame, sys
from pygame.locals import *

# Inicializamos Pygame
pygame.init()

# Definimos el color de fondo y el de la diagonal
COLOR_FONDO = (50, 150, 200)
COLOR_LINEA1 = (255, 0, 0)
COLOR_LINEA2 = (0, 0, 255)

# Definimos el tamaño de la aplicación y la tasa de refresco
pantalla = pygame.display.set_mode((800, 600))
refresco = pygame.time.Clock()

while True:
time_passed = refresco.tick(30)
# Comprobamos el cierre de la aplicación y en caso afirmativo lanzamos la función salir
for event in pygame.event.get():
if event.type == QUIT:
sys.exit()

# Fijamos el color de fondo y las lineas de diferentes colores, y lo sacamos por display
pantalla.fill(COLOR_FONDO)
pygame.draw.aaline(pantalla, COLOR_LINEA1, (1, 1), (799, 599))
pygame.draw.aaline(pantalla, COLOR_LINEA2, (799, 1), (1, 599))
pygame.display.flip()

NOTA: Para lanzar directamente la aplicación desde el IDE Geany podemos hacerlo pulsando F5 o desde el icono designado para esta operación.

De esta forma, el resultado que obtenemos tras ejecutar nuestra primera aplicación es el mostrado en la figura 4.

Figura 4: Ejecutando nuestro primer programa

Controlando los eventos

Es posible que al empezar en la programación de aplicaciones gráficas mediante Pygame nos surjan dudas acerca del manejo de eventos a través del programa desarrollado. Es por ello que vamos a dedicar este pequeño apartado a tratar de aclarar las diferentes maneras que tenemos para registrar los eventos que se suceden en nuestra aplicación.

Será importante diferenciar los métodos que pueden ayudarnos a registrarlos a guardarlos de una forma temporal antes de ser analizados. Así:

• pygame.event.get: Obtenemos los eventos mediante una cola. Esta función es la usada en el ejemplo anterior, de forma que definimos un tiempo de refresco a partir del cual recorremos los eventos registrados y ejecutamos sus acciones asociadas. Esta es quizás la forma más común de registro de eventos no forzado, y de esta manera no nos obliga a realizar una pulsación o control del flujo del programa en un punto.
• pygame.event.poll: Obtenemos un evento simple de la cola. Simplemente es capaz de guardar el último evento sucedido. Resulta práctica cuando únicamente queremos dejar constancia de un evento registrado en un intervalo de tiempo definido.
• pygame.event.wait: Espera un evento de la cola. Este lo he usado en el ejemplo planteado a continuación, de forma que podamos ir viendo algunos de los eventos que podemos controlar así como estudiar las posibilidades que nos ofrece esta vía de registrar eventos.

Podemos ver el resto de eventos accesibles por teclado en el siguiente enlace: Documentación oficial de Python.

El ejemplo que muestra su uso, a continuación:

# -*- coding: utf-8 -*-

import pygame
from pygame.locals import *

pygame.init()
pygame.display.set_mode((200, 200))
pygame.display.flip()
event = pygame.event.poll()

while True:
cursor = pygame.mouse.get_pos()
evento = pygame.event.wait()
if evento.type == QUIT or evento.type == K_ESCAPE:
print ”Has abandonado la aplicación”
raise SystemExit
if pygame.mouse.get_pressed()[0]:
print ”Has usado el botón izquierdo del ratón”
if pygame.mouse.get_pressed()[1]:
print ”Has usado el botón central del ratón”
if pygame.mouse.get_pressed()[2]:
print ”Has usado el botón derecho del ratón”
if evento.type == KEYDOWN and evento.key == K_SPACE:
print ”Has pulsado espacio”
if evento.type == KEYDOWN and evento.key == K_BACKSPACE:
print ”Has pulsado backspace”

La figura 5 muestra su ejecución:

Figura 5: Controlando los eventos de la aplicación

Más figuras e imágenes

Al estar basado en SDL, Pygame tiene la capacidad de poder mostrar imágenes así como formas básica de una forma casi trivial, las primitivas que se encargan de realizar estas operaciones las comentamos en el siguiente ejemplo y vemos su resultado:

# -*- coding: utf-8 -*-

# Importamos las librería de Pygame y las del sistema, necesarias para forzar el cierre
import pygame
from pygame.locals import *

# Inicializamos Pygame
pygame.init()

# Definimos el color de fondo y el de las figuras
COLOR_FONDO = (50, 100, 50)
COLOR_CUADRADO = (255, 0, 0)
COLOR_CIRCULO = (0, 0, 255)
# Cargamos la imagen y hacemos transparente el fondo (antes verde)
imagen_nave = pygame.image.load(‘nave.bmp’)
imagen_nave.set_colorkey((0, 255, 0))

# Definimos el tamaño de la aplicación y la tasa de refresco
pantalla = pygame.display.set_mode((800, 600))

while True:
time_passed = pygame.time.Clock().tick(30)
# Comprobamos el cierre de la aplicación y en caso afirmativo lanzamos la función salir
for event in pygame.event.get():
if event.type == QUIT:
raise SystemExit

# Fijamos el color de fondo y dibujamos las figuras y la imagen
pantalla.fill(COLOR_FONDO)
pygame.draw.rect(pantalla, COLOR_CUADRADO, (50, 50, 100, 100))
pygame.draw.circle(pantalla, COLOR_CIRCULO, (400, 300), 75 )
pantalla.blit(imagen_nave, (500, 400))
# Actualizamos la pantalla
pygame.display.flip()

NOTA: Podemos ver cómo al no disponer de transparencia la imagen de la nave se la fijamos mediante el método set_colorkey().

Y el resultado lo podemos ver en la figura 6.

Figura 6: Ejemplo con figuras e imágenes

Y el sonido

Para terminar con esta introducción a Pygame vamos a realizar un test de sonido, para lo cual usaremos la el módulo mixer. El ejemplo:

# -*- coding: utf-8 -*-

import pygame, os
from pygame.locals import*

# Iniciamos el módulo mixer
pygame.mixer.init()
# Cargamos la pista de audio haciendo uso del sistema, mediante el cual podemos indicar rutas relativas sin dependencia del sistema operativo
pygame.mixer.music.load(os.path.join(“1vs0_JuniorGroove.ogg”))
# Y reproducimos la pista cargada de forma continua, valor -1.
pygame.mixer.music.play(-1)

Podéis consultar el resto de opciones desde la documentación de Python.

NOTA: La pista de audio utilizada tiene licencia Creative Commons, 1vs0 – Junior Groove.

Bibliografía

• Koders.com
• Wikipedia.org
• SourceForge [pySDL]
• ActiveState.com
• 01audio-video.com [OGG Files]

Cuando leí ayer la noticia en Kabytes la verdad que me resultó un tanto curiosa, pero era algo escéptico en cuanto a las posibilidades que podía brindar en realidad ideone, que es el nombre del servicio. Por ahora es una versión beta por lo que todavía puede haber defectos, pero en líneas generales funciona bien.

La web nos presenta un cuadro donde elegir el lenguaje: Ada, C, C#, C++, Cobol, Common Lisp, Java, Lua, Prolog, Python, Ruby, Visual Basic.NET… entre otros muchos, un cuadro para elegir si queremos resaltar la sintaxis y un cuadro de texto para introducir nuestro código. Una vez lo hayamos introducido lo enviamos y la web nos devuelve el resultado de la ejecución.

Como podréis imaginar muchas de las librerías que normalmente tenemos disponibles cuando desarrollamos no están disponibles, pero sí las estructuras básicas de todos los lenguajes y podemos usarlo para curiosear simplemente o para compartirlo con un amigo o a través de una blog, gracias a un sistema de generación de enlaces con el que podemos enviar nuestra prueba.

Si alguna vez habéis programado en un lenguaje de programación con sintaxis heredada de C: el mismo C, C++, Java, C#… seguro que habéis utilizado el operador postincremento, sobre todo en iteraciones for, el famoso: i++ (o equivalente). Lo que es menos frecuente es haber utilizado el operador ++i, pero si lo habéis utilizado seguro que lo habéis hecho para algo similar al anterior. La diferencia entre ambos es algo que un día me inquietó y que hoy os voy a comentar.

La diferencia es la precedencia del operador, es decir, qué operador realiza su acción antes. Esta diferencia no importa cuando la única operación de una sentencia es i++ o ++i, es decir:

i++;
++i;

Típica situación del caso de las iteraciones for, es lo mismo. Sin embargo, cuando hay otra operación de por medio, las cosas cambian. Veamos:

i = 0;
v = i++;

La variable v contendrá 0 e i contendrá 1. Primero se ha asignado el valor de i a v y posteriormente se ha incrementado i. Si utilizamos el otro operador, que tiene más precedencia, se ejecutará antes el incremento de i y posteriormente se asignará su nuevo valor, 1, a la variable v.

i = 0;
v = ++i;

En este caso ambas variables, v e i, contienen 1.

La diferencia funcional, como podéis ver, existe y es conveniente conocerla, para poder utilizarla, explotarla y de paso, conocer algo más sobre los lenguajes de este tipo.

Aparte existe otra diferencia, ésta de carácter computacional y que es conveniente conocerla de cara a hacer más eficiente nuestro código. ++i realiza dos instrucciones, incrementar y retornar; mientras que i++, por lo que acabamos de comentar lleva a cabo tres: guardar el estado actual, incrementar, retornar el estado anterior.

La siguiente función devuelve:

• 1 si la fecha a es mayor que la fecha b
• 0 si son iguales
• -1 si la fecha a es menor que la fecha b

function comparar_fechas_mysql($a, $b)
	{
		$a_v=explode("-",$a);
		$anyo_a = $a_v[0];
		$mes_a = $a_v[1];
		$dia_a = $a_v[2];

		$b_v=explode("-",$b);
		$anyo_b = $b_v[0];
		$mes_b = $b_v[1];
		$dia_b = $b_v[2];

		if($anyo_a > $anyo_b)
			return 1;
		else
		{
			if($anyo_a < $anyo_b)
				return -1;
			else
			{
				if($mes_a > $mes_b)
					return 1;
				else
				{
					if($mes_a < $mes_b)
						return -1;
					else
					{
						if($dia_a > $dia_b)
							return 1;
						else
						{
							if($dia_a < $dia_b)
								return -1;
							else
								return 0;
						}
					}
				}
			}
		}
	}

Esperamos vuestras sugerencias, mejoras y rectificaciones de este y todos los tips de programación que vayamos incorporando.

Aunque todavía queda un poco para el lanzamiento de la versión estable de Java 7 (ahora mismo si no me equivoco están en la actualización 17 de Java 6), aquí os traigo una serie de mejoras que va a incorporar y que podéis ya probar a través del JDK 7 Early Access.

La recopilación de las mejoras ha salido publicada en el blog tecnológico de JoeJag (en inglés) y aquí os la dejo traducida:

Soporte mejorado para colecciones

A partir de ahora las colecciones podrán declararse al estilo de Ruby o Perl. En lugar de tener que hacer:
List list = new ArrayList();
list.add("item");
String item = list.get(0);

Set set = new HashSet();
set.add("item");


Map map = new HashMap();
map.put("key", 1);
int value = map.get("key");

Se podrá hacer directamente:
List list = ["item"];
String item = list[0];

Set set = {"item"};

Map map = {"key" : 1};
int value = map["key"];

Manejo automático de recursos

Algunos recursos como InputStream, Writers, Sockets o clases relacionadas con Sql, tienen que ser ser cerrados manualmente en cada utilización, por ejemplo:
BufferedReader br = new BufferedReader(new FileReader(path));
try {
return br.readLine();
} finally {
br.close();
}

Sin embargo, a partir de ahora, automáticamente podremos hacer:
try (BufferedReader br = new BufferedReader(new FileReader(path)) {
return br.readLine();
}

O si tenemos más de un recurso:
try (
InputStream in = new FileInputStream(src);
OutputStream out = new FileOutputStream(dest))
{
// código
}

Inferencia de tipos mejorada para creación genérica de instancias (operador diamante < >)

Si antes estábamos obligados a hacer:
Map> anagrams = new HashMap>();

Ahora simplemente:
Map> anagrams = new HashMap<>();

Barras bajas en literales numéricos

Porque los números grandes son complejos de leer sin problemas:
int un_millon= 1_000_000;

Cadenas para la clausula switch

Posiblemente el más esperado de todos (hasta ahora sólo los tipos enum y números podían ser utilizados en los switch). Ya podremos hacer directamente:
String s = ...
switch(s) {
case "linuxhispano":
llamar(w);

case "web":
case "internet":
procesar(w);
break;

case "foo":
procesarfoo(s);
// fall-through

default:
demas(s);
break;
}

Binarios literales

Utilizando el prefijo 0b (es un cero ’0′ no una o), podremos representar directamente enteros en formato binario:
int binary = 0b1001_1001;

Simplificación de la invocación de métodos con argumentos variables

Si hasta ahora el compilador emitía warning en el lugar de la llamada al método, ahora lo hará en el de la declaración del mismo para facilitar la labor a los desarrolladores.

A través de un post publicado por Omeyas Web, el blog de unos amigos (que a su vez está referenciado de otro post aparecido en el blog de Andrés Nieto) me entero de un sencillo método para controlar los atajos de teclado en las aplicaciones web.

En aplicaciones en local es muy fácil y útil manejar los atajos de teclado, mientras que en aplicaciones web, los métodos para hacerlo no son nada estándares y tenemos que remitirnos a script como el que os dejo. El futuro facilite todo esto, ya que sistemas operativos como Google Chrome OS y proyectos similares, trasladan la realidad a la web, por lo que es necesario potencia este tipo de herramientas.

DIA es una aplicación libre para la creación de diagramas bajo GTK+ y multiplataforma, bajo licencia GPL. Personalmente la considero una de las mejores aplicaciones en cuanto a creación de diagrama (de casi cualquier tipo) para nuestro entorno GNU/Linux.

¿Por qué os cuento todo esto? Ayer sábado, leyendo la lista de correo de mi universidad me sorprendió la opinión que tienen al respecto algunos compañeros sobre DIA y las alternativas propuestas, bajo mi opinión no son comparables. A continuación tenéis el hilo de la conversación, he decidido no proporcionar direcciones de correo ni nombres por preservar el anonimato de esta gente:

Estudiante1  escribió:
Hola a todos

¿Qué programas estáis usando para hacer los diagramas EE-R? Hemos probado Visio pero no sabemos como realizar las relaciones. También hemos usado DIA y SmartDraw, pero tenemos problemas a la hora de poner los atributos a las entidades. ¿Los vais a hacer con la notación antigua (la de los circulitos al lado de las entidades)?

Estudiante2  escribió:

Hola,
Nosotros estamos utilizando el DIA, aunque es bastante malo, ya que cuesta trabajo poner los atributos, y el programa falla mucho. Pero es el unico que he encontrado que tenga todo lo necesario para un EE-R.

Estudiante3  escribió:

Nosotros estamos haciendo los diagramas con el esquema “Diagramas de flujo” del DIA. Estamos haciendo los mismos que aprendimos en 2º.

Espero que os sirva.

¿Qué opinas vosotros? A los que por alguna razón u otra habéis usado DIA, ¿qué opináis sobre DIA? Por cierto, parece que Estudiante3 fue el único sensato.

Algunas de las nuevas etiquetas son análogas a <div> y <span>, pero tienen un significado semántico, como es el caso de  <nav> (que es el bloque de navegación del sitio web) y <footer> (el pie de página).

Nos podemos encontrar además, con nuevos elementos que proporcionan funcionalidades anteriormente implementadas por otras vías (como por ejemplo Macromedia Flash), estos son <audio> y <video>, y habrá que esperar que codificación utilizará cada navegador en tal caso. También podemos destacar el elemento <canvas> y cómo algunos de los elementos de HTML 4 quedan obsoletos en pros del uso de CSS, como son las etiquetas <font> y <center>.

Esta útil y a la vez sencilla utilidad nos permite comprobar si 1) el servidor existe y si 2) el usuario es válido, para ello, realiza los siguientes pasos:

• Obtiene los registros MX para el dominio dado.
• Se conecta a los servidores de correo.
• Intercambia datos con el servidor utilizando el protocolo SMTP.
• Obtiene el código de respuesta para comprobar si es una dirección de email válida.

Os recomiendo que os deis una vuelta y lo probéis, merece la pena, y podemos descargarlo para integrarlo en nuestras aplicaciones.