Moving a Monolithic Application towards a Microservices Architecture

by Jan Stenberg on  Dec 31, 2016

Migrating an existing system towards microservices is very different from building a new micoservices-based system, Joris Kuipers, architect at Trfork Amsterdam, claims in a presentation describing an ongoing process of refactoring a large monolithic application, based on CQRS using Axon framework, towards a microservices architecture.

Start with Events and DDD When Building Microservices

by Jan Stenberg on  Dec 28, 2016 2

Domain-Driven Design (DDD) is a great technique bringing designs closer to the domains we are working in, but too often we make early decisions with a focus on structure, which is not the intention of DDD. Instead we should start with the events in a domain, Russ Miles claims when describing the advantages of going “events-first” when building microservices.

Vaughn Vernon on Microservices and Domain-Driven Design

by Jan Stenberg on  Jul 31, 2016

Although a monolith can be modeled in a respectable way, often they are turned into a big ball of mud. This is caused by multiple domain models becoming entangled within the monolith, and in Vaughn Vernon's experience this can happen within a few weeks or months, he claimed in a presentation at the Scala Days conference earlier this year.

Eric Evans: Is Domain-Driven Design Beneficial for Software Development?

by Jan Stenberg on  Jun 16, 2016 1

The last couple of years the interest in Domain-Driven Design (DDD) has increased, Eric Evans noted in his keynote at the recent DDD eXchange conference in London. He thinks that we are in a time when developers care more about design, partially because we are working more with distributed systems where models have a higher value.

Comparison of Event Sourcing with Stream Processing

by Jan Stenberg on  May 25, 2016

Event sourcing and CQRS are two patterns that has emerged in the Domain-Driven Design (DDD) community. Stream processing builds on similar ideas but has emerged in a different community, Martin Kleppmann noted in his presentation at the Domain-Driven Design Europe conference earlier this year comparing event sourcing with stream processing.

A Whole System Based on Event Sourcing is an Anti-Pattern

by Jan Stenberg on  Apr 26, 2016 4

Command Query Responsibility Segregation (CQRS) was never meant to be the end goal of what we are trying to achieve, it is a stepping stone towards the ideas of Event sourcing, Greg Young stated in his presentation at the Domain-Driven Design Europe conference earlier this year. He noted though that just applying CQRS is still a valuable pattern.

Lagom, a New Microservices Framework

by Jan Stenberg on  Mar 08, 2016 1

Lightbend, the company behind Akka, has released an open source microservices framework, Lagom built on their Reactive Platform, in particular the Play Framework and the Akka family of products together with ConductR for deployment. By default, Lagom is message-driven and asynchronous, and using distributed CQRS persistence patterns with event sourcing as the primary implementation.

CQRS Example Using Axon Framework

by Jan Stenberg on  Jan 31, 2016

Command Query Responsibility Segregation (CQRS) separates the part that changes the state from the part that queries the state in an application. Axon is a Java framework implementing the building blocks of CQRS to help in when building CQRS applications, Dadepo Aderemi, writes in a series of blog post explaining CQRS by building a small demo application based on the Axon Framework.

CQRS, Read Models and Persistence

by Jan Stenberg on  Oct 20, 2015 4

Storing events in a relational database and creating the event identity as a globally unique and sequentially increasing number is an important and maybe uncommon decision when working with an event-sourced Command Query Responsibility Segregation (CQRS) system Konrad Garus writes in three blog posts describing his experiences from a recent project building a system of relatively low scale.

Dino Esposito on CQRS, Messages and Events

by Jan Stenberg on  Aug 31, 2015 1

Command Query Responsibility Segregation (CQRS) is the starting point of a change that will have a profound impact on system architecture, Dino Esposito claims in three articles in MSDN Magazine. It’s the first step in an evolution transitioning software architects from the idea of “models-to-persist” to the idea of “events-to-log” and about event-based data instead of data snapshots.

DDD, Events and Microservices

by Jan Stenberg on  Jun 29, 2015 1

To make microservices awesome Domain-Driven Design (DDD) is needed, the same mistakes made 5-10 years ago and solved by DDD are made again in the context of microservices, David Dawson claimed in his presentation at this year’s DDD Exchange conference in London.

Introducing CQRS and Event Sourcing with a Demo Application

by Jan Stenberg on  Jun 08, 2015

Improving on his understanding of the architecture and patterns involved in Command Query Responsibility Segregation (CQRS), Sacha Barber has created a complete CQRS demo application including event sourcing and an article with a cross examination of the inner workings.

Advantages of CQRS

by Jan Stenberg on  May 06, 2015

Today’s applications are commonly unnecessarily complex or slow because of not using Command Query Responsibility Segregation (CQRS), Gabriel Schenker claims while stating he believes CQRS to be one of the most useful architectural patterns when used in the context of complex Line of Business (LOB) applications.

The Future of Microservices

by Jan Stenberg on  Dec 01, 2014 2

Microservices are not new ideas and we will over the course of 3-5 years end up rebuilding WS-* the same way Web Services did rebuild all from CORBA unless we learn from our mistakes and improve to prevent them from being made again, Greg Young stated in a presentation at the Microservices Conference in London.

CQRS as a Style of Thinking

by Jan Stenberg on  Nov 20, 2014 3

A common context for Command-Query Responsibility Segregation (CQRS) is a collaborative domain with multiple users working on the same set of data, it is less suitable in domains with only a single user working on a piece of data, Udi Dahan explained when discussing CQRS in an interview.