There are many books available that deal with modernising legacy codebases. These books generally focus on how to go about understanding the legacy system, improving test coverage, introducing build automation, as well as strategies for refactoring or rearchitecting the codebase. However, Marianne Bellotti’s Kill It With Fire is a radical departure from the existing literature on legacy systems. You will not find any discussion of how to get code with awkward dependencies into a test harness here. The mechanics of setting up build automation (and most other purely technical tasks) are largely taken for granted.
Instead, Bellotti’s approach is best summarised by the first paragraph of Kill it With Fire’s conclusion:
“The hard part about legacy modernization is the system around the system. The organization, its communication structures, its politics, and its incentives are all intertwined with the technical product in such a way that to move the product, you must do it by turning the gears of this other, complex, undocumented system.”
To put the focus on the organisational and psychological aspects of managing computer systems in context, Bellotti — in addition to a career spanning Auth0, the US Digital Service, and the United Nations — holds a degree in anthropology. Thus, instead of the mechanics of refactoring, Kill It With Fire focuses on topics such as how to structure teams tackling modernization projects that have failed previously — is it better to use the existing team structure, to set up an architecture group, or to embed members of a modernization team into existing teams?
Bellotti is particularly skilled at laying out the pros and cons of particular approaches and explaining why different strategies can work better than others in particular contexts. Conversely, those seeking a book that lays out a systematic approach to modernization will be disappointed, as will those who primarily want to address the technical level of legacy systems. Still, it is unavoidably true that context matters immensely in decision making, particularly in the fraught area of rotting yet mission-critical software systems. Better to grasp the nettle, craft a plan specific to your own situation and succeed than to follow a cookie-cutter approach and fail.
The other distinctive element of Kill It With Fire is that instead of primarily approaching the problem of modernisation from a software engineering perspective, Bellotti draws on lessons from Site Reliability Engineering (SRE) and the broader area of software operations work. There is enormous value in considering operations together with modernisation, for two reasons. The first is that the people running a given system are generally the first to become aware of problems (and have to manage them). The second is that modernization projects almost always involve significant operational changes. The SRE influence is woven through Kill it With Fire, with sections dealing with Code Yellows (an approach used at Google to handle critical reliability issues involving multiple teams), the mechanics of migrations, and the benefits of turning systems off as an investigative method. Kill It With Fire deals always with software as a running system, not a codebase.
The final chapter — ‘Future-Proofing’ — is something of a smorgasbord of topics. As well as a fun vignette on time bugs (time being the one inescapable shared failure domain), there’s a particularly useful section called ‘Building Something Wrong the Correct Way’ which discusses how to take teams’ capacity to manage additional work and complexity into account when evaluating competing architectural goals. Bellotti argues — with some justification — that it’s better to run a slightly suboptimal architecture that needs less care and feeding than to overload a team and lose staff to burnout. As always in Kill It With Fire, human factors are at least as important in decision making as the technical aspects of problems.
Kill It With Fire is not a complete reference on software modernization. Nevertheless, it is a valuable addition to the literature on the topic, particularly for managers and senior contributors. After all, legacy is more a matter of degree than of kind. Every system you run today will someday be turned down or redesigned, every system spends far longer in maintenance than in initial development, and every team will sometimes need to deal with failure, with loss of momentum or morale, or with suboptimal decisions that have been made in the past. Kill it With Fire is a useful and highly readable guide to solving these problems by leveraging the organisation — the system around the system.
