Organizing principles for services

One of the questions that comes up from time to time is how to define your services. This has come up for me in two independent fora: within the OASIS Service Oriented Architecture work and in the context of human provided services, for example at Genietown.

In the work on the SOA Reference Model we decided that “services are the mechanism by which needs and capabilities are brought together”; i.e., its about needs and capabilities to satisfy those needs, and the access mechanism.

However, this still begs the question somewhat. In the domain of human services, where the services are things like “building a home”, “walking the dog”, “taking care of my elderly parents”; it gets even fuzzier. Sometimes a service seems to organized around the person offering the service, for example, an architect, or a doctor. Sometimes the service is organized around a particular kind of product, such as doors or skylights. At other times, the service is organized around a material, such as glazing and paint services. Another kind of organizing principle is location; for example, landscape services involve a whole range of things in the garden.

While it is clear that a service is typically organized around a set of actions, and one or more resources; I do not believe that there is a single ‘syntactic’ condition that can be applied to define a service.

Currently, we do not have a good higher-level handle on how to organize a large suite of resources and actions into well differentiated services. The standard technologist’s answer to all this is to throw the problem ‘upstairs’ and appeal to business function (e.g., accounts, sales, library book management etc.). What that amounts to is asking someone else to come up with the organizing principles for defining a service. It may just be that the business level is the right level to ask these questions.

The humble parameter

As any software engineer will know, it is often easier and better to design a system that is too general for the particular task at hand and then to govern the actual behavior with a parameter. At one extreme you get sort functions with the comparator supplied as a parameter to the sort. At the other extreme you get entire policy-based frameworks where the parameters that govern the system are represented as rules.

A similar phenomenon occurs in mathematics: it is often simpler to solve a more general problem than to solve the particular problem. The more general solution is often parameterized in such a way that the particular solution falls out of the general case.

Recently, I learned of a use that Nature has put to the parameter, it seems that Finches’ beaks may also be governed by one or two genes (BMP4) which show up in many wildly different animals (Finches, fish, butterflies, …). I would suggest that what is going on here is that we have a general mechanism (the HOX genes) with a system of parameterization that is easily modified.

There seems to be a general principle at work here — that the pattern of having a general mechanism tied to a parameter to give particular instances — applies to many things and in many areas of the world. Perhaps this is one of those natural joints that philosophers love to carve.

Perhaps a Math grad student would be interested in designing an algebra of parameters?

The Perils of Meta

An age ago there was a time when the solution was “meta-level”, and “What was your question?” This was during the heyday of Logic Programming when it seemed that we were going to take over the world (when they woke up to it that is).

Meta-programming is extremely powerful, and it seemed that there was nothing that could not be solved using some kind of meta-level approach: compilers, debuggers, abstract interpretation, program transformation, utility programming; the list had no end.

Unfortunately there were, and are, some problems with meta-level programming. From a logic perspective a key problem was that you had to prove, again, the logical validity of the meta-level inferences that you made in your application. More pragmatically, there were issues with the ‘standard’ way of reflecting from logical formulae to data structures in Prolog that caused logical and practical problems.

Like most Prolog-ers, I have been somewhat amused by the apparent enthusiasm for all things meta in the Java world. It has had a distinct been-there-done-that kind of feel about it.

Recently I came across one of the down-sides of the meta-fever. Wicket uses a lot of reflection to simplify programmers’ tasks. However, the down-side is that using a string to denote a method confuses most IDEs; making refactoring a tricky proposition.

The Yin and Yang of Actions and Events

Today, in our telcon we invented something. It is not often that we can claim that; but today we did.

There are, it sometimes seems, people who think that everything is an event. There are others (including a lot of philosophers) who think everything is an action. (Well, everything that people are involved with anyway.)

Well, they are wrong.

In human communication, the only way of getting someone to understand something you want them to is by saying something to them: by performing one or more speech actions. In the SOA we interpret this by committing to a view that participants in a service interaction denote the actions to be performed by exchanging messages. I.e., an appropriately formatted message that is effectively communicated between participants counts as an effort to perform an action.

But, not all messages encode actions. Some encode events. For us, an event can be defined as something that happened that someone has an interest in. We can encode a description of an event as a message, in exactly the same way that an action can be so encoded.

