Index of All Content

This site contains some 857 items of content. Here is a list of all of them, sorted by their title. The tags provide a better way of exploring the content by their subject or nature.

A Cherry Picker's Guide to Doctor Who

A Guide to Threat Modelling for Developers

A Language Workbench in Action - MPS

A Proof-of-Concept of BigQuery

APIs should not be copyrightable

Abundant Mutation

Academic Rotation

Access Modifier

Accounting Patterns

Activity Oriented

Aggregate Oriented Database

Aggregation And Composition

Agile Australia 2010

Agile Book Club: Refactoring

Agile Brazil Interview

Agile Certification

Agile Handover

Agile Imposition

Agile Manifesto Authors' 10 year anniversary reunion

Agile Manifesto Meeting

Agile Signatory

Agile Versus Lean

Agile at 10



Agilists and Architects: Allies not Adversaries

Aliasing Bug

Alienating Atmosphere

Alignment Map

Alpha Geek

Alt.NET Conf

Amalfi Coast

An Appropriate Use of Metrics

An Open Letter to Pearson about SOPA/PIPA

An example of LLM prompting for programming

An example of preparatory refactoring

Analysis Patterns

Andaman Islands


Anecdotal Evidence

Anemic Domain Model


Anti Pattern

Appeal To Authority

Application Boundary

Application Database

Application Facades

Assertion Free Testing

Asset Capture

Atom Feeds

Avoiding Repetition

Avoiding Video

Ball And Socket

Beck Design Rules

Before Clarity

Belkin Kvm Linux

Beyond Software Architecture

Big Screen

Bimodal IT

Bitemporal History

Blue Green Deployment

Boiled Carrot

Book Code

Born for it

Bounded Context

Branch By Abstraction

Brass Birmingham becomes #1 on BoardGameGeek

Broad Stack Test

Build Language

Building Architect

Building Boba AI

Building Infrastructure Platforms


Business Capability Centric

Business Facing Test

Business Readable DSL

C- Refactory



Call Super

Canadian Workshop on Scaling XP/Agile Methods

Canary Release

Cannot Measure Productivity

Canon 60D

Canon S90


Catalog of Patterns of Distributed Systems

Catastrophic Failover

Certification Competence Correlation

Changes for the 2nd Edition of Refactoring

Changes in UML Versions

Charity Code Jam

Cheaper Talent Hypothesis

Circuit Breaker

Class Instance Variable

Clock Wrapper

Cloud Computing

Cobol Inference

Code As Documentation

Code Examples

Code Ownership

Code Smell

Collection Pipeline

Collections On Class Diagrams

Command Oriented Interface

Command Query Separation

Communal Dashboard

Comparative Values

Compliance in a DevOps Culture

Component Test

Components and the World of Chaos

Composed Regex

Computational Notebook

Configuration Synchronization

Constructor Initialization

Consumer-Driven Contracts: A Service Evolution Pattern

Contextual Validation

Continuous Delivery

Continuous Delivery

Continuous Delivery

Continuous Delivery Guide

Continuous Delivery for Machine Learning

Continuous Design

Continuous Flow

Continuous Integration

Continuous Integration

Continuous Integration Certification

Continuous Integration with Visual C++ and COM

Contract Test

Contradictory Observations

Conversational Stories

Conway's Law

Coping with Covid-19

Coping with Covid-19, part 2

Coup 53

Courtesy Implementation

Craftmanship And The Crevasse

Creating an integrated business and technology strategy

Cross Platform Mobile

Crossing Refactoring's Rubicon

Currency As Value

Customer Affinity

Customer Loyalty Software

D D D_ Aggregate

DIP in the Wild

DSL Catalog


DSL interview with Neal Ford and Jeffery Snover (JAOO 2008)

Dark Launching

Data Access Routines

Data Clump

Data Lake

Data Management Guide

Data Mesh Accelerate Workshop

Data Mesh Principles and Logical Architecture

