La Gaceta de Linux ...¡ haciendo a Linux un poco más divertido !

RDF y la Web Semántica

By Jimmy O'Regan

Traducción al español por Eleonora Batt
el día 17 de Septiembre de 2005, para La Gaceta de Linux

RDF es un marco para definir metadatos; datos que describen datos. Fue desarrollado por el W3C, basado en un trabajo realizado porRamanathan V. Guha, y fue originalmente usado en la característica de Navegación inteligente ("¿Con qué se relaciona esto?") de Netscape Navigator 4.5, y por elDirectorio abierto. RDF siguió a un trabajo que Guha había realizado anteriormente, ambos en el proyecto Cyc, y en el proyecto Hotsauce de Apple.

RDF actualmente se usa en varias áreas: MusicBrainz lo usa para proveer información en las playlist (listas de temas musicales a ser reproducidos) acerca de álbums y canciones, como reemplazo de formatos tales como los archivos M3U de winamp, or el ASX de Microsoft; Mozilla lo usa para varios propósitos: e.g. guardar detalles de archivos descargados (muestra), recordar qué acción realizar para cada tipo de MIME, y demás. RDF también se usa en algunas variantes de RSS para proporcionar detalles acerca de artículos sindicados.

RDF es un componente clave de la Web Semántica. En un artículo publicado en mayo de 2001 en Scientific American, Tim Berners-Lee et al. describieron este concepto:

La Web Semántica es una extensión de la web actual donde a la información se le da significado bien definido, proporcionando a las computadoras y a las personas una mejor posibilidad de trabajar en cooperación.

La Web Semántica es el futuro "gran suceso" de la Web: el W3C está desarrollando varias tecnologías, basadas alrededor de RDF, lo cual proporciona una manera legible para las máquinas de representar metadatos. Varios esquemas existen ya:RSS 1.0, para resumir los contenidos de un sitio (los sitios de noticias proporcionan canales de información (feeds) de  las noticias que contienen a través de RSS);OWL, que proporciona una base para crear nuevos esquemas a la vez proveyendo compatibilidad con esquemas similares; FOAF, que proporciona una manera de describir personas y la relación entre ellas. Hay muchos otros también. Edd Dumbill incluso ha propuesto que los metadatos de GNOME se represente en RDF.

Breve historia del RDF

Cyc es un proyecto para crear inteligencia artificial con un "sentido común" básico. Consta de una gran base de datos que contiene definiciones tales como: un árbol es una especie de planta, un sicomoro es una especie de árbol, etc. Cyc puede por lo tanto deducir de estas definiciones que un sicomoro es una planta. Si bien el trabajo continúa en pos de una versión comercial de Cyc, también existe una versión de código abierto,OpenCyc.

Hotsauce fue un plug-in para navegadores web creado por Apple en 1996 que permitía a los usuarios utilizar navegación 3D en un sitio que incluyera una definiciónMCF. MCF, Meta Content Framework, (Marco de Meta Contenido) era una definición basada en texto que se utilizó en formatos de tipo RFC822 para describir un sitio. Siguiendo los ejemplos que encontré en Internet, he creado un ejemplo propio que describe el trazado de un sitio sencillo.

Cuando Guha se mudó a Netscape, se encontró con Tim Bray, co-autor del XML 1.0, y los dos trabajaron en crear una versión basada en XML del MCF, que enviaron al W3C en mayo de 1997. (También he creado un ejemplo sencillo de esto).

Con la adición de espacios de nombre (namespaces) a XML, RDF empezó a cobrar su forma actual. RDF usa espacios de nombre de XML para extender su vocabulario usando esquemas RDF, aunque vale la pena hacer notar que si bien el XML es el formato contenedor más común para RDF, también se usan otros formatos. El W3C usa un formato diferente llamado N3 (Notation3), que tiene gran similitud con los idiomas de estilo LISP, tales como el CycL y elKIF.