So, what is the relationship between events and actions?

If you look at the message that denotes the action, you can call it an event (the event is the performing of the action). On the other hand, traditional speech act theory would encode an event as a speech action: an inform of the change.

Personally, I do not like the smushing together of events and actions in this way: each is a first class idea, not to be subordinated by the other. But they do seem to be very closely connected; almost two sides of a coin — a yin to a yang.

So, we now have two fundamental ‘things’ being communicated: actions and events. Incidentally, an event can be used to communicate a real world effect – one of the cornerstones of the SOA Reference Model. And that is our invention for today.

OASIS Service Oriented Architecture Reference Architecture Face to Face

And if you make it past the title …

This week we had a face-to-face meeting of the RA group. About 10-12 people popped in at some time during the meeting, with a hard core of 7 or 8.

I think that the work is still not at the Jello stage, but we are beginning to get there.

This is not yet reflected in the written work, but there will be three main sections, each of which represents a major viewpoint on the reference architecture:

1. Business as Service view
2. Realizing Service Oriented Architecture
3. Owning Service Oriented Architecture

The first view focuses on the how people fit into the SOA; the second focuses on how you put one together, and the third focuses on keeping one going.

I am particularly happy with this kind of breakdown, as I believe it reflects customers’ true concerns.

Algorithms versus Architecture

I was trying to explain to someone the other day what I did; he was in BioInformatics. It occurred to me that there was a dimension in computer science that I had not been able to articulate properly before: algorithms and architectures.

Some people who call themselves Computer Scientists of one flavor or another focus on solving what seem to be basically algorithms. For example, getting the right image processing algorithm or credit scoring algorithm. On the other hand, others who also call themselves Computer Scientists focus less on the algorithms but on the organization of the computer system. For example, ensuring that the image processing can actually be used effectively in a user’s context.

I have noticed a tendency for people to clump themselves into either the algorithm class or the architecture class. I personally gravitate to the latter. I have also noticed a tendency for algorithmists (sic) to discount the contribution and relevance of the work of the architects — and vice versa. It shows up as “I’ve solved the problem with this cool algorithm” on the one hand and “Apply that function here” on the other hand.

Of course, both are important. It does happen that many of the hard architecture problems are in arenas where the algorithms themselves are trivial (adding up a column of numbers anyone). Similarly, the UI for a video player is also pretty simple, even if the playback algorithm itself is not.

In the world of Service Oriented Architecture, with action at a distance to be supported in a safe and effective way, we have a situation where we need both world-class algorithms (e.g., to correctly infer the consistency of a purchase order with a vendor’s Ontology) and world-class architectures (e.g., to ensure that we can actually place those orders in a reliable, safe and effective way).

A missing piece

For some time now I have been thinking that the key to a framework for safe and effective action across the Internet was the Norms and Institutions paradigm. In that paradigm, the key concept (it seems to me) was the social act; or rather, that all human actions are rooted in the social context.

At the same time, we have been working on the SOA Reference Architecture, and I feel that it is important that SOA itself be grounded in the N&I paradigm. In the approach that we are taking, we are taking multiple views on the SOA theme. Each view is characterized by a viewpoint — literally a point of view of the architecture. One of these views is the Service as Business view, and this view is expressed in language that would be instantly familiar to anyone aware of the Norms and Institutions framework.

A challenge in such a multi-layered approach to architecture is to link the different levels together in a convincing way (ideally, in a way that is both clear and obviously supporting).

In this case, one such challenge is in linking the information exchange level of the SOA (e.g., SOAP message exchange) with the business view (e.g., buying a book). It is certainly true that any interpretation of a SOAP message as anything other than a bunch of XML is somehow extraneous to the SOAP message itself. SOAP (and related specs) simply does not have the language or conceptual framework to deal with book buying (say).

Hence the concept of a business transaction. For business types, this is a fundamental idea: we agree that you will ship me the book and I will pay for it. From the business perspective how this agreement is reached is pure IT (and boring).

For us, however, we need to relate a business transaction to an interchange of SOAP. This leads to the concept of supervenience.