Data Models

Database And Build Time

Database Styles

Database Thaw


Dealing With Roles

Dealing with Properties

Debian Java

Decentralizing the Practice of Architecture at Xapo Bank

Decorated Command

Decreed Stories

Default Trial Retire

Defining the UML Kernel

Definition Of Refactoring

Demo Front-End

Democratic Political Technology Revolution

Dependency And Association

Dependency Composition

Deployment Pipeline

Derived Information

Design Payoff Line

Design Stamina Hypothesis

Design to Accommodate Change

Designed Inheritance


Dev Ops Culture

Developing Patterns in Enterprise Software

Diff Debugging

Digital SLR

Directing Attitude


Diversity Imbalance

Diversity Mediocrity Illusion

Does My Bus Look Big in This?

Domain Driven Design

Domain Logic and SQL

Domain Specific Language

Domain Specific Languages

Domain-Oriented Observability


Dominion Second Edition

Don't Compare Averages

Don't get locked up into avoiding lock-in

Don't put data science notebooks into production

Don’t start with a monolith

Dot Voting

Dsl Boundary

Dsl Exceptionalism

Dsl Migration

Duck Interface

Duplex Book

Dynamic Type Check

Dynamic Typing

Eager Read Derivation

Early Pain

Editing Publishing Separation

Eliminating Sales Commissions

Embedded Document

Embedment Helper

Enabling Attitude

Encapsulated Collection

Engineering Practices for LLM Application Development

Engineering Room Conversation with Dave Farley

Enterprise Application

Enterprise Architects Join the Team

Enterprise Architecture

Enterprise Integration Patterns

Enterprise Integration Using REST

Enterprise Rails

Enterprise Transforming Projects That Don't Kill the Enterprise

Eradicating Non-Determinism in Tests

Errant Architectures

Erratic Test Failure

Estimated Interest

Etymology Of Refactoring


Evaluating Ruby

Evans Classification

Event Poster

Evolutionary Database Design

Evolutionary S O A

Evolving Publication

Evolving a Mobile Implementation Strategy

Exploratory Testing

Exploring Generative AI

Exploring Mastodon

Expositional Architecture

Expression Builder

Extemporary Speaking

Extreme Presentation

Extreme Programming

Fail Fast

Feature Branch

Feature Devotion

Feature Flag

Feature Toggles (aka Feature Flags)

Fine Detail

First Law

Five Midsummer Nights

Five Pound Bag

Fixed Length String

Fixed Price

Fixed Scope Mirage

Flaccid Scrum

Flag Argument

Flexible Antlr Generation


Fluent Interface

Focusing on Events

Focusing on Events

Foreword to Building Evolutionary Architectures

Forging a New Alliance

Foundation Platform

Frequency Reduces Difficulty

Function As Object

Function Length

Functional Staff Organization

GUI Architectures

Gang Of Four

Garmin Oregon 600 - a brief review

Generating Code for DSLs

Getter Eradicator

Given When Then

Google I/O Talk on Cloud

Goto Amsterdam Keynote

Goto Fail, Heartbleed, and Unit Testing Culture

Groovy or JRuby

H P_ N36 L

Half Size Composition

Harvested Platform

Header Interface

Headless Component: a pattern for composing React UIs

Heathrow Hotel

Heavy Cardboard

Heavy Cardboard Review of Brass Birmingham

Hello Antlr

Hello Cup

Hello Racc

Hello Sablecc

Hexagonal Architecture and Rails

Hidden Precision

Hierarchic Data Model

Historically Discriminated Against

History Is Not Bunk

History Of Iterative Development

Hollywood Principle

Hot Rod

How .NET's Custom Attributes Affect Design

How I use Twitter

How Standard is Standard UML?

How platform teams get stuff done

How to Move Beyond a Monolithic Data Lake to a Distributed Data Mesh

How to break a Monolith into Microservices

How to do effective video calls

How to extract a data-rich service from a monolith