Los esquemas RDF separan los datos RDF - definiciones de cómo términos nuevos se relacionan unos con otros - de los metadatos "normales". En vez de definir la relación entre distintos elementos, tales como "A es hijo de B y una especie de C", como se hacía en MCF y MCF-XML, éstos son definidos en esquemas separados, a los cuales se puede hacer referencia usando y reusando espacios de nombre de XML  (aunque también es posible incluir un esquema en el documento).

Declaraciones RDF

Cualquiera que se sienta interesado en aprender acerca de RDF haría bien en leer el RDF Primer de W3C, y/o "Una guía seria de la Web Semántica para la gente de XML", pero haré mi mejor esfuerzo en explicar los conceptos.

Cada declaración RDF se llama "triple", lo que significa que consiste de tres partes: sujeto, predicado y objeto; el sujeto puede ser tanto una URI RDF, o un nodo en blanco (no he visto buenas explicaciones acerca de por qué estos nodos están "en blanco", así que sólo me referiré a ellos como nodos). Por eso, reformulando la oración "Linux Gazette es el nombre del sitio en http://linuxgazette.net" se vé así:

http://linuxgazette.net tiene la propiedad name con el valor "Linux Gazette"

Los predicados sólo pueden ser URIs RDF - referencias a definiciones de esquemas de la propiedad - mientras que los objetos pueden ser URIs, nodos en blanco, o literales. Así podemos expresar el triple anterior como un N-Triple, lo cual es la forma válida más simple de RDF, así:

# Nótese que cada URI debe estar encerrada, y que cada triple debe terminar con un '.'
<http://linuxgazette.net>  <http://example.org/sample#name> "Linux Gazette".
En XML, el estilo general es:
<?xml version="1.0"?>
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">

<rdf:Description rdf:about="subject">
  <predicate>Object</predicate>
</rdf:Description>

</rdf:RDF>
por ende, al usar XML QNames, que sean URIs válidas, nuestro ejemplo se transforma en:
<?xml version="1.0"?>
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
        xmlns:example="http://example.org/sample#">
	
<rdf:Description rdf:about="http://linuxgazette.net">
 <example:name>Linux Gazette</example:name>
</rdf:Description>

</rdf:RDF>
RDF permite abreviar múltiples propiedades incluyéndolas en el mismo grupo de etiquetas, entonces:
<rdf:Description rdf:about="http://linuxgazette.net">
  <example:name>Linux Gazette</example:name>
</rdf:Description>

<rdf:Description rdf:about="http://linuxgazette.net">
  <example:nickname>LG</example:nickname>
</rdf:Description>
es lo mismo que:
<rdf:Description rdf:about="http://linuxgazette.net">
  <example:name>Linux Gazette</example:name>
  <example:nickname>LG</example:nickname>
</rdf:Description>
He mencionado que los objetos pueden ser nodos: un ejemplo rápido de esto es:
<rdf:Description rdf:about="http://linuxgazette.net">
  <example:editor>
   <example:name>Ben Okopnik</example:name>
  </example:editor>
</rdf:Description>
A estos nodos se les puede poner identificadores, y uno  puede referirse a ellos a través del identificador, para mayor claridad:
<rdf:Description rdf:about="http://linuxgazette.net">
  <example:editor rdf:nodeID="ben"/>
</rdf:Description>

<rdf:Description rdf:nodeID="ben"> <example:name>Ben Okopnik</example:name> </rdf:Description>

FOAF

FOAF significa "Friend of a Friend" (Amigo de un amigo). FOAF fue diseñado como una forma de representar información acerca de la gente en línea, y la relación entre ellos. Las direcciones de correo electrónico se usan como identificadores, aunque dada la cantidad de correo basura que todos recibimos últimamente, también es posible usar un shalsum de una dirección de correo electrónico, o ambos.

