Translate

sábado, 12 de mayo de 2012

Apache Hadoop y Microsoft??

Leyendo infoQ me interese en la siguiente nota: http://www.infoq.com/news/2012/05/hadoop-microsoft

Parece ser que Microsoft anuncio una alianza con Hortonworks para traer  Hadoop en Windows Server y Windows AzureHortonworks es una empresa especializada en la consultoria para adopción de Apache HadoopLa visión de Microsoft gira en proporcionar herramientas relacionadas con  Hadoop y Big Data accesibles por usuario final y para ello se integra con el análisis de SQL Server y Reporting Services, así como de PowerPivot de Excel.


Lo interesante de esta noticia o el análisis que hago; es el ruido que esta haciendo Apache Hadoop como para que Microsoft se interese por el. Espero que siga creciendo!!

viernes, 11 de mayo de 2012

Empleos en linux

Vía Ubuntizandoelplaneta encuentro esta infografía que muestra una estadística sobre el mercado laboral de Linux reuniendo datos de jobs.linux.com, herramienta de la Linux Foundation que permite buscar y encontrar trabajos relacionados con Linux.


miércoles, 9 de mayo de 2012

OpenStack, nubes privadas y Open Sources



OpenStack permite hacer nubes privadas, esto es muy flexible, para una organización. Todo sobre Open Source por supuesto.

OpenStack es un proyecto liderado por la empresa Rackspace, que ha decidido liberar el código de sus servicios Cloud Files y Cloud Servers bajo una licencia Apache 2.0. Este código forma la piedra angular de OpenStack, ofreciendo la posibilidad a usuarios o empresas de crear sus propios servicios de cloud computing.

Rackspace aporta la parte de almacenamiento, llamada Swift, la base de los servicios anteriormente citados. La NASA, que también participa en el proyecto, colabora con Nova, base de su plataforma NEBULA, ambos servicios están desarrollados utilizando Python.

Como se ha comentado, OpenStack ofrecerá dos servicios: OpenStack Compute permite gestionar el despliegue y ejecución de aplicaciones a través de múltiples servidores. La tecnología Nova, se basa en el protocolo de mensajeria AMQP y es el sistema utilizado en la NASA para proveer sistemas de virtualización bajo demanda.

OpenStack Object Storage permite gestionar el almacenamiento de datos en varios servidores que trabajen de manera conjunta en clústers, para conseguir un almacenamiento masivo de objetos estáticos, de manera supérflua y fiable. El software de OpenStack es el responsable de garantizar la replicación de los datos y la integridad a través de todo el clúster, permitiendo añadir nuevos nodos y configurarlos de manera automática.

Aunque el código en el que se basan los servicios comentados lleva siendo utilizado durante bastante tiempo, se espera que las aportaciones de la comunidad open source mejoren su funcionamiento. Las primeras versiones estables de Compute y Object Storage se liberarán a mediados de octubre y septiembre, respectivamente.

Detrás del proyecto OpenStack se encuentran empresas como Dell, Citrix, Intel o como ya se ha comentado, la agencia espacial estadunidense. El objetivo final del proyecto es facilitar un sistema de cloud computing de código abierto y fácilmente adaptable a sistemas hardware de bajo coste, facilitando su implantación en empresas de todos los niveles.

Y dejo una infografia sobre el crecimiento del proyecto:


Dejo la fuente: http://www.genbeta.com/actualidad/openstack-cloud-computing-de-codigo-abierto
Y dejo link del proyecto: http://openstack.org/

lunes, 7 de mayo de 2012

Ohloh

Ohloh es un directorio de software libre, La idea es que la comunidad pueda buscar proyectos o código fuente. 

"Al recuperar datos de los repositorios de control de versiones (como CVS, SVN, o Git), Ohloh proporciona estadísticas acerca de la longevidad de los proyectos, sus licencias (incluida la licencia conflicto información) y las cifras de software, como líneas de código fuente y las estadísticas de los Commit. El codebase history informa sobre la cantidad de actividad para cada proyecto. Software stacks (lista de aplicaciones de software utilizadas por los miembros del Ohloh) y las etiquetas se utilizan para calcular la similitud entre los proyectos.


