Steve Vinoski's Blog

I figured the decentralized media types idea that Stefan Tilkov and I each wrote about recently couldn’t be all that simple. So, not surprisingly, it turns out that at least Mark Baker (and according to Mark, also Mark Nottingham (mnot) as well), Bill de hÓra, and James Snell don’t like it. When either Mark or Mark speaks on matters pertaining to the web, I listen; I’ve been around each of them long enough to know that when they aren’t sure whether something is a good idea, it’s definitely worthwhile to take the time to understand why. I don’t believe I’ve ever met Bill or James in person, but I read their blogs for a good reason, plus James just got his blue belt so I’d like to avoid getting on his bad side. :-)

I particularly like Stu Charlton’s opinion on the matter, though, in part because he acknowledges the tension between the needs of the Internet vs. those of intranets.

At the end of the day, I understand the various explanations for why decentralizing media types is not a good idea after all, and I agree with them. I was unaware that mnot had already tried to go down this path. I see this issue as another stop along the way to a more thorough understanding of REST, and bringing it up has gotten some good technical explanations out in the open, where perhaps more people can see them and learn from them. Thanks to those mentioned above for providing those explanations, and to Stefan for kicking off the discussion.

In RESTful systems, media types define the formats of data exchanged between client and server. Standard media types are centrally registered and managed via the Internet Assigned Numbers Authority (IANA). If none of the registered IANA media types fits your application, you’re free to write up and submit a new one that does.

Less than one week ago I was wondering to myself why media types are centrally managed when the web typically prefers decentralization. I was therefore pleasantly surprised today when I read Stefan Tilkov’s posting on this very topic. The proposed solution he describes, from Sanjiva Weerawarana, Paul Fremantle, Jonathan Marsh, and James Clark, is pretty much in line with what I was thinking: register a new media type that has a URI parameter for identifying an actual data description. Very simple and yet potentially extremely effective.

I like this approach for several reasons beyond just the decentralization win. First, this allows us to gain experience with new media types before they’re standardized. Second, this augments rather than replaces the current IANA registration approach, and doesn’t break the existing IANA registration process in any way. Third, it doesn’t break or otherwise negatively impact any existing applications.

So, enough emailing and blogging about it — who’s going to write it and submit it to the IANA? I hereby offer to pitch in and help in whatever way I can.

Since a number of people seem to be experimenting with adding Erlang-style concurrency to other languages, Ulf Wiger has written a nice explanation of what Erlang-style concurrency actually is. Definitely informative.

On a related note, I chuckled when I saw this posting from Robert Virding, who helped create Erlang, in the erlang-questions list about a month ago:

After reading the blogs about how good Erlang’s concurrency model is and how we just just made a super implementation of it in XXX I have been led to formulate Virding’s First Rule of Programming:

Any sufficiently complicated concurrent program in another language contains an ad hoc informally-specified bug-ridden slow implementation of half of Erlang.

This is, of course, a mild travesty of Greenspun but I think it is fundamental enough to be my first rule, not the tenth.

I can understand where he’s coming from. When I see the kind of blog postings he’s referring to, I always wonder why they don’t just use Erlang itself instead of trying to reinvent it in another system whose design trade-offs are unlikely to be able to support it. Well, I guess it would make sense in the case where they’re specifically studying various implementations of concurrency, but other than that, I don’t get it.

On another related note, I found the comment below in another blog. It refers specifically to my own use of Erlang:

it’s [sic] be interesting to see how Steve mix [sic] Erlang and HTTP, since Erlang is asynchronous in nature and does not have any “resource” concept and HTTP’s sweet spots are just the opposite

That’s easy. If you want to experience HTTP as implemented in Erlang, just go to the Yaws website, which of course is powered by Yaws itself. As Ulf’s blog posting explains, Erlang message passing is asynchronous, but that really has nothing to do with Erlang’s ability to support protocols like HTTP. For example, when I was learning Erlang, given my CORBA background I wrote a subset of IIOP, and it was really quite easy. Furthermore, Erlang doesn’t need a “resource” concept to support HTTP. A resource in that context is, after all, ultimately just a chunk of code that processes incoming requests, and of course Erlang can do that.

If you want to know more, go pick up Joe Armstrong’s Erlang book — it’s quite excellent.

Regarding the REST and IDL discussion, Joe Gregorio already wrote an excellent explanation six months ago. Perhaps the rest of us should have just linked to it to begin with and avoided wasting our time rehashing it all.

But then again, rehashing is fun! :-) On the same topic, I agree with much of what Dare said, except for this:

When building services with WS-*, you have a WSDL to describe your methods & expected inputs/outputs and XSD schema(s) to describe the schemas for said inputs/outputs. When building a RESTful Web Service, the need for both of these documents does not go away regardless of how often you repeat the phrase “uniform interface”.

I still disagree. The HTTP verb set defines a RESTful uniform interface. When comparing CORBA IDL or WSDL to HTTP web services, that verb set must be considered because it’s the only thing that you can directly relate to IDL and WSDL interfaces. Otherwise, you’re talking apples and oranges. The uniform HTTP interface is the only way for applications to interact with web resources in the same sense that CORBA applications interact with CORBA objects, and WSDL applications interact with WSDL services.

Much of the typical IDL and WSDL definition is devoted to defining one or more specialized interfaces consisting of specialized methods/operations and specialized data types to pass across them. For web resources that use the uniform interface, however, there’s simply no need whatsoever to define interfaces like that. What are you going to do, define GET again and again for each of your resources, each time with exactly the same semantics already specified in RFC 2616? Obviously not.

It’s easy to see that Joe’s OpenSearch document bears no semantic resemblance to a CORBA IDL or WSDL definition. Similarly, an AtomPub service document is nothing like IDL or WSDL either. Both of those documents essentially inform you of service URIs and media types, but they don’t define methods or operations. They don’t have to, because of the HTTP uniform interface. That’s important, and it’s why I disagree with Dare’s point quoted above.

Consider the mindset of the CORBA and WS-* developer. They use systems that force them to always think about all their service endpoints in terms of specialized interfaces. Given how much time I’ve spent in that world (and don’t forget, I still use CORBA too), I know for certain that the concept of the uniform interface is one of the big items that trips these developers up when they try to figure out what REST is about. It’s therefore important to keep the uniform interface as part of the conversation.