domingo, 4 de septiembre de 2011

Análisis del portátil HP Pavilion dv6-6151es (QC804EA)

Del 1 al 7 de septiembre de 2011 en la tienda Mediamarkt de Barakaldo encontramos este portátil HP Pavilion dv6-6151es al precio de 799 euros, un portátil muy potente de 15,6 pulgadas con el que podremos satisfacer la gran mayoría de nuestras necesidades.
La potencia viene proporcionada principalmente por el procesador Quad-Core y la tarjeta gráfica de gama alta que incorpora. En este portátil podría haber problemas con las temperaturas, ya que el calor a disipar de los componentes es elevado, pero HP ha conseguido con su sistema de refrigeración mantenerlas dentro de unos límites de seguridad.

El procesador que integra este HP Pavilion es un Intel Core i7-2630QM. Se trata de un procesador de cuatro núcleos y 8 hilos de procesado, cada núcleo funciona a una velocidad de 2 GHz pudiendo llegar uno de ellos a los 2,9 GHz gracias a la tecnología TurboBoost. Este procesador va a tener un rendimiento extraordinario para todas las tareas que le exijamos al portátil, ya que se trata uno de los micros más potentes del mercado de portátiles. Los 6 MB de memoria caché se agradecerán en tareas como la edición de vídeo y el uso de programas pesados, dando una agilidad extra al ordenador en todas las demás situaciones. Pertenece a la nueva generación de procesadores de Intel, los llamados Sandy Bridge, y no se han detectado problemas de temperaturas excesivas con ellos, como sí pasó con los Core i7 de la antigua generación.

Otro de los componentes destacados de este HP es su tarjeta gráfica, una ATI Radeon HD 6770M con 2 GB de memoria GDDR5, una bestia si consideramos que nos encontramos en un portátil de menos de 800 euros. Tiene un rendimiento un 25-30% superior a la nVidia GT 540m, con lo que nos aseguramos jugar de forma fluida a la mayoría de juegos de la actualidad con detalles altos o muy altos y pudiendo aplicar filtros de mejora de la imagen. Cuenta con una tecnología parecida a nVidia Optimus, se llama AMD Dynamic Switchable Graphics, con ella podremos utilizar la tarjeta gráfica integrada en el procesador Sandy Bridge cuando no se requiera tanta potencia gráfica, consiguiendo así ahorrar batería. También incorpora las instrucciones ATI Stream, similares a las CUDA de nVidia, que para codificar vídeos y para programas que incorporen estas instrucciones nos vendrá bien. La salida HDMI facilitará el uso de este gran portátil como centro de diversión familiar.

Una cosa que no me ha gustado es la inclusión de un disco duro de 5400 RPM, ya que normalmente HP para esta gama de productos incorpora unos de 7200 RPM, más veloces aunque con un mayor consumo. La capacidad utilizada es de 750 GB, que de todas formas está bastante bien. La memoria RAM es de 6 GB dividida en un módulo de 4GB en un zócalo y otro de 2GB en el otro zócalo, con lo que en un futuro podríamos quitarle el módulo de 2GB y reemplazarle por otro módulo de 4GB para llegar a los 8GB que son lo maximo que permite este portatil. La conectividad es un apartado a destacar en este HP Pavilion DV6, ya que cuenta con dos puertos USB 2.0 y dos USB 3.0 con vistas al futuro. La conexión inalámbrica viene asegurada por el adaptador wifi b/g/n que incorpora. Lamentablemente no trae Bluetooth así que si se necesita no queda más remedio que comprarlo aparte y ponerselo en uno de sus 4usb's. La webcam con tecnología TrueVision y con micrófono digital integrado mejorará las conferencias en condiciones de luz escasa.