One system can be said to supervene over another if (a) the first system uses the second in a replaceable manner (a different message exchange mechanism would do just as well) and (b) the second lower-level system is neutral in respect of the higher-level system. I.e., if the higher-level use is simply one possible application of the lower-level system and could be applied to other uses without fundamentally affecting its functioning.

So, the business transaction ‘system’ supervenes on the message exchange system quite nicely. Another way of saying this is that business transactions provide an effective way of capturing the meaning of SOAP-level information exchange at a level that is meaningful to people who are not IT geeks.

We did it … the SOA Reference Model passed the vote

Today the SOA Reference Model passed the threshold for voting as an OASIS standard. It is still possible, but pretty unlikely to go down.
Champagne, etc. all round to everyone involved.

Safe and effective software

Someone recently asked me why I was working on the particular topics that I was interested in. I am afraid that in the heat of the moment I had a reasonable but ultimately lame answer (something about reducing friction in the marketplace).

In fact, the true answer is simpler and much more powerful. I want to be part of a ‘professional’ industry, and I believe that we are not really there yet. It is a constant source of amazement to me that there have not been any class action lawsuits against certain high profile software companies.

I like the phrase safe and effective, which describes the basic requirements for medicines of course, but should be equally applicable to software.

What would the benefits of being able to label a system safe and effective? Primarily it means that someone using the system has some assurance that the software will do what it is supposed to do, and that it wont lead you into trouble.

Of course, if you take too many aspirin, or if you misuse a software system, it can hardly fail to cause you grief: so in the end safety and effectiveness is never absolute. But we, as an industry, can do a lot better than we do today.

In the case of services, what does it take to be safe and effective?

I have written before that SOA is about action at a distance. We want to be able to use the Internet to achieve our objectives, to perform tasks. This is fundamental difference between SOA and the Web architecture (for example).

For services to be widely used it will be necessary to be able to show that they are safe and effective too.

Since it of the essence that service is about crossing ownership boundaries, about you using my system, a key piece of figuring out Safety and Effectiveness in relation to services is in being able to answer some simple questions:

1. What is the effect of using the service? (Will it cure my disease?)
2. Do the participants in the service have the appropriate rights in using and delivering the service? (Is the patient an appropriate target for the medicine?)
3. What are the potential side effects of using/offering the service? (What are the complications?)

That is the heart of the problem it seems to me. And, I firmly believe that when we can reliably answer these issues in a systematic way then we will be entitled to call ourselves a profession.

A Semantic Engagement

When someone says something to the effect “We will add Semantics and all your problems will be solved” the image that that conjures up for me is salt: “Let us sprinkle some Semantics and it will taste better”. And, yes, somehow, Semantics always seems to be capitalized.

Needless to say, I do not buy this for a couple of reasons:

• Everything has some kind of semantics. It just may not be all that useful.
• Any explicit representation of the semantic relationships becomes syntactical. Processing therefore becomes processing of structures; you are still writing regular code to do that processing.
• There is no such thing as two people or agents having the same interpretation of a term. Oops, there goes all that Ontology stuff What a chair means to me is overlapping, but different to what it means to you. Even for me, the meaning depends on what I am trying to do (arrange them for dinner, sit on one, ship it and so on.).

Luckily, agreement on the meaning of a term is neither possible nor necessary. All that is needed is some form of congruence in the interpretations.

I think that the really important concept is “Semantic Engagement”. Or, in simple terms, “What it means to me at the moment”.

Semantic engagement is the relationship between an agent (software, person, whatever; but active) and some body of information that defines the agent’s interpretation of that information.

For example, a Web browser’s semantic engagement with information that is sucks in is founded on HTML: it understands HTML in order that it can display it; but does not generally understand what the HTML is for.

This applies to people as well as software. Just in case you thought that you always understand what something is for, just consider the last time that your eyes ‘glazed over’ some topic and you just let it wash over you. For most people, reading EULAs comes into that category.

Semantic Engagement is a useful concept because it limits what you have to do: in the formal setting of a software system you can often define pretty well what a particular module has to do. As in the case of the browser, it often amounts to a fairly shallow understanding of the information while anything deeper in the information is somehow transmitted further on to a different module/layer.

In the case of Ontologies, I believe that the implication is that you cannot separate semantics from intended purpose. Any ontology is a model; and to paraphrase

All ontologies are wrong, some are useful.