FOAF se usa en sitios como plink ("People Link") donde las personas pueden conocerse unas con otras, también sitios como LiveJournal generan FOAF para que las interrelaciones entre los usuarios sean automáticamente descriptas. También estáSharedID, que es un intento de  construir un único servicio de registración basado en FOAF.

Mejor que hablar de esto al detalle hasta que dé náuseas, voy a mostrar un ejemplo simple, el cual debería ser relativemente auto-descriptivo. (Esto está basado en un ejemplo generado por FOAF-a-matic).

<rdf:RDF
     xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
     xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
     xmlns:foaf="http://xmlns.com/foaf/0.1/">
     
<foaf:Person rdf:nodeID="jimregan">
<foaf:name>Jimmy O'Regan</foaf:name>
<foaf:title>Mr.</foaf:title>
<foaf:givenname>Jimmy</foaf:givenname>
<foaf:family_name>O'Regan</foaf:family_name>
<foaf:nick>jimregan</foaf:nick>

<foaf:mbox rdf:resource="mailto:jimregan@o2.ie"/>
<foaf:mbox_sha1sum>9642c26da203ef143f884488d49194eb0747547c</foaf:mbox_sha1sum>

<foaf:homepage
rdf:resource="http://linuxgazette.net/authors/oregan.html"/>
<foaf:depiction
rdf:resource="http://linuxgazette.net/gx/authors/oregan.jpg"/>
<foaf:phone rdf:resource="tel:+353872441159"/>

<foaf:knows>
  <foaf:Person>
    <foaf:name>Mark Hogan</foaf:name>
    <foaf:mbox_sha1sum>7dbf56320b204be2e2bee161abed3ffc5825b590</foaf:mbox_sha1sum>
    </foaf:Person>
</foaf:knows>

</foaf:Person>

</rdf:RDF>

La mayoría de los elementos en FOAF pueden ser agregados tantas veces como uno lo desee - muchos de nosotros tenemos varias direcciones de correo electrónico, sitios web, etc.

Cualquier cosa que uno agregue a la definición <foaf:Person> de uno, se le puede agregar a cualquier otro nodo dentro del nodo <foaf:knows>.

<foaf:knows>
<foaf:Person>
<foaf:name>Mark Hogan</foaf:name>
<foaf:mbox_sha1sum>7dbf56320b204be2e2bee161abed3ffc5825b590</foaf:mbox_sha1sum>
<foaf:nick>Sprogzilla</foaf:nick>
<foaf:dateOfBirth>1997-06-29</foaf:dateOfBirth>
</foaf:Person>
</foaf:knows>

Más Detalles

Hay muchas cosas que se pueden describir usando FOAF, de lo útil a lo divertido (como la etiqueta <foaf:dnaChecksum>). Agreguemos algunas de las opciones más útiles, como aquellas generadas por LiveJournal:

<foaf:workplaceHomepage rdf:resource="http://www.dewvalley.com"/>
<foaf:schoolHomepage rdf:resource="http://www.lit.ie"/>
<foaf:schoolHomepage rdf:resource="http://www.gairmscoilmhuirethurles.ie/"/>
<foaf:dateOfBirth>1979-07-31</foaf:dateOfBirth>

<!-- Generated by LiveJournal -->
<foaf:page>
  <foaf:Document rdf:about="http://www.livejournal.com/userinfo.bml?user=jimregan">
  <dc:title>LiveJournal.com Profile</dc:title>
    <dc:description>
      Full LiveJournal.com profile, including information such as interests 
      and bio.
    </dc:description>
  </foaf:Document>
</foaf:page>

<foaf:weblog rdf:resource="http://www.livejournal.com/users/jimregan/"/>