How to manage a program in a product-mode organization

Huffpost live panel on "The Brogrammer Effect"

Humane Interface

Humane Registry

Humble Object

Ideal Time

Illustrative Programming

Immutable Server

Implicit Interface Implementation

Improvement Ravine

In Memory Test Database

Include And Extend

Incremental Migration

InfoQ Interview with Jez and me on Continuous Delivery


Infrastructure As Code

Installing Debian

Integration Database

Integration Test

Intelli Csharp

Intentional Software

Interface Implementation Pair

Internal Dsl Style

Internal Reprogrammability

Interview with

Interview with Kent Beck and Martin Fowler on Extreme Programming

Interview with Sam Newman about Microservices

Interviewed by Jim Highsmith

Introduction to NoSQL

Inversion Of Control

Inversion of Control Containers and the Dependency Injection pattern

Is Agile For All

Is Changing Interfaces Refactoring

Is Declaration Ordering Refactoring

Is Design Dead?

Is Fixing An Unknown Bug Refactoring

Is High Quality Software Worth the Cost?

Is Optimization Refactoring

Is TDD Dead?

Is there such a thing as Object Oriented Analysis?

It's Different with Data

It's Not Just Standing Up: Patterns for Daily Standup Meetings

JAOO 2005


JRuby Velocity


Javascript Promise

John Vlissides

Junit New Instance

Keeping Software Soft

Key Points from NoSQL Distilled

Keynote at Agile Development Conference

Keynote for RailsConf 2006

Keyring Laptop

Keystone Interface

Kinesis Advantage2 - Review after three years of use



Language For Learning Objects

Language Workbench

Language Workbench Readings

Language Workbenches and Model Driven Architecture

Language Workbenches: The Killer-App for Domain Specific Languages?

Language-Oriented Programming and Language Workbenches

Large Agile Projects

Law Of Demos

Lay Programmer

Layering Principles

Lazy Initialization

Leadership Divide

Lean Inception

Legacy Seam

Limitations Of General Advice

Linking Modular Architecture to Development Teams

List And Hash

Local D T O

Local Variables In Class Diagrams

Lock In Cost

MDA: Revenge of the Modelers or UML Utopia?


Machine Justification

Magellan Meridian Gps

Making Stubs

Manifesto for Agile Software Development

Maturity Model

Maximizing Developer Effectiveness

Measuring Developer Productivity via Humans

Media Server

Memory Image

Mercurial Squash Commit

Meta Programming System

Meta-Introduction to Domain Specific Languages

Metaphoric Questioning

Micro Frontends

Microservice Premium

Microservice Prerequisites

Microservice Trade-Offs


Microservices Guide

Microservices Talk

Microservices and the First Law of Distributed Objects

Mike Mason and I talk about Feature Branching

Mind the platform execution gap

Minimal Interface

Mocks Aren't Stubs

Model Driven Architecture

Model Driven Software Development

Modeling with a Sense of Purpose

Modern Mocking Tools and Black Magic

Modifiability: Or is there Design in Agility

Modularizing React Applications with Established UI Patterns

Module Assembly

Monolith First

More Version Control

Motion Graphics

Moving Away From Xslt

Moving To Nokogiri

Multiple Canonical Models

Multiple Desktops

Multiple Mobiles

Multiplicity Not Cardinality


Musings on Ebooks

Muted spaghetti line charts with R's ggplot2

My Book Colophon

My favorite musical discoveries of 2020

My favorite musical discoveries of 2021

My favorite musical discoveries of 2022

My favorite musical discoveries of 2023

Nashville Project


Net Nastiness

Network Data Model



No Silver Bullet Reloaded

NoSQL Distilled

Nosql Definition

Not Just Code Monkeys (OOP 2014)



Object Mother

Objects And Iteration

Observable State

Observed Requirement

On Pair Programming

On the Diverse And Fantastical Shapes of Testing

Once Upona Time In The West

