---

A while ago, Paul E. Jones, the prophet of AMS, mentioned that AMS would use XML encoding:

“We just finished a meeting yesterday. During the meeting we reached agreement to use XML for this new system. Personally, I think that’s going to be very cool. There is a huge amount of tool support for XML. We also had a person from the W3C attend who shared information on the Efficient XML Interchange (http://www.w3.org/XML/EXI/). In theory, this allows one to create a very compact binary representation of XML without losing the benefits of XML. We have to investigate this one further, but it looks promising.”

Paul seems to be catering to the masses while staying true to efficient engineering.

Got to have text

I’ve had plenty of discussions about text and binary encodings (and I wrote about them here and there). The leading argument for using text protocols always seems to be “text protocols are easier to debug”, which I fondly call “Debug Folly“.

Debug Folly:

“The assumption that something that is easier for the programmer to do or understand is also easier to code or debug. The consequence is usually an overly complex code which is hard to debug.”

Last time I had to debug a text-based protocol, the parser was so complicated I treated the entire layer as “white noise” and waited until control came out of it. For simple protocols, like HTTP or RTSP, it works: you can read the command word, read the argument, watch them being parsed, find the bug and correct it. For complex protocols like SIP (which, ironically, started out as the simple alternative to H.323), tracing the control through the parser, parts of which were generated by software out of a rules-file, is virtually impossible.

At any cost

I have a live example, from a few days ago, of what makes text parsers so complicated. We were talking about SDP and the ways to represent, in text, the G.711 codec:

• “G.711″
• “g.711″
• “G711″
• “g711″
• “G-711″
• “g-711″
• “711″
• “G.711alaw”
• “G.711a”
• “PCMA”

There are more.

For every text scheme, there are dialects and accents, variations and gotcha’s. Why does that happen? They are so easy to debug. You just go to your code, find the specific section that deals with the specific token, make a few changes, and voila – the next person who debugs there has to deal with a code twice as complicated.

The binary of text

XML, in a way, is like writing binary in text. The schema is defined, it is case-sensitive (it is sensitive to everything), and anyway, the code throws the message at some optimized XML tool and you can’t really debug that. If there is something wrong with the message, the sender of the message should just fix his schema and everything works fine. If needed, the protocol can even move to binary encoding (e.g. for cellular networks).

Technology is always a bit like a popularity contest:

• Popularity of the operating system (OS X, Windows, Linux)
• Input techniques (iPhone multi touch, Blackberry QUERTY keyboard, Palm graffiti)
• Architecture (single core, multi core, distributed)
• Ideas (software as a service, dot-com, web 2.0).

The popular idea right now, for protocols, is that text is simpler. To get the attention of protocol developers, Paul E. Jones has to approach them with a text-based protocol.

I see through your plan, Mister – come version 2, they’ll all be sending binary!