Los acabados son en aluminio, con lo que disiparán de una forma más eficiente el calor generado por todos los componentes. Destacar el mayor peso con sus 2,91kg frente a los 2,6 kg de los portátiles de 15,6 pulgadas debido a los elementos de refrigeración interna. El teclado es completo, con su apartado numérico. Dispone de un lector de huellas dactilares con el que supongo que nos podremos identificar para encender el ordenador aunque también permite loguearse en aplicaciones tipo hotmail, facebook o linkedin. La batería es de 6 celdas, pero debido al excesivo consumo de los componentes nos dará una duración de 3 horas y media con un uso básico del portátil. Y el sonido con el sistema de audio beats ofrece una alta calidad a través de sus dos altavoces.

En definitiva, estamos ante un portátil con un precio excepcional para aquellos que necesiten potencia ya sea para jugar o para trabajar.

Link a la página de HP con las especificaciones del portatil
Link a un video de los portatiles HP dv6 en el que aparece este portatil (solo que éste no trae lector de Blu-ray)

sábado, 3 de septiembre de 2011

Consejos para alargar la vida de las bateri­as de ion de litio

Hoy en día son muchos los dispositivos que actualmente utilizan baterías de ión litio (móviles, portátiles, consolas, reproductores mp3, receptores GPS, etc). En contra de lo que nos enseñaron con los primeros móviles donde las baterías eran de níquel, ahora todo ha cambiado y a las empresas les interesa que la gente siga creyendo lo mismo, ya que las baterías de ión litio suelen tener de unos 300 a 400 ciclos de carga/descarga completa (es decir, de 0 a 100% de carga).

Evita en lo posible que tu batería se descargue por completo con frecuencia.

En contraposición a la creencia general sobre el cuidado de baterías, dejar que tu batería se agote del todo antes de ponerla a cargar hace que ésta se vaya deteriorando poco a poco. Para las baterías de ión de litio es mucho mejor hacer recargas frecuentemente, sin que se hayan descargado demasiado. Lo ideal será recargar por completo nuestras baterías cuando éstas se encuentran al 50% -60% de su capacidad. Para poneros un ejemplo, yo sigo esa política con mi portátil, durándome unos 4 días (dependiendo del uso, claro. Puede ser menos, o incluso más de 4 días) en llegar al 50%-60% de su capacidad. Es entonces cuando vuelvo a cargarla hasta el 100%. Nunca la he tenido a menos del 50% de capacidad.
Esto quizás le choque la gente que tenga un portátil y piense que la duración de la batería de su portátil ha disminuído considerablemente por culpa de cargarla sin dejar que se agotase. Pues que no se arrepientan de no haberla cuidado más, porque no podrán hacer nada. Si la batería es de ión de litio la política que hay que seguir es la que he mencionado aquí. El problema es que las baterías de portátil tienen un problema “de nacimiento”: La duración de las baterías de Ion de litio se ve seriamente afectada por las altas temperaturas. Es la alta temperatura que alcanzan los portátiles lo que hace que la duración de su batería descienda tan rápidamente. Una forma de “alargar su vida” podría ser quitarle la batería cuando lo tenemos enchufado (aunque algunos fabricantes advierten de que el polvo que se acumularía en el “hueco” de la batería también sería problemático).

En resumen, cargar una batería de ión de litio cuando ésta no está descargada por completo no daña en absoluto la batería (eso pasaba con las baterías basadas en níquel).

En las baterías con indicador de carga (por ejemplo las de los portátiles y de la PSP), es ideal realizar un recalibrado una vez cada 30 cargas normales (de esa que indicaba de volver a cargar sobre el 50%).
Algunas baterías tienen incluido un circuito que sirve como indicador de batería (que sirve por ejemplo para indicar con un LED su nivel de carga). Pues con las sucesivas cargas de estas baterías, el indicador va perdiendo poco a poco precisión. Para evitar esto, es bueno realizar un recalibrado, es decir, dejar que la batería se descargue por completo y entonces cargarla hasta el 100%. Esto no choca contra la primera pauta, ya que este recalibrado lo deberíamos hacer una vez cada 30 cargas de las normales, más o menos.