Las estadísticas globales por lenguaje para medir la popularidad de determinados lenguajes de programación desde principios de los años 90. Las estadísticas mundiales en todos los proyectos en Ohloh también se han utilizado para identificar aquellos con la más amplia revisión continua de control de historias.


Las estadísticas de contribuidor también están disponibles, la medición de los desarrolladores con experiencia de código abierto como observables en el código ha suministrado a los repositores de control de versiones. Características de la red Social (kudos) se han introducido para permitir a los usuarios evaluar a los contribuyentes de código abierto. Ofrece un KudoRank para cada usuario y contribuyente código abierto en una escala de 1 a 10, se extraen automáticamente de todos los kudos en el sistema. La idea de medir los desarrolladores de código abierto sus aptitudes y la productividad sobre la base de estadísticas de los commit o calificación mutua ha recibido reacciones muy diversas en los blogs de tecnología." Gracias Wikipedia!


Es una herramienta muy buena para analizar que proyecto de software utilizar. 


Dejo Link:
https://www.ohloh.net/

sábado, 5 de mayo de 2012

El Software Libre y la educación

Richard M. Stallman habla de la importancia del uso del Software Libre en el ámbito educativo.

miércoles, 2 de mayo de 2012

Squeryl

Squeryl es un orm escrito en scala que provee un potente dsl de consulta a datos por lo poco que leí quede asombrado. No quiero ahondar en configuraciones, transacciones y esas cosas. Voy a hablar del dsl de consulta a datos, que esta orientado a ser fácil de usar, intuitivo y typesafe. 

Veamos un ejemplo:

def songCountByArtistId: Query[GroupWithMeasures[Long,Long]] =
  from(artists, songs)((a,s) =>
    where(a.id === s.artistId)
    groupBy(a.id)
    compute(countDistinct(s.id))
  )

Y esto va a devolver el siguiente query: 

Select
  Artist1.id as g0,
  count(distinct Song2.id) as c0
From
  Artist Artist1,
  Song Song2
Where
  (Artist1.id = Song2.artistId)
Group By
  Artist1.id

Noten lo legible que queda usando closures; muy bueno. Yo estuve viendo otros frameworks de consulta a datos, dejo el link para que comparen:

Dejo links de Squeryl:

martes, 1 de mayo de 2012

Jasper en jsf, parte 2. La leyenda continua!


Siguiendo con el post:
http://emanuelpeg.blogspot.com.ar/2012/04/jasper-en-jsf.html

Ahora vamos a crear objetos que representen a los reportes y sus parámetros. Luego hacemos una pagina donde se pueda elegir el reporte,completar los parámetros e imprimir.
Clase reporte:

import java.util.ArrayList;
import java.util.List;

/**
 * @author emanuel
 *
 */
public class Report {
 
 private Long id;
 
 private String nombre;
 
 private List parameters = new ArrayList();
 
 private String fileName;
 
 private String urlConnection;
 
 private String driver;

 public Report() {
 }

 public Report(Long id, String nombre, List parameters,
   String fileName, String urlConnection, String driver) {
  super();
  this.id = id;
  this.nombre = nombre;
  this.parameters = parameters;
  this.fileName = fileName;
  this.urlConnection = urlConnection;
  this.driver = driver;
 }

 //Getters and setters
 
}


Clase Parametro
package org.assembly.tyr.reports.model;

/**
 * @author emanuel
 *
 */
public class Parameter {
 
 private String nombre;
 
 private Type type;
 
 private Object value;
 
 public Parameter(String nombre, Type type) {
  super();
  this.nombre = nombre;
  this.type = type;
 }

 //Getters and setters
}


El enum type
public enum Type {
 
 STRING, NUMBER, DATE

}

Ahora hago un dao, no quiero usar la base de datos por lo tanto hago un mapa, ustedes usen la base de datos.

package org.assembly.tyr.reports.dao;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.assembly.tyr.reports.model.Parameter;
import org.assembly.tyr.reports.model.Report;
import org.assembly.tyr.reports.model.Type;

/**
 * @author emanuel
 *
 */
public class ReportDao {
 
 private Map reports = new HashMap();
 
