Geeks With Blogs

Brian Loesgen's *OLD* Blog, new blog is http://blog.BrianLoesgen.com This blog has moved to http://blog.BrianLoesgen.com

I'm part of a curriculum  advisory panel for California State University for an upcoming SOA program. As part of that, I spoke with someone there recently, relating real-world experiences, in a rather wide-ranging conversation. I started thinking "gee, I should write some of this down, it could be a good blog post". So, here it is!

I'll start off by saying that I could probably write a book about this, and there's likely a bazillion of my peers that could co-author. Many have already written books about this. However, instead, I'm going to distill selected thoughts down into a soap box-ish ranting blog post. I have boiled down some key points into just a few phrases. Maybe it works, maybe the value gets lost in a haze of over-simplification. Maybe I should do a series of posts (but I have NO plans to do so!).

Think big, do small

I'd say the single most important factor is planning. And by that, I don't mean lock a bunch of smart people in a room for a year and have them emerge with a detailed waterfall Gantt chart. I mean realizing that you're embarking on a path that will transform the way you create, deploy and manage your business-critical applications. Done right, your enterprise becomes more agile, cost and time to deploy new functionality decreases, and you achieve the nirvana of code re-use we as an industry have been seeking for decades. Done wrong, and you'll squander precious people resources and budget on an initiative with little or no return.

Mitigation: "boil the ocean" approaches fail. Think it all through, and then select some small services, then gradually pilot/deploy/build-up from there.

 

Think across the enterprise

In a large company with multiple IT sub-organizations, you need to have enterprise-level vision. Create a governing body. Identify a services portfolio. Without this, you could be doomed to costly inefficiencies such as duplication of efforts where multiple departments create different variants on a service, inconsistent naming, and eventually, a maintenance nightmare.

Mitigation: If you don't already have an enterprise architecture group chartered with setting enterprise-wide standards and policies, form one.

 

Take a holistic view

A developer will write 12 lines of super elegant code and say "there, the service is done, you can deploy it now".  It's no fault of the developer, in their opinion they are done. The problem of course is that you need a services management strategy, and that goes far beyond the realm of what the rank and file developer sees, or in most cases, beyond what they need to see, and certainly beyond what they usually think about.

Mitigation: Think about the entire lifecycle of a service. How will you deploy it? Is there an approvals process? How will you secure it? How will you manage it? How will you monitor it? How will you retire it?

 

Recognize the people challenges

SOA thinking moves people into the realm of message-oriented, or contract-first if you like, architectures. This requires a different mindset than traditional object-oriented or procedural architectures. You're in a realm where everything is loosely-coupled, and operations often become asynchronous. I have seen firsthand at challenged client sites just how horribly wrong things can go if you try to apply object-oriented thinking and functional decomposition in a message-oriented environment.

Mitigation: recognize this paradigm shift, and invest in your people (architects and developers) to help them make the transition. Get them training and mentoring.

 

Recognize the infrastructure challenges

Creating an efficient operations environment for services is something that will be new to many IT folks. Your SLA's will drive requirements such as high availability and response times. Policy-driven SLAs and policy-driven security add a layer of indirection that result in a more change-tolerant and resilient infrastructure.

Mitigation: Plan for the near-term future, but look to the long-term future to ensure the environment you are putting in place will be able to scale to meet future demands. Your tooling may be great when you have 6 services in production, but how will it be when you have 1,000?

 

Think beyond the technologies and into the processes

Today's fast-paced world and rapidly changing business requirements of course lead to rapidly changing needs from the applications we create. Back when applications were monolithic silos, change came slowly, and evolution and deployments occurred at the monolith level. In a services-oriented world where there are numerous services acting as cogs in the machine, the new unit of deployment is at the service or service-composition level. Change is assured, and solution subset deployments become normal. "cowboy deployments" although almost always bad, in this type of environment become disastrous.

Mitigation: recognize Application Lifecycle Management as a key part of your process, and invest in it. Put procedures in place to assure repeatable, reliable builds. Have a testing strategy. Have a versionning strategy. Code migration should not be something people are afraid of.

Plan for disasters

An interesting side effect in the reuse of code assets by implementing intelligent stratification is that you inevitably build dependencies. For example, if all your services use an exception management service to log and respond to exceptions, what happens if that service is unavailable? The impact of a single service outage could ripple through your entire environment.

Mitigation: Think carefully about the dependencies, and architect and build robust services that incorporate mechanisms to respond to outages.

 

Benefiting from a successful SOA strategy is possible, but it's something you (as an architect) need to think about. As technologists, we often naturally gravitate towards and get caught up in the technologies. However, there are many touch-points beyond just the technology decisions, what I've listed above are just some of the things I've observed out in the real world, out where people are actually implementing SOA-based initiatives. I'm hoping by posting this that I'll help ease the path for some of you....

 

Technorati Tags: ,,,
Posted on Monday, May 19, 2008 8:59 AM General , BizTalk Server , ESB , SOA | Back to top

Copyright © Brian Loesgen | Powered by: GeeksWithBlogs.net | Join free