Intenta mantener la batería a una temperatura normal, incluso algo fresquita, así no te pasará lo que pasa con los portátiles. Cuando vayas a guardar una batería y vaya a estar mucho tiempo sin ser utilizada, lo mejor sería guardarla en la nevera (sin que se congele, eh?) a un 40% de carga más o menos.

No compres baterías para el futuro
Mucha gente acostumbra a comprar una batería de repuesto para utilizar en un posible viaje que harán algún día y así poder cambiar directamente la batería cuando la primera se agote. Pero hay un pequeño problema con eso: por muy bien que las cuidemos, las baterías de ión de litio hoy en día tienen una vida limitada. Cuanto más tiempo pase sin que la utilicemos, más cerca estarán de su “fecha de caducidad”. Esto debería llevaros a desconfiar de las baterías en stock en las tiendas, aunque estén a muy buen precio. Mirad siempre sus fechas de fabricación antes de comprarlas. Y, si así y todo las compráis, pues entonces seguid las instrucciones de la pauta anterior.
Otros consejos relacionados con las baterías de los portátiles:
Antes de nada debemos tener en consideración que las baterías de Ion-Litio tienen una vida útil que suele ser de 300-500 ciclos de carga/descarga y de 2-3 años. Recordad que la cuenta atrás comienza cuando sale de la cadena de producción, no en el momento en el que se comienza a usar. Esto puede prolongarse algo por medio de los siguientes consejos.

Consejos para prolongar la vida útil de la batería:

1. EN BATERIAS DE ION-LITIO EVITAR que los ciclos de batería sean completos. Es mejor descargar y recargar parcialmente la batería de manera frecuente, que una descarga completa. Las descargas parciales en las baterías de ion-litio no son dañinas ya que no disponen de memoria. (Son las baterías basadas en Níquel las que necesitan descargas completas para ajustar la memoria digital de la batería con el estado de carga real. Estos dos tienden a desajustarse tras múltiples periodos de carga y descarga parcial, descargando completamente la batería se consigue un calibrado sincronizado entre el estado real de carga de la batería y la memoria digital en las baterías basadas en Níquel)
Descargar la batería y recargarla completamente SOLO DE VEZ EN CUANDO. (Sobretodo si la batería no ha sido usada hace un tiempo, para activar todos los componentes químicos. Se recomiendan 3 ciclos de carga/descarga.) o cada 30 ciclos completos de carga/descarga. No afectara a la vida útil de la batería, sino a la precisión del indicador de carga.

2. Ajustar las configuraciones del sistema para aprovechar al máximo la batería (Enhanced Speedstep, Powernow!, evitar escrituras a disco duro innecesarias (revoluciones), bajar brillo de pantalla, desactivar wifi cuando no sea necesario, desactivar dispositivos tras periodos de inactividad (discos, pantalla, ..), etc..)

3. Si no se va a usar la batería durante un periodo de tiempo, guardarla descargarla (con 40% de carga aprox.) y en lugares en los que NO este sometido a temperaturas altas y a los rayos del sol (Ej. Vehículo). Lugares frescos. En ningún caso, guardarla a carga completa en sitios calurosos.

4. Cuando el portátil se encuentre enchufado a la red eléctrica, quitar la batería. Si la batería se encuentra al 100% no seguirá cargando y funcionara únicamente con la red eléctrica.

5. Evitar comprar baterías y almacenarlas, ya que su vida útil se consume aunque no este en uso. Al comprar la batería observar la fecha de fábrica, teniendo precaución de NO comprar stock viejo aunque sea a precios baratos.

jueves, 1 de septiembre de 2011

Antivirus gratuito Microsoft Security Essentials


Microsoft Security Essentials, es un servicio gratuito para equipos que tengan instalado Windows original, te ofrece protección completa y avanzada contra amenazas malintencionadas tales como virus, troyanos, spyware y otro malware.

Obtener Microsoft Security Essentials es tan fácil como hacer clic en un botón de descarga. Tu sistema descargará Microsoft Security Essentials en el idioma que necesites y se instalará con unos pocos clics. Una vez que hayas instalado Microsoft Security Essentials, el software se actualiza automáticamente, para que descanses tranquilo.

