Want to hear about SOA and/or Indigo? Eric Rudder, Don Box, Doug Purdy and Rich Turner are all speaking at VS Live (as is yours truly).

Even if you like me, are rather skeptical about SOA, the fact is that Indigo is coming.

Don't let the SOA hype fool you. Indigo will impact you if you use .NET.

Personally I look at Indigo much more as a replacement for remoting and DCOM, along with integrating the WSE stuff into Web services. Because of this, Indigo is a very important thing to me - and to anyone building client/server or n-tier distributed systems in .NET.

Indigo alters the way objects are serialized, the way data is marshalled across networks and more. It is pretty extensive, and is going to be harder to abstract away than either asmx or remoting have been. This means we, as consumers of the technology, will need to understand more of it than we have needed to with existing technologies.

Since VS Live has a whole day on Indigo, this is a chance to get a good look at what's coming and assess what it is going to do to you.

And of course while you are at VS Live, you can attend my distributed object-oriented workshop

Dan Miser blogs that there's a new version of Trillian out there. Off to download we go  - and I suggest you buy it! It is well worth the money!

You can now get details about, and download the beta of, Microsoft's new AntiSpyware software at this location.

I was going to post this on my personal blog, but it occurred to me that it is technical enough in nature to fit here. 

EPIC is a flash video (which has been out for a while now) that portrays the future of media. It is scary, but interesting. Moreover it is thought provoking.

Certainly the web/blog/wiki thing has driven down the value of professional writing. Magazines (and vendors such as Microsoft) are paying less and less for content. Why should they pay when tons of people will produce content for free? Why should advertisers go with established publishers when some blogs outstrip them in readership?

Book sales are down. Even factoring in the dot-bust and the Bush-era recession of the past few years, book sales are down from where they should be. Who needs to buy a book when you can get so much online for free through a quick google search.

It is easy to look at Epic from a technology perspective, but it is the larger social perspective that I find interesting and troubling. And the social effects are real and there's active debate.

Take the controversy over wikipedia.org for example - the encyclopedia business is under siege by who? Us. Anyone with a fact can share it with the world, without going through a formal company or process. Without any opportunity for anyone to make money on it. On one hand this is good, but on the other it is bad. Who’s going to fund archeological research? Who’s going to do the hard parts of finding facts? For free?

In the technology space, many of us blog things – including me. In many cases these are things that might have been paid articles prior to blogging, but now we gleefully put them on the web for free. That's fun for a while, and is good for notoriety, but in the long run it isn't sustainable.

Several people (friends or acquaintances of mine in both the Microsoft and Java spaces) recently have indicated that they are done writing - books, articles - they are done. This is troublesome. Is Atlas shrugging? Will the content of the future consist merely of the myriad voices of mundane souls?

Epic portrays at least one alternative, where it is at least possible for an author to get paid for their craft. Whether that is a realistic model doesn't matter as much as the fact that some model must be found.

Because we're not talking about just technical authors. We're talking about fiction. We're talking about music, and eventually movies. How will content creators get paid to do their work when random people do it for free? Will true artists bother? Do we care? Perhaps the people doing it for free are as good or better?

Perhaps they are just good enough, which is even scarier. That, after all, is the primary sin people ascribe to Microsoft. That they aren't the best, but rather are just good enough – leaving us stuck living in a “good enough“ world rather than a really kick ass world.

I don't necessarily buy that viewpoint on Microsoft. Having used various flavors of Linux I don’t see that as the “kick-ass world” I’m personally looking for anyway. But it is easy to look at reality TV and see where everything could sink to that level.

Epic raises serious questions that only time will answer...

In my previous entry Randy H notes that Microsoft has a different approach to marketing:

MS has some incredibly talented marketers. The Technical Product Manager role is essentially a marketer that helps to determine what features go into products and how things should work. To me, that kind of marketing has a lot of value. I wouldn't dismiss the role of marketing in our greatest technology companies. Wasn't .NET a whole lot of marketing as well?

