Announcing the Second Edition of "Refactoring"
For the past two years, I've been working on a second edition of my book "Refactoring". Here I have details about the new edition and some memos describing my thoughts in the last months of this project. The book is now available and you can buy it from informit (the web presence of the publisher), Amazon, or your favorite book seller. Purchasing the book gives you access to the canonical web edit
The Practical Test Pyramid
The "Test Pyramid" is a metaphor that tells us to group software tests into buckets of different granularity. It also gives an idea of how many tests we should have in each of these groups. Although the concept of the Test Pyramid has been around for a while, teams still struggle to put it into practice properly. This article revisits the original concept of the Test Pyramid and shows how you can
MachineJustification
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 natura
Foreword to Building Evolutionary Architectures
Recently my colleagues: Neal Ford, Rebecca Parsons, and Pat Kua, wrote a book entitled "Building Evolutionary Architectures". I was honored that they asked me to write the foreword. For a long time, the software industry followed the notion that architecture was something that ought to be developed and completed before writing the first line of code. Inspired by the construction industry, it was f
The Rise of Test Impact Analysis
Test Impact Analysis (TIA) is a modern way of speeding up the test automation phase of a build. It works by analyzing the call-graph of the source code to work out which tests should be run after a change to production code. Microsoft has done some extensive work on this approach, but it's also possible for development teams to implement something useful quite cheaply. 22 August 2017 Paul Hammant
Roy sells Thoughtworks
Thoughtworks, my employer, had some big news to share today. Our founder and owner, Roy Singham, has decided to sell Thoughtworks to Apax Funds - a private equity firm based in London. Apax wishes the current management team to continue running and growing Thoughtworks, using the same model that's driven our growth and success for the last twenty-odd years. Why Roy is selling Thoughtworks Roy Sing
bliki: Function As Object
In programming, the fundamental notion of an object is the bundling of data and behavior. This provides a common data context when writing a set of related functions. It also provides an interface to manipulating the data that allows the object to control access to that data, making it easy to support derived data and prevent invalid modifications of data. Many languages provide explicit syntax to
bliki: Continuous Integration Certification
Continuous Integration is a popular technique in software development. At conferences many developers talk about how they use it, and Continuous Integration tools are common in most development organizations. But we all know that any decent technique needs a certification program — and fortunately one does exist. Developed by one of the foremost experts in continuous delivery and devops, it’s know
bliki: Boiled Carrot
I hated carrots when I was growing up, hating the smell and texture of the things. But after I left home and started to cook for myself I started to like them. Nothing changed about the carrots, nor did my taste buds get a radical overhaul, the difference was in the cooking. My mother, like so many English people of her generation, wasn't a great cook - particularly of vegetables. Her approach was
bliki: Bimodal IT
Bimodal IT is the flawed notion that software systems should be divided into these two distinct categories for management and control. Front Office systems (systems of engagement) should be optimized for rapid feature development. These systems of engagement need to react rapidly to changing customer needs and business opportunities. Defects should be tolerated as the necessary cost for this rapid
bliki: Serverless
Serverless architectures are internet based systems where the application development does not use the usual server process. Instead they rely solely on a combination of third-party services, client-side logic, and service hosted remote procedure calls (FaaS). Serverless applications often make extensive use of third party services to accomplish tasks that are traditionally taken care of by server
Serverless Architectures
Serverless architectures are application designs that incorporate third-party “Backend as a Service” (BaaS) services, and/or that include custom code run in managed, ephemeral containers on a “Functions as a Service” (FaaS) platform. By using these ideas, and related ones like single-page applications, such architectures remove much of the need for a traditional always-on server component. Serverl
bliki: CQRS
CQRS stands for Command Query Responsibility Segregation. It's a pattern that I first heard described by Greg Young. At its heart is the notion that you can use a different model to update information than the model you use to read information. For some situations, this separation can be valuable, but beware that for most systems CQRS adds risky complexity. The mainstream approach people use for i
Refactoring to an Adaptive Model
Most of our software logic is written in our programming languages, these give us the best environment to write and evolve such logic. But there are circumstances when it's useful to move that logic into a data structure that our imperative code can interpret - what I refer to as an adaptive model. Here I'll show some product selection logic in JavaScript and show how it can be refactored to a sim
bliki: Microservice Premium
The microservices architectural style has been the hot topic over the last year. At the recent O'Reilly software architecture conference, it seemed like every session talked about microservices. Enough to get everyone's over-hyped-bullshit detector up and flashing. One of the consequences of this is that we've seen teams be too eager to embrace microservices, 1 not realizing that microservices int
Microservices and the First Law of Distributed Objects
When I wrote Patterns of Enterprise Application Architecture, I coined what I called the First Law of Distributed Object Design: "don't distribute your objects". In recent months there's been a lot of interest in microservices, which has led a few people to ask whether microservices are in contravention to this law, and if so why I am in favor of them? It's important to note that in this first law
bliki: Branch By Abstraction
"Branch by Abstraction" is a technique 1 for making a large-scale change to a software system in gradual way that allows you to release the system regularly while the change is still in-progress. 1: This technique has been around for a long time, although it never got a popular name. Paul Hammant introduced the term "Branch by Abstraction" while arguing in favor of Trunk Based Development (he cred
Hangout on TDD with Kent Beck and David Heinemeier Hansson
As we’ve announced via Twitter, Kent Beck, David Heinemeier Hansson (DHH) and I will be doing a series of video hangouts to discuss TDD, and the trade-offs around testing and architecture. The first one is on Friday May 9, at 11:00 Eastern time. The hangout will be around 30 minutes and will be recorded so you can watch it later. We’ll also release an audio version via a podcast stream for those l
Modern Mocking Tools and Black Magic
An example of power corrupting The positive effect modern mocking tools can have on our ability to work with legacy code and the possible negative implications of using those tools. 10 September 2012 Brett is currently with Thoughtworks and he has numerous years of experience across a number of domains and disciplines including Training (from 1985), solution-based consulting (from 1992) and coachi
NoSQL Distilled
A Brief Guide to the Emerging World of Polyglot Persistence by Pramod J. Sadalage and Martin Fowler 2012 We've spent some twenty years in the world of enterprise computing. We've seen many things change in languages, architectures, platforms, and processes. But through all this time one thing has stayed constant—relational databases store the data. There have been challengers, some of which have h
リリース、障害情報などのサービスのお知らせ
最新の人気エントリーの配信
j次のブックマーク
k前のブックマーク
lあとで読む
eコメント一覧を開く
oページを開く
