Thursday, October 14, 2004
« A rambling rant on programming languages... | Main | Generics research for CSLA .NET »

I'm listening to Pat Helland (a serious thought leader in the service-oriented space) speak and it has me seriously thinking.

 

I think that one fundamental difference between service-oriented thinking and n-tier is this:

 

We've spent years trying to make distributed systems look and feel like they run in a single memory space on a single computer. But they DON'T. Service-oriented thinking is all about recognizing that we really are running across multiple systems. It is recognition that you can’t trivialize, abstract or simplify this basic fact. It is acknowledgement that we just can’t figure it out.

 

Things like distributed transactions that are designed to make many computers look like one. Heck, CSLA .NET is all about making multiple computers look like a single hosting space for objects.

 

And these things only fit into a service-oriented setting inside a service, never between them. The whole point of service-orientation is that services are autonomous and thus don’t trust each other. Transactions (including work-arounds like optimistic concurrency) are high-trust operations and thus can not exist between autonomous services – they can only exist inside them.

 

Personally I don’t think this rules out n-layer or n-tier applications, or n-layer and n-tier services. But I do think it reveals how the overall service-oriented may be fundamentally different from n-tier (or OO for that matter).

Thursday, October 14, 2004 3:01:43 PM (Central Standard Time, UTC-06:00)
Now, Rocky: welcome to the club. That's it...
I have to admit that I followed with joy nearly all of your blog entries surrounding SOA or not-SOA in the last few weeks. But now we have it. That's good.

Now on to the more interesting things: transactions and the like... I think Pat refers to transactions to the classical tx he knows best. But there is more in a SOA world. But maybe more on that later.
Thursday, October 14, 2004 10:48:58 PM (Central Standard Time, UTC-06:00)
Christian, I think I've been consistent in saying that I think SO could be a new and different thing - but defining those differences is not a clear and easy process.

I've been working on an article for a while now that tries to call out some of the key differences. One of them is transactions - but the thing that came to me listening to Pat today was the realization that there's a fundamental difference between SO and most previous distributed application philosophies. To date, most philosophies have been around giving the developer the illusion of a single memory space, while SO is all about REALLY giving the developer a single memory space. If you cross memory spaces, you cross trust boundaries, services and applications. There is no such thing as an n-tier application, there are just n applications (services) being strung together to do some work.

Not that I'm sold on this idea. It presents a whole host of really tough problems, especially around replication of business logic and behaviors. Of course I have also come to the conclusion that SO includes recognition that we have failed to share code and logic and represents surrender in that regard. SO just gives up and says that Yes, there will be duplication of code - deal with it. Personally I'm not sure I'm ready to give up just yet, because the cost of such a move is tremendous...

Rocky
Friday, October 15, 2004 1:31:04 PM (Central Standard Time, UTC-06:00)
In many ways SOA simply explains what happens inside the tiers. Many developers understood tiered designs but they were at a loss to figure out just how to structure the insides of the tiers themselves!

I've always told consultants in my company who were aspiring to jump to the business systems architecture practice to think beyond the classic service boundary limits. Imagine your services as organisms floating on a simplified nervous system (the network), just waiting to receive, process and maybe forward "things", like crude synapses. These organic blobs never touch each other, and they speak using a language that all of them can understand although they're all fundamentally different. The language, the contract and the wire (the transport and packing system; TCP, WSDL and WS-* or SOAP for example) are the only well-known things in this system and everyone has to be fluid in them.

This isolation has many levels and facets, but the important thing is that it exists and is actively enforced.

BUT, the architecture itself (whether we're talking about an enterprise-wide system or a localized one) is a single organism - it's the business. Trust is an ancillary consideration unless you are actually leaving the organism (don't kiss any strangers =) - security is just a desirable side effect of the isolation because the protocols often require it.

I've seen too many designs (especially in the integration space) hobbled and crippled by too much security. Yes, you *can* have too much security... or rather you can fall into institutional paranoia very easily.
Tuesday, November 02, 2004 11:46:53 AM (Central Standard Time, UTC-06:00)
Isn't SOA just Cobol over the internet?
anonymous
Comments are closed.