While it is true that Microsoft has a unique approach to marketing, they really aren't much different than anyone else. While .NET was as much marketing as anything else (since the ".NET" got slapped on _everything_ for a while), the reason it has been successful is due to its technical merits.

Notice that the ".NET" label is fading already - Visual Studio 2005, Visual Basic 2005, etc. No .NET left in the product names at all. My guess is that ".NET" the term will fade away into the same marketing hole that swallowed up Remote OLE Automation, MTS and soon SOA.

I have always found it amazing when Microsoft is said to have this "great marketing machine". In many ways they are the worst marketers out there. Certainly far, far worse than Apple or IBM for instance.

Apple has the trendy thing going, and has for a very long time. Microsoft has never been trendy or fashionable or cool or hip. But Apple sure is hip, and it shows in their iPod sales. For some reason though, having powerful marketing in the "cool space" doesn't translate to widespread use.

IBM has those really kick-ass commercials that juxtapose business situations with strange solutions. And prior to that they had the cool commercials showing non-tech scenarios that were just metaphors for IT issues. Very cool and very smart stuff. Very effective too, as IBM’s global consulting arm has become large and influential due to that kind of marketing.

Microsoft has never had anything remotely similar to “real” marketing like that. Microsoft’s marketing has always been more subtle and focused on technologists. In reality, Microsoft’s marketing has always been more grass-roots, much like the open-source world.

And there’s some humor for you. The open-source world has apparently decided that it too needs marketing. Even if you make no money off your work, you certainly want the fame/notoriety – and to get fame you need people to use your stuff rather than your competitors’ stuff (regardless of whether they are commercial or OSS).

At the same time, Microsoft really wants to move into the enterprise space, and so they have been trying to figure out how to do “actual” marketing along the lines of IBM. And they want to sell consumer items like the Media PC, so they’ve been struggling to figure out how to be hip like Apple. Hopefully as they do this, they’ll manage to continue the MSDN and TechNet-style marketing to the technical community. We’ve been the bread-and-butter for them over the past 12 or so years after all.

Don Box put out his predictions for 2005, including #3 which states that the term SOA will be replaced by some new hype-word invented by the marketing wonks of various software and industry analysis companies.

As I said months ago, the S in SOA is a dollar sign. SOA is much more hype than reality, which means it is created and defined by marketing people far more than it is by actual computer scientists or engineers.

As is often the case with over-hyped concepts, the terms related to those concepts rapidly become meaningless. What is SOA? Depends on which vendor you ask. What is a service? Depends on which vendor you ask. It is all a meaningless jumble here at the start of 2005.

Of course the concept is too valuable to marketeers[1] for them to give up just because a term has been lost. So I am sure Don is right and marketing groups at Microsoft, IBM, Gartner and many other organizations are busily working to decide on the next term or terms to use for a while.

So for better or worse SOA itself isn’t dead, but I agree that the term is living on borrowed time.

[1] Yes, I know the term is marketers, but that extra “e” in there makes it sound so much more, well, Disney somehow

In recent SOA related posts I’ve alluded to this, but I wanted to call it out directly. SOA is founded on the principal of passive data. Dima Maltsev called this out in a recent comment to a previous blog entry:

In one of the posts Rockford is saying that SOA doesn't address the need of moving data and also the logic associated with that data. I think this is one of the main ideas of SOA and I would rather state it positively: SOA wants you to separate the logic and data.

Yes, absolutely. SOA is exactly like structured or procedural programming in this regard. All those concepts we studied way back in the COBOL/FORTRAN days while drawing flowcharts and data flow diagrams are exactly what SOA is all about.

Over the past 20-30 years two basic schools of thought have evolved. One ways that data is a passive entity, the other attempts to embed data into active entities (often called objects or components).

Every now and then someone tries to merge the two concepts, providing a scheme by which sometimes data is passive, while other times it is contained within active entities. Fowlers Data Transfer Objects (DTO) design pattern and my CSLA .NET are examples of recent efforts in this space, though we are hardly alone.