 public ReportDao() {
  List parameter1 = new ArrayList();
  Report report1 = new Report(1l,"hola1", parameter1, "/resources/reports/reporte.jasper",    
                                             "jdbc:mysql://localhost:3306/holaMundo?user=root&password=", 
                                             "com.mysql.jdbc.Driver");
  reports.put(1l, report1);
  
  List parameter2 = Arrays.asList(new Parameter("prueba1", Type.NUMBER), 
                      new Parameter("prueba2", Type.STRING), 
                      new Parameter("prueba3", Type.DATE));
  Report report2 = new Report(2l,"hola2", parameter2, 
                         "/resources/reports/reporte2.jasper", 
                         "jdbc:mysql://localhost:3306/holaMundo?user=root&password=", 
                         "com.mysql.jdbc.Driver");
  reports.put(2l, report2);
 }
 
 public Collection getAll() {
  return reports.values();
 }
 
 public Report get(Long id) {
  return reports.get(id);
 }

}


Ahora agrego en el face-config.xml el controller.

  
  reportGenerator
  org.assembly.tyr.reports.ui.ReportGeneratorController
  session
 

Agrego la pagina


    Report


    
    

Report


y modifico el controller

package org.assembly.tyr.reports.ui;

import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.faces.context.FacesContext;
import javax.faces.event.ActionEvent;
import javax.faces.model.SelectItem;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;

import net.sf.jasperreports.engine.JRException;
import net.sf.jasperreports.engine.JasperRunManager;

import org.assembly.tyr.reports.dao.ReportDao;
import org.assembly.tyr.reports.model.Parameter;
import org.assembly.tyr.reports.model.Report;

public class ReportGeneratorController {
 
 private ReportDao reportDao = new ReportDao();
 private Long reportId;
 private List parameters;
 private Map parameterValues = new HashMap();
 
 public List getReportList() {
  List result = new ArrayList();
  Collection reports = reportDao.getAll();
  for (Report report : reports) {
   SelectItem item = new SelectItem(report.getId(), report.getNombre());
   result.add(item);
  }
  return result;
 }
 
 public Long getReportId() {
  return reportId;
 }

 public void setReportId(Long reportId) {
  this.reportId = reportId;
 }

 public List getParameters() {
  if ( reportId!= null) {
   Report report = this.reportDao.get(reportId);
   parameters = report.getParameters();
  }
  return parameters;
 }

 public void setParameters(List parameters) {
  this.parameters = parameters;
 }
 
 public Map getParameterValues() {
  return parameterValues;
 }

 public void setParameterValues(Map parameterValues) {
  this.parameterValues = parameterValues;
 }
 
 public Object getParameterValue(String key) {
  return this.parameterValues.get(key);
 }

 public String generateReportSubmit()
   throws ClassNotFoundException, SQLException, IOException,
   JRException {
  Connection connection;
  
  if (parameters != null) {
   for (Parameter parameter: parameters) {
    parameterValues.put(parameter.getNombre(), parameter.getValue());
   }
  }
  
  Report report = this.reportDao.get(reportId);
  
  //Buscamos el contexto de jsf
  FacesContext facesContext = FacesContext.getCurrentInstance();
  HttpServletResponse response = (HttpServletResponse) facesContext
    .getExternalContext().getResponse();
  //Con el contexto buscamos el jasper
  InputStream reportStream = facesContext.getExternalContext()
    .getResourceAsStream(report.getFileName());
  ServletOutputStream servletOutputStream = response.getOutputStream();
  
  //Nos conectamos a la base de datos (creamos una coneccion)
  Class.forName(report.getDriver());
  connection = DriverManager
     .getConnection(report.getUrlConnection());
  facesContext.responseComplete();
  //seteamos el contentType
  response.setContentType("application/pdf");
  
  //ejecutamos el reporte
  JasperRunManager.runReportToPdfStream(reportStream,
    servletOutputStream, this.parameterValues, connection);
  // Cerramos la coneccion a la Base
  connection.close();
  // flush y close del reporte
  servletOutputStream.flush();
  servletOutputStream.close();
  return null;
 }
 
}


