Gregor's Ramblings on Enterprise Integration
	Home • Patterns • Ramblings • Articles • Talks • Download • Links • Books • Contact

I have been looking for a way to share more thoughts and ideas on my site without committing to a regular blog. For now, I created these "rambling" pages to talk about timely topics. Most entries will be longer than typical blog entries but will likely also appear much less frequently (I'll try to post something every other week or so). I call them "ramblings" because these notes are typically based on my personal opinions and observations as opposed to official "articles".

I created a very simple RSS Feed. This is my first experiment with RSS, so forgive me if something does not work quite right.

One of the biggest perceived fears of authors is that someone publishes a book or an article on the same topic just ever so slightly ahead of you that you have done all the work but look like a copy cat if you still publish your work. In reality this actually does not happen very often (at least not for books) as each author has his or her unique style and view even on the same topic. This time, though, Ken Arnold stole a little bit of my show by publishing an excellent article in ACM Queue magazine called "Programmers are People, too". [Full Text]

As many people have already heard, I changed employers. Before the rumor mill completes its work entirely, here a few comments from my end. [Full Text]

I just returned from Microsoft TechEd Europe in Amsterdam. I was lucky enough to present on event-driven architectures in front of almost 600 people. Since multiple people asked me for the source files, I figured I'd post a quick summary of the talk, including the source files. [Full Text]

Having been to a number of conferences and their attached expo floors recently it was not surprising that I was not able to escape the line "this tool does not require programming, everything is done through configuration". Hearing this tag line for the third or fourth time got me wondering, "what really is the difference between coding and configuring?" [Full Text]

This year I actually missed putting in a proposal for TechEd. However, that has not kept me from actually presenting :-) So I am here fighting the Orlando Summer humidity together with 11000 other geeks and am actually having a good time. [Full Text]

On a recent project we developed a Web services framework that supports asynchronous callbacks and asynchronous invocation with polling. The difficulties we had describing what we were trying to do to my fellow ThoughtWorkers on other projects prompted me to discuss the different forms of asynchrony in a little more detail. [Full Text]

When you build a distributed system you have to choose between latency and reliability. Sticking your head in the sand will not help (and you get sand in your ears...). [Full Text]

In my perennial battle to free distributed system developers' minds from the perils of the call stack mentality I came across another reason why a call stack is not appropriate for distributed applications: the call stack is inherently asymmetric. However, when building distributed applications, that asymmetry really has no place. [Full Text]

It seems like I spend all my time at conferences. I am speaking at the Patterns and Practices Summit and SD West this week. This one is setup by Keith Pleas in close collaboration with the Patterns and Practices group at Microsoft. So yes, I am still promiscuous when it comes to platforms. But it makes me feel better that Ted Neward seems to beat me in that category, though. [Full Text]

A number of people have already blogged, er ranted, in detail about the TSSS but that can't stop me from occupying my fair share of the cyberspace with my impressions. [Full Text]

OK, so I am officially the slowest blogger on the 'Net... last week I attended two conferences, the BTW in Karlsruhe, Germany and TheServerSide Symposium in Las Vegas. Too bad they are over 6000 miles apart :-( [Full Text]

Today's rambling takes a look at the application side of application integration. We recently looked at a packaged application under development and looked at criteria and options for how this application can live in an evolutionary and connected environment. [Full Text]

Happy New Year everybody! Over the holidays I tried to sort out some of my thoughts on Web services, SOA, architectural styles, coupling and all the other good stuff. I started to think about service-oriented architectures as an architectural style and how it compares to prior styles, such as distributed component architectures. Maybe it was the New Year's mood but I started to think that the evolution of architectural styles is a little bit like drunk driving... [Full Text]

One of my favorite pastimes is to argue with people whether a solution is stateless, whether it should be stateless and what it means to be stateless in the first place. Ideally, the debate would involve alcoholic beverages and the other person would pick up the check. After "loosely coupled", "stateless" must be a close runner-up as the ultimate nirvana in buzzword-compliant architectures. It is also equally hotly debated. Today, I 'd like to share my view on state and lessness. If you disagree you are welcome to argue with me, but you are buying! :-) [Full Text]

Loosely coupled architectures are often portrayed as the holy grail of architecture. But all too often these architectures turn into what Martin Fowler coined the "Architect's dream but the developer's nightmare". This time I want to share some of the challenges we have found working with loosely coupled architectures and how we addressed them. [Full Text]

People often criticize asynchronous messaging solutions as too complicated and cumbersome. Or, they believe distributed solutions cannot be successful unless they include a distributed transaction model. There is little doubt that asynchronous solutions require us to think in new ways as we have to deal with concurrency, out-of-sequence issues, correlation and other. However, the real world is full of examples of asynchronous processes that deal successfully with exactly the same issues. We don't have to go further than the local coffee shop... [Full Text]