<foaf:interest dc:title="charles dickens" rdf:resource="http://www.livejournal.com/interests.bml?int=charles+dickens"/>
<foaf:interest dc:title="foaf" rdf:resource="http://www.livejournal.com/interests.bml?int=foaf" />
<foaf:interest dc:title="guitar" rdf:resource="http://www.livejournal.com/interests.bml?int=guitar" />
<foaf:interest dc:title="linux" rdf:resource="http://www.livejournal.com/interests.bml?int=linux" />
<foaf:interest dc:title="linux gazette" rdf:resource="http://www.livejournal.com/interests.bml?int=linux+gazette" />
<foaf:interest dc:title="neal stephenson" rdf:resource="http://www.livejournal.com/interests.bml?int=neal+stephenson" />
<foaf:interest dc:title="open source" rdf:resource="http://www.livejournal.com/interests.bml?int=open+source" />
<foaf:interest dc:title="terry pratchett" rdf:resource="http://www.livejournal.com/interests.bml?int=terry+pratchett" />
<foaf:interest dc:title="wikipedia" rdf:resource="http://www.livejournal.com/interests.bml?int=wikipedia" />

Las etiquetas <dc:title> y <dc:description> son del esquema Dublin Core, así que tendríamos que cambiar nuestras definiciones de namespace para agregar la url:

<rdf:RDF
     xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
     xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
     xmlns:foaf="http://xmlns.com/foaf/0.1/"
     xmlns:dc="http://purl.org/dc/elements/1.1/">

También hay muchas otras formas de identificar las múltiples cuentas de mensajeros que uno tiene en línea:

<foaf:jabberID>jimregan@jabber.org</foaf:jabberID>
<foaf:icqChatID>113804615</foaf:icqChatID>

y muchos otros detalles variados.

Ahora bien, todo eso es muy interesante, pero ¿qué hay de las cosas menos útiles? FOAF tiene etiquetas para agregar cosas divertidas como los tipos de personalidad de Myers-Briggs, bloques de código geek e información .plan.

<foaf:myersBriggs>ENTP</foaf:myersBriggs>
<foaf:geekCode>
GCS/IT/MU/TW/O d-(+)>--- s: a--(-) C++(+++)>++++$
UBLAC++(on)>++++$ P++(+++)>++++ L+++>++++$ E+(+++) W+++>$
N+ o K++ w(++)>-- O- M !V PS+(+++) PE(--) Y+>++ PGP-(+)>+++
t+() !5 X+ !R tv+ b++(+++)>++++$ DI++++ D++ G e h r-
y--**(++++)>+++++
</foaf:geekCode>
<foaf:plan>Consiga un mejor trabajo</foaf:plan>

Otros Esquemas

FOAF contiene mucha información útil y entretenida, pero hay también muchos otros esquemas esperando ser usados.

Del lado divertido:

<rdf:RDF
     xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
     xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
     xmlns:foaf="http://xmlns.com/foaf/0.1/"
     xmlns:zodiac="http://www.ideaspace.net/users/wkearney/schema/astrology/0.1#"
     xmlns:quaff="http://purl.org/net/schemas/quaffing/">

<zodiac:Sign>Leo</zodiac:Sign>

<quaff:owesBeerTo rdf:nodeID="doyle"/>
<quaff:drankBeerWith rdf:nodeID="doyle"/>

<foaf:knows>
<foaf:Person rdf:nodeID="doyle">
<foaf:name>Jimmy Doyle</foaf:name>
<foaf:mbox_sha1sum>a0610d4a3086354b9ef1daf50d24de232115c965</foaf:mbox_sha1sum>
</foaf:Person>
</foaf:knows>

También hay esquemas externos más útiles - geo, para describir dónde se localiza un lugar; y srw para describir los idiomas que uno habla, lee y domina.

<rdf:RDF
     xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
     xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
     xmlns:foaf="http://xmlns.com/foaf/0.1/"
     xmlns:geo="http://www.w3.org/2003/01/geo/wgs84_pos#"
     xmlns:srw="http://purl.org/net/inkel/rdf/schemas/lang/1.1#">


