Enterprise Integration Patterns
Gregor’s Ramblings on Integration
HOME PATTERNS RAMBLINGS ARTICLES TALKS DOWNLOAD BOOKS CONTACT
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?
(Whitepaper)
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
(TheServerSide)
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.
TOPICS
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) 
POPULAR RAMBLINGS

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 Integration. See all Ramblings.    Subscribe  Subscribe to my ramblings via RSS.


Serverless Loan Broker @ GCP   May 20, 2022

Do serverless solutions lock you in? Let's find out by porting / rebuilding the Serverless Loan Broker on top of Google's Cloud Platform (GCP).  Read more »

Serverless Loan Broker @ AWS, Part 5: Integration Patterns with CDK   Jan 25, 2022

Infrastructure as Code (IaC) brings repeatability into the provisioning and deployment of cloud applications. However, the vocabulary used by most automation tools describes cloud platform resources as compared to the application's intent. As serverless applications take us further away from the infrastructure, we should also find better abstractions to express our automation. Perhaps, Enterprise Integration Patterns give us a head start? Read more »

Serverless Loan Broker @ AWS, Part 4: Automation   November 30, 2021

Infrastructure as Code (IaC) has a whole new meaning for serverless applications. Rather than provision resources (the serverless frameworks do that for us), automation determines the system composition and configuration. As expected, quite a few options are available from simple command line to programming frameworks. Time to have a look. Read more »

Serverless Loan Broker @AWS, Part 3: Publish-Subscribe with SNS   July 20, 2021

Part 3 of the mini-series on implementing the EIP Loan Broker as a serverless solution with AWS Step Functions uses a Publish-Subscribe Channel and a stand-alone Aggregator to request and process loan quotes. Read more »

Loan Broker @AWS, Part 2: Recipient List   July 20, 2021

In part 2 of this blog series I implement the Loan Broker Example using a Recipient List pattern, implemented in DynamoDB, Step Functions, and Lambda. Read more »

Loan Broker Implementation with AWS Step Functions   July 20, 2021

A lot has happened since we implemented the Loan Broker Example in EIP: we have the cloud, serverless computing, machine learning, service meshes and all sorts of other bells and whistles. Nevertheless, the integration patterns have passed the test of time as we shall see by implementing the original loan broker example with AWS Lambda and AWS Step Functions. Read more »

Same Old Architecture - Best of Ramblings   May 15, 2015

Architects can often be found commenting or complaining that many things in IT are the same old stuff in new packaging, created by marketing departments who were in need of a new buzzword. For example, aren't microservices really just SOA done right while SOA itself stands for "Same Old Architecture"? And the whole reactive movement seems to have re-discovered callbacks. Maybe there is some truth in this as at the recent SATURN conferences I found myself saying more often than I had expected "I blogged about this". So let's see which of my past ramblings are still relevant these days. Read more »

Free Gift with Subscription (Pattern)   APR 26, 2015

Discussing the Google cloud Pub/Sub system in the last rambling reminded me that the Publish-subscribe Channel pattern makes for a good example of the subtle but important difference between Messaging Patterns and Conversation Patterns. This comparison is timely as I picked up documenting Conversation Patterns again. 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 »

RESTful Conversations   MAR 15, 2015

As indicated a good while ago I spent some time thinking about patterns that instead of following a message through multiple systems, looks at the message exchange over time between a (mostly) fixed set of systems. I call these message exchanges "conversations". Sadly my writing efforts on Conversation Patterns fell very much asleep around 2008, partly due to my fear that with the rise of REST, stateful conversations between systems would step into the background as most integration problems are now solved with a simple POST or GET. A presentation and conversation at Frank Leymann's IaaS PhD Seminar enlightened me that this is not at all true: systems following the REST architectural style very much engage in conversations. Read more »

Mashups Tools Market   August 18, 2007

As I reported from Mashup Camp, an increasing number of vendors play in the mashup space. I am obviously not the only one who noticed. Dion Hincliffe recently discussed 17 different mashup tools. Maybe I have an MBA hidden inside me (or 10 years of consulting left some marks), but I was temped to conduct my own market segmentation. Gartner would be proud of me. Just be aware that my analysis is not meant to be comprehensive and all statements carry a 0.5 probability of being right :-) Read more »

Mashups == EAI 2.0?   July 27, 2007

Mashups pull data from different sources, aggregate and transform the data to be used in different contexts. EAI solutions pull data from different sources, aggregate and transform the data to be used in different contexts. Huh? Read more »

I Want My Events   July 15, 2007

Last time I claimed that users like events. This time I want to show how I fulfilled my personal desire for events off the Web. I built two solutions to alert me to new book reviews on Amazon, one using a Python script, the other using Yahoo! Pipes. Read more »

Integration Patterns in the Wild   July 20, 2006

Hanging out with my intellectual drinking buddies reminded me that our integration patterns have been embraced by a fair number of commercial as well as open source projects. In my eyes this is really the best indicator of success for a pattern language. Latin, a dead language used mostly by doctors to sound more knowledgeable, is not a good model for a pattern language. You want a language that is alive and actually used by people. Talking to a few folks who did embrace our language motivated me to take a quick survey of the places where our patterns pop up. Read more »

Integration Styles   May 5, 2004

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

What Makes a Good Integration Developer?   November 25, 2003

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

Hub and Spoke [or] Zen and the Art of Message Broker Maintenance   November 12, 2003

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

Doodleware   November 1, 2003

Many integration tools offer graphical development tools. Do they really make integration easier? Read more »

Integration Appliances   October 1, 2003

Integration appliances aim to make integration cheaper faster and more reliable. Is this technology ready for prime time? Read more »