Re: Usefulness of WSDL

["RL 'Bob' Morgan" <[e-mail]>]

> I see WSDL proposed for some spec in the IETF every so often but 
> nobody's ever explained to me what it solves.

The motivations for Interface Definition Languages (IDLs), of which WSDL 
is an example, and of Remote Procedure Call (RPC) systems, of which IDLs 
are a component (and of which WS-* is an example), are straightforward. 
Among other places they are described in RFCs 1057 and 1831, which 
document Sun's ONC RPC (1831 is standards-track even).  The seminal paper, 
as mentioned in 1831, is

   Birrell, A. D.  & Nelson, B. J., "Implementing Remote Procedure
   Calls", XEROX CSL-83-7, October 1983.

for which a cursory search doesn't reveal an online instance.  (Some might 
flame at calling WS-* "RPC", so OK, substitute "RPC-like distributed 
computing system" instead.)

The idea is that protocols are hard to write, and software implementing 
protocols is hard to write.  So an RPC system creates a meta-protocol; a 
concrete protocol to do real operations is created by writing an interface 
definition in an IDL.  The IDL serves as generator for both a protocol 
spec and an API spec; the IDL is fed into a language-specific stub 
generator which produces libraries for use in that language for that 
interface (ie, that protocol).  The programmer just uses those libraries 
like she would any other libraries when implementing a system.  Voila, the 
pain of writing protocol implementations, and protocols, vanishes.

This argument has been so compelling that dozens (maybe hundreds) of RPC 
systems have been invented, and many widely deployed, over the years. 
Each promises to solve the problems that have led to the previous ones not 
meeting the hype of their promoters.  And of course the gap between hype 
and adoption has led to some of them being among the highest-profile 
computing failures (see "DCE"), at least in popular opinion.

I think the story has remained largely the same for the last 25 years or 
so.  Using an RPC system is undeniably better than the usual system 
integration alternative of making up a new protocol from scratch, which 
anyone doing system integration knows leads to appalling protocol 
interfaces on systems of all kinds.  But RPC systems never seem to escape 
this niche of home-grown interfaces for a small purpose with a few 
consumers.  Probably there are lots of reasons why this has been so.  I'd 
guess among the most important is that IDL toolkits inevitably become 
language- and vendor-centric, so the theoretical cross-platform agility 
and interop doesn't happen in real life.  So people with real scalable 
distributed systems work to do focus on real protocols and accept the 
burden of writing implementations of them more or less from scratch (often 
these days based on HTTP+REST).  (Obviously there are many perspectives 
and counterexamples, it's a big Internet.)

Given that Internet protocols specified in RFCs are presumably intended 
for those widely distributed and widely implemented cases, it seems like 
RPC/IDL technology, including WS-*/WSDL, is generally inappropriate. 
Obviously there have been exceptions, as RFCs 1831-3 and 3530 demonstrate.

  - RL "Bob"