Favourite posts

23 March 2019

Why SAFe can be agile kryptonite

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.

24 February 2019

Should teams choose their own languages and tools?

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

6 January 2019

Finding service boundaries: more than just the bounded context

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.

27 November 2018

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

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.

12 October 2018

Messaging anti-patterns in event-driven architecture

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

12 August 2018

Building Twelve Factor Apps with .Net Core

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.

16 February 2018

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

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.

18 November 2017

Technical debt is an overused and lazy metaphor

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.

28 January 2017

Why agile software architects should write code

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.

7 January 2017

Event stores and event sourcing: some practical disadvantages and problems

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.

29 July 2016

Designing an event store for scalable event sourcing

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

9 March 2015

How big is a microservice?

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

22 November 2014

The RESTafarian flame wars – common disagreements over REST API design

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.

9 July 2014

The problem with tiered or layered architecture

An architecture based on tiers or layers is too inflexible to deal with the more flexible demands of modern systems, particularly when you working with high-volume systems that require distributed processing.

21 April 2014

Hackable URIs may look nice, but they don’t have much to do with REST and HATEOAS

Structured and Hackable URIs are a staple part of SEO-friendly websites. Although developers generically expect to see them in HTTP-based APIs, they should be irrelevant to consumers of a fully RESTful API that leverages HATEOAS.