One Language

One Line of Code that Compromises Your Server

Onsite Customer

Open Inheritance

Open Intellectual Property

Open Source Research

Open Space

Opportunistic Refactoring

Organization Structures (Accountability)

Organizing Presentation Logic

Orm Hate


Our Responsibility to Defeat Mass Surveillance

Outcome Oriented

Outcome Over Output

Output Build Target

Overloaded Getter Setter


Package Customization

Page Object

Pair Programming

Pair Programming Misconceptions

Parallel Change

Parser Fear

Pattern Share

Pattern: Gateway


Patterns Are Nothing New

Patterns for Accounting

Patterns for Managing Source Code Branches

Patterns for things that change with time

Patterns of Distributed Systems

Patterns of Enterprise Application Architecture

Patterns of Legacy Displacement

Pedestal Phobia

Pending Head

People Matter Most

People Oriented

Periodic Face-to-Face

Perspectives on DSLs with Chris Sells

Pervasive Versioning

Phoenix Server

Planning Extreme Programming

Planning and Running an XP Iteration

Platform Building

Platform Independent Malapropism

Playlist of my talks on YouTube

Pleasing The Customer

Podcast on Agility and Architecture


Polyglot Persistence

Post Modern Programming


Pourquoi, pas comment

Prefer Design Skills

Prefer Functional Staff Organization

Premature Ramp Up

Presentation Domain Data Layering

Presentation Domain Separation

Presentation Smells

Priming Prime Directive

Principles of XP

Privacy Enhancing Technologies: An Introduction for Technologists

Privacy Protects Bothersome People

Privacy on the internet

Probabilistic Illiteracy

Product-Service Partnerships

Products Over Projects

Projectional Editing

Protected Data

Protected Variation: The Importance of Being Closed

Provide Service Stub

Public Csharp Fields

Public versus Published Interfaces

Published Interface

Pull Request

Purpose Of Estimation

QA in Production


Question Time Panel

Race for the Galaxy and San Juan

RailsConf 2007


Reckoning with the force of Conway's Law

Recollections of Writing the Agile Manifesto

Recurring Event in Calendars

Reducing Coupling


Refactoring Boundary

Refactoring Code to Load a Document

Refactoring Cringely

Refactoring Databases

Refactoring Guide

Refactoring HTML

Refactoring Malapropism

Refactoring Module Dependencies

Refactoring Photran

Refactoring Ruby Edition

Refactoring a JavaScript video store

Refactoring code that accesses external services

Refactoring to Patterns

Refactoring to an Adaptive Model

Refactoring with Loops and Collection Pipelines

Refactoring: Doing Design After the Program Runs

Refactoring: This class is too large

Refinement Code Review

Reflection vs Code Generation

Relational Data Model

Remote versus Co-located Work

Replacing Throwing Exceptions with Notification in Validations

Reporting Database

Reproducible Build

Request Stream Map

Required Interface

Resource Pool

Restoring a deleted note in Apple's notes app

Retrospectives Antipatterns

Revitalizing Enterprise Software

Richardson Maturity Model

Rigorous Agile

Role Interface

Roller Skate Implementation


Roy sells Thoughtworks

Roys Social Experiment

Rss Feeds

Ruby Annotations

Ruby Microsoft

Ruby People

Ruby Ploticus

Ruby Rogues Podcast on Refactoring

Ruby Rogues episode discussing P of EAA

Ruby at Thoughtworks

Rule Of Tincture

Rules Engine

SE Radio Podcast on Agile Database Development

SE Radio Podcast on Domain-Specific Languages


Sacrificial Architecture

Savannah Charleston

Scaling the Practice of Architecture, Conversationally

Schemaless Data Structures

Schools Of Software Development

Scope Limbering


Security And Design


Segmentation By Freshness

Segregated DOM

Selecting a Mobile Implementation Strategy

Self Encapsulation

Self Initializing Fake

Self Testing Code

Semantic Conflict