Para ver el codigo:
https://code.google.com/p/jaspertyr

Apache Foundation anuncia Apache TomEE v1.0


Leyendo javahispano me tope con la siguiente nota: http://www.javahispano.org/portada/2012/5/1/apache-foundation-anuncia-apache-tomee-v10.html

Apache anuncio el primer release de Apache TomEE del que ya hablamos en el blog. Este es un servidor que certifica Java EE 6 Web Profile. Es una gran noticia, dado que muchas veces no utilizamos JEE pero si necesitamos usar algún servicio como JMS o JTA o otros servios y por comodidad terminamos deployando en un JBoss o Glassfish.

Dejo link:
http://openejb.apache.org/apache-tomee.html

sábado, 28 de abril de 2012

MapReduce, con que se come?



Mucha gente habla de MapReduce, pero que es MapReduce? Porque estan importante?
MapReduce fue introducido por google en 2004 y consiste en una técnica para procesamiento de grandes cantidades de datos ditribuidos. Sigue la filosofía “divide y venceras!”
La implementación de este algoritmo fue escrito en varios lenguajes de programación.
MapReduce es un algoritmo para la resolución de problemas los cuales es necesario procesar  enormes conjuntos de datos utilizando un gran número de equipos (nodos), denominados clusters (si todos los nodos están en la misma red local y el uso de hardware similar) o grid (si los nodos esta distribuidos geográfica   o  no son tan similares). Procesamiento computacional puede ser en cualquiera de los datos almacenados en un sistema de archivos (no estructurada) o en una base de datos(estructurados).

El algoritmo cuenta con 2 pasos Map y Reduce:

  • Map: El nodo maestro toma la entrada, la divide en pequeños sub-problemas, y los distribuye a los nodos. Un nodo puede hacer esto de nuevo a su vez, conduce a una estructura de árbol multi-nivel. El nodo procesa el problema más pequeño, y pasa a la parte posterior respuesta a su nodo maestro. 
  • Reduce: El nodo maestro a continuación recoge las respuestas a todos los sub-problemas y los combina de alguna manera para formar la salida, la respuesta al problema que fue originalmente tratando de resolver.


Parece fácil, y bastante lógico. MapReduce permite el procesamiento distribuido de los nodos hoja y las operaciones de reducción. Siempre que cada operación de asignación es independiente de los demás, todos los mapas se puede realizar en paralelo, aunque en la práctica está limitada por el número de fuentes de datos independientes y / o el número de CPU cerca de cada fuente. De manera similar, un conjunto de 'reductores' puede realizar la fase de reducción, proporcionan todas las salidas de la operación de mapa que se presentan comparten la misma clave para el reductor mismo al mismo tiempo. Si bien este proceso pueden aparecer a menudo ineficientes en comparación con los algoritmos que son más secuencial, MapReduce se puede aplicar a conjuntos de datos significativamente mayores que "commodity" servidores pueden manejar una granja de servidores de gran tamaño se puede utilizar MapReduce para ordenar petabytes de datos en tan sólo unas pocas horas. El paralelismo también ofrece alguna posibilidad de recuperarse de una falla parcial de servidores o almacenamiento durante la operación: si un asignador o reductor falla, el trabajo se puede reprogramar, asumiendo que los datos de entrada aún está disponible.

Los datos de entrada están formadas por una (clave, valor) y a cada dato es aplicada la función map, la cual produce una serie de resultados intermedios (de 0 a N), dichos resultados también están formados por (clave, valor). Luego, una vez finalizado todas las funciones map el proceso de MapReduce agrupa por clave los resultados intermedios, y a cada dato (clave, [resultado1, resultado2, ... resultadoN]) aplica la función reduce. De esta forma obtiene el resultado del problema inicial.

Hadoop es la implementación MapReduce más usada en el mundo del software libre, proveyendo no solo una implementación MapReduce sino toda una infraestructura distribuida.

Dejo links:

http://hadoop.apache.org/mapreduce/


viernes, 27 de abril de 2012

Bibliotecas en PHP


PHP incorpora, sin necesidad de ningún tipo de instalación ni habilitación extras, una gran cantidad de bibliotecas, por lo cual contaremos con múltiples funciones para comenzar a desarrollar sitios profesionales. Entre estas extensiones se encuentran:

