Software development is a young profession, and we are still learning the techniques and building the tools to do it effectively. I've been involved in this activity for over three decades and in the last two I've been writing on this website about patterns and practices that make it easier to build useful software. The site began as a place to put my own writing, but I also use it to publish articles by my colleagues.
In 2000, I joined Thoughtworks, where my role is to learn about the techniques that we've learned to deliver software for our clients, and pass these techniques on to the wider software industry. As this site has developed into a respected platform on software development, I've edited and published articles by my colleagues, both Thoughtworkers and others, to help useful writing reach a wider audience.
photo: Christopher Ferguson
Martin Fowler
If there's a theme that runs through my work and writing on this site, it's the interplay between the shift towards agile thinking and the technical patterns and practices that make agile software development practical. While specifics of technology change rapidly in our profession, fundamental practices and patterns are more stable. So writing about these allows me to have articles on this site that are several years old but still as relevant as when they were written.
As software becomes more critical to modern business, software needs to be able to react quickly to changes, allowing new features to be conceived, developed and put into production rapidly. The techniques of agile software development began in the 1990s and became steadily more popular in the last decade. They focus on a flexible approach to planning, which allows software products to change direction as the users' needs change and as product managers learn more about how to make their users effective. While widely accepted now, agile approaches are not easy, requiring significant skills for a team, but more importantly a culture of open collaboration both within the team and with a team's partners.
This need to respond fluently to changes has an important impact upon the architecture of a software system. The software needs to be built in such a way that it is able to adapt to unexpected changes in features. One of the most important ways to do this is to write clear code, making it easy to understand what the program is supposed to do. This code should be divided into modules which allow developers to understand only the parts of the system they need to make a change. This production code should be supported with automated tests that can detect any errors made when making a change while providing examples of how internal structures are used. Large and complex software efforts may find the microservices architectural style helps teams deploy software with less entangling dependencies.
Creating software that has a good architecture isn't something that can be done first time. Like good prose, it needs regular revisions as programmers learn more about what the product needs to do and how best to design the product to achieve its goals. Refactoring is an essential technique to allow a program to be changed safely. It consists of making small changes that don't alter the observable behavior of the software. By combining lots of small changes, developers can revise the software's structure supporting significant modifications that weren't planned when the system was first conceived.
Software that runs only on a developer's machine isn't providing value to the customers of the software. Traditionally releasing software has been a long and complicated process, one that hinders the need to evolve software quickly. Continuous Delivery uses automation and collaborative workflows to remove this bottleneck, allowing teams to release software as often as the customers demand. For Continuous Delivery to be possible, we need to build in a solid foundation of Testing, with a range of automated tests that can give us confidence that our changes haven't introduced any bugs. This leads us to integrate testing into programming, which can act to improve our architecture.
San Francisco
There are many kinds of software out there, the kind I'm primarily engaged is Enterprise Applications. One of the enduring problems we need to tackle in this world is data management. The aspects of data managment I've focused on here are how to migrate data stores as their applications respond to changing needs, coping with different contexts across a large enterprise, the role of NoSQL databases, and the broader issues of coping with data that is both Big and Messy.
A common problem in complex software systems is how to capture complicated domain logic in a way that programmers can both easily manipulate and also easily communicate to domain experts. Domain-Specific Languages (DSLs) create a custom language for a particular problem, either with custom parsers or by conventions within a host language.
I've written seven books on software development, including Refactoring, Patterns of Enterprise Application Architecture, and UML Distilled. I'm also the editor of a signature series for Addison-Wesley that includes five jolt award winners.
I'm often asked to give talks at conferences, from which I've inferred that I'm a pretty good speaker - which is ironic since I really hate giving talks. You can form your own opinion of my talks by watching videos of some my conference talks.
I've long been a fan of board games, I enjoy a game that fully occupies my mind, clearing out all the serious thoughts for a bit, while enjoying the company of good friends. Modern board games saw dramatic improvement in the 1990's with the rise of Eurogames, and I expect many people would be surprised if they haven't tried any of this new generation. I also appear regularly on Heavy Cardboard.
If you'd like to be notified when I post new material, subcribe to my RSS, LinkedIn, X (Twitter), or Mastodon feeds. I also have a page dedicated to recent changes.
Tue 29 Oct 2024 10:34 EDT
My colleagues are often involved in modernizing legacy systems, and our approach is to do this in an incremental fashion. Doing this with a mobile application raises some specific challenges. Matthew Foster and John Mikel Amiel Regida share their experiences of a recent engagement to do this, shifting from a monolithic legacy application to one using a modular micro-app architecture.
Fri 04 Oct 2024 09:16
I was interviewed on the Book Overflow podcast about the Refactoring book. We talked about the origins of the book, the relationship between refactoring, testing, and extreme programming, how refactoring is used in the wild, and the role of books and long-form prose today.
Tue 17 Sep 2024 09:07 EDT
Most of the talk about the impact of GenAI on software development is about its ability to write (messy) code. But many of us think it's going to be much more useful to help us understand existing messy code, as part of a modernization effort. My colleagues Alessio Ferri, Tom Coggrave, and Shodhan Sheth have been considering how GenAI can do this, including building an internal tool to help explore the possibilities. The tool uses an LLM to enhance a knowledge graph based on the AST of the code base. It also uses an LLM to help users query this knowledge graph.
Thu 05 Sep 2024 09:37 EDT
Decentralized data management requires automation to scale governance effectively. Fitness functions are a powerful automated governance technique my colleagues have applied to data products within the context of a Data Mesh. Since data products serve as the foundational building blocks of a data strategy, ensuring robust governance around them significantly increases the chances of success. Kiran Prakash explains how to do this, starting with simple tests for key architectural characteristics and moving on to leveraging metadata and Large Language Models.
Wed 04 Sep 2024 00:00 EDT
Cycle Time is a measure of how long it takes to get a new feature in a software system from idea to running in production. In Agile circles, we try to minimize cycle time. We do this by defining and implementing very small features and minimizing delays in the development process. Although the rough notion of cycle time, and the importance of reducing it, is common, there is a lot of variations on how cycle time is measured.
Thu 22 Aug 2024 11:51 EDT
Two decades ago, I posted that I found that the strangler fig plant was an interesting metaphor for the gradual replacement of a legacy system. I didn’t refer to the metaphor since, but meanwhile it grew a life of its own. Other people increasingly referred to the strangler fig approach to modernization, and traffic to that post steadily increased: currently it gets about 5000 page views a month, one of the more popular pages on this site. So I decided I needed to update that page, and have rewritten it, focusing on the core activities we need to do to make a success of such a venture.