I just attended the ACM Middleware conference in Toronto (I thought a 1/2 day tutorial in integration patterns). This conference is more of an academic events when compared to some of the purely commercial conferences like JavaOne. It was interesting to see what academia are working on these days in the areas of middleware and SOA. [Full Text]

Last year's OOPSLA tutorial on Enterprise Integration Patterns was quite well received. The most frequent constructive criticism was that the whole tutorial was PowerPoint as opposed to running code. I took that feedback to heart and set out to develop a toolkit that demonstrates the routing and transformation patterns in our book. After a lot of deja-vu in Windows GDI programming I created a toolkit that contains each pattern as a small executable. The toolkit is a lot of fun and makes for great demos, but it also triggered a bigger question. Are patterns meant to be codified as components? [Full Text]

I just attended the Indigo Strategic Design Review in Redmond. This means we got to interact with the product team and play with some pre-beta bits. Naturally, a lot of details are under NDA and are likely to evolve before the beta release. So here some rather general impressions -- I heard Internet connectivity in jail is really bad :-). [Full Text]

Our most recent project was to replace a batch-oriented stored procedure with a more flexible, maintainable and scaleable Java-based architecture. We chose an event-driven architectural style that processes events as they occur. For the initial roll-out we did not even have to distribute the solution so it all runs in single JVM (if you ignore clustering for the moment). Read on to learn more about the implementation and our experiences with intra-JVM EDA. [Full Text]

The notion of Dependency Injection or Inversion of Control has generated quite a bit of interest lately. To a large extend, the move towards this architectural style is driven by developer's dissatisfaction with strong dependencies of individual components on their run-time container (for example, J2EE). These dependencies make it difficult or impossible to test components outside of their container, throwing a major monkey wrench into test-driven development of these types of applications. Dependency Injection avoids these dependencies and therefore improves testability. On a recent project we developed an event-driven architecture (intra-JVM, not distributed) and found that we could realize many of the same benefits. [Full Text]

It is nearly impossible to keep track of all the Web Services (WS-*) specifications or proposed "standards". The matter is only worsened by the many competing proposals. Should you be using WS-Eventing or WS-Notification? How about WS-Reliability vs. WS-ReliableMessaging? Even if you choose the "right" specification, it still is likely to evolve over time. So are these standards useful at all for Web Services development today? I contend that they are, albeit in a somewhat unconventional way.... [Full Text]

Many of you have seen my rants on doodleware and top-down modeling. At the same time, anyone who has seen my book must believe me when I say that I am a very visual person. Is Gregor going schizophrenic (or becoming a hypocrite)? Not at all! I am a big fan of visual representations that are harvested from an actual running system and present the user with an accurate, big picture view of a working system. I felt it was time to put some money (time) where my mouth is and try to build such a solution and see what actually happens... [Full Text]

For a change I spoke at a conference without traveling halfway around the world. At over 15,000 attendees, JavaOne is one of the largest developer conferences. Unfortunately, the signal-to-noise ratio is not always all that great, but it is still a good place to meet old and new friends. This year's conference was littered with talk and demos on SOA, ESB, Web Services, orchestration etc. Here my impressions... [Full Text]

When using asynchronous messaging, we can no longer rely on the linear, in-sequence execution of events. Therefore, the notion of correlating multiple messages is fundamental to designing robust messaging solutions. While correlation seems to be a simple concept at first glance, there are quite a few interesting nuances. [Full Text]

A number of integration books classify integration into styles such as database integration, functional integration and so on. However, on closer examination it turns out that there is a fair amount of confusion about what these styles really mean. Let me give my view. [Full Text]

I had never thought about having guest appearances on my ramblings, but this e-mail response from my friend Hyon made me laugh hard enough that I think it would be a waste not to share it with the community. [Full Text]

Design decisions can be influenced by many factors. In order to make matters more predictable, many architects look for clear-cut borderlines. How complex does my screen navigation have to be in order to justify a Front Controller as opposed to a Page Controller? How complex does my integration problem have to be to justify use of an EAI suite instead of hand wiring the solution? Invariably, the answer is "it depends". Let's have a closer look at why that is so. [Full Text]

Encapsulation and abstraction are the holy grail of today's software development. One of the great successes of hiding the implementation details under a common, abstracted interface are TCP/IP stacks. But as so often, overwhelming success can also have a flip side. [Full Text]

When we assess the quality of a software engineer we don't look as much how long he has worked with a specific language but rather whether he or she has a good grasp of the underlying models and techniques, such as OO design, systems architecture. Still most EAI job offers sound like a software catalog: "x years TIBCO IntegrationManager", "y years Vitria Businessware" etc. etc. Some thoughts on what we should be really looking for... [Full Text]

The Hub-and-Spoke concept manifests itself in many ways in integration solution. Like any popular concept, it can sometimes cause as much confusion as it provides help. [Full Text]

Many integration tools offer graphical development tools. Do they really make integration easier? [Full Text]

Integration appliances aim to make integration cheaper faster and more reliable. Is this technology ready for prime time? [Full Text]

© 2005  • All rights reserved.