Enterprise Integration Patterns
Gregor’s Ramblings on Messaging
My latest thoughts on integration architecture:
Serverless Loan Broker @ GCP
Serverless Loan Broker @ AWS, Part 5: Integration Patterns with CDK
Serverless Loan Broker @ AWS, Part 4: Automation
A Decade of Enterprise Integration Patterns
(IEEE Software)
20 Years of Patterns' Impact
(IEEE Software)
Conversations Between Loosely Coupled Services
(Video on InfoQ)
Developing in a Service-oriented World
(Video on InfoQ)
SOA Patterns - New Insights or Recycled Knowledge?
Let's Have a Conversation
(IEEE Internet Computing)
Programming Without a Call Stack - Event-driven Architectures
(ObjektSpektrum, 2006)
Your Coffee Shop Does Not Use Two-Phase Commit
(IEEE Software)
Developing in a Service-Oriented World
(ThoughtWorks Whitepaper)
An Asynchronous World
(Software Development)
Nearfield Communication (NFC) in Japan
(OOP 2012)
Embedded OSS
(OOP 2012)
Programming the Cloud
(QCOn Tokyo 2010)
Distributed Programming the Google Way
(Devoxx 2009)
Developing in a Service-Oriented World
(SOACon 2007)
Programming without a Call Stack: Event-driven Architectures
(SOACon 2007)
Software Visualization and Model Extraction
Where did all my beatiful code go?
(SpringOne, 2006)
Conversations Between Loosely Coupled Systems
(SD West, 2006)
Enterprise Integration Patterns
(JAOO, 2003)
Gregor HohpeHi, I am Gregor Hohpe, co-author of the book Enterprise Integration Patterns. I like to work on and write about asynchronous messaging systems, service-oriented architectures, and all sorts of enterprise computing and architecture topics. I am also an Enterprise Strategist at AWS.
ALL RAMBLINGS  Architecture (12)  Cloud (10)  Conversations (8)  Design (26)  Events (27)  Gregor (4)  Integration (19)  Messaging (12)  Modeling (5)  Patterns (8)  Visualization (3)  WebServices (5)  Writing (12) 

I call my collection of blog entries "ramblings" because they are based on my personal opinions and observations as opposed to official "articles". The topics cover a variety of topics, ranging from integration, messaging, and conversation patterns to enterprise architects and architecture, events I spoke at as well as patterns and writing.

My blog posts related to IT strategy, enterprise architecture, digital transformation, and cloud have moved to a new home: ArchitectElevator.com.

These are my Ramblings on Messaging. See all Ramblings.    Subscribe  Subscribe to my ramblings via RSS.

Serverless Integration Patterns on Google Cloud Functions   April 20, 2017

After examining which patterns are embedded in Google Cloud Pub/Sub in an earlier post, I implemented a few common patterns on top of Google Cloud Functions, Google's serverless implementation. It's amazing how easy it has become to get messaging patterns running in the cloud with only a minimum of wrapper code. Read more »

Google Cloud Pub/Sub    APR 8, 2015

Google released the beta version of their publish-subscribe API just a few weeks ago. I show how to build a very simple demo app using the Java API and map the functionality to integration patterns to illustrate the design choices the team made. Read more »

Sync or Swim   FEB 15, 2015

We were tempted multiple times to extend the EIP icon language, but always felt that simplicity should win over precision. However, seeing the visual vocabulary that my former Google colleague Ivan Gevirtz created, I am convinced that combining the two is useful. Read more »

What Does It Mean to Use Messaging?   FEB 17, 2010

I was recently asked to help a team decide whether they should use messaging. Of course, I have not forgotten what I learned during many years in consulting: the consultant always answers "it depends." A good consultant can tell you what the answer depends on. And a truly great consultant can convince you that you are asking the wrong question in the first place. Read more »

Users Like Events   July 12, 2007

Two weeks ago I presented a keynote at the DEBS (Distributed Event-based Systems) conference. The emphasis of the conference was on academic work in the field but event-based systems are rapidly gaining traction in commercial applications as CEP (Complex Event Processing) is becoming a household name like SOA (equally difficult to pin down). All this talk about events reminded me that applications on the Web are becoming increasingly event driven. Read more »

What is in a Name?   Mar 5, 2006

Computer science is known as the field where every problem can be solved by just one more level of indirection. Well, a message channel berween two components is such a level of indirection. As it turns out naming this additional element can have a more profound influence on the system design than might appear at first. Read more »

Will the Real Asynchrony Please Stand Up?   May 15, 2005

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. Read more »

Are You Driving a DeLorean or a Toyota?   March 30, 2005

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...). Read more »

Can You Say "Synchronous Asymmetry or Asynchronous Symmetry"?   March 25, 2005

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. Read more »

Look Ma -- No Middleware! Using Event-Driven Architectures inside a JVM.   October 1, 2004

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. Read more »

Dependency Injection in Messaging Architectures   September 3, 2004

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. Read more »

Correlation and Conversations   May 21, 2004

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. Read more »