Shadowfax v3 is out ( if you read this blog, then you doubtlessly already know that ) and can be found here: http://www.gotdotnet.com/Community/Workspaces/Workspace.aspx?id=9c29a963-594e-4e7a-9c45-576198df8058

I’m very pleased to see that my thoughts about entities have made it in. A special hats off to the team for finding a better name for my PersistenceService – now called Entity Services. In hindsight, its obvious that there needs to be more than one low level service for dealing with entities.

“Entity Services represent simple atomic operations on an entity like orders, accounts, customers etc.  May write directly to store or component, external partner or legacy system.”

Now, the services exposed by the Entity Services aren’t to be exposed to the world. They are too low-level, and have no business value. That’s why there needs to be another service above ( around ? ) them. What I previously called the BusinessService is now referred to as Activity Services. Again, it only makes sense that there be more than one if necessary.

“Activity services coordinate the operation of several Entity Services into a single atomic operation (UpdateCustomer, AcceptPO)”.

These services are ready for prime time – at the single system level anyway. It makes perfect sense for a system to expose these services for consumption by other systems in the enterprise. On the other hand, I don’t think that they are so suited to be exposed to external partners.

For this reason, there are Process Services. “Process services represent long running business processes that may involve complex workflow and human interaction”. This is an area that I have to give some more thought to, from an implementation perspective. Specifically, how the Business Rules Services interact with the Process Services. It is fairly clear ( to me, at least ) how the Business Rules Services work in concert with the Activity Services. So, I’ll have to see how to resolve these issues.

All in all, I think that Shadowfax is going in the right direction. I specifically like the way that all of this sits with developing a single system. There has been much ado about nothing on the whole “SOA is about integrating different systems vs SOA is about how to build one system” debate. I’m glad to see that Shadowfax has taken the high road.

Tell me what you think. Is Shadowfax on target ?

I’m going to try something new for a change. Up until now I’ve always put special effort in my posts to make sure that they were worth reading. As such, the time it took to actually get a post out was considerable. So, I’m going to try to speed-post ( speed writing as real authors call it ). Should the quality suffer too much, let me know and I’ll go back to the way things were before.

Following up my last post on prototyping, I have recently finished a project for a client – a prototype. No, not a paper prototype. A .Net Winforms prototype, hooked up to a MS SQL Server 2000 database, with stored procs. It was actually more of a full-blown application – but it was still a prototype for a huge military system.

The client is a BDUF software shop – well, actually they’re more system integration than just software. But, despite that, the prototype was not developed by their strict methods and just sort of happened. Think “quick & dirty” but dirty is out ( because that doesn’t sound good ) and quick didn’t really happen. Hmm…

Anyway, my prior post on prototypes came as a result of a discussion on a different blog ( fabrice’s I think ). There, comments discussed the value in putting more effort in a prototype in the hope that some of the prototype could be then reused in the actual system. I have issues with this since it takes you out of the proper mindframe required for prototyping. Bottom line: you should not reuse code from prototypes. The most important thing to get from a prototype is to learn. The lessons learned are the value of a prototype.

Anyway, after talking to several people on the team at the client I got the distinct impression that the lessons learned would be only those that were planned. In other words, other than the UI, no element of the prototype was to be studied. The famous statement ( the fact that it is famous makes it all the more prone to misinterpretation ) that you wouldn’t drive a clay model of a car ( or live in a cardboard house, or whatever analogy of the moment presents itself ) was used as justification.

The most important lesson I learned from the prototype was the difficulty of getting the layered architecture to sit with the OO design used at cross-functional boundaries ( UI elements – Domain elements for instance ). Later, I redid the design using a SOA and you’d be surprised at how well everything held together.

Since I’m running out of time I’ll wrap it up. The moral of the story, don’t put on the blinders when it comes time to learn. Don’t just learn what you plan to. Be ready to learn totally new things that you didn’t expect. Make time for this kind of learning. It is the most valuable there is.

I’ve decided, after much thought, not to give up on this location. I’ve grown attached to it – especially the configurability of the MoveableType engine. What will be happening is that I will be posting here as my primary post, and shadowing the post ( not sure if its entirety or some proper excerpt ) on the GeekDojo.

Your thoughts would be most welcome.

Although I’ve always been somewhat annoyed by people I subscribe to moving, it appears that the inevitable has finally knocked on my door.

This isn’t a bad thing, really. I will be joining the ranks of the GeekDojo.

So, for all those who will be inconvenienced by the move – my apologies. But, life goes on. And, after all, change is good.

I will make an effort to bring over my existing content to my new home, but it’ll take a while so please bear with me.