Las extensiones se pueden categorizar en estados (estables, obsoletas, y experimentales). Es posible obtener un listado accediendo a http://www.php.net/manual/es/extensions.state.php.

  • Funciones para manejo de matrices
  • Funciones matemáticas
  • BCMath (desde PHP 4.0.4, más funciones matemáticas)
  • Para manejo de clases/objectos
  • Para manejo de variables de tipo de carácter
  • Para tratamiento de fecha y hora
  • Para acceso directo a entrada / salida
  • Funciones de directorio
  • Funciones de gestión de errores y registros
  • Funciones de sistema de archivos
  • Para utilizar el protocolo FTP
  • Para utilizar el protocolo HTTP
  • Funciones de correo
  • Funciones de red
  • Funciones de control de salida
  • Para ejecución de programas
  • Funciones para el manejo de sesiones
  • Funciones de secuencia
  • Funciones de cadenas
  • Funciones URL
  • Funciones para manejo de variables

Para que los cambios (en este caso, la habilitación o deshabilitación de extensiones) tengan efecto, habrá que reiniciar el servidor web.
Podemos ver qué bibliotecas tenemos activas en nuestro sistema si utilizamos la función phpinfo de la siguiente manera:

<?php phpinfo(); ?>


JPOP


jPOP (JavaScript Powered On PHP) es una alternativa ideal para aquellos desarrolladores que quieran implementar Ajax en sus aplicaciones sin sobrecargar las páginas (la librería base pesa alrededor de 16 KB) ni gastar demasiado tiempo en realizar las configuraciones necesarias para que todo funcione. Su uso es libre, y podemos descargar la última versión disponible si visitamos la página que se encuentra en la dirección web http://jpop-framework.sourceforge.net.

Descomprimidos los archivos, copiamos en un directorio accesible por las demás páginas y configuramos el archivo config.php. La variable path indica la ruta hacia el directorio que contiene la raíz de la distribución jPOP el que incluye al archivo jPOP.php:

$path = ‘./jPOP/’;

Para disponer de las funcionalidades de esta librería, debemos ubicar en cada página la siguiente línea, suponiendo que jPOP se encuentra en un directorio llamado jPOP:

<?php require(‘jPOP/jPOP.php’); ?>
Y por último, generar el código JavaScript necesario a través del método init:

<head> <?php jPOP::init(); ?> </head>

jPOP posee tres funciones principales:
  • newAjaxControl
  • newAjaxDiv
  • newAjaxLink
jPOP incluye Prototype en su distribución, permitiendo incluir los efectos y comportamientos disponibles. Prototype es un framework JavaScript de propósito general orientado a objetos, que podemos descargar desde su página oficial: www.prototypejs.org

XAJAX




A diferencia de Sajax, Xajax (www.xajax-project.org) es una librería orientada a objetos. Admite más opciones y conserva la facilidad para implementar Ajax.

Xajax funciona con Apache o IIS (Internet Information Server, para Windows XP o su periores) y precisa de PHP versión 4.3 o superiores. En lo referido a los navegadores, soporta Internet Explorer 5.5 y superiores, Firefox 1.0 y equivalentes, Safari 1.3, y Opera 8.5. De todos modos, no debemos olvidarnos de que el soporte para ésta y las demás librerías se actualiza de manera permanente, por lo que recomendamos acceder a los sitios oficiales para obtener la información de última hora al respecto.

Para disponer de Xajax en una aplicación, primero debemos descargar la distribución, copiarla a un directorio accesible desde las demás páginas, e incluir el archivo xajax.inc.php en cada una de ellas:

require_once(“xajax.inc.php”);

Y luego crear una instancia de la clase xajax:

$xajax = new xajax();

Nuevamente, tendremos que definir las funciones en PHP, registrarlas y generar el código JavaScript necesario para disponer de ellas (mediante el método denominado printJavascript, que se ubica dentro del elemento HEAD de la página). Además, antes de cualquier salida, debemos incluir una llamada al método processRequest, que procesa y maneja las peticiones.

SAJAX



