A Cherry Picker's Guide to Doctor Who

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 Brazil Interview

Agile Certification

Agile Handover

Agile Imposition

Agile Manifesto Author Interview by Agile Uprising

Agile Manifesto Authors' 10 year anniversary reunion

Agile Manifesto Meeting

Agile Signatory

Agile Versus Lean

Agile at 10

Agile2010

Agiledox

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 preparatory refactoring

Analysis Patterns

Andaman Islands

Android

Anecdotal Evidence

Anemic Domain Model

Annotation

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

Blue Green Deployment

Boiled Carrot

Book Code

Born for it

Bounded Context

Branch By Abstraction

Broad Stack Test

Build Language

Building Architect

Buildix

Business Capability Centric

Business Facing Test

Business Readable DSL

C- Refactory

C3

CQRS

Call Super

Canadian Workshop on Scaling XP/Agile Methods

Canary Release

Cannot Measure Productivity

Canon 60D

Canon S90

Canon70-300

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

Component Test

Components and the World of Chaos

Composed Regex

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 Integration

Continuous Integration

Continuous Integration Certification

Continuous Integration with Visual C++ and COM

Contract Test

Contradictory Observations

Conversational Stories

Courtesy Implementation

Craftmanship And The Crevasse

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 Q & A

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

Data Access Routines

Data Clump

Data Lake

Data Management Guide

Data Models

Database And Build Time

Database Styles

Database Thaw

Datensparsamkeit

Dealing With Roles

Dealing with Properties

Debian Java

Decorated Command

Decreed Stories

Defining the UML Kernel

Definition Of Refactoring

Democratic Political Technology Revolution

Dependency And Association

Deployment Pipeline

Derived Information

Design Payoff Line

Design Stamina Hypothesis

Design to Accommodate Change

Designed Inheritance

Detestable

Dev Ops Culture

Developing Patterns in Enterprise Software

Diff Debugging

Digital SLR

Directing Attitude

Diversity

Diversity Imbalance

Diversity Mediocrity Illusion

Does My Bus Look Big in This?

Domain Logic and SQL

Domain Specific Language

Domain Specific Languages

Domain-Oriented Observability

Dominica

Dominion Second Edition

Don't get locked up into avoiding lock-in

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

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

Eurogames

Evaluating Ruby

Evans Classification

Event Interception

Event Poster

Evolutionary Database Design

Evolutionary S O A

Evolving Publication

Evolving a Mobile Implementation Strategy

Expositional Architecture

Expression Builder

Extemporary Speaking

Extreme Presentation

Extreme Programming

Fail Fast

Feature Branch

Feature Devotion

Feature Toggle

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

Flooded

Fluent Interface

Focusing on Events

Focusing on Events

Foreword to Building Evolutionary Architectures

Forging a New Alliance

Foundation Framework

Framework Building

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 Framework

Header Interface

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 Standard is Standard UML?

How do you estimate on an Agile project?

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

How to break a Monolith into Microservices

How to extract a data-rich service from a monolith

Huffpost live panel on "The Brogrammer Effect"

Humane Interface

Humane Registry

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

Infodeck

Infrastructure As Code

Installing Debian

Integration Database

Integration Test

Intelli Csharp

Intentional Software

Interface Implementation Pair

Internal Dsl Style

Internal Reprogrammability

Interview with Artima.com

Interview with Kent Beck and Martin Fowler on Extreme Programming

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 Not Just Standing Up: Patterns for Daily Standup Meetings

JAOO 2005

JRake

JRuby Velocity

Japan

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

Knoppix

Lambda

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

Limitations Of General Advice

List And Hash

Local D T O

Local Variables In Class Diagrams

Lock In Cost

MDA: Revenge of the Modelers or UML Utopia?

MDS and DSL

Machine Justification

Magellan Meridian Gps

Making Stubs

Manifesto for Agile Software Development

Maturity Model

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

Microservices Guide

Microservices Talk

Microservices and the First Law of Distributed Objects

Mike Mason and I talk about Feature Branching

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

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

Music2005

Musings on Ebooks

Nashville Project