Microsoft Security Essentials usa el servicio Microsoft Update para garantizar que las firmas, el motor antimalware y la aplicación se actualicen automáticamente. Las firmas de malware nuevas se descargan una vez al día, pero las firmas también están accesibles en tiempo real a través del servicio de firma dinámica. A medida que el panorama de amenazas cambia y surge nuevo malware, el motor de malware se actualiza y las nuevas características de la aplicación se descargan en tu equipo automáticamente a través del servicio Microsoft Update.

No afecta al rendimiento del equipo.
Microsoft Security Essentials no conlleva el peso de los productos de conjuntos de programas y tiene un tamaño de descarga muy inferior. Los exámenes y las actualizaciones se programan para ejecutarse cuando el equipo está inactivo y se usa un subproceso de baja prioridad. El límite de CPU garantiza que para la actividad de Microsoft Security Essentials no se use más del 50 por ciento de la CPU de manera que el sistema continúe realizando las tareas que seguramente esté realizando, como abrir archivos o ventanas del explorador, guardar archivos, y usar las funciones de cortar, copiar y pegar. Microsoft Security Essentials usa el almacenamiento en caché inteligente y el intercambio de memoria activo para que las firmas que no se utilicen no ocupen espacio, limitando así la cantidad de memoria utilizada aunque siga aumentando el volumen del malware conocido. Esto hace que Microsoft Security Essentials sea adecuado igualmente para los equipos más antiguos y para los modelos más pequeños y de menor capacidad actuales, como los ultraportátiles.

Para descargarlo haz click aquí

Fuel: un nuevo Framework MVC en PHP open source


FuelPHP es un reciente framework MVC para el desarrollo de aplicaciones web en PHP 5.3 con software libre y según indican en su web destaca por ser simple, flexible, rápido y ligero.  Por lo tanto podríamos decir que tiene similitudes con Codeigniter o Kohana en cuanto a simplicidad, sin embargo no se basa directamente en ninguno de ellos sino que por el contario, recoge conceptos de diseño exitosos de los principales frameworks y los integra en una única base para la implementación de aplicaciones web.

El desarrollo del framework ha sido veloz ya que lo empezó a finales de 2010 Dan Horrigan pero por el momento ya han publicado la versión 1.0.1.  La documentación también ha ido evolucionando rápidamente. Actualmente está dividida en secciones que se pueden revisar directamente y hay una guía de instalación pero por el momento no he encontrado ningún manual en el que indiquen como crear un proyecto con Fuel paso a paso.

Por el momento, poco más puedo decir pero en cuanto disponga de un poco de tiempo intentaré instalarlo y hacer unas pruebas porque parece un framework prometedor.

Crear informes con JasperReports en Java

Recientemente he estado comparando librerías para hacer reportes en java. Tras haber usado en proyectos anteriores otras librerías, finalmente me he decantado por  JasperReports ya que programando solo una plantilla .jrxml él se encarga de exportarla a un gran número de formatos y además dicha plantilla ya no tienes que crearla a mano sino que puedes hacerla en vista diseño con la herramienta opensource iReport.

JasperReports es una popular librería de reportes open source (LGPL) escrita en Java. Desafortunadamente no está muy bien documentada y puede costar un poco crear tu primer reporte si no buscas bien. Por ello, intentaré resumir todo lo necesario para empezar con JasperReports por si a alguien le puede servir.

Lo primero es descargar la última versión de esta herramienta, directamente desde la página del proyecto http://jasperforge.org/projects/jasperreports para poder descargar no es necesario registrarse en el sitio si pinchas donde pone “No Thanks, Continue to Download”, luego haces click en el primer enlace de la lista para descargar el zip que contenga la última versión (cuando yo lo hice era la JasperReports 4.0.2)

Una vez que termine la descarga, descomprime el archivo, aquí hay varias carpetas, la que nos interesa es la que dice lib y dist, de la carpeta dist, sacamos el jar de jasperReport que necesitemos dependiendo del tipo que sea nuestro proyecto, para un proyecto web cogeremos el jasperreports-4.0.2.jar y lo pegaremos en la carpeta lib de nuestro proyecto.