Sajax (Simple Ajax) es una herramienta que nos permite desarrollar aplicaciones web utilizando Ajax. Además de PHP, incluye soporte para ASP, Cold Fusion, Io, Lua, Perl, Python y Ruby. Es software libre y se distribuye bajo la licencia BSD. Podemos encontrar más información en http://absinth.modernmethod.com/sajax. Es compatible con los siguientes navegadores web: Internet Explorer, Mozilla Firefox, Safari y también Opera.

Para trabajar con Sajax, tendremos que definir funciones en PHP, que deberemos registrar previamente para ser aceptadas por la aplicación cliente.

Las funciones en el lado cliente tienen el mismo nombre que las funciones del lado servidor, pero precedidas por x_ (x guión bajo). El último argumento a las funciones x_ es el nombre de la función JavaScript que recogerá el resultado obtenido como respuesta (función callback). A continuación veremos una serie de ejemplos donde presentaremos tanto las funciones del lado del cliente, como las funciones del lado del servidor, y la interacción entre ellas a través de Sajax.

Sajax se encarga de crear el código necesario para que podamos acceder desde el lado cliente a las funciones PHP registradas.

Elementos estructurales y semántica en HTML 5


Sabemos que en nuestra lengua, la semántica se refiere al significado que tienen las estructuras y elementos lingüísticos que la componen; esto se aplica en forma similar a los lenguajes de programación.

Cuando hablamos de un lenguaje de etiquetas, como HTML, la semántica se refiere al significado que tienen los elementos. Veamos un caso concreto para comprenderlo mejor. Si pensamos en la etiqueta <h1>, sabemos que se aplica sobre títulos que tengan la máxima jerarquía en una página web. Su valor predeterminado en la representación de la mayoría de los navegadores está definido por una
tipografía Serif (por lo general, Times New Roman) y un tamaño de 2 em. Ahora bien, para la semántica, lo importante de <h1> es definir un elemento que será el título principal del contenido de esa página; los aspectos de representación son características que pueden (y deben) ser definidos desde los estilos que corresponden a CSS.

Es necesario recordar que este concepto debemos trasladarlo al resto de los elementos de HTML y tener en cuenta que su uso debe estar relacionado con el objetivo para el cual han sido creados en el lenguaje y no, en la manera en que se representan por defecto.

La Web semántica siempre estuvo en la cabeza de Tim Berners-Lee desde los comienzos de sus proyectos. Y es ahora, en esta nueva etapa de la web, con la aparición del lenguaje HTML5 como
estandarte, cuando el sueño del padre de la Web por fin comienza a tomar un papel mucho más relevante.

Con la web semántica se abren nuevos caminos. Por ejemplo, es posible que los agentes informáticos logren reconocer los elementos por su significado semántico y, posteriormente, puedan guardar esa
información para que, en otra etapa, se actúe sobre la base de ella. Esto contribuirá también a la creación de aplicaciones y dispositivos cada vez más robustos e inteligentes, que podrán resolver mayor cantidad de situaciones de manera totalmente automática.

Declaración de página y cabecera del documento
Cuando observamos una página HTML, en primer lugar encontraremos la declaración del tipo de documento. Una de las buenas noticias que nos trae HTML5 es, precisamente, la simplificación
de la declaración del tipo de documento. A partir de ahora, solo debemos indicar: <!DOCTYPE html>. Es importante recordar que esta declaración se ubica antes de escribir la etiqueta <head>.
Dentro de <head>, debemos incluir el título <title> y también las etiquetas <meta> para los metadatos.

En lo que se refiere a la etiqueta <meta>, en HTML5 soporta los atributos charset (nuevo en HTML5, permite definir la codificación de los caracteres), content, http-equiv y name, deja de soportar scheme.
Entre los atributos <meta>, es importante resaltar los valores que puede recibir name a partir de HTML5 (debemos tener en cuenta que algunos de ellos son heredados de HTML4):

  • author: autor del documento.
  • copyright: información de copyright del documento.
  • description: descripción del documento.
  • distribution: define el nivel de distribución del documento.
  • generator: permite especificar con qué programa se creó el documento.
  • keywords: posibilita introducir las palabras clave relacionadas con el documento (se escriben separadas por comas).
  • progid: este atributo nos permite indicar la id del programa que estamos usando para generar el documento.
  • rating: permite indicar el rating de la página.
  • resource-type: permite indicar el tipo de recurso.
  • revisit-after: permite definir la tasa de actualización de la página.
  • robots: brinda la posibilidad de indicar reglas para los robots.
  • others: se puede utilizar para definir names propios en el esquema.