Other than that, here’s my new home:

http://blogs.geekdojo.net/udi

My posts seem to be garnering lots of comments from around the blogosphere. However, many seem to view the posts made so far as a recommendation on how to do SOA. This is not quite true. I’m trying to take you, step by step, from LA – which you already know – to SOA. The journey isn’t complete, yet.

What’s been covered so far is this:1. How to create a layer/project in .Net that behaves like a service; 2. How to create an entity layer/project containing all the kinds of data that will be passed between layers/services.

These are necessary first steps to take, and are by no means the final solution.

I also gave several examples of classic services – security, logging, exception management, etc.

Steve Maine states in his post that all I’ve done so far is migrated LA to something called an application framework. If this is in fact true, I’m well pleased with myself. Achieving orthogonality, generality, and reusability in any architecture can be viewed as a success. In his opinion, this falls short of the pure SOA. To tell you the truth, if all you get from all this hoo-hah is how to make orthogonal, general, and reusable architectures, then my daily dollar’s been well spent.

I think that it’s important to point out at this point that the stages above are indeed prerequisites to SOA. Sure, any idiot can create a webservice that forwards calls to other code without giving a thought to any of the *ilities above ( and a lot of idiots do ) – but that’s not SOA. More importantly, none of the benefits of SOA can be achieved. This is why I focus so much on the “small-scale” SOA. Doing “large-scall” SOA while ignoring the small may make for a well-designed large machine, but low-quality gears, drive chains, and cogs won’t bear the weight.

So, what are the next steps, you ask. Well, that’s an excellent question. There are various ways to proceed, so I’ll start from the most understandable steps.

First off, lets see how to do persistence, which, for some reason, was always the sticking point for a lot of developers used to O/R mapping. So, we have a PersistenceService project, which has a one public class called PersistenceService. This class has a private constructor ( nobody needs to initialize this because … ) and all static methods. All the methods you’d expect to find are still there. Personally, I don’t like the catchall “Save” method and prefer having separate “Create” and “Update” methods. All the basic CRUD operations are there for every entity.

I once tried having all entities inherit from an IBaseEntity which pretty much only declared an Id property. This was so that the PersistenceService exposed only one Create, Read, Update, and Delete method – each accepting an IBaseEntity. Then, in the internal service implementation I did a “.GetType()” on the parameter and passed in on to the relevant class. Although this decreased the number of methods in the API, it didn’t have as far-reaching benefits as I’d hoped.

Here’s some code:

namespace PersistenceService

  public class PersistenceService

    public void Create(Entities.Customer c)

      // calls to logging service omitted

      // exception management service calls which wrap the following call omitted

Before getting into the responses of the blogosphere to my last post, I wanted to reiterate what it was about. The purpose of my post was “assuming that you know how to build a LA, how do you go about migrating to an SOA”. Meaning, how do you migrate your existing ( and probably well-founded ) knowledge of LAs to knowledge of SOAs.

Now, I’d like to acknowledge the following posts that referred to my previous post on “How To Do SOA”:

My good friend Roy Osherove, as always raining compliments down on me, writes “Using SOA on existing N-tier applications”, but I’m afraid that there was a misunderstanding here. “when you need to introduce the SOA theme on an existing N-tier application” is not at all what I was attempting to show. Should you have a working application, do NOT change its architecture unless absolutely necessary. No, “SOA is cool” doesn’t count.

I think I should stop a second to make a distinction. The definition of SOA has not yet solidified. The way I see it, there are 2 distinct and complementary views. 1. SOA is about how to integrate different systems. 2. SOA is about how to architect a single system. ( Steve pushes the first view with his post: “Making the N-Tier to SOA conversion” )

What I was referring to in my previous post was in the light of the second definition. What Roy refers to is more in line with the first. I won’t be getting much into how to do the first kind of SOA, because there are big vendors out there that plan to make loads of money based on that definition. I’m more interested in helping Joe Developer use a new(old) paradigm to develop systems which, IMHO, is the most suitable today.

Let me reiterate. SOA is how to architect a system ( according to view 2 above ). You would be best served choosing this architecture before starting to code, than after. Even the Agile camps have a System Metaphor which must(?) be decided at project start which guides them throughout the project lifecycle – of course, it evolves over time.

Both Roy and Steve make valid points about putting a facade over existing parts of a system to expose them a services. In this way, they continue to support existing client code that is already dependent on it. I totally agree !

But, if your starting a new system, wouldn’t it be preferable to have all client code access the given functionality in the same way ? Maybe/Yes. 

Wouldn’t it be that much easier to scale out the system if/when necessary ? Yes.

