My name is Martin Fowler: I’m an author, speaker, and loud-mouth on the design of enterprise software. This site is dedicated to improving the profession of software development, with a focus on skills and techniques that will last a developer for most of their career. I’m the editor of the site and the most prolific writer. It was originally just my personal site, but over the last few years many colleagues have written excellent material that I’ve been happy to host here. I work for ThoughtWorks, a really rather good software delivery and consulting company. To find your way around this site, go to the intro guide.

News and Updates

My atom feed (RSS) announces any updates to this site, as well as various news about my activities and other things I think you may be interested in. I also make regular announcements via my twitter feed, which I copy to my facebook page.

Revised Agile Fluency Model

Tue 06 Mar 2018 09:21 EST

Several years ago, Diana Larsen and James Shore came up with their Agile Fluency model. This categorizes agile usage into four zones, where later zones produce more benefit, but also require greater investment. I've found this model a useful way to understand how different groups of people use agile ideas in varying ways. James and Diana have revised their article, renaming the zones, and adding more material on the benefits from each zone, the proficiencies they expect to see, and the investments required to get there.


What I Talk About When I Talk About Platforms

Mon 05 Mar 2018 17:31 EST

Evan Bottcher has been involved with several of our clients with microservices and platform building over the last few years. A couple of years ago, at one of our radar writing meetings, he gave a great presentation on what makes an effective way to think about platforms. We urged him to turn it into an article, but for a long time he was too busy to write it down. He talks about common un-platform problems, the danger of backlog coupling, and the balance between autonomy and efficient use of infrastructure.


photostream 113

Sat 03 Mar 2018 10:54 EST

Queenstown, New Zealand (2016)

Completing the Pyramid

Thu 01 Mar 2018 10:22 EST

Ham completes his article on showing how to use test pyramid in practice by looking at acceptance tests and exploratory testing. He also finishes with a few words on pipelines and the need to avoid duplication in testing between the layers of the pyramid.


UI and End-to-End tests

Mon 26 Feb 2018 09:22 EST

The whole point of the test pyramid is to remind us that broad scope tests should be rare, since they are usually expensive and slow. Rareness isn't the same as absence, so now Ham takes a look at role of UI tests and end-to-end testing in general.


Contract Tests Ensure Faithful Doubles

Thu 22 Feb 2018 10:50 EST

Our approach to integration testing avoids hitting real services in order to make testing easier and faster. But then a question rears up - how do we know the test doubles for our integration tests are true doubles of the collaborating service? Ham answers this question by discussing Contract Tests and showing the role they play in his example application.


Integration Tests in the Pyramid

Tue 20 Feb 2018 09:12 EST

People find the notion of integration tests confusing, since they are ill-defined even by the standards of testing terminology. So they are a great topic for Ham's example application and explanation.


Unit Tests in the Pyramid

Thu 15 Feb 2018 10:32 EST

Ham now starts looking at the pyramid in earnest, beginning with the foundation of the pyramid - unit tests.


The Practical Test Pyramid

Wed 14 Feb 2018 10:27 EST

The Test Pyramid has become a well-used part of software development. But many people still struggle with how to use it in practice. My colleague Ham Vocke has used it in teaching several teams about effective testing and has gathered together his experiences into an article that shows examples of different kinds of tests applied to a simple sample application using Java and Spring Boot.

In this first installment he introduces the notion of the pyramid and the structure of the sample application.



Refactoring has become a core skill for software developers, it is the foundation behind evolutionary architecture and modern agile software development. I wrote the original book on refactoring in 2000, and it continues to be an interest of mine.

