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.
Wed 06 Dec 2017 15:25 EST
Tue 28 Nov 2017 09:44 EST
Mon 20 Nov 2017 09:45 EST
Sriram continues his examination of why products are better than projects by looking into the benefits of product-mode thinking. With products you can quickly change direction and have faster cycles to get ideas into production - which are the consequences of truly iterative development. Product teams' more stable team members result in better knowledge retention and more architectural integrity in the code base.
Sun 19 Nov 2017 15:14 EST
Thu 16 Nov 2017 08:19 EST
For a long time, my colleagues and I have been arguing the organizations need to organize their software efforts as products rather than projects. But we haven't really come up with a great way to articulate what we see as the difference. Finally my colleague Sriram Narayam has stepped up to fill in the gap with a long-form article here. In the first installment, he covers the difference between project and product thinking. Later installments will cover the benefits and challenges of product-mode.
Tue 14 Nov 2017 09:34 EST
I remember in my teens being told of the wonderful things Artificial Intelligence (AI) would do in the next few years. Now several decades later, some of these seem to be happening. The most recent triumph was of computers teaching each other to play Go by playing against each other, rapidly becoming more proficient than any human, with strategies human experts could barely comprehend. It's natural to wonder what will happen over the next few years, will computers soon have greater intelligence than humanity? (Given some recent election results, that may not be too hard a bar to cross.)
But as I hear of these, I recall Pablo Picasso's comment about computers many decades ago: "Computers are useless. They can only give you answers". The kind of reasoning that techniques such as Machine Learning can result in are truly impressive in their results, and will be useful to us as users and developers of software. But answers, while useful, aren't always the whole picture. I learned this in my early days of school - just providing the answer to a math problem would only get me a couple of marks, to get the full score I had to show how I got it. The reasoning that got to the answer was more valuable than the result itself. That's one of the limitations of the self-taught Go AIs. While they can win, they cannot explain their strategies.
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:
- 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.
- 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.
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.