savas parastatidis

“Why WSDL Is Not Yet Another Object IDL”


Jim and I wrote an article few months ago that was just published in the Web Services Journal called “Why WSDL Is Not Yet Another Object IDL“. We even had some feedback… “very poor” by James Greeve. However, he didn’t say why he thought the article was bad so we could get it right next time. What others think? We don’t pretend to know everything; we like technical discussions.

It seems that Mark has read it already. BTW, he also comments on my earlier post.

7 responses to ““Why WSDL Is Not Yet Another Object IDL””

  1. Mark Little
    I wouldn’t say it is “poor”. I’d say it’s wrong IMO. For a start don’t confuse IDL with OO. IDLs (I use the generic term here and not limiting to CORBA IDL, which is just a specific instance) existed before OO and before distributed OO. Take a look at http://www.cs.ucsd.edu/classes/fa00/cse120/lectures/15-rpc-bw.pdf for a basic, but useful set of slides on RPC+IDL: the term “object” isn’t used anywhere in the slide set. The first IDL I ever used was for Sun’s RPC, which used to ship on Sun OS 3.x in the days when C was the implementation language of choice. It was used to define the contractual obligations between clients and servers. Who cares *how* the server is implemented (objects, procedures, monkeys, …)? But I do need a contract of how I can talk to the service. Anyway, I’m just going over what the slides say. Then take a look at this quote: “Interface Definition Language: part of the CORBA standard specified by the Object Management Group (OMG). It is used to define an abstract definition of an interface to a distributed server component. An IDL compiler is used to generate specific language bindings for the language that a component (client or server) is written in. IDL is a key component within CORBA and enables it to be a language transparent standard. This means that each individual component within a distributed application can be written without any knowledge of the language that any other component is written in.” Hmmm, doesn’t mention objects, but does talk about components. A quick trawl around the Web and you’ll find other definitions that talk about services too. Most people see IDL as a contract. Again, a random URL http://corbaweb.lifl.fr/papers/oracle/ And finally, take a look at http://www.xml.com/pub/a/2002/01/16/endpoints.html It’s old, but still relevant. (And talks about IDL as a contract between clients and servers). Doh! And I haven’t even got around to the “don’t confuse IDL with Java interfaces” yet 😉
  2. Savas Parastatidis
    Hey Mark. As I have explained to you, we are not talking about situations where the concepts of service-orientation are applied using distributed object technologies, as it can be the case with CORBA. We are referring to the object-oriented approach to building distributed applications and we suggest that it is not appropriate for building internet-scale applications. IDL is used in distributed-object systems as a way to describe the shared abstractions, it is used as a common type system. Yes, one could use it to describe a service but when we describe a Person interface in CORBA IDL and we pass references to instances of the Person class around, then we are doing distributed-objects which is bad for scalability and creates fragile applications. Could you program around that? Yes, of course you could. In fact, you’ve been doing it with CORBA services. However, not everyone sees that. For example, many think that WSDL can be used to describe classes of objects (look at how WSRF uses it) and build applications around that.
  3. Mark Little
    No no no no no no no. And no! Don’t confuse IDL with CORBA or distributed objects. I was very explicit in the text I sent and did say that there too. You are using an example and a specific use-case for IDL to “prove” your point, when if you look at the whole picture (where IDLs came from, why they were used and why they are still used in general), then you’d see that there really is no difference between what WSDL is defining and what IDL defines. Ignore the specific *implementation* of IDL and please go back to basics. What it does is define a contract between a client and a *service* in terms of the operations that the service provides. It doesn’t say anything about *how* that service provides the operations (it could backend into different implementation services for each operation running on entirely different infrastructures, for example) [Note: no use of the word object in that sentence!] The message exchange pattern is implicitly specified by the interaction between the IDL and the stub-compiler (e.g., CORBA IIOP, or Sun RPC, or Rajdoot).
  4. Savas Parastatidis
    Mark, I understand where you are comming from and I agree. However, the title of our article is “Why WSDL is not yet another _object_ IDL”. We are talking about the use of IDLs in an object-oriented environment and NOT about their use in general. So, while you are not mentioning the word “object”, we are.
  5. Jim Webber
    If we ignore the legacy names of for some of the WSDL features (e.g. operation), then all WSDL describes is messages and message exchange patterns. IDLs (irrespective of what they map to) don’t describe messages, they describe interfaces to some component. I know that there is a relationship between interfaces and messages, and that you can infer one from the other, but the point is WSDL is now being interpreted by some as a message description langauge (a view which I have long held), and that view enables all kinds of good things (like super-loose coupling).
  6. Mark Little
    The problem I think is with your article. It doesn’t make it clear that this is not an issue with the concept of general IDL, as epitomised by some of the references I gave, but by a specific type of IDL and a specific environment (CORBA, Java, DCOM) and a specific useage pattern within those environments. It is easy to read the article as IDL=object pattern, when that’s simply not the case. Putting “object” in the title of the paper isn’t sufficient IMO.
  7. Mark Little
    Jim, first you need to enable comments on your blog 😉 Secondly, “super-loose coupling” isn’t the sole domain of Web services and WSDL. Hey, even if we do go back to a specific IDL that is mapped to objects at the back end (and BTW, CORBA doesn’t require object-oriented languages at the back-end), then the object that implements the interface is only the initial point of contact for a message invocation. My point is that something somewhere has to receive messages: whether that’s a dispatcher at the level of listen or a “higher-level” object at the level of an IDL boundary (aka a server-side stub) who cares? What that receive does with the message is important and I can write loosely coupled CORBA applications just as well with DII/DSI. However, we’ve been this route before.