I’ve recently posted several essays on refactoring here:

  • JavaScript offers many targets for refactoring, so Refactoring a JavaScript Video Store takes the original video store example from the book and explores it in JavaScript. It outlines four directions you can take the refactoring: a nested function with a dispatcher, using classes, and transformation using an intermediate data structure.
  • While most of our logic is written directly in an imperative language, it is sometimes very useful to represent such logic in a data structure. Refactoring to an Adaptive Model describes this refactoring, which produces an adaptive model interpreted by generic code.
  • As a program grows in size it’s important to split it into modules, so that you don’t need to understand all of it to make a small modification. In Refactoring Module Dependencies I modularize a small example using layering and introducing Service Locator and Dependency Injection. I illustrate these using both Java and JavaScript so you can see how this modularization looks in different languages.
  • When I write code that deals with external services, I find it valuable to separate that access code into separate objects. Refactoring code that accesses external services shows how I would refactor some congealed code into a common pattern for this.
  • Modern languages give us the opportunity go beyond the loop as a way of handling repetitive behavior. Refactoring with Loops and Collection Pipelines provides a series of small examples of refactoring loops into my preferred approach.
  • Refactoring Code to Load a Document looks at how manipulating large JSON documents can often be made easier by encapsulating a combination of loading strategies.

TW logo

I discovered ThoughtWorks in 2000: then a small American company whose philosphy of software development was remarkably similar to my own. Now we’ve grown to around 4000 people world-wide, but kept the values that make us special. My colleagues have built critical systems for many clients in that time, and I’ve learned many lessons from them. While doing this, we found we often didn’t have the tools we needed, so we started to build them. This led to open-source tools such as CruiseControl, Selenium, Frank, and Moco as well as commercial products.

I have many opportunities, but I’ve stayed at ThoughtWorks because of the quality of my colleagues, who include both well-known speakers and those who may not be famous names but do an excellent job of software delivery (and feed me the information to write about). We are inspired by working with each other and our unusual three-pillar philosophy that raises professional excellence and social justice to the same level as financial performance.

And we are always looking for more great people to join our curious company. Maybe I’ll see you in one of our offices some day.

Continuous Integration and Delivery

For a long time I’ve been a champion of Continuous Integration which reduces integration risk by integrating early and often, an application of the principle of Frequency Reduces Difficulty. We’ve found CI to be a core technique at ThoughtWorks and use it almost all the time. At the heart of this is a style of development that minimizes long feature branches with techniques like Branch By Abstraction and Feature Toggles.

While this is useful, there was still risk present from software that works in the development environment to getting it to work in production. As a result we developed Deployment Pipelines to reduce this risk, moving closer to our aim of Continuous Delivery: building software in such a way that we confidently deploy the latest builds into production whenever there is a business need. We find this improves feedback, reduces risk, and increases the visibility of project progress.

For more information: take a look at my guide page on Continuous Delivery.

photo: Manuel Gomez Dardenne

Upcoming Talks
24Kafka Summit: London
18Agile Australia: Melbourne


API design · academia · agile · agile adoption · analysis patterns · application architecture · application integration · bad things · big data · board games · build scripting · certification · clean code · collaboration · computer history · conference panels · conferences · continuous delivery · database · design · dictionary · distributed computing magazine · diversions · diversity · documentation · domain driven design · domain specific language · domestic · encapsulation · enterprise architecture · estimation · event architectures · evolutionary design · expositional architectures · extreme programming · gadgets · ieeeSoftware · infodecks · internet culture · interviews · language feature · language workbench · lean · legacy rehab · legal · metrics · microservices · microsoft · mobile · model-view-controller · noSQL · object collaboration design · parser generators · photography · podcast · popular · presentations · privacy · process theory · productivity · programming platforms · project planning · projects · recruiting · refactoring · refactoring boundary · requirements analysis · retrospective · ruby · scrum · security · software craftsmanship · talk videos · team environment · team organization · technical debt · technical leadership · test categories · testing · thoughtworks · tools · travel · uml · version control · web development · web services · website · writing

2018 · 2017 · 2016 · 2015 · 2014 · 2013 · 2012 · 2011 · 2010 · 2009 · 2008 · 2007 · 2006 · 2005 · 2004 · 2003 · 2002 · 2001 · 2000 · 1999 · 1998 · 1997 · 1996

All Content