Tras esto, copia los siguientes jars de la carpeta lib de jasperReports a la carpeta lib de tu proyecto y agregalas al classpath para poder compilar los reports que crees con la herramienta iReport:
commons-beanutils-1.8.0.jar
commons-collections-2.1.1.jar
commons-digester-1.7.jar
commons-logging-1.0.4.jar
groovy-all-1.7.5.jar
iText-2.1.7.jar
jasperreports-4.0.2.jar
jasperreports-applet-4.0.2.jar
jasperreports-fonts-4.0.2.jar
jasperreports-javaflow-4.0.2.jar
jaxen-1.1.1.jar

Si te has descargado una versión más reciente de JasperReport no debes fijarte en los numeros de versión que aparecen en las librerías anteriores puesto que habrán cambiado.
Una vez ya tengas en el classpath todas las librerías, vamos a crear nuestro primer reporte, uno muy sencillo, todavía no voy a mostrar como pasarle datos ni parámetros, por el momento solo sacaremos un hola mundo en el reporte.
Para crear reportes el procedimiento es el siguiente, primero necesitas diseñar el report para lo cual lo mejor es utilizar la herramienta open source iReport que te permite evitarte tener que escribir el .jrxml (su formato es XML) del reporte a mano puesto que es un entorno como el del netbeans con vista diseño, vista de código y preview y es muy sencillo crear un reporte con ella.
Una vez que hayas creado el diseño del reporte lo guardas con extensión .jrxml, después necesitas compilarlo para generar su correspondiente archivo .jasper, la compilación se hace una sola vez y una vez que tienes el fichero.jasper lo cargas en memoria y le mandas los parámetros e información que quieres desplegar (en caso de que te sea necesario), lo exportas al formato deseado y lo guardas
Ahora que tenemos la idea del proceso completo, comenzaremos con el primer paso, el cual es diseñar el reporte en jrxml. Pero antes vamos a explicar los elementos que debe contener un típico fichero jrxml:
  • <jasperReport> - es el elemento raíz
  • <title> - su contenido se imprime solo una vez al comienzo de el reporte y como su nombre indica es el título que el reporte tendrá.
  • <pageHeader> - esta sección será impresa en cada página que el reporte contenga, es la cabecera del reporte.
  • <columnHeader> - esta sección se utiliza para poner la cabecera de la sección “detail”, en otras palabras el titulo de la información desplegada en el “detail”.
  • <detail> - esta sección  es el body del report, es decir, es donde se colocan la información a desplegar del reporte, generalmente en esta sección se despliegan tablas.
  • <pageFooter> - esta sección el pie de página y es impresa al final de cada página del reporte, aquí puedes poner el número de página o alguna otra información.
  • <band> - define una sección del reporte, todos los elementos de arriba contienen un elemento hijo <band>
Todos los elementos son opcionales, excepto el elemento raiz jasperReport A continuación veréis un ejemplo de jrxml para generar un simple reporte que muestra "Hello World!"

<?xml version="1.0"?>
<!DOCTYPE jasperReport
  PUBLIC "-//JasperReports//DTD Report Design//EN"
  "http://jasperreports.sourceforge.net/dtds/jasperreport.dtd">

<jasperReport name="Simple_Report">
 <detail>
    <band height="20">
      <staticText>
        <reportElement x="180" y="0" width="200" height="20"/>
        <text><![CDATA[Hello World!]]></text>
      </staticText>
    </band>
  </detail>
</jasperReport>