<foaf:based_near>
  <geo:Point>
    <geo:lat>52.6796</geo:lat>
    <geo:long>-7.8221</geo:long>
  </geo:Point>
</foaf:based_near>

<srw:masters>en</srw:masters>
<srw:reads>fr</srw:reads>
<srw:reads>ga</srw:reads>

Una de las cosas interesante que uno puede hacer con localizaciones geográficas es hacer correr FoafGeoGraph en su archivo FOAF. Éste busca la localización geográfica de personas, o enlaces a sus archivos FOAF, de lo cual genera datos que se ingresan a XPlanet, los cuales pueden ser usados para mostrar su posición en relación con sus amigos. Lindo, ¿no?

También puede hacer referencia a otros documentos (aunque esto es parte de RDF). Por ejemplo, hay un esquema que representa datos de iCalendar en RDF. Usando esto, puedo proporcionar mi esquema de horiarios de trabajo y algunos cumpleaños de mi archivo foaf (work.cal.rdf.txt y birthdays.cal.rdf.txt, generados con este script en Perl script, del cual perdí el enlace):

<rdfs:seeAlso rdf:resource="http://linuxgazette.net/misc/oregan/work.cal.rdf.txt" dc:title="Esquema de Horarios de Trabajo"/>
<rdfs:seeAlso rdf:resource="http://linuxgazette.net/misc/oregan/birthdays.cal.rdf.txt" dc:title="Cumpleaños"/>
Ya he mencionado que es posible describir cuentas de mensajeros instantáneos con servicios como Jabber, y MSN. También es posible representar otras cuentas. Las cuentas de mensajeros instantáneos que no tienen una etiqueta específica disponible también pueden ser representadas usando la etiqueta<foaf:OnlineChatAccount>, mientras que otras cuentas usan la etiqueta <foaf:OnlineAccount>.
<foaf:holdsAccount>
  <foaf:OnlineChatAccount>
    <foaf:accountName>jimregan</foaf:accountName>
    <foaf:accountServiceHomepage dc:title="irc.freenode.net" rdf:resource="http://www.freenode.net/irc_servers.shtml" />
  </foaf:OnlineChatAccount>
</foaf:holdsAccount>

<foaf:holdsAccount>
  <foaf:OnlineAccount>
    <foaf:accountName>jimregan</foaf:accountName>    
    <foaf:accountServiceHomepage dc:title="Wikipedia" rdf:resource="http://en.wikipedia.org" />
  </foaf:OnlineAccount>
</foaf:holdsAccount>

Especificando una Relación

FOAF fue originalmente diseñado para describir la manera en que la gente se relaciona unos con otros, aunque esto parece haberse vuelto difícil de hacer funcionar. Aun así es posible transmitir esta información:

<dcterms seems to be required by rel -->
<rdf:RDF
     xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
     xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
     xmlns:foaf="http://xmlns.com/foaf/0.1/"
     xmlns:dcterms="http://purl.org/dc/terms/"
     xmlns:rel="http://purl.org/vocab/relationship/">

<rel:parentOf rdf:nodeID="markinho"/>

<foaf:knows>
<foaf:Person rdf:nodeID="markinho">
<foaf:name>Mark Hogan</foaf:name>
<foaf:mbox_sha1sum>7dbf56320b204be2e2bee161abed3ffc5825b590</foaf:mbox_sha1sum>
<foaf:nick>Sprogzilla</foaf:nick>
<foaf:dateOfBirth>1997-06-29</foaf:dateOfBirth>
<rdfs:seeAlso rdf:resource="http://linuxgazette.net/105/misc/oregan/mark.rdf.txt"/>
</foaf:Person>
</foaf:knows>

Red de Confianza

El robo de identidad se está transformando más y más en un problema en Internet. Para protegerse contra esto, hay un esquema disponible que describe varios aspectos de una firma PGP, y permite a un archivo FOAF ser firmado digitalmente.