But most people stick with one model or the other. Mixing the models is complex and typically requires extra coding.

Thus, most software is created using a passive data model, or an active entity model alone. And the reality is that the vast majority of software uses a passive data model.

In my speaking I often draw a distinction between data-centric and object-oriented design.

Data-centric design is merely a variation on procedural programming, with the addition of a formalized data container of some sort. In some cases this is as basic as a 2-dimensional array, but in most cases it is a RecordSet, ResultSet, DataSet or some variation on that theme. In .NET it is a DataTable (or a collection of DataTables in a DataSet).

The data-centric model is one where the application goes to the database and retrieves data. The data in the database is passive, and when the application gets it, the data is in a container – say a DataTable. This container is passive as well.

I hear you arguing already. “Both the database and DataTable make sure certain columns are numeric!”, or “They both make sure the primary key is unique!”. Sure, that is true. Over the past decade some tiny amount of intelligence has crept into our data containers, but nothing really interesting. Nothing that makes sure the number in the column is a good number – that it is in the right range, or that it was calculated with the right formula.

Anything along the lines of validation, calculation or manipulation of data occurs outside the data container. That outside entity is the actor, the data container is merely a vessel for passive data.

And that’s OK. That works. Most software is written this way, with the business logic in the UI or a function library (or maybe a rules engine), acting against the data.

The problem is that most people don’t recognize this as procedural programming. Since the DataSet is an object, and your UI form is an object, the assumption is that we’re object-oriented. Thus we don’t rigorously apply the lessons learned back in the FORTRAN days about how to organize our code into reusable procedures and organize those procedures into function libraries.

Instead we plop the code into the UI behind button clicks and key press events. Any procedural organization is a token effort, unorganized and informal.

Which is why I favor an active entity approach – in the form of object-oriented business entity objects.

In an active entity model, data is never left out “on its own” in a passive state. Well, except for when it is in the database, because we’re stuck using RDBMS databases and the passive data concept is so deeply embedded in that technology it is hopeless…

But once the data comes out of the database it is in an active entity. Again, this is typically an entity object, designed using object-oriented concepts. The primary point here is that the data is never exposed in a raw form. It is never passive. Any external entity using the data can count on the data being validated, calculated and manipulated based on a consistent set of rules that are included with the data.

In this model we avoid putting the logic in the UI. We avoid the need to create procedures and organize them into function libraries like in the days of COBOL. Instead, the logic is part and parcel with the data. They are one.

Most people don’t take this approach. Historically it has required more coding and more effort. With .NET 1.x some of the overhead is gone, since basic data binding to objects is possible. However, there’s still the need to map the objects to/from the database and that is certainly extra effort. Also, the data binding isn’t on a par with that available for the DataSet.

In .NET 2.0 the data binding of objects will be on a par (or better than) binding with a DataSet, so that end of things is improving nicely. The issue of mapping data to/from the database remains, and appears that it will continue to be an issue for some time to come.

In any case, along comes SOA. SOA is all about active entities sending messages to each other. When phrased like that it sounds almost object-oriented, but don’t be fooled.

The active entities are procedures. Each one is stateless, and each one is defined by a formal contract that specifies the name of the procedure, the parameters it accepts and the results it returns.

Some people will argue that they aren’t stateless. Indigo, for instance, will allow stateful entities just like DCOM and Remoting to today. But we all know (after nearly 10 years experience with DCOM) that stateful entities don’t scale and don’t lead to reliable systems. So if you really want to have an unscalable and unreliable solution then go ahead and use stateful designs. I’ll be over here in stateless land where things actually work.

The point being, these service-entities are not objects, they are procedures. They accept messages. Message is just another word for data, so they are procedures that accept data.

The data is described by a schema – often an XSD. This schema information has about the same level of “logic” as a database or DataSet – which is to say it is virtually useless. It can make sure a value is numeric, but it can’t make sure the number is any good.

