Just reading through a relatively recent update to the Grid’s Grid Service Specification. In there, they actually provide some (extended) WSDL that is used to access all Grid services; a generic interface, who would’ve thunk it? Some of the relevant text from that part of the spec includes;
In order to support discovery, introspection, and monitoring of Grid service instances, we introduce the concept of service data, which refers to descriptive information about a Grid service instance, including both meta-data (information about the service instance) and state data (runtime properties of the service instance). — from section 4.4
So it’s good to see them getting this important aspect right (at least to an extent – it’s still much less useful than GET/PUT/POST/etc..), but it would be nice to see them embrace the Web rather than getting distracted with what people know to be Web services, since the Web already does most of the things they’re trying to do, and many beneficial things they haven’t even thought about. I attended a BOF of theirs at WWW 2002, and they had absolutely no interest in using URIs (though I see they’re using them as Grid Service Handlers), and thought that protocol independance was a feature, not a bug. They really need a protocol guru on the team; without one, and some major changes, the Grid isn’t going anywhere.
I just made an interesting observation regarding all these orchestration, workflow, choreography Web services specs recently released. Let’s see who in the Web Services Architecture WG picks up on this …
Clemens writes some moreabout HTTP, transactions, reliability, despite his publication deadline. Go, Clemens!
FWIW, I don’t disagree that this is a commonly held view, but in my view, it’s entirely incorrect. HTTP is not a panacea, but it’s also not just a web page retrieval protocol. Some point-by-point responses;
- I said that HTTP, without resorting to things like tunneling or callbacks, doesn’t support any flavor of transactional behavior[…]. This is incorrect. HTTP supports what is sometimes referred to as a “state alignment transaction”. That is, any party in the transaction can synchronize with the state of the other party using HTTP GET. State alignment is a form of transactional style that fits very well with the Internet/Web. Obviously, just using GET isn’t sufficient for all transactional needs, even with a state alignment approach, so more work remains to be done. But to suggest that HTTP doesn’t and can’t do transactions is false.
- For additional cases where HTTP doesn’t really work (P2P in general and even non-transactional, long running operations)[…]. I use HTTP for P2P on a daily basis. My company’s HTTP routing platform is premised on the fact that HTTP is suitable for P2P, and we’ve built some really cool, useful, and scalable stuff with it. Ask KnowNow about this too. WRT long running operations, see above re state alignment; you just have to look at the problem differently.
- I can’t say that I understand what you mean by the TIP/BEEP/HTTP pictures, but the prose preceding it suggests that you didn’t understand my point that you quoted. I see reliability as an application layer issue, not a transport one. See what Jim Waldo has to say about the topic (chapter 5, if you don’t have time to read the whole thing).
Clemens responds. It’s a bit long to respond to in detail, but I will point out another big misconception about HTTP; that it is unreliable. It is as reliable as any other workable protocol can be without being brittle, because it attempts to expose what needs exposing, and hides what can reasonably be hidden. Going back to those fallacies, number one is “the network is reliable”. This should hopefully not come as a surprise to anybody, but what might is a corrolary of that fallacy (that I just devised 8-); Not only is the network not reliable, no layer that attempts to abstract that network can be reliable. “Reliability”, in the context of Internet-scale systems, is an aspect of the coordination semantics of the over-the-wire agreement, not of the quality of service of the transport of the message.
The “theory monster” rears its ugly head again. Clemens Vasters writes “Hence, the “I love HTTP” discussion (aka REST) is solely academic and of very little relevance for complex real-world designs now and even less moving forward — methinks.”. REST is the furthest thing from theory in existence; it is 100% practice. It is what you get when you closely study how the Web works today. In contrast, “Web services architecture” is almost entirely theory in the context in which it’s being used (the Internet). It, and its implicit resemblance to the OMA, has never been deployed at a scale even approaching the Web. Perhaps it’s worth repeating; The Web is a giant leap forward in distributed computing architectures. Ignore it at your peril.
For many years, people have talked about how normal ACID/2PC transaction semantics are unsuitable for use on the Internet. That is still the case. We need to rethink what a transaction is on the Web, and I can guarantee you that when we do, it will be implementable as an HTTP extension.
Sam and I are still disconnected, but we appear to have narrowed it done to this one key point. Must .. find .. way …. to explain.
Time for an example.
POST /some-uri/ HTTP/1.1
Host: example.org
Content-Type: text/plain
[blank line]
795
This is a client POSTing the data “795” to http://example.org/some-uri/. I consider this more hormone-like, because what the code bound to that URI does with the number “795”, is completely up to it. And without additional information, the sender of that HTTP message has no idea what to expect will happen when he does. How this works in HTTP, is that the client (in HTML’s case, a user) forms an expectation by believing the assertions in the HTML that they previously got, that if you submit some text, we’ll send it to an LED flasher in our office (or will dial a phone number, or hunt down and kill the person with that SIN, or whatever). So different behaviours are negotiated out of band, not requested in band.
That should hopefully highlight the difference. Does it? It wasn’t intended to compare the approaches. I’ll leave that as an exercise to the reader. 8-)
Sam Ruby, “I still do, however, see value in perfectly clear protocol specifications, a role that WSDL fulfills”.
Here’s how I see it. HTTP is the protocol, and no other protocols are required in order to get stuff done. I agree that WSDL does define protocols – application protocols in fact – but why is it required? I’m not sure how best to describe the difference, but Sam’s own neurotransmitters essay might be a start; “In the second mechanism, the receiver determines the action to be taken. The request matches a receptacle on the membrane and the cell uses this information to trigger biological processes.”. That is, the the “server” determines what is done, not the client. Using WSDL as a protocol definition mechanism (as practically all Web services use it), the client is asking that some action be taken by invoking some operation on the server. This is not the hormone/membrane, it’s the virus. For the hormone approach, the protocol data unit is simply “handed off” to the recipient without any specific request for action other than “hand off”. This is what POST means.
I’m a few days late, but Sam Ruby posted his excellent REST+SOAP essay last week. I was surprised to see it not get more fanfare. I commented to Sam that I was concerned about this bit;
Now add high level methods which take care of all composite
create, update, and delete operations.
Sam suggested to me off-line that he was thinking about it in terms of just passing data over a wall/membrane, to which I responded that this is exactly how POST works; that the operation that occurs is determined solely by the server. So we may be in synch, but given previous things I’ve heard him say, and his work on SOAP and WSDL, I wonder if we really are. But here’s hoping!!
An interesting discussion on xml-dist-app about implicit versus explicit use of the Web Method Specification Feature of SOAP 1.2. I guess I just have a hard time understanding why you’d want to hide the method, either by defining a default, or deriving it from the MEP in use. I mean, how else do you accomplish something without knowing what method you’re invoking?