« July 2008 | Main | September 2008 »

August 2008

August 19, 2008

IBM updates SOMA

Blogger: Anne Thomas Manes

643

IBM recently published an update of its Service Oriented Modeling and Architecture (SOMA) methodology in IBM Systems Journal. The article has an academic style, and is chock-full of techno-speak, but the information is valuable.

SOMA is the software development lifecycle (SDLC) methodology that IBM Global Services uses in its SOA project engagements. It is based on IBM's patented Unified Method Architecture (UMA), IBM's meta-model that provides the foundation for the Rational Method Composer (RMC). RMC is the Rational tooling that supports the Rational Unified Process (RUP).

As you would expect from a RUP-based methodology, SOMA is a heavyweight, top-down, model-driven, iterative SDLC methodology. The article describes two cases studies --one short case to get a big-picture sense of the process, and one long case to illustrate the process. This graphic shows an overview of the SOMA lifecycle.

According to Tilak Mitra, one of the SOMA guys from IBM:

"The fundamental difference between SOMA as it existed and what it is now, is that the former version had it just as a service modeling and design method. However, now SOMA is a full lifecycle engagement model for project execution."

One other significant difference that I see is the adoption of "service cases" in place of "use cases".

The described methodology seems appropriate for organizations in the early stages of their SOA initiatives. The methodology appears to be missing a major set of capabilities associated with service portfolio management, though. It makes no mention of capturing information about the services in a registry or repository, and it makes only one parenthetical reference to searching a registry for available services. Of course, since it's RUP-based,  the process will generate a huge number of artifacts about the services, but I'm not convinced that the raw artifacts will enable service discovery and reuse of the services. It would be beneficial if SOMA provided some guidance regarding registration and reuse of services in the service portfolio.

The article sprinkles the term "governance" throughout the introduction, but provides no examples of actual governance processes used during the lifecycle.

The described methodology also seems to be very WS-* centric. I'm sure that the methodology could be used to implement RESTful services, but the illustrated case focuses on WSDL and operation-oriented services rather than resource-oriented ones.

August 15, 2008

The Endowment Effect – is my CIO a chimp?

Rwatson_biopic Blogger: Richard Watson

The Economist published an article  recently on a cognitive bias called The Endowment Effect.   Put simply, this effect means that we place a higher value on something we own than we did before we acquired it.  The article details many experiments that bear this out.  We see students preferring to keep coffee mugs rather than exchange for chocolate which they would prefer in a straight choice.  Chimpanzees endowed with peanut butter keep it in 20% more cases than when faced with a straight choice of peanut butter or orange juice.  Similar effects are observed in financial portfolio management, despite the transaction costs for professional traders approaching zero.

This got me thinking about application portfolio management and how service-oriented architecture (SOA) can reduce the negative consequences of the Endowment effect.

What does the Endowment effect mean for IT?

Is creating and delivering invoices one of your organization’s core capabilities?  Probably not, however creating and selling insurance policies or designing and manufacturing cars might be.

There are service providers that just create and deliver invoices.  Let’s say you meet with Jim, the VP of business development of SpeedyBills.    Jim encourages you and your Enterprise Architects to measure the cost of sending an invoice across each line of business.  Let’s say you manage to calculate this – no mean feat in itself – as X cents.  Jim assures you SpeedyBills can do it for X/4 cents.  Oh, and you can send it whenever you like, not on a random day in the five days after the monthly batch.  And you can change the formatting or content whenever you like, not when the developers decide to upgrade the templating package.

That sounds great, but you know what Jim, we’ll stick with what we’ve got, thanks.  That’s the Endowment effect kicking in, corporate IT style.  You probably have 3 systems for creating and delivering invoices that are each integrated in an arts and crafts way with 5 other systems.  This complexity keeps the cost of change very high, as each minor change causes a costly domino effect.  The changes required to expose enough data and process to use SpeedyBills are mind bending.

Network_spagetti_5

To be fair to most CIOs, they’re not choosing to hold onto these systems because they prefer their spaghetti to the SOA bento box.  One endowment effect driver is transaction cost. Satisfying similar requirements with a different system will often require significant switching cost.  How we got here is another day’s post, but poor architecture is at the root of this cost.  Monolithic applications, point-to-point integration, myopic project scope and funding, the “I’m special” business unit attitude and constraints imposed by proprietary and legacy technologies all contribute to IT system complexity.

