Favourite posts

Establishing a new architecture practice in agile organisations

2 September 2023

How should you go about building an architecture practice in organisations where people are allowed to say “no”? Ultimately, this becomes an exercise in persuasion, pragmatism, and patience.

The shared code fallacy: Why internal libraries can be an anti-pattern

15 July 2023

Most internal shared libraries are based on the fallacy that code sharing always makes development more efficient.

Why the Scaled Agile Framework (SAFe) can be agile kryptonite

23 March 2019

The problem with SAFe is that you can implement it without writing a single unit test or automating a single build…scaled agile may be an oxymoron.

Should teams choose their own languages and tools?

24 February 2019

Standardisation does have a place, but it should be reserved for infrastructure and collaboration rather than languages and tools.

Finding service boundaries: more than just the bounded context

6 January 2019

When you are identifying service boundaries, it’s not enough to consider the domain model alone. There are other, more pragmatic concerns to bear in mind.

Writing ArchUnit style tests for .Net and C# to enforce architecture rules

27 November 2018

ArchUnit is a java library that provides a fluent API for creating self-testing architectures via unit tests. A similar library can be written for .Net Standard that acts on compiled assemblies rather than raw code.

Messaging anti-patterns in event-driven architecture

12 October 2018

Event-driven integration can improve the scalability, resilience and scalability of distributed applications… but this does depend on the design of your event messages…

Building Twelve Factor Apps with .Net Core

12 August 2018

Twelve factor apps provide a methodology for building apps that are optimised for modern cloud environments. It’s only been achievable in the Microsoft world since the advent of .Net Core.

Relax. There's no conflict between architecture and agile.

16 February 2018

Agile teams still need to make architecture decisions, but in supporting them architects should seek “just enough” architecture over “big design up front” and practical solutions over large-scale abstract thinking.

Technical debt is an overused and lazy metaphor

18 November 2017

Technical debt may be a useful metaphor for describing how bad code design undermines productivity to non-technical audiences, but it does not help in understanding the longer term problems that affect code bases.

Why agile software architects should write code

28 January 2017

No architect will ever admit to being out of touch with software development. However, unless you are writing code then it’s difficult to avoid becoming an ivory tower or PowerPoint architect that can only discuss systems in the abstract.

Event stores and event sourcing: some practical disadvantages and problems

7 January 2017

Event stores and event sourcing are a powerful idea, but they can be vulnerable to a number of technical and operational challenges when faced with real world complexity.

Designing an event store for scalable event sourcing

29 July 2016

Event sourcing can scale very nicely, though this does depend on a number of key design decisions for the underlying event store.

How big is a microservice?

9 March 2015

We know that micro services are small and focused by design – just how small is this in practice?

The REST flame wars – common disagreements over REST API design

22 November 2014

Debates on the finer points of REST can bring out the worst in people as they seek to define what is and is not “RESTful”. In most cases the debate is unlikely to make the difference between success and failure for an API.