Posted by Viktor Grgic mid-afternoon: October 5th, 2009
Many have assumption that IT / software architecture is a thing of logic. So, there are many discussions about ESB and that we should not have those. The fact is that in large companies, we do not often do architecture – we do politecture. The politics drive the architecture. It’s not the way it should be, but that’s the way it is.
Let’s do one more shot…why do we need ESB? This time from politecture perspective:
Preventing a mess
It allows for a greater degree of control on delivered solutions. Before you even think about creating another quick and dirty integration solution; there is that annoying ESB compliancy making sure that integration mess created with each new technology is at least visible.
Disruptive Innovation
An alternative like REST is a “disruptive innovation” and does not fit in the line of old mindsets (CORBA, RMI, EJB, SOAP, WS-*,…). ESB fits in this line. Of course, it is a matter of time before something like REST wins from ESB’s.
Legacy
Quite often the cleanest solution is to change or replace the legacy in case of integration problems. So you still don’t need an ESB. But the real problem is who is going to let you change that legacy that has not been changed and (barely) working in production for a long time.
Posted by Michaël van Leeuwen around lunchtime: August 3rd, 2009
Rik de Groot wrote a blog entry about a year ago about versioning services as part of the Top 10 SOA Pitfalls. He touched the subject on different versions in deployment and basically offered us the option of rerouting services using an ESB.
It is a common knowledge that consumers will keep on using a service hoping to only upgrade if *they* need additional or changed functionality. Services however are not meant for a single consumer but for a lot of consumers. Even if they want to upgrade they won’t do it simultaneously. So you will have multiple versions of services running.
I see several options to address versions of services:
1. Minimize by using rerouting within the ESB.
2. Keep all versions running while in use.
3. Have a contractual agreement with expiry date.
4. Use content based routing.
5. Construct adapters for conversion
First I would like to look at which versions might appear. A major version increment of a service means we are no longer backward compatible. A consumer wanting to use the next major release therefore needs to start coding to make use of this service. When a minor increment occurs there is backward compatibility and additional functionality offered. This means a consumer can make use of it without much effort (changing the binding would suffice). A patch increment of a service indicates a change without breaking specifications. A new patch release can – and should – therefore replace the older version.
Clearly in all options we should limit the number of versions of a service created. This means services should not be created within projects but (re-)created in a separate track in order to have generic services and optimal reuse. This track should collect all requirements of (potential) customers, take the common denominator and bring a new version into existence. More than often a new version is created because a single customer wants certain functionality not yet offered and without looking around the new version is tailor-made.
(more…)
Posted by Jeroen van Wilgenburg mid-morning: December 24th, 2008
Last week I installed WebLogic and the AquaLogic Service Bus on a Mac. There is no Mac-download on the download page, but by using the HP-UX version everything works fine, you just have to add some command line parameters.
Posted by Gero Vermaas around lunchtime: June 29th, 2008
The Top 10 SOA Pitfalls countdown hit #1 last week with Rik de Groot’s post on “Ignoring culture when introducing SOA“, time for a wrap-up.
Putting all pitfalls together in one simple 10 item list quickly reveals a grouping of types pitfalls. Number #1 and #2 are both related to organizational aspect. If the culture, mindset and attitude are not right, these are typically the pitfalls that a SOA endeavor may run in to. The next group covers the items #3 till #7, these are all related to architectural/design skills. And the last group, numbers #8 till #10, relates to implementation issues (although proper design could help to prevent these pitfalls from manifesting themselves).
Posted by Rik de Groot around lunchtime: June 23rd, 2008
Last week Viktor Grgic explained Unclear ownership / Project based funding. This week we’ll continue with #1 – Ignoring culture when introducing SOA.
SOA is an approach. The culture aspect of introducing a SOA is important, but it seems that companies want to invest in tools and not in people. In order of making this SOA to work they force their employees into this new way of thinking/acting. Often this leads to resistance which undermines the SOA goals. In this part we will look into ignoring culture when introducing SOA.
(more…)
Posted by Viktor Grgic in the late afternoon: June 16th, 2008
Last week Viktor Grgic explained the Missing skills en this week we’ll continue with #2 – Unclear ownership / Project based funding
In the world of standalone applications, there is typically a clear sponsorship and ownership of an application. There is also a single project with one project manager. The systems could be small or big, but the pattern remains the same. Funding is based on a business case and can be easily defended.
In SOA world, the story is different. There are the usual projects, each having their own objectives and often reluctant to work on generic services or enterprise components. If the ownership and funding for these components and aspects are unclear then chances are high that nothing happens on enterprise level or that it’s not according to enterprise architecture or nobody feels responsible when things on enterprise level go wrong (e.g. security).
Several projects working together is not a bad situation, but there should also be a SOA steering committee and SOA competence center well funded and supported by company board.
(more…)
Posted by Viktor Grgic in the early morning: June 9th, 2008
Last week Gero Vermaas explained the Incorrectly Applied CDM en this week we’ll continue with #3 – Missing skills
Just like any other paradigm, a level of new knowledge and experience is required. Unfortunately, SOA requires lots of new knowledge and experience. It requires a different way of thinking of more or less everyone involved. People are used to closed environments on both organisational and technical level; largely well protected from influences and unwanted dependencies with the outside world. It’s all in their area of influence which makes achieving short term results relatively easy. I’m referring to silo applications where the world is complicated enough. From their view, SOA makes things even more complex. There should be awareness that there is lack of knowledge, experience and attitude and something should be done about this first. There is no real solution, except for the obvious one: educate everyone involved. Also, agile methodologies have proven to be effective in building up knowledge and experience.
(more…)
Posted by Gero Vermaas mid-morning: June 2nd, 2008
Last week Vincent explained the BDUF Pitfall en this week we’ll continue with #4: Incorrectly applied Canonical Data Model (CDM).
CDM is one of the silver bullets often fired in SOA projects. It should address miscommunication, ease integration and reduce integration costs. It surely can facilitate all of this, but attempts to use a CDM can also turn your SOA project into an endless discussion because one attempts to cover too much, because of a lack of alignment with business and because of a lack of design principles.
(more…)
Posted by Vincent Partington in the early evening: May 26th, 2008
Last week we discussed #6 - which means we’ve now passed the halfway point of SOA Pitfall countdown! Let’s quickly move on to #5.
Like the Not Invented Here syndrome we discussed earlier, Big Design Up Front (BDUF) is something not only witnessed within the realm of SOA. However, where the NIH syndrome is generally accepted to be a bad thing, things are not that simple when it comes to BDUF.
Posted by Rik de Groot late at night: May 19th, 2008
After discussing #7: Incorrect granularity of services , let’s move on to #6.
In organizations data and functionality/processes are often fragmented, but are needed centrally. What are the causes of this fragmentation. Does a SOA solve this complexity automatically? Most companies start with a SOA and are confronted with this complexity during the implementation of the SOA.
(more…)