Semantic Diff

Semantic Diffusion


Separating User Interface Code


Serverless Architectures

Service Custodian

Service Design Patterns

Service Oriented Ambiguity

Setter Initialization

Setting up a ruby development VM with Vagrant, Chef, and rbenv

Shifting To Code Ownership

Ship / Show / Ask

Should social media dampen uncertain stories?

Shu Ha Ri

Signature Series Criteria

Singing Detective

Site Report for 2018




Smalltalk Books

Smut On Rails

Snow Leopard

Snowflake Server

Social Networks

Software And Engineering

Software Architecture Hour with Neal Ford: The Future of Software

Software Component

Software Development Attitude

Software Patent

Software and Obama's Victory

Sony a6000 with 16-70mm lens

Source Editing


Specification By Example

Spreading Incrementalism


Standard Story Points

Standards Speak

State Of Dev Ops Report

Static Substitution

Status Report for at the end 2014

Stepping Back from Speaking

Sticky Timeline

Story Counting

Story Point

Story Test

Strangler Fig Application

Subcutaneous Test


Suite Of Talks

Sunk Cost Driven Architecture


Syntactic Noise

Synthetic Monitoring

Talk Notes

Talk: 3.years.of(:ruby)

Talk: A Conversation about Hexagonal Rails

Talk: Agile Architecture

Talk: Agile Essence and Fluency

Talk: Agile Manifesto: 10 years later

Talk: Agilists and Architects: Allies not Adversaries

Talk: An Enterprise Cumulonimbus?

Talk: An Introduction to Language-Oriented Programming

Talk: Architecture without Architects

Talk: Continuous Delivery

Talk: Continuous Delivery (YOW 2011)

Talk: Cultivating Architecture

Talk: Does my bus look big in this?

Talk: Economics of Software Design

Talk: Event Sourcing

Talk: Evolving a Mobile Implementation Strategy

Talk: Forging a New Alliance

Talk: Infrastructure as Code

Talk: Interview: Privacy on the Internet

Talk: Introduction to NoSQL

Talk: Is TDD Dead?

Talk: Making Architecture Matter

Talk: Microservices

Talk: NoSQL and Consistency

Talk: Non-Determinism and Testing

Talk: Not Just Code Monkeys

Talk: Our Responsibility to Defeat Mass Surveillance

Talk: Practices for an Agile Codebase

Talk: Retake on the Agile Manifesto

Talk: Schemaless

Talk: Technology in the Obama Campaign

Talk: The Evolving Panorama of Data

Talk: The Many Meanings of Event-Driven Architecture

Talk: The Yawning Crevasse of Doom"

Talk: What Does Tech Excellence Look Like?

Talk: Why Agile Software Works

Talk: Workflows of Refactoring

Talks on schemalessness, consistency in NoSQL, and economics of software design

Team Room

Team Topologies

Technical Debt

Technical Debt Quadrant

Technical Staff Organization

Tell Dont Ask

Temporal Patterns

Test Cancer

Test Coverage

Test Double

Test Driven Development

Test Invariant

Test Pyramid

Testing Asynchronous JavaScript

Testing Language

Testing Methods: The Ugly Duckling

Testing Resource Pools

Testing Strategies in a Microservice Architecture

The Agile Fluency Model

The Almighty Thud

The Architect Elevator — Visiting the upper floors

The Architecture of Gap Inc's SCMS

The Architecture of the Morrison's OrderPad

The Basics of Web Application Security

The Death of Goldman Sachs

The Difference between Marketecture and Tarchitecture

The Elephant in the Architecture

The Evolving Panorama of Data

The Evolving Role of Data in Software Development

The Future is not NoSQL but Polyglot Persistence

The LMAX Architecture

The Lies that can Undermine Democracy

The Manifesto for Agile Software Development - an early article.

The Most Important Design Guideline?

The New Methodology

The People vs. NoSQL Databases: Panel Discussion