Para este simple ejemplo (le guardaremos con el nombre jasperreports_demo.jrxml) he omitido los elementos opcionales <title>, <pageHeader> y <pageFooter>. El elemento <staticText> como su nombre indica sirve para mostrar texto estático en el reporte, para ello contiene el elemento <text> en el cual introduciremos el texto que queramos que se muestre en el reporte.
Los jrxml necesitan ser compilados en un formato binario que es especifico para JasperReports. Para compilarlo hay que llamar al metodo compileReport() de la clase net.sf.jasperreports.engine.JasperCompileManager.
Hay varias versiones de este método, en nuestro ejemplo usaremos una en la que se le pasa un único parámetro de tipo String con la ruta relativa del jasperreports_demo.jrxml anterior.
A continuación se muestra la clase que genera el report:

public class JasperReportsIntro
{
  public static void main(String[] args)
  {
    JasperReport jasperReport;
    JasperPrint jasperPrint;
    try
    {
      //1)Compilamos el archivo XML y lo cargamos en memoria
      jasperReport = JasperCompileManager.compileReport(
          "reports/jasperreports_demo.jrxml");
 
      //2)Llenamos el reporte con la información y parámetros necesarios (En este caso nada)
      jasperPrint = JasperFillManager.fillReport(
          jasperReport, new HashMap(), new JREmptyDataSource());
 
      //3)Exportamos el reporte a pdf y lo guardamos en disco
      JasperExportManager.exportReportToPdfFile(
          jasperPrint, "reports/simple_report.pdf");
    }
    catch (JRException e){
      e.printStackTrace();
    }
  }
}       
En el ejemplo anterior primero compilamos el jrxml, para aplicaciones reales, esto basta con hacerlo solo una vez, y generas un archivo jasper, luego en el paso 2 se le pasan tres parámetros a la función fillReport, el cual es el reporte, un HashMap con los parámetros y no se le pasa información, por ahora no le estamos pasando nada, ya que esto es solo una introducción.
Espero que este post os haya servido como introducción y hasta la próxima!

jueves, 10 de febrero de 2011

Servidor REST con PHP y peticiones mediante jquery y ajax

Un servidor REST (Representational State Transfer) puede ser muy útil para la creación de aplicaciones HTML5. Utilizaríamos el servidor para el módelo de datos y el cliente (navegador) para la lógica de la aplicación, realizando llamadas ajax al servidor que devolvería los datos en formato JSON, por ejemplo. En un sistema REST, cada recurso es direccionable únicamente a través de su URI, y disponemos de un conjunto de aplicaciones (POST, GET, PUT y DELETE), propias del protocolo HTTP, para trabajar con esos recursos.
Por ejemplo, si disponemos de una base de datos de clientes y queremos objetener una lista con ellos, tendríamos que acceder a la URL del recurso "clientes", http://servidor.com/clientes. Una petición GET a este recurso nos devolvería un array con todos los clientes que tenemos en nuestra BB.DD. Si lo que queremos es obtener la información de un cliente en particular, por ejemplo el cliente con identificador igual a 00001, haríamos una petición GET a la url http://servidor.com/clientes/00001. Para crear un cliente nuevo tendríamos que enviar por POST una petición a http://servidor.com/clientes con los datos del nuevo cliente. Para modificar algún dato del cliente 00001 usaríamos una petición PUT con los nuevos datos a http://servidor.com/clientes/00001. Si la petición es DELETE a esa misma url, borraríamos ese registro de la BB.DD. Normalmente los datos que devuelve el servidor estarán en formato JSON o XML. Para nuestro ejemplo utilizaremos JSON, ideal para trabajar con aplicaciones javascript.
Para tratar mediante PHP las peticiones en nuestro servidor utilizaremos un código parecido a este:

Utilizando jquery es muy sencillo realizar peticiones a nuestro servidor con la función $.ajax:
Con estas simples indicaciones ya tenemos las bases para la construcción de una aplicación. Si diseñamos bien nuestro modelo de datos tendremos la oportunidad de crear gran variedad de aplicaciones para distintos tipos de clientes (navegadores web, móviles, aplicaciones de escritorio ...), sin tener que modificar nuestro servidor, utilizando un método estandar, sencillo e intuitivo.

miércoles, 15 de septiembre de 2010

Ontologías con Jena