Wouldn’t it make the client code loosely coupled to the functionality ? Yes.

Wouldn’t it make the functionality itself more testable ? Yes.

Wouldn’t it be that much easier to handle logging, exception management, security, and other cross-cutting concerns ? Definitely.

<pause />

I’ve reached a conclusion. My next post won’t be so much of an example of an implementation of a service. My next post will be about replacing the BL as we know it. I think that once you’ll see what the BusinessService looks like in a system with an SOA, things will become that much clearer.

Of course, should you have something you’re dying to see next, let me know =)

How to do SOA ?

That’s a question that’s been popping up a lot lately. I’ve been answering small facets of the question in comments all over the place, but I think that it’s time to handle the big one.

First of all, I assume that the architecture that you’re currently using is a layered architecture ( N-tier counts despite the “tier” misnomer, N=3 is also OK ). What I’m going to do is to do a step-by-step migration from a layered architecture (LA) to an SOA.

First some history. In your basic 3 tier LA, the layers are PL, BL, and DL. PL = presentation layer, BL = business layer, DL = data layer. Over time, people realized that layers were a nice abstraction and started changing the above layers to a system with more layers. For instance, tables in the database were the storage layer (SL), data access code to interact with the storage was often split into 2 layers – database Dal ( data access layer ) consisting primarily of stored procedure, and the app Dal which was code that exposed those sp’s to the system in its own framework. ( Note that in many cases it is possible and even desirable to do away with the stored procedures and have the same sql code in the app Dal. ) The BL primarily was implemented by Fowler’s Domain Model Pattern – rich objects holding both the data, behaviour, and “structure” of the system ( think Customer.Orders ). The PL use of the BL was by way of its objects. In other words, the PL was intimately aware of ( and dependant on ) the BL’s inner workings.

So … What’s the problem ? Well there are quite a few, and I’ll eventually make some exhaustive list of what the problems are, and why you should move to SOAs. For one, the BL may be a good API for working with it in process, but if you start to use them for remote invocation your performance will die. Why ? Because the BL is chatty, meaning everything is done in small bites – give me this, now give me that – when what is needed for remote clients ( or other systems ) is a chunky API – give me everything I need at once. Well, this problem can be fixed by putting in another layer, but I won’t get into that ( unless you ask nicely =) ).

So, assuming that you know how to build a LA, how do you go about migrating to an SOA ? Here’s how.

First you have to change your layers so that they behave like services. Then, if you want, you can wrap them up using webservices or some other plumbing choice. You’ll need to have a standard way for passing data to your services ( SOA’s schema ). How do you do that ?

Well, there’s implicit knowledge scattered all around the system. Its the domain itself. The PL presents it. The BL performs logic on it. The DL stores it. Its data. It doesn’t have behaviour. These are the “entities” of the system. What are the entities you ask ? They are the objects in your BL without the behaviour. Customer, Order, Product, etc, all these are entities that ALL parts of the system deal with. This is the stuff the will be passed between the services. If you wanted to integrate with other systems, you could easily serialize the entities to xml.

So, step 1 is to create a new layer, called Entities ( or something else if you prefer ) and copy all the classes of your BL that are part of the domain model to it. Next, remove all methods from those classes. There is some disagreement on whether or not the relationships should be left in or handled by a different service. ( I’ve tried using a separate service for handling relationships between entities with quite a lot of success, but can’t generalize it enough to push for it as a part of the SOA proper. )

So, from now on, whenever you have to pass data between layers, use the corresponding entity.

So, you now know how to get data to your service, but its still a layer. So lets change the layer to a service. A service has a single point of entry, allowing only method calls. So …

For each layer, make only one visible class, something like ($WhatYourServiceDoes)Service – like PersistenceService or AuthenticationService. I can see your getting mixed up.

When working in .Net, I have a project called PersistenceService, in it I have a class called PersistenceService. When somebody needs persistence services, they add a reference to the PersistenceService project, at the top of their client code file they write “using PersistenceService;” and then, in the code itself, when they write “PersistenceService.Update(u);” they are actually accessing the PersistenceService.PersistenceService class – it just makes it more readable like this.

All other classes inside a service are internal, nobody should be able to get at them. The public class has only public static methods – like “public static void Update(Entities.User u)” mentioned above ( you might want to return bool in your specific case, or maybe int ).

Now, the public class handles all security, logging, exception management, and other infrastructure code for each call, finally passing the call on to an internal class which holds the logic for actually doing the work.This class has almost the same structure as the public class and is the one in charge of actually getting the work done. There’s no problem in instantiating other objects there to do the work.

