The Legacy Code Programmer's Toolbox: Practical Skills for Software Professionals Working with Legacy Code Paperback – September 21, 2019

I had this book sitting on my desk for a few years, recommended by a coworker. Life got busy. I decided to pick it back up and finish it! Here’s some of the insight I’ve learned from it.The author begins by defining legacy code as code that is hard to understand, uncomfortable to change, and causes concern. Attitude plays a significant role in how we approach legacy code. There’s the natural mindset, often negative, versus the effective mindset, which is more constructive. We can choose to understand legacy code as a solution to past problems accumulated over time and recognize it as a reason we have jobs.A few pieces of advice the author shares:* If you don’t like a piece of code, reflect on why.* Read good code to learn new problem-solving techniques.He also outlines three techniques for gaining an overview of unfamiliar code:1. Choosing a stronghold: Start from a code section you understand.2. Analyzing inputs and outputs: Focus on how the program receives and returns data.3. Well-chosen stacks: Set breakpoints to inspect the call stack during execution.Knowledge is key. Legacy code is challenging primarily due to a lack of understanding. Writing valuable documentation can help spread knowledge within the team, so it’s crucial to keep it aligned with the code. Presentations, pair programming, and external meetups are great ways to share insights.The author discusses strategies for finding a bug, echoing some methods familiar to our engineering team. The quickest way to find the source of a bug:* Step 1: Reproduce the issue.* Step 2: Start with small differences, then move to larger ones.* Step 3: Formulate and validate a hypothesis.Lastly, the importance of strategic refactoring is emphasized—knowing what to fix to maximize value while minimizing costs is vital.If you’re seeking to grow as a developer, I recommend this insightful read!

(Disclaimer: I have volunteered for proof-reading the book while it was being written.)We usually think of legacy code as that written years ago by strangers, with its secrets long forgotten. This is hardly the case: as soon as code is not maintained, it becomes legacy code---including our *own* code. Anyone working with software long enough will, eventually, deal with legacy code. Dealing with legacy code tends to be a frustrating experience and sometimes seen as a chore, with little value.In this book, Jonathan presents pragmatic approaches for dealing with legacy code and, in the process, improving one's general attitude towards writing code. Perhaps one of the most important lessons from the book is transforming what would seem to be an unpleasant task into an important and encompassing learning opportunity.The book contains numerous advices that are immediately applicable to code, as well as many strategies to rely on when the burden seems too heavy and you feel stuck. Either if you are on your own handling legacy code or you are part of a team, the book will prove very valuable. The strategies are diversified and will help making continuous progress, and should help you deliver better code---either as maintenance to a legacy code base, or new code. In addition, interpersonal skills are not ignored: there are strategies for discussing, mentoring, and calling out for help, greatly increasing the chances of a successful outcome.On a personal note, while reviewing the book I'd recall about cases where I had proceeded in a similar way as described in a few of the techniques presented. It was enlightening to know that other people were facing similar challenges, and reassuring that a specific strategy was actually a good idea, having successfully worked for others.

I've read the book twice by now. First when I was proofreading and now again after getting a physical copy. This book contains a lot of immediately applicable advice and some very valuable insights. It is the kind of book that would have helped me a lot as a beginning software engineer. Even now, as an engineer with a number of years of industry experience, I gained valuable insights while reading this book, and I feel I've expanded my set of engineering tools.Two things that stand out to me about this book are, 1) it teaches you a few almost data-mining like techniques for exploring complicated code and 2) a very important part of dealing with legacy code is empathy. You should think about the person who originally wrote the code and consider they might think it was good (at the time). You should also think about the next person who will work with the code and try to share your understanding.This book will teach you to approach legacy code differently and maybe even learn to enjoy untangling a complicated system. It also teaches you a number of techniques for sharing and persisting your knowledge and understanding.Whether you've dealt with legacy code in the past, are dealing with it now or will have to work with it in the future, this book will help you.

It is a very pleasant read. The examples do not feel contrived as often is the case in some similar books.I definitely enjoyed seeing some of the techniques I already use "validated" and especially enjoyed trying some of the new ones in the book.

If you follow Jonathan's blog, you already know that he write great and fluently ;)His book is yet another great addition to his collection.I managed to quickly apply his suggested techniques directly in my daily job.Most of our time, we all deal with Legacy code which makes such written well book an excellent resource for any software engineer.

I'm a data scientist consistently working on legacy code. This book has helped me in becoming more efficient when working with the codebase. It gives concrete advice about understanding code, with lots of examples.Highly recommend!