The Practical Test Pyramid

The Rise of Test Impact Analysis

The Role of an Enterprise Architect in a Lean Enterprise

The Second Edition of "Refactoring"

The State of Agile Software in 2018

The Test Bus Imperative

The Thrilling Adventures of Lovelace and Babbage

The XP 2000 Conference

The XP 2002 Conference

The Yawning Crevasse of Doom

The strong and weak forces of architecture

Thinking about Big Data

Thoughts writing a Google App script

Thoughtworks 2005

Thoughtworks China

Thoughtworks Technology Radar FAQ

Thoughtworks UK

Three Pillars

Three Years of Real-World Ruby

Three reasons a liberal arts degree helped me succeed in tech

Threshold Test

Thrown Estimate

Thunderbolt Display

Time Zone Uncertainty

Timeboxed Iterations

To Be Explicit

Tolerant Reader

Tor for Technologists

Touch File

Toyota Failings

Tradable Quality Hypothesis

Trans Media Application



Transparent Compilation

Travel Clothing

Two Hard Things

Two Pizza Team

Two Stack CMS

Type Instance Homonym

Typed Collection

U Pod

UML Diagrams for Analysis Patterns

UML Distilled

Ubiquitous Language

Ui Patterns Readings

Uml Activity Diagram

Uml As Blueprint

Uml As Notes

Uml As Programming Language

Uml As Sketch

Uml Mode

Uml Sketching Tools


Uncovering the Seams in Mainframes for Incremental Modernisation

Unforgiven Contract

Uniform Access Principle

Unit Test

Unwanted Modeling Language

Use Case

Use Cases And Stories

Use Of Xml

Use and Abuse Cases

User Defined Field

User Journey Test

User Story

Using ChatGPT as a technical writing assistant

Using Metadata

Using a command line script to export from OmniGraffle

Using an Agile Software Process with Offshore Development

Using the Rake Build Language

Utility Vs Strategic Dichotomy

Value Object

Variations on a Theme of XP

Vcs Survey

Version Control Tools

Very Low Defect Project

Video: Introduction to Domain Specific Languages

Visual Channel

Viticulture and The Gallerist

Vote Against Trump, Again

Voting Machines


Waterfall Process


What Does a Technical Author Look Like?

What I Talk About When I Talk About Platforms

What Is Failure

What Isa Bliki

What It's Like to Work at...Thoughtworks

What do you mean by “Event-Driven”?

What if we rotate pairs every day?

What's a Model For?

When to Make a Type

Who Needs an Architect?

Wikipedia Death

Workflows of Refactoring

Workflows of Refactoring (OOP 2014)

Writing Software Patterns

Writing The Agile Manifesto

Writing with XML

Xp Velocity




Yesterdays Weather

Yet Another Optimization Article

You Can't Buy Integration

Your Coffee Shop Does Not Use Two-Phase Commit

Your organization should run its own Mastodon server

goto Aarhus 2011

goto Aarhus 2012


xUnit Test Patterns

All tags

API design · agile · agile adoption · analysis patterns · application architecture · application integration · bad things · board games · build scripting · certification · collaboration · computer history · conference panels · conferences · continuous delivery · covid-19 · data analytics · database · design · dictionary · distributed computing magazine · diversions · diversity · documentation · domain driven design · domain specific language · domestic · encapsulation · enterprise architecture · estimation · event architectures · evolutionary design · experience reports · expositional architectures · extreme programming · front-end · gadgets · generative AI · ieeeSoftware · infodecks · internet culture · interviews · language feature · language workbench · lean · legacy rehab · legal · metrics · microservices · mobile · noSQL · object collaboration design · parser generators · photography · platforms · podcast · popular · presentation technique · privacy · process theory · productivity · programming environments · programming style · project planning · recruiting · refactoring · refactoring boundary · requirements analysis · ruby · security · 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

2024 · 2023 · 2022 · 2021 · 2020 · 2019 · 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