In SOA, not everything is a service. /* cheap shot at the OO crowd */

<aside> This is getting rather long … </aside>

Its time for some examples ( I’ll only be showing the SOA way ):

1. Login ( From your PL call this instead of what you did before )

<code>

Entities.User u = new Entities.User();

u.Username = txtUsername.Text;

u.Password = txtPassword.Text;

if (AuthenticationService.CanLogin(u))

  // let the user continue

else

  // show some error message (ask them to try again ?)

</code>

The AuthenticationService has a CanLogin method which takes the user’s credentials from the entity, authenticates them somehow, and returns the result.

Why is this preferable to having a BL.User.Login() method ? Well, is it really the user’s responsibility ( in the “real” world ) to authenticate themselves ? No. If you’d like to change the mechanism for authenticating users ( say moving to ADAM instead of a DB ), is there any reason to touch the User object ? No. There are more reasons, but let’s not get into that.

What is needed is a separation of concerns. How you do something and where you do it (even at the interface level), should be separate from what you do it on.

So, to sum up, make layers into a services. And when you pass/get data to/from a service use entities. Next time, I’ll go about implementing an entire service, something you doubtless have as a layer in ( at least one ) system, so that all this theory makes more sense.

BTW, if you have anything you’d like me to include in the next post specifically, let me know.

I will be presenting at next month’s ( February ) VB.Net User Group Meeting in Israel.

Mark Bonafe wrote an interesting post on the whole OO vs procedural debate and how SOA may be just the return to procedural programming.

The problem I have with this, and several other posts on the topic is this, SOA has almost nothing to do with programming. Its about the (functional and non-functional) decomposition of a system. What are its main building blocks. And you know what ? Programming language/style has little do with it.

Frans Bouma asks if “OO is the goal or the tool” ? My answer: I have one goal, and it has nothing to do with OO, SOA, or Domain models. My goal is for my clients to be happy with the system, and to make a profit.

Anything that drives me to this goal is welcome. It used to be that OO was my favorite tool/roadmap, today I use SOA for architecture, and OO for the actual development. Gone is OO Analysis and Design at the system level, supplanted by SOA.

I find that the pendulum doesn’t have much to do with it, and here’s why. SOA isn’t about code, OO is.

I think that it is common knowledge in the industry, that the larger a project, the lower chance that it would succeed. Even ( especially ? ) if using an OO methodology ( aghh! the “M” word ! ). Anybody wondering why ? Could it possibly be that the methods that we were using for small-medium scale development efforts in the past don’t work so well on big projects today ?

I think that the main reason that OO couldn’t hold up, was that OO was about modelling the world – for every object in the real world, we’ll have an object in code. Big systems aren’t so much about objects in the real world, but more about interactions, processes, and flows.

This may sound like the pendulum swinging back to procedural programming, only, its not programming. Its about the system’s architecture. And its not done by programmers using a computer language, but rather by business drivers and 30,000 foot architects. ( I actually wish there were some “low-level” programmers that brought them down to earth every now and then ). These are the people who tell us what we need to build.

Here’s a hypothetical discussion between a business driver(B) and an architect (A):

<anecdote>
(B)We need to a way to save the data we get, and use it later. (A)We should have a persistence thing (service) in the system.

(B)We need to do all sorts of checks to see that the data we get is valid. (A) We should have a validation thing too.

(B) We need to integrate this stuff with our partner companies’ systems. (A) Well, we need some way for our systems to talk together – webservices might work, but our development shop knows more about MSMQ. But, we’ll need to have a way to move to different communications later. We should also have something to authorize things ( authorization service ).

(A talking to staff later ) I guess we need some way to get all of these high level requirements to fit together. Did somebody say OO ( or OOD&A ) ? That has nothing to do with any of this stuff ! What we need is something to tell us about how to structure a system to do all this.
</anecdote>

SOA is about what the major building blocks of a system are, and how they work together. In other words, the executive summary. This IS the system. OO is how to build each part – or, at least OO seems to be the best tool we have today for actual development.

Frans – SOA is about WHAT is the system, not so much as to WHY. The why is actually quite simple – “because that’s what the client wants”. OO is, as you said, about HOW to get it done.

After spending quite some time commenting on other people’s posts about SOA, I thought I’d bring them all together in a post. My apologies for not editing it into a single coherent post.

Following “Adventures in SOA, Part 2”: from my comments:

If you want to go SOA all the way, Fowler’s domain model doesn’t quite fit. This is because it exists in the context of an OO architecture.