(Para más información con respecto a firmar un documento FOAF, vea la página de Edd Dumbill).

<rdf:RDF
     xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
     xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
     xmlns:foaf="http://xmlns.com/foaf/0.1/"
     xmlns:wot="http://xmlns.com/wot/0.1/">

<!-- Firma para verificar el documento -->
<foaf:Document rdf:about="">
  <wot:assurance rdf:resource="foaf-example.rdf.asc" />
</foaf:Document>

<!-- mi firma -->
<wot:pubkeyAddress
rdf:resource="http://linuxgazette.net/104/misc/oregan/jimregan.asc"/>
<wot:hex_id> 773730F8</wot:hex_id>
<wot:length>1024</wot:length>
<wot:fingerprint>D675 279B 24AC BDC3 BAE9 BB7A 666C 30CA 7737 30F8</wot:fingerprint>

Co-Representación.

La Co-representación es un tema caliente en los círculos FOAF. La extensión lógica a decir que uno conoce a alguien es probarlo con una foto. Expandamos el primer ejemplo para mostrar una co-representación de Mark y yo:

<foaf:homepage rdf:resource="http://linuxgazette.net/authors/oregan.html"/>
<foaf:depiction rdf:resource="http://linuxgazette.net/gx/authors/oregan.jpg"/>
<foaf:depiction rdf:resource="http://linuxgazette.net/105/misc/oregan/IMAGE0004.jpg"/>
<foaf:phone rdf:resource="tel:+353872441159"/>

<foaf:knows>
<foaf:Person>
<foaf:name>Mark Hogan</foaf:name>
<foaf:depiction rdf:resource="http://linuxgazette.net/105/misc/oregan/IMAGE0004.jpg"/>
<foaf:mbox_sha1sum>7dbf56320b204be2e2bee161abed3ffc5825b590</foaf:mbox_sha1sum>
</foaf:Person>
</foaf:knows>

Nada especial, simplemente la misma etiqueta <foaf:depiction> en dos o más etiquetas <foaf:Person>, lo que hace más fácil para una computadora encontrar dónde dos personas están co-representadas.

El próximo paso en la co-representación va a ser la adición de una sinopsis SVG, para mostrar quién es quién en una foto, aunque desafortunadamente, a nadie se le ha ocurrido todavía una manera de hacer referencia a datos SVG que se encuentran en alguna computadora, de manera legible. (SVG, como formato basado en XML, es capaz de incluir metadatos RDF sin dificultad).

Otro problema es que SVG todavía no ha tenido mucha difusión, aunque la última versión de KDE lo soporta, y futuras versiones de Mozilla deberían soportarlo.

Como están las cosas, sin embargo, puede ser útil mostrar quién es quién entre humanos. Veamos por ejemploesta imagen, la cual muestra a mi hijo, a su amigo Adam, y a mí en el fondo. En el futuro, será posible usar cualquier imagen SVG como esta - que contiene un perfil invisible, con algunos metadatos adicionales, para entregar a la computadora información legible, de manera similar a los mapas de imágenes de HTML.

Por el momento, podemos usar una imagen como esta, que contiene los mismos perfiles pero está coloreada de manera diferente según cada persona que muestra, y simplemente decir que Mark está representado por el área verde, Adam por la roja y yo por la azul. (Uso el programasvgdisplay que viene con KSVG; aquellos sin un visor para SVG pueden ver esta imagen PNG para visualizar lo que mencioné).

DOAP

DOAP significa "Descripción de un Proyecto" ("Description of a Project"). DOAP es un vocabulario RDF, influenciado por FOAF, el cual fue creado por Edd Dumbill para proporcionar detalles acerca de un proyecto de software de código abierto. Al momento de escribir esta artículo, DOAP, como proyecto, sólo tiene una semana de antigüedad, y ya ha acaparado mucha atención.