Neologism

Net Nastiness

Network Data Model

Nexus7

No DBA

No Silver Bullet Reloaded

NoSQL Distilled

Nosql Definition

Not Just Code Monkeys (OOP 2014)

OOPSLA 2004

OOPSLA 2005

Object Mother

Objects And Iteration

Observable State

Observed Requirement

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

Oslo

Our Responsibility to Defeat Mass Surveillance

Our Responsibility to Defeat Mass Surveillance

Outcome Oriented

Output Build Target

Overloaded Getter Setter

P O J O

Package Customization

Page Object

Pair Programming Misconceptions

Parallel Change

Parser Fear

Pattern Share

Patterns

Patterns Are Nothing New

Patterns for Accounting

Patterns for things that change with time

Patterns of Enterprise Application Architecture

Pedestal Phobia

Pending Head

People Matter Most

People Oriented

Perspectives on DSLs with Chris Sells

Pervasive Versioning

Phoenix Server

Planning Extreme Programming

Planning and Running an XP Iteration

Platform Independent Malapropism

Playlist of my talks on YouTube

Pleasing The Customer

Podcast with Rebecca Wirfs-Brock on Agility and Architecture

Podcasts

Polyglot Persistence

Post Modern Programming

Post-IntelliJ

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 Protects Bothersome People

Privacy on the internet

Probabilistic Illiteracy

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

Purpose Of Estimation

QA in Production

Quantity

Question Time Panel

Race for the Galaxy and San Juan

RailsConf 2007

Range

Recurring Event in Calendars

Reducing Coupling

Refactoring

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

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

Retread

Revitalizing Enterprise Software

Richardson Maturity Model

Rigorous Agile

Role Interface

Roller Skate Implementation

Rotation

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

Saba

Sacrificial Architecture

Savannah Charleston

Schemaless Data Structures

Schools Of Software Development

Scope Limbering

Seal

Security And Design

Seedwork

Segmentation By Freshness

Segregated DOM

Selecting a Mobile Implementation Strategy

Self Encapsulation

Self Initializing Fake

Self Testing Code

Semantic Conflict

Semantic Diff

Semantic Diffusion

Semat

Separating User Interface Code

Serverless

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

Shu Ha Ri

Signature Series Criteria

Singing Detective

Site Report for 2018

Slideument

Slimp3

Smalltalk Books

Smut On Rails

Snow Leopard

Snowflake Server

Social Networks

Software Development Attitude

Software Patent

Software and Obama's Victory

Sony a6000 with 16-70mm lens

Source Editing

Specification

Specification By Example

Spreading Incrementalism

Squeezebox

Standard Story Points

Standards Speak

State Of Dev Ops Report

Static Substitution

Status Report for martinfowler.com at the end 2014

Sticky Timeline

Story Counting

Story Point

Story Test

Strangler Fig Application

Subcutaneous Test

Subversion

Suite Of Talks

Sunk Cost Driven Architecture

Swebok

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

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 Difference between Marketecture and Tarchitecture

The Evolving Panorama of Data

The Future is not NoSQL but Polyglot Persistence

The LMAX Architecture

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

Thinking about Big Data

ThoughtWorks 2005

ThoughtWorks China

ThoughtWorks Technology Radar FAQ

ThoughtWorks UK

Three Pillars

Three Years of Real-World Ruby

Threshold Test

Thrown Estimate

Thunderbolt Display

Time Zone Uncertainty

To Be Explicit

Tolerant Reader

Tor for Technologists

Touch File

Toyota Failings

Tradable Quality Hypothesis

Trans Media Application

Transactionless

Translations

Transparent Compilation

Travel Clothing

Two Hard Things

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

Uml2

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 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

Voting Machines

Wardish

Web2.0

What Is Failure

What Isa Bliki

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

What do you mean by “Event-Driven”?

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

Xunit

YAaaS

Yagni

Yesterdays Weather

Yet Another Optimization Article

Your Coffee Shop Does Not Use Two-Phase Commit

goto Aarhus 2011

goto Aarhus 2012

iPad

xUnit Test Patterns