Resistance to change is a fundamental that underpins the endowment effect.  Behavioral economist Pete Lunn refers to resistance to change and its relationship to familiarity:

"Of course there is something conservative about a bias towards what is familiar, because it also implies that we are instinctively biased against change.  Results back this up.  When opinion surveys ask people to state preferences between alternative spending plans (say for governments, local  authorities companies, or individuals), if the accompanying description reveals which option is the current one, many  more people choose it.  This “status quo” bias is also found in experimental economic games, in which people are given scenarios and must select strategies to win or lose money.  People are often slow to abandon their current strategy and switch to a more profitable one.  Status quo bias is part of our common understanding, summarized by “better the devil you know”.

Pete Lunn. Basic Instincts: Human Nature and the New Economics. London: Marshall Cavendish, 2008.

How does SOA enable this?

IT portfolio management’s endowment effect is caused by financial and psychological fear of change.  Adopting SOA helps in two ways: reducing the cost of change and moving the mindset of an organization from resisting change to expecting it.

SOA loose-coupling principles will connect systems in a manner whereby changes to dynamic systems remain as isolated as possible.  Business processes composed from reusable, loosely-coupled, policy-driven services are more flexible than applications with arbitrary boundaries and integration.  Flexibility will enable IT to substitute a different provider of a discrete business capability at predictable low cost. You can take advantage of SpeedyBills and other lower cost and flexible providers. For example, obtaining new sourcees of financial reference data or a healthcare provider that offers better choice of health plan benefits to your employees.

Change is the underlying driver for SOA.  If system requirements don’t change, or the services are not reused, then the business case for applying service-oriented principles won’t stack up.  Change is baked into the whole deal, and adopting SOA means accepting change as business-as-usual.

How to get there?

We can’t move from techie-spaghetti to lean-n-mean, warm-pluggable business capabilities overnight.  But we can think big and take small steps.  Getting to the SOA bento box requires a deep commitment to application portfolio management and business architecture as Mike Rollings has identified.

Funding for transformational initiatives can be hard to come by; I’ve blogged previously on the paradoxes inherent in securing funding for SOA.  Nevertheless, businesses are always interested in funding medicine for their pain points.  Delivering analgesic to the business pain, while working on the root cause is the way to go.  The patient will start to listen to the get-well plan once you’ve cured the immediate pain, so focus on manageable, but visible projects and measure the outcomes.

Exercise for the reader

By the way, there’s no shortage of other cognitive biases  to choose from in corporate IT departments – I leave it as an exercise for the reader to spot some more in the wild.  For a start, look out for bandwagon effect (“if everyone’s doing REST this year, it must be a winner”), confirmation bias (“I’ve gathered the metrics that show my software development process is top class”) and post-purchase rationalization (“of course buying that ESB to kick start our SOA initiative was a sensible thing to do”).

August 11, 2008

A Continuous Integration Story

Blogger: Kirk Knoernschild

Kirk Continuous Integration (CI) is the practice of integrating and building a software product as often as is feasibly possible. CI was popularized by Extreme Programming (XP), a few years ago, but can be traced to the practices of Microsoft and other companies as far back as the mid-90’s. Since that time, CI tools and best practices have evolved to the point where implementing a rich CI strategy should be on the roadmap for any software development team. Unfortunately, not all teams choose to practice CI.

Recently, I encountered an interesting situation that clearly illustrates the value of CI. Two software teams were each working on separate software modules. Eventually, these teams knew they’d need to integrate the two modules into a larger whole. Unfortunately, communication wasn’t that great between the two teams, and while they each had a rich suite of unit tests (they created test stubs when testing the integration points between each other), and regularly tested their individual components, they didn’t ever integrate them and test them together. Finally, the day came (late in the project, mind you), when the two teams needed to integrate. In fact, integration even went fairly well. Since each team had been using test stubs that exposed the other module’s API, the act of integration went fairly well, and the two modules were able to communicate with each other without many problems. Unfortunately, things fell apart fairly quickly after that, as integration testing revealed something alarming. A major piece of functionality was missing. Each team thought the other was providing that behavior.

The moral of the story, of course, is that had these separate teams been focused on integrating their two components early and often, this problem would have been discovered much earlier in the development lifecycle. But working in silos is easy and integration is hard. Creating a false sense of progress by avoiding integration until late in the lifecycle can jeopardize the project. With CI, your product isn’t just “done”, it’s “shippable”.

Burton Group Podcast

Blog powered by TypePad