Graham Brooks Photo

Hello! This is the website for Graham Brooks: architect, developer and sometime blogger.

Disclaimer: This is a personal weblog. The opinions expressed here represent my own and not those of my employer (LexisNexis).My thoughts and opinions change over time as I learn. This weblog is intended to provide a semi-permanent record of these thoughts and is for informational purposes only.

Event Driven Architecture

Notification Event Pattern

There are many event patterns or styles in event driven architectures. One of the significant advantages of the notification event pattern is can be introduced into existing systems quite simply to provide a more loosely coupled design.

Event-Carried State Transfer Pattern

In contrast to the notification pattern the Event-carried state transfer discourages calls to the publishing service by containing all the required data in the event payload. This decoupling leads to a very clean architecture but not without significant costs.

Event Sourcing

Event Sourcing is a fascinating design pattern with some real advantages over maintaining single states within systems. But there is a darker side that requires careful consideration.


Consistency - the absence of contradiction is a challenge in any application. Event driven asynchronous distributed systems turn up the dial of complexity. What does consistency mean?

Measuring Consistency

Consistency Measurement - understanding key operational metrics of a distributed event driven system

Integrating Event Driven Systems

It is very rare for an application or system to exist in isolation. Systems need to be integrated to deliver business value.

Blog posts

Technical Health over Technical Debt

Prefer technical health over technical debt as a metaphor for developer practice changes for better code.

Of Languages And Containers

Run production on a workstation or embrace a new way of working...

Orchestration And Choreography

Orchestration and Choreography are often confused. This is how I think of them.

Quantifying Commit Risk

All change carries an element of risk but not all changes are equal.

The path to a million (loc)

How do projects get to a million lines of code.

Builder anti-patterns

The Builder pattern has become very popular over the last few years but there is a growning tendency to use it everywhere. Here are some of the problems and alternatives that you might find a better fit.

Commit History Metrics

What can your commit history tell you about the health of your project?

Defending the Domain Model

Keeping a domain model is hard. Implementing a anti-corruption layer with the right separation of concerns can help.

Testing Logging

Logging - one of the most crucial aspects of any system. But how well is your logging tested?

Templated styles

A clean/DRY way to style content based on model data

Emacs es-mode - REPL experiences for ElasticSearch development

I don’t usually write reviews but I was so deleted by es-mode for emacs that I felt compelled to share. If you have worked with REST APIs and ElasticSearch in particular you probably have had similar experiences of using something to develop queries. Coding in one of the client libraries does not provide the interactive experience you need to develop quickly and it often becomes a frustrating exercise. es-mode takes away a lot of that pain.

Dependency Inversion - Applying the principle

Another look at a classic OO pattern

The Value in value types

Value types are an oven often overlooked OO and DDD technique. Here is why I think they are an undervalued technique

Build Analytics - better development understanding

Working with small teams is a lot of fun and I find it fairly easy to keep track of what is happening with version control and build systems. Errors and failures don’t come up that often and when they do they can quite often get solved there and then. On larger projects or working in a large organisation it’s impossible to keep track of everything. There are too many moving parts and changes. Incidents are more frequent and their impact much larger. A broken build or build system can affect 10s or 100s of people. For these larger development projects I find I have to collect and chart data, looking for tends and anomalies and then delve deeper into the data if and systems if there are problems.

Service IoC containers

How can we get the benefits of IoC containers at a higher level - the services that we deploy into environments? Typical service tiers are implemented with a fronting load balancer that allocates servers to satisfy requests. Applications or services that need these services are give domain or IP information of the load balancers and the load balancers are given details of the servers running instances of the services that they need. Essentially each system with dependencies news an instance of its dependencies. Inverting this dependency requires a container but it leads to some interesting advantages.

comments powered by Disqus