DOAP está diseñado como reemplazo para diferentes formatos de descripción de proyectos, como los usados porFreshmeat o el Directorio GNU de Software Libre, lo cual complementa a FOAF. Aquí hay un ejemplo que describe Linux Gazette, generado usandoDOAP-a-matic (versión de texto):

<?xml version="1.0" encoding="iso-8859-15"?>
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" 
	 xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#" xmlns:doap="http://usefulinc.com/ns/doap#" 
	 xmlns:foaf="http://xmlns.com/foaf/0.1/" 
	 xmlns:admin="http://webns.net/mvcb/" 
	 xml:lang="en">
  <rdf:Description rdf:about="">
    <admin:generatorAgent rdf:resource="http://www.bonjourlesmouettes.org/doap-a-matic.php"/>
  </rdf:Description>
  <doap:Project>
    <doap:name>Linux Gazette</doap:name>
    <doap:shortname>LG</doap:shortname>
    <doap:homepage rdf:resource="http://linuxgazette.net"/>
    <doap:created>1995-07</doap:created>
    <doap:description>
      La Gaceta de Linux es una publicación mensual a través de internet, dedicada a proporcional una revista gratuita pra la comunidad de Linux y hacer a Linux ¡un poquito más divertido!
    </doap:description>
    <doap:shortdesc>La Gaceta de Linux es una publicación mensual a través de internet.</doap:shortdesc>
    <doap:mailing-list rdf:resource="http://linuxgazette.net/mailman/"/>
    <doap:programming-language>HTML</doap:programming-language>
    <doap:os>Linux</doap:os>
    <doap:license rdf:resource="http://linuxgazette.net/105/misc/oregan/OPL.rdf.txt"/>
    <doap:download-page rdf:resource="http://linuxgazette.net/ftpfiles/"/>
    <doap:download-mirror rdf:resource="http://www.tldp.org/LDP/LGNET/ftpfiles"/>
    <doap:maintainer>
      <foaf:Person>
	<foaf:name>Ben Okopnik</foaf:name>
	<foaf:nick>Ben</foaf:nick>
	<foaf:mbox_sha1sum>30073b332dac6fc812dcdd806ac1e9715ceac46a</foaf:mbox_sha1sum>
      </foaf:Person>
    </doap:maintainer>
  </doap:Project>
</rdf:RDF>

DOAP-a-matic no tiene soporte para el OPL, la licencia usada por LG, pero es simple definir una nueva (versión en texto):

<rdf:RDF xmlns="http://web.resource.org/cc/"
    xmlns:dc="http://purl.org/dc/elements/1.1/"
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#">

<License rdf:about="http://linuxgazette.net/105/misc/oregan/OPL.rdf.txt">
  <rdfs:label>OPL</rdfs:label>
  <dc:title>Open Publication License</dc:title>
  <rdfs:seeAlso rdf:resource="http://www.opencontent.org/openpub/" />
</License>

</rdf:RDF>

Conclusión

RDF y la Web Semántica son temas apasionantes, y espero haber estimulado el interés de alguien con este artículo. Cualquiera que desee averiguar más puede simplemente buscar RDF en Google, o probar con la lista de marcadores que acumulé mientras leía sobre RDF.

 


[BIO] Jimmy ha estado usando computadoras desde la tierna edad de siete años, cuando su padre le heredó una Amstrad PCW8256. Después de unos breves flirteos con una Atari ST y numerosas versiones de DOS y Windows, Jimmy entró al mundo de Linux en 1998 y nunca miró hacia atrás.

Jimmy es padre de un niño de siete años muy interesado en la tecnología, llamado Mark. Durante el tiempo libre que disfruta fuera de su círculo personal del Infierno, trabajando en una fábrica, a Jimmy le gusta tocar la guitarra y editar artículos en Wikipedia.

Copyright © 2004, Jimmy O'Regan. Publicado bajo los términos de la Open Publication License

Publicado en el número 105 de Linux Gazette, Agosto 2004