En esta entrada veremos, mediante ejemplos muy simples, cómo podemos gestionar nuestra ontología con Jena. Los puntos que abordaremos serán: 1. Crear una ontología desde cero con la API de Jena, 2. Leer datos de una ontología, 3. Escribir datos en la ontología y 4.Cargar una ontología previamente creada.
Usaremos la versión 2.6.4 de Jena, disponible en su web oficial.
Empecemos…

Conceptos iniciales

Durante esta entrada vamos a manejar una serie de conceptos, que creo que es conveniente describir un poco, para que nadie se pierda y pueda seguir el hilo fácilmente.
En primer lugar usaremos el término “Clase“. Una Clase será un conjunto de conceptos relacionados jerarquicamente que nos permitirá identificar y clasificar elementos de un dominio de forma concisa y concreta. Podemos pensar en las clases de una ontología como las clases de un diseño de POO (Programación Orientada a Objetos). La gran diferencia es que nuetra ontología tendrá un significado semántico que no tendrá nuestro diseño de clase de POO. Por supuesto una clase tendrá subclases, superclases, clases hermanas, …, todo lo relacionado con la herencia. Toda ontología tiene siempre una clase base de la que parten todas las demás. (owl:Thing)
Usaremos el término “Instancia“. Una instancia será una representación concreta de una clase. Una instancia quedará identificada y definida por la clase a la que pertenezca y por toda la jerarquía de clase que haya por encima. Además, una instancia definirá valores concretos para todas las propiedades que tenga la clase a la que pertenece.
Aquí entra en juego otro término. “Propiedades“. Las propiedades son la forma de asignar más contenido a una clase. Por tanto, las propiedades se definen a nivel de clase. Hay tres tipos básico de propiedades: 1. Propiedades de objeto: Su valor es un objeto (Instancia) de la ontología, 2. Propiedades de Datos: Su valor es un dato de tipo primitivo (int, float, string,…) y 3. Propiedades de Anotación: Sirven para escribir anotaciones y descripciones en lenguaje natural.
No vamos a ver ningún tipo de restricción lógica en esta entrada, ya que el objetivo es mostrar una breve introducción a Jena y establecer algunos conceptos más básicos y útiles. Bueno, creo que con estos conceptos en mente, podemos empezar a ver algo de código. Usaremos el lenguaje Java.

1. Crear una ontología

Lo primero para crear una ontología es documentarnos mucho y a fondo, sobre el dominio en el que vamos a movernos. Las ontologías deben ser lo más detalladas posible, no debe haber lugar a duda. Debemos ser capaces de identificar inequívocamente un elemento (Instancia) en cualquier momento. No debe haber posibilidad de confusión a la hora de obtener información de una instancia.
Nosotros, en esta entrada, vamos a trabajar con una ontología muy sencilla y muy simple, que nos servirá a modo de ejemplo. Nuestro dominio serán los Animales. Dividiremos a los animales en dos grupos: Vertebrados e Invertebrados. Por tanto, tendremos una clase base que será Animales y dos subclases que serán Vertebrados e Invertebrados. La clase Animales, será una clase abstracta, no podrá tener instancia directas. De esta forma “obligamos” a que cualquier animal que forme parte de nuestra jerarquía sea Vertebrado o Invertebrado. Por supuesto Vertebrado e Invertebrado serán clases disjuntas: los animales que pertenezca a una, no podrán pertenecer a la otra.

La clase Animales tendrá una propiedad de tipo int, que será Peso, por tanto sus subclases, heredarán esta propiedad. Además crearemos cuatro instancias: Pulpo y Sepia (Invertebrados) y León y Leopardo (Vertebrados).
Es un ejemplo muy sencillo, hecho a modo de inicio, sin mayores pretensiones.
//Creamos nuestro modelo
OntModel model = ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM);

