
W3C Approves RDFa 1.1 for HTML5 - mindcrime
http://www.w3.org/News/2013#entry-9919
======
samsquire
I'm a believer in the semantic web.

I highly recommend this app: [https://bitbucket.org/alexstolz/rdf-
translator](https://bitbucket.org/alexstolz/rdf-translator) for converting
between:

Microdata, RDFa, RDF, JSON-LD, N3 and N-Tuples

I recommend Apache Fuseki if you want to do some querying over tuples.

I'm currently trying to build a semantic living document editor and I've been
experimenting with Fuseki to do so.

[http://samsquire.github.io/livingdocuments/](http://samsquire.github.io/livingdocuments/)

~~~
agibsonccc
Another thing of note here are the different databases RDF traditionally uses.

Take a look at: [https://github.com/openlink/virtuoso-
opensource](https://github.com/openlink/virtuoso-opensource)

This is the triples store traditionally used. You will also want to look in to
sparql.

An example link:
[http://www.ibm.com/developerworks/xml/library/j-sparql/](http://www.ibm.com/developerworks/xml/library/j-sparql/)

The syntax is a bit weird, but it's not that different from a document store.

For those of you who use the Facebook API, you can also get RDF data out with
the rdf Accept header. Something neat to think about.

------
justincormack
Hold on, whats this XHTML5 they mention? We dont want XHTML5!

The W3C is just a weird organization, basically owned by some members who
pursue their own agendas, producing reams of "standards" that, largely, no one
uses, or even implements. Tim Berners-Lee is a great guy but it is a failed
organization as far as I can see.

~~~
rdtsc
Maybe that is a little harsh but I noticed that. Some working groups have
obscure people who enjoy generating standards and come up with alphabet soup
standard abbreviations and then spend a lot of effort convincing the world
that they need it.

RDF is one of those things, JSON-LD is another. Most efforts I have seen so
far involve trying to convince me that I need it. It wasn't me looking for a
solution. There is a big difference.

~~~
rpwverheij
That might be true in some cases, but - for me - that's certainly not true of
RDF (and the whole familly of semantic web standards produced by the W3C).
After a lot of selfstudy on something quite similar to RDF/triples I was
really glad to come across the W3C standards that were already there. Using
the 'frameworks' of RDF,RDFS and OWL enourmously reduces my workload and
greatly enhances my capabilities for the A.I. development I'm doing.

------
drderidder
I tend to agree the W3C is a bit pointy headed. Still, some kind of referee is
needed to keep the browser-makers playing fair. Firefox's switch from RDF to
JSON for bookmarks was anecdotal evidence that the RDF format was just too
obtuse for a lot of practical use cases. Way back I tried modelling data in
RDF; it was challenging and not well received internally. By comparison the
JSON modelling I've done recently has been intuitive, easy, and well received.
Although I used be be a big fan of RDF, its become a relic, and modelling
relationships isn't so hard a problem that you need RDF to do it, IMHO.

------
taliesinb
Quick poll: is anyone here using RDF in their technology stack? What has your
experience been like?

~~~
jerven
As an early adopter it was though (since 2008). However, if you are starting
today it is not bad. And RDFa (lite) is a really easy way of getting in to it.
Just make you site indexable using schema.org and RDFa for Google et al is a
nice start.

I work for UniProt (a databases for biologists) and for us it is really a nice
way of providing data to other users to integrate into their own systems. We
also provide a sparql endpoint at beta.sparql.uniprot.org for other scientist
to run analytical queries without having to deal with running a large
datawarehouse of their own (beta.sparql.uniprot.org). i.e upload 5kb of SPARQL
queries to us instead of downloading a 100Gb of data them to run SQL in their
own systems.

These days there are a number of off the self systems that work well enough.
Your main danger in the beginning is trying to deal with existing (large)
public data before you are ready. The philosophical/reasoning side of the
semantic web can also be very confusing but can be ignored in the beginning.
Just use RDF as graph data format and SPARQL as a query language and you are
good to go.

~~~
possibilistic
How do you like working for UniProt? Where are you guys based?

In the future I'd like to work at a place like this, so if you could tell me
more I'd be grateful. (My email is in my profile.)

Thanks!

------
Groxx

      <p xmlns:ex="http://example.org/vocab#"
         xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
        Two rectangles (the example markup for them are stored in a triple):
        <svg xmlns="http://www.w3.org/2000/svg"
          property="ex:markup"
          datatype="rdf:XMLLiteral">
        ... svg ...
        </svg>
      </p>
    

Does `property="ex:markup"` and `datatype="rdf:XMLLiteral"` seem to anyone
else like a _phenomenally_ bad idea? Don't inject namespaces in values! How
would you escape that anyway?

Is there some reason we don't have e.g. <svg ex:property="markup"
rdf:datatype="XMLLiteral" />, or can you not do that with XML? And if so, why
not? It seems like it would be very useful for mixing in data like this.

~~~
porges
Property and Datatype are in the HTML namespace* and their values are
namespaced identifiers (in XML, QNames).

The identifiers are namespaced so that if you have differing vocabs with the
same property names (or datatypes), you can distinguish which one you're
talking about.

Your proposed transformation means that Property lives in the example
namespace, meaning it has a completely different interpretation, which is
specific to the example namespace.

*: (before someone pulls me up on this, it's not 100% correct)

~~~
Groxx
ah, so 'property' and 'datatype' are intended to be paired, and intended to be
used to store namespaced values? I can't really find anything describing them
as such, but then they're about as difficult to search for as it's possible to
be :/ if you have a link, I'm curious and I'd appreciate it, but I'll take you
at your word :)

Still leaves a bad taste in my mouth (you can't have two on the same element,
for example. unless you can whitespace-separate them? and still, what if your
value contains a colon?), but I guess less so.

------
artificialidiot
At least it doesn't look actively harmful to what we already have.

------
thenerdfiles
Who cares ? Templates are JSON data anyway, in well-established meta-media
domains: [http://schema.org/AssessAction](http://schema.org/AssessAction)

All you end up arguing for is how well your Text Editor implements things like
git or LightTable watches over text objects.

Sublime text, for example, only gives a deprecated Skeumorph of the microwave
when in Find/Replace mode. Compare this to vim/Fuf,Unite, the fact that in
this eco system one also discovers Gundo, grep, etc. easily pluggable within
this system. Don't do any of it __at__ compilation, so who wholly cares? (Holy
C, anyone?)

Vim enables enhanced Python (mocka chaining permutations of tags, WebObjects)
development along with things things like Zen Coding and haml linters, which
do we decide; does it matter today, tomorrow? And what have you learn'd in the
meantime ?

I for one welcome our COBOL Overlords: [https://github.com/eevee/project-
euler/blob/master/heteroglo...](https://github.com/eevee/project-
euler/blob/master/heteroglot/015.cob)