So Dima is absolutely correct. SOA is all about separating the data (messages) from the logic (procedures aka services).

Is this a good thing? Well that’s a value judgement.

Did you like how procedural programming worked the first time around? Do you like how data-centric (aka procedural) programming works in VB or Powerbuilder? If so, then you’ll like SOA – at least conceptually.

Or do you like how object-oriented programming works? Do you appreciate the consistency and centralized nature of having active entities that wrap your data at all times? Do you feel that the extra effort of doing OO is worth it to gain the benefits? If so, then you’ll probably balk at SOA.

Note that I say that people happy with procedural programming will conceptually like SOA. That’s because there’s always the distributed parallel thing to worry about.

SOA is inherently a distributed design approach. Yes, you might configure your service-entities to all run on the same machine, or even in the same process. But the point of SOA is that the services are location-transparent. You don’t know that they are local, and at some point in the future they might not be. Thus you must design under the assumption that each call to a service is bouncing off two satellites as it goes half-way around the planet and back.

SOA (as described by Pat Helland at least) is also inherently parallel. Calls to services are asynchronous. Your proxy object might simulate a synchronous call, so you don’t even realize it was async. But a core idea behind SOA is that of transport-transparency. You don’t know how your message is delivered. Is it via web services? Is it via a queue? Is it via email? You don’t know. You aren’t supposed to care.

But even procedural aficionados may not be too keen to program in a distributed parallel environment. The distributed part is complex and can be slow. The parallel part is complex and, well, very complex.

My predication? Tools like Indigo will avoid the whole parallel part and it will never come to pass. The idea of transport-transparency (or protocol-transparency) will go the way of the dodo before SOA ever becomes truly popular.

The distributed part of the equation can’t really go away though, so we’re kind of stuck with that. But we’ve dealt with that for nearly 10 years now with DCOM, so it isn’t a big thing.

In the end, my prediction is that SOA will fade away as people realize that the reality is that we’ll be using it to do exactly what we did with DCOM, RMI, IIOP and various other RPC technologies.

The really cool ideas – the ones with the power to be emergent – are already fading away. They aren’t included (at least in the forefront) of Indigo, and they’ll just slip away like a bright and shining dream and we’ll be left with a cool new way to do RPC.

And RPC is fundamentally a passive data technology. Active entities (procedures) send passive data between them – often in the form of arrays or more sophisticated containers like a DataSet or perhaps an XML document with an XSD. It is all the same stuff with tiny variations. Like ice cream – chocolate, vanilla or strawberry, it is all cold and fattening.

So welcome to the new world, same as the old world.

One of the areas where the non-Microsoft world has long criticized Microsoft is in their use of a closed bug and issue tracking system. The open-source world, in particular, claims that having an public submission process is one of their key benefits.

With Visual Studio 2005 and .NET 2.0, Microsoft has launched what is apparently a little publicized and little-known public submission web site for bugs and suggestions. It was code-named Ladybug, and is now called the Product Feedback Center.

Not that it is totally unheard of, or unused. Ladybug is rumored to be the primary motivation in C# getting edit-and-continue. E&C wasn't even on the C# feature list, but large numbers of ex-VB developers who are now enjoying semi-colons apparently voted E&C to the top of the Ladybug wish list, putting pressure on Microsoft to add the feature.

True story? I don't know, but that's the rumor.

The point being, Microsoft pays attention to the stuff on this site. If you have a bug or issue in VB, C#, ASP.NET or whatever you should make sure to report it on Ladybug!!!

I was relaxing today, visiting with my wife and she read me the text from this link. It got me thinking… (and yes, I am way too geeky for my own good sometimes )

The ancient Egyptians had a pretty solid understanding of decomposition into object-oriented models al la CRC-style analysis.

(Stargate SG-1’s general misuse of the goddess Maat notwithstanding, and totally ignoring the real world speculation that Maat was an alien)