//Establecemos el NameSpace por defecto para nuestra ontología
String NS = "animales";
model.setNsPrefix(NS, "http://www.owl-ontologies.com/OntologyAnimals.owl");
Ya tenemos nuestro modelo vacío y listo para contener una ontología en lenguaje OWL y almacenarla en memoria principal. Lo siguiente será comenzar a crear nuestras clases, propiedades e instancias. El NameSpace es necesario para obtener una URI absoluta de cada elemento de la ontología. La dirección http que aparece en el ejemplo es inventada.
Vamos a crear las clases, las propiedades y las instancias:
//Clases. Hay que crearlas con el NameSpace definido
OntClass animales = model.createClass(NS+":"+"Animales");
OntClass vertebrados = model.createClass(NS+":"+"Vertebrados");
OntClass invertebrados = model.createClass(NS+":"+"Invertebrados");

vertebrados.setDisjointWith(invertebrados);
animales.addSubClass(vertebrados);
animales.addSubClass(invertebrados);

//Creamos la propiedad peso
DatatypeProperty peso = model.createDatatypeProperty(NS+":"+"Peso");
peso.addDomain(animales);//Clase a la que pertenece
peso.addRange(XSD.xint);//Tipo de la propiedad
peso.convertToFunctionalProperty();//Para que solo acepte un valor.

//Creamos las instancias y damos valor a la propiedad Peso
Individual leon = model.createIndividual(NS+":"+"Leon",vertebrados);
leon.setPropertyValue(peso, model.createTypedLiteral(250));

Individual leopardo = model.createIndividual(NS+":"+"Leopardo",vertebrados);
leopardo.setPropertyValue(peso, model.createTypedLiteral(200));

Individual pulpo = model.createIndividual(NS+":"+"Pulpo",invertebrados);
pulpo.setPropertyValue(peso, model.createTypedLiteral(10));

Individual sepia = model.createIndividual(NS+":"+"Sepia",invertebrados);
sepia.setPropertyValue(peso, model.createTypedLiteral(1));

//Almacenamos la ontología en un fichero OWL (Opcional)
File file = new File("C:\\Animales.owl");
//Hay que capturar las Excepciones
if (!file.exists()){
     file.createNewFile();
}
model.write(new PrintWriter(file));

2. Leer datos de la ontología

Llegados a este punto, ya tenemos nuestra ontología de Animales creada y almacenada en un fichero OWL en nuestro disco duro. Lo siguiente que vamos a hacer es recorrer las clases que tiene nuestra ontología y mostrar las instancias que tiene cada clase. Para ello haremos uso de los Iteradores.
//Recorremos la ontologia
for (Iterator<OntClass> i = model.listClasses();i.hasNext();){
 OntClass cls = i.next();
 System.out.print(cls.getLocalName()+": ");
 for(Iterator it = cls.listInstances(true);it.hasNext();){
  Individual ind = (Individual)it.next();
  if(ind.isIndividual()){
   System.out.print(ind.getLocalName()+" ");
  }
 }
 System.out.println();
}

3. Escribir datos en la ontología

Vamos a ver cómo podemos cambiar el valor de la propiedad peso para cualquier instancia. Si queremos añadir nuevas instancias o nuevas propiedades, simplemente tendremos que seguir los pasos del punto 1.
Para cambiar el valor de la propiedad “Peso” de cualquier instancia, simplemente debemos hacer lo siguiente:
//Obtenemos la instancia y la propiedad y le damos un nuevo valor
model.getIndividual(NS+":"+"Leon")
              .setPropertyValue(model.getProperty(NS+":"+"Peso"),
                                           model.createTypedLiteral(255));

4. Cargar una ontología previamente creada

Para cargar una ontología que tengamos previamente almacenada en el disco duro (en un fichero OWL), debemos simplemente utilizar el método read() de la clase OntModel. A este método debemos pasarle por parámetro una URI absoluta y bien construida que contenga la ruta al fichero en disco. Bueno, en realidad tenemos que pasarle un String que contenga una URI absoluta.
Simplemente sería:
OntModel model = ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM);
model.read("file:C:/Animales.owl","RDF/XML");
Y listo, a trabajar con nuestra ontología.

Más info

Jena | Web Oficial
API Jena | http://jena.sourceforge.net/javadoc/index.html