re. the layer cake and recent discussion on twitter with @kidehen
 
1. Currently, we have:
 
┌────────────────────────────────┐
│                                      │
│               RDF                    │
│                                      │
│                  ┌────────────────┘
│                  │┌───────────────┐
│                  ││                  │
│                  ││       XML        │
│                  ││                  │
└───────────────┘└───────────────┘
 
2. We could just have:
 
┌────────────────────────────────┐
│                                      │
│                                      │
│                RDF                   │
│                                      │
│                                      │
│                                      │
└────────────────────────────────┘
┌────────────────────────────────┐
│          HTTP (URI etc.)             │
└────────────────────────────────┘
 
3. Or we could have:
 
┌────────────────────────────────┐
│                RDF                   │
└────────────────────────────────┘
[XML] [JSON] [text/plain] [(X)HTML] etc.
┌────────────────────────────────┐
│          HTTP (URI etc.)             │
└────────────────────────────────┘
 
I think if you think about the layer cake fundamentally as being a political
document, then you should plump for (2). The reasoning is simple: to
understand the significance of the Semantic Web, you don't need to think about
it in terms of data, data representations, "bags of bytes" (as the HTML5 crowd
say) or any of that stuff. RDF transcends XML or JSON or RDFa or whatever way
you represent the same data. RDF should be sitting inside music, movies,
pictures, documents, our own heads and so on, just like, say, the relational
database model or the spreadsheet model or the filesystem models (or the
threads/processes model) or whatever.
 
But I think if you are trying to build a useful diagram, it is supposed to
help technologists with the practicalities of building the Semantic Web. If
I'm building a Semantic Web system, and I see a layer cake diagram, I can use
that to make decisions about building or using software. My line of thought my
go like this:
 
"Well, if I'm working in Java, I can use Apache Commons library for HTTP, I
can use json.jar for RDF/JSON, I can use Xalan for XML handling, I can parse
the N3 using ANTLR. But if I'm using Ruby, perhaps I should use net/http,
Nokogiri, the JSON gem and Treetop for parsing the N3."
 
The layer cake is both a political and a technical document though. If
something is a significant dependency that might require non-trivial
development work for someone to support, it should probably be put in the
layer cake. You can expect that being able to handle UTF-8 text/plain is
pretty obviously a requirement, but being able to handle XML properly or JSON
or whatever - that should be pointed out. It should (and does, as per (1))
point out that RDF is representation-agnostic. But having *nothing* doesn't
signify representation agnostic, it's really implying that there *is* no
representation or that RDF is just 'something else'.