Look at the description of the goddess Maat’s role. She has a very clearly delineated and focused responsibility. As an object, Maat’s job is to measure justice vs evil. Arguably this is the job of the scale, but given that there’s a goddess involved, I’m giving more weight (pun intended) to her than to the inanimate scale.

She doesn’t decide what to do about evil, or how to mete out justice. This is not her role.

Osiris on the other hand, doesn’t measure justice or evil, nor does he perform punishment. His responsibility is also clearly delineated as a single “business rule” wherein he passes the Judged off to the appropriate “handler“.

To do this he collaborates with Maat (and technically with the scale) and with the Judged. He has a using relationship with Ahemait, where he passes the Judged if they fail to meet the business requirement by having an excess quantity of evil (as measured by Maat).

The fact that the Egyptians realized that justice had two parts, or two responsibilities, is very interesting. They properly separated the responsibility of measuring evil (as a single, discrete concept) from the responsibility of judging outcomes based on that measurement. A distinction that was fortunately carried forward into the US justice system. The measurement of evil is the responsibility of the jury, while the judging is a separate concern as is the actual implementation of punishment. Next time you are called for jury duty, keep in mind that you are filling the role of the goddess.

Not only did the Egyptians get the separation of responsibilities, but they understood the idea of object collaboration. This is illustrated by the fact that Osiris can’t do his job without collaborating with other “objects” in the system.

And to think. All this time I’ve been saying that object-orientation has been around for about 30 years. I guess I was off by a couple orders of magnitude. It is more like 3000 years

Sorry for the blatantly commercial nature of this entry, but as we close out 2004 and head into 2005 it turns out that the Microsoft-oriented consulting business is doing pretty well. Thus my employer, Magenic, is in need of more consultants (see below for details).

As most people are only too aware, the computer field (and in particular consulting) had a very rough time from 2001 to 2003 (give or take a bit). Not only was there the dot-bomb, but there was the post-9/11 effect and the overall economic recession. This was all amplified in the computer field because of the overly optimistic positions taken by many companies during the Clinton-era economic boom.

But the reality is that over the past 18-24 months the consulting business stabilized and has started to grow once again. At least that has been my observation watching Magenic’s business slow and then grow over the past 4+ years.

I think there are many factors going into the return of growth. Certainly the weak dollar is making offshoring less attractive. But so is the slow realization among many companies that they really aren’t getting the savings they’d hoped for (given the high cost of management, requirements gathering, communications and rework).

Add to that the slow, but persistent recovery of the economy overall. While it is true that a lot of people (in the general pool of workers) are working multiple odd jobs to make ends meet, the fact is that companies are now resuming investment in IT in order to improve efficiency. This is triggering renewed interest in line-of-business software development, and in turn is causing demand for consulting.

Finally there’s the maturation of .NET. Many organizations wait until a couple service packs and maybe a point release come out before moving aggressively to any technology. And I don’t blame them in the least. But .NET (and all of Microsoft’s related (or quasi-related) server products now have at least a point release and/or some service packs that have been out for a while. Even conservative organizations are starting to seriously look at moving some or all their IT into the .NET space.

This is even leading to a lot of coexistence with Java and J2EE. I can’t count the number of organizations I’ve talked to that switched to the big J in reaction to Windows DNA, and are now choosing (yes, choosing!) to bring in .NET in addition to Java. Every now and then they are even replacing Java, but more often it is a clear strategy of coexistence and integration.

Ultimately this growth means that Magenic actually has more work than we have people. The fact that Magenic is pretty selective in its hiring makes finding people more difficult, but we’d rather lose work before compromising on who we hire. Even so, we’re the largest privately held Microsoft-focused consulting company in the US (possibly in the world).

Magenic is looking for .NET architects and developers. But even harder to find are people with good experience in Biztalk Server, Commerce Server, Sharepoint and Business Intelligence (or other SQL Server skills). If you are interested, Magenic has offices in Boston, Atlanta, Chicago, Minneapolis and San Francisco.