Tracing Request IDs
Evolutionary Database Design
Over the last decade we've developed and refined a number of techniques that allow a database design to evolve as an application develops. This is a very important capability for agile methodologies. The techniques rely on applying continuous integration and automated refactoring to database development, together with a close collaboration between DBAs and application developers. The techniques wo
Crossing Refactoring's Rubicon
In January 2001 two Java tools crossed Refactoring's Rubicon. Refactoring in Java now has serious tool support
Is Design Dead?
For many that come briefly into contact with Extreme Programming, it seems that XP calls for the death of software design. Not just is much design activity ridiculed as “Big Up Front Design”, but such design techniques as the UML, flexible frameworks, and even patterns are de-emphasized or downright ignored. In fact XP involves a lot of design, but does it in a different way than established softw
Keeping Software Soft
Why we need methods that assume software should be soft and open to change.
Canadian Workshop on Scaling XP/Agile Methods
As XP and other Agile methods gain popularity, questions are beginning to surface regarding how to scale XP beyond teams of 10-12 people. In mid February 2003 a workshop dedicated to the subject was held in Banff Alberta Canada. In this article we report on the keynote speeches from Ken Schwaber, and Martin Fowler, as well as other leading practitioners.
Microservices Guide
The microservice architectural pattern is an approach to developing a single application as a suite of small services, each running in its own process and communicating with lightweight mechanisms, often an HTTP resource API. These services are built around business capabilities and independently deployable by fully automated deployment machinery. There is a bare minimum of centralized management
To Be Explicit
Often designs techniques are used to make a system more flexible, but end up being harder to work with. One of the reasons is that explicitness is a property that often gets forgotten in design.
Using Metadata
You can use metadata based approaches to remove the pain from tedious data oriented tasks.
When to Make a Type
Guidelines on when to make a new user defined type (or class) for values.
The XP 2000 Conference
In late June over a hundred people gathered on the Mediterranean island of Sardinia to take part in the XP2000 conference to discuss Extreme Programming (XP) and other flexible methodologies.
Variations on a Theme of XP
One of the attractive things about XP is that it gives quite definite statements about what you should do to be doing XP. Furthermore that set of practices is carefully designed to fit together. Taking anything out has serious consequences. Yet one of the principles of XP and other agile methods is that they be self adaptive: that is you should change the process as you are developing the project.
Public versus Published Interfaces
Many modern languages make a distinction between public and private features in a module. A distinction that doesn't get made so often is between public and published features: and that may be a more important distinction.
Domain Logic and SQL
Over the last couple of decades we've seen a growing gap between database-oriented software developers and in-memory application software developers. This leads to many disputes about how to use database features such as SQL and stored procedures. In this article I look at the question of whether to place business logic in SQL queries or in-memory code, considering primarily performance and mainta
Continuous Delivery Guide
It’s hard enough for software developers to write code that works on their machine. But even when that’s done, there’s a long journey from there to software that’s producing value - since software only produces value when it’s in production. he essence of my philosophy to software delivery is to build software so that it is always in a state where it could be put into production. We call this Cont
The Almighty Thud
Why you shouldn't write a lot of documentation.
Enterprise Architects Join the Team
Enterprise Architecture groups often get separated from day to day development. This can lead to their knowledge of development work getting out of date and development teams not taking a broad company-wide perspective. Having seen this happen frequently my colleague (Thoughtworks CTO) Rebecca argues that enterprise architects can be much more effective by joining development teams.
Use and Abuse Cases
Ways in which to go badly wrong with Use Cases.
Is there such a thing as Object Oriented Analysis?
My thoughts on the role of analysis in OO projects..
Testing Methods: The Ugly Duckling
Why testing is much more important than most methodologists realize..
What's a Model For?
What is the point of drawing up UML Models?
Refactoring: Doing Design After the Program Runs
A short introduction to Refactoring.
How Standard is Standard UML?
What does it mean to have a standard UML, and why the standard doesn't standardize as many things as people think it does..