There has been a bunch to my post "Why name-value pairs are a bad idea for the exchange of identity information". Some I can point to, and some that people allowed me to quote from e-mail conversations:

• Joaquin Miller (NetMesh) said:

  You are definitely right. The point in brief is: Data is not a collection of data elements; instead data has structure.

• Chuck Mortimore said:

  I completely agree ...

  It's too bad rdf is so difficult for people to work with (or even grok)... the simple injection of a predicate into the name/value pair and you'd retain the ability to serialize complex object graphs.

• John Panzer points out that some people have argued that one could do RSS without XML. Sure one can, just like one can do the contortions in my examples ... Certainly, the contortions for RSS would be much simpler than the ones that we would have to go through for more complex identity.

• Rohan Pinto encourages his readers to read my post, but I'm not quite sure whether he agrees or not.

• Phil Hunt writes:

  Your argument on name/value pairs is a great one. It keeps bugging me that when there is any complexity, things break. I guess it is my turn to play devil's advocate... consider the experience with LDAP and different schema interpretations between Microsoft and other vendors. LDAP is for all intensive purposes nothing but name value pairs and it has had a lot of data inter-op problems. Apps written for Sun or Oracle directory don't work on AD.

  If we talk about complex structures, at what point do we move beyond exchange of identity information and becomes transactional. Even if name/value pair was too limiting, who is to say some other service access can't take place if deeply structured relational data is needed?

  I wonder, if this is more of a case where we want to force things to be simple rather than allow infinite possibilities?

  I'm on the fence.... intrigued by this argument. ;-)

  Very good questions, and they go hand in hand with the following:

• Mark Wilcox, also of Oracle, writes (selected quotes):

  I would argue that it's not name-value pairs are the problem, it's resolving relationships of different pairs.

  And this isn't a new problem, all meta-data systems have this problem. Successful meta-data systems make it so that you don't even understand this is what is happening. Unsuccessful make dealing with these relationships so cumbersome that only their designers can evn comprehend (RDF comes to mind here).

  The problem exists because meta-data systems are really referential systems for describing "objects". And those objects are often comprised of other objects...

  He then goes on to give examples for identity information on physical cards and in directories. He concludes:

  I would say the problem isn't the name-value pair limitation, it's how can we improve upon our ability to make it easier for developers to manage pointers as values in the name-pair use case.

This is a really good conversation today! The points made by Phil Hunt and Mark Wilcox warrant a separate post in response, which I'll write in a bit and post here once I have it.