For instance, in an SOA there is a persistence service to which you send entities (entities are objects without behaviour); rather than calling myCustomer.Save() you would call your persistence service and pass in myCustomerEntity as a parameter.

SOA is a different way of thinking about systems. In order to migrate my thinking from OO to SO, I started by introducing a facade for each layer. The only way I could interact with a layer was through the facade. So, instead of doing:

new BL.Customer().GetById(id);

I would call:

BL.Facade.GetCustomerById(id);

This morphed my BL layer, for all intents and purposes, to a service. From there, things sort of came along by themselves.

In a general view, an SOA has a coarse grained Business service which replaces the Domain Model pattern in an OOA. The Business service uses a business rules service/engine for determining whether actions can be performed. Rules include things like DoesOrderQualifyForADiscount(Order o).

In many cases it also makes sense to have a validation service for lower level checks. The lowest level checks, nullability and string lengths for example, can be implemented in the entities themselves.

I find SOAs to be more suited for today’s development challenges than OOAs since they allow for an increased separation of concerns in systems.

Following “Adventures in SOA, Part 3”: from my first comment:

I’ve just become a little disillusioned about OO architecture.

Why ?

Because of the “Where does this go ?” syndrome. This syndrome attacks after you’ve already built quite a lot of the system, and usually takes the form of some method you need to add, but just don’t know to which object.

For example, I do a lot of systems for academic institutions, and the following requirement sums it up: A lab administrator registers a student to a final project, for a course that the student is registered to in the given semester.

From this I know I need a “RegisterStudentToFinalProjectForCourseAndSemester(Student s, Project p, Course c, Semester r)” method. But where does it go ? On the LabAdmin class ? The Student ? Project ? Course ? Semester ? Eventually I just pick one and moved on.

What’s the problem with this ?

Well, the class that I choose becames tightly coupled to all the other classes. Martin Fowler probably would have found a nice solution using aspects ( as Brian McCallister posted here: http://kasparov.skife.org/blog/2003/12/27#design-ideas ), but I am not so skilled.

I look for architecture to push the developer into consistently making good choices ( see The Pit of Success, a la Brad Abrams: http://blogs.gotdotnet.com/BradA/PermaLink.aspx/b7a0cf5c-a283-4f95-a508-819102d2feae ). Unfortunately, in an OOA Joe can make bad decisions that will have far reaching ramifications on the entire system.

IMHO, services are a step up on the ladder from objects when it comes to architecture. Services will become the major building blocks of the future. Finally, services encourage developing coarse-grained APIs, which is exactly what will be required when the services will be distributed throughout the enterprise. Essentially, this will force us developers to deal with these important issues ahead of time. And, well, its nice to get things right the first time around. Isn’t it ?

from my second comment:

One final note =)

The example I gave of BL.Customer().GetById(id) and BL.Facade.GetCustomerById(id) was given in the context of migrating OO thinking to SO thinking. This is by no means a “Rule”.

Once you give up the “everything’s an object” way of thinking, and begin to adopt services when they seem to fit, then the system’s structure becomes more suited to the tasks its required to perform. Which leads me to persistence as a service.

Although I’ll probably regret this, the great O/R debate that’s been raging recently seems to focus too much on a relatively minor portion of moderate and up complexity systems. Yes, persistence is important. No, it should not be the driving force behind your entire architecture.

And, in all this debate, nobody stops to talk about the business rules. Who says myCustomer.Save() is allowed to be called now, in this context, by the current user, etc. Where does this code fit in ?

I guess the one thing that I can say here is this: Don’t lose sight of the forest for the trees.

Following “Adventures in SOA, Part 4”: my comment:

The service should not be implemented as:

AuthenticateUser(username, password, application)
AddUser(name, address, etc)
UpdateUser(userId, name, address, etc)

But rather:

AuthenticateUser(Entities.User u)
AddUser(Entities.User u)
UpdateUser(Entities.User u)

Where Entities.User has the following properties:

int Id { get; set; }
string Name { get; set; }
string Address { get; set; }
etc…

Note that you would implement basic validation checks in the setters – such as checking the string passed in is of the appropriate length.

Now the Entities “layer” is really just a part of the common type system for the application. So, when distributing your services and setting up the calls over web services or message queuing, these entities will be passed as Xml.

This is how you move to the “Share schema, not type” directive, since, all these entities in essence just define a schema. From an implementation perspective, yes, they are a type too, but that’s really just internal to the service.

And a final note:

The set of Service Layer, Remote Facade, and Data Transfer Object patterns ( from Fowler’s PoEEA ) are essential components of SOA. The Data Transfer Object pattern is implemented by what I call entities. These entities form the schema in SOA.