Estructura semántica de documentos en HTML5
Recordemos que conocer el significado semántico de los elementos que componen los lenguajes que interactúan en la Web, resulta fundamental para crear cimientos sólidos para todas las páginas que conforman la estructura de nuestros sitios Web.

Como ya hemos mencionado, una de las características más valoradas de HTML5 está relacionada con la semántica. En este sentido, HTML5 introduce elementos específicos para poder definir secciones del documento y también características que pretenden hacer de la semántica una capacidad importante para el lenguaje.


En lo que se refiere a la estructura del documento, en HTML4 estábamos acostumbrados a definir las partes del cuerpo mediante el uso de la etiqueta <div>. El problema se planteaba en la imposibilidad de asignarles la semántica correspondiente a las diferentes partes. Por ejemplo, si bien podíamos aplicar una id con el valor nav o footer (barra de navegación y pie), esto no era más que el valor de un atributo y no le daba un significado semántico diferente al elemento.


A partir de HTML5 se definen etiquetas que nos permiten estructurar el cuerpo de una página con una semántica específica para cada elemento. Entre estas etiquetas encontramos:

  • <header>: se utiliza para definir la cabecera de la página. No hay que confundir esta etiqueta con <head>, ya que <header> se emplea para elementos del cuerpo del documento.
  • <hgroup>: brinda la posibilidad de agrupar títulos con subtítulos. Por ejemplo, en el caso de que, luego de un título <h1>, ubiquemos un subtítulo <h2> que se relaciona de manera directa con el primero.
  • <nav>: esta etiqueta está pensada para definir la barra de navegación del sitio web. Aquí podremos definir enlaces internos y también hacia otros sitios. Cabe destacar que no todo conjunto de enlaces es una barra de navegación.
  • <section>: se encarga de definir una sección de contenido que se representa en la página. Vale destacar que no se trata de un contenedor genérico, como puede ser un <div>.
  • <article>: sirve para definir artículos o contenidos que pueden ser individualizados. Por ejemplo, se podría utilizar para contener cada noticia o post en un sitio de noticias o blog. En ese contexto, también podría utilizarse para individualizar comentarios.
  • <aside>: se puede emplear para todo el resto de las cosas que se incluyen en el sitio y no está directamente relacionado con el contenido principal de dicha página (aunque sí puede estar referido de alguna manera). Puede utilizarse como sidebar en un sitio web o blog, aunque esa no es su única aplicación.
  • <footer>: se utiliza para el pie de la página. Más adelante, en este mismo capítulo, veremos cómo realizar una estructura utilizando las etiquetas que analizamos.

También encontramos la etiqueta denominada <figure>, que puede actuar de manera independiente o junto con <figcaption>. A continuación, nos preocuparemos de analizar un ejemplo que agrupa
varias imágenes con un epígrafe descriptivo.

La etiqueta <time> nos permite incluir información de hora (en formato de 24 horas) o fecha del calendario Gregoriano (también podemos incluir opcionalmente la hora).
Con la etiqueta <details>, es posible describir detalles de un documento (o de algunas partes de este). Con <summary>, se puede especificar un sumario que ofrezca detalles del documento.
En lo referido al texto, debemos saber que se incorpora <mark> para indicar que un texto está marcado o destacado.

Como podemos ver, las etiquetas que nos permiten definir una estructura semántica en nuestros documentos HTML nos brindan la posibilidad de dar un paso adelante en un código mucho más
claro de leer, tanto para los desarrolladores como también para los agentes informáticos, por ejemplo, los robots de los buscadores o los dispositivos electrónicos que requieren estas particularidades para facilitar las características de accesibilidad.

Atributos soportados
Entre los atributos que soportan los elementos <header>, <hgroup>, <nav>, <section>, <article>, <footer>, <figure> y <figcaption>, encontramos algunos que se heredan de la versión 4 de HTML:
accesskey, class, dir, id, lang, style, tabindex y title.
Para estos elementos, también podemos aplicar los nuevos atributos de HTML5, entre los que figuran: contenteditable (soporta true o false y permite indicar si un elemento puede ser editado o no
por el usuario), contextmenu (permite especificar el menú contextual para un elemento), draggable (soporta true, false o auto; permite indicar si un elemento puede ser arrastrado), dropzone  (soporta copy, move o link; permite indicar qué hacer cuando un ítem es arrastrado sobre ese
elemento), hidden (se utiliza para indicar cuando un elemento se encuentra oculto) y spellcheck
(tengamos en cuenta que se emplea para la ortografía y gramática de un elemento).
Por parte de <time>, entre los atributos encontramos datetime (se utiliza si la fecha y la
hora no se incluyen en el elemento y deseamos especificarlas por medio de este atributo). El otro
atributo soportado es pubdate (booleano); cuando se coloca, permite especificar si la hora y fecha del elemento son las que corresponden al documento o al elemento antecesor (<article>) que resulta más próximo.

Para cada artículo (<article>) no debería haber más de un elemento de tiempo (<time>) con el atributo pubdate definido. Por otro lado, <details> soporta el atributo open, que permite indicar si está abierto el detalle, es decir, si es visible; <summary> solo soporta los atributos globales de HTML5.

El atributo rel
En las versiones anteriores de HTML/XHTML, conocimos la importancia del atributo rel para agregarles información a los enlaces. En el caso de usar este atributo con <link>, le brindamos
más información al navegador; si lo usamos con <a>, le estaremos incluyendo datos que podrán ser útiles para los buscadores. También puede utilizarse con la etiqueta <area>.
Básicamente, el atributo rel nos permite establecer la relación entre el documento actual y el que se está vinculando.

Entre los valores que puede adquirir este atributo en el lenguaje HTML5 encontramos los que vemos en el siguiente listado:
  • alternate: vincula a una versión alternativa del documento.
  • archives: enlace a información histórica.
  • author: enlace a información relativa al autor del documento.
  • bookmark: vínculo a dirección permanente del documento.
  • external: enlace a un documento externo.
  • first: vínculo al primer documento de una selección.
  • help: enlace a un documento de ayuda.
  • icon: vínculo al icono del documento.
  • index: vínculo al índice del documento.
  • last: vínculo al último documento de una selección.
  • licence: vínculo a la información de licencia del documento.
  • next: vínculo al siguiente enlace de una selección.
  • nofollow: comúnmente se utiliza para indicar que los robots de los
  • buscadores no sigan el link correspondiente.
  • noreferrer: se trata de un valor que permite especificar que el navegador no debe enviar referrer en las cabeceras HTTP, es decir, que no indique desde qué página se llega a la siguiente.
  • pingback: la URL para hacer pingback.
  • prefetch: permite indicar que el documento debe ser cacheado.
  • prev: vínculo al documento previo de una selección.
  • search: se encarga de establecer un vínculo a la herramienta de búsqueda del documento correspondiente.
  • sidebar: se utiliza para el vínculo de los elementos secundarios del documento, los que se ubican en la sidebar.
  • stylesheet: vínculo a la hoja de estilos que se importa en el documento.
  • tag: etiqueta del documento actual.
  • up: permite indicar que el enlace está por encima del actual en un árbol jerárquico de documentos.
Vale aclarar que, en esta lista, se incluyen tanto los valores heredados que siguen vigentes así como también los que se incorporaron a partir de la versión 5 de HTML.

Los valores bookmark, external, nofollow y noreferrer no son soportados por <link>. Por su parte, icon, pingback, prefetch y stylesheet no pueden utilizarse con <a> ni con <area>.

Estructurar una página en HTML5
Con lo que ya hemos visto en este capítulo, tenemos suficientes datos para poder enfrentar la creación de nuestra estructura de página utilizando la semántica de HTML5, aunque aún debemos
revisar muchos conceptos importantes.