The Legacy Code Programmer's Toolbox
Last updated on 2019-01-31
About the Book
The Legacy Code Programmer's Toolbox is a guide for professionals that have to work with legacy code.
Working with legacy code is challenging. However legacy code is everywhere, and this is what many developers have to work with to create value.
This book will show you how to deal with legacy code efficiently and with a positive approach: how to be in a motivated mindset, how to understand the code, reduce the size of long functions, and how you can even turn legacy code to your advantage to learn how to improve your programming skills.
You'll see the power of knowledge to be effective with legacy code as well as how to have you and every member of your team acquire this precious knowledge.It will teach you efficient ways to work as an individual as well as how to collaborate with your teammates to work effectively with legacy code.
Finally, this book will show you how you can skip to the places of the codebase where you can create the most value. You will learn how to find the source of a bug quickly in a codebase even if you don't know a lot of it, and where to target your refactoring efforts so that they make a difference.
About the Author
Reader Testimonials
Kate Gregory
"The material will leave you ready to take on whatever legacy code you encounter"
This is a warm and reassuring book that will equip you to read, understand, and update legacy code in any language. The advice is immediately actionable, and you can start to use it right after reading the chapters. The experience of the author is clearly hard-won; he generously shares it to save you a lot of trouble. The material will leave you ready to take on whatever legacy code you encounter, with a smile on your face. I happily endorse it.
Bartłomiej Filipek
"Tools to make your daily job much fun and rewarding"
Let's face it - legacy code is everywhere! We can complain or... make it our friend. And this is excatly what Jonathan is offering is his book. With a vivid language, lots of examples and use cases the text will shift your attitude towards legacy code. You'll be equipped with a lot of tools to make your daily job much fun and rewarding.
Arne Mertz
"A great read for everyone"
The Legacy Code Programmer's Toolbox gives actionable advice about how to deal with the sometimes harsh reality of our work. You'll learn how to understand and when to refactor legacy code, and what attitude keeps you sane and productive when facing legacy code. This book is a great read for everyone: Junior developers wondering what is coming for them and how to face it, and seniors still wondering what could have been done differently when that old project came to a screeching halt.
Rainer Grimm
"A unique book about our day to day life as a professional software developer"
Wow! I read the book in one day. For two reasons. First, it is quite entertaining. Second, it is even more enlightening. Jonathan Boccara wrote a unique book about our day to day life as a professional software developer: Working with legacy code. He shows with many examples, how we should approach, understand, and improve legacy code if necessary. You should read it, because Jonathan's book will give you new, critical insight.
Victor Ciura
"My top recommendation on the subject"
As I read Jonathan's book I found a lot of comfort knowing that it will be a lot easier for many developers coping with understanding & working with legacy code. The book helps you get in the right mindset to deal with legacy code and explores various techniques and tools to help you along the way, with lots of carefully crafted code examples. I enjoyed this book a lot and learned some handy tricks along the way. "Jonathan's toolbox" just became my top recommendation on this subject.
Table of Contents
-
- Foreword
- Acknowledgments
-
Introduction: There is a lot of legacy, out there
- Legacy code
- You didn’t become a developer for this
- There is a lot of legacy, out there
-
Part I: Approaching legacy code
-
Chapter 1: The right attitude to deal with legacy code
- The natural reaction: who the f*** wrote this
- A humble view of legacy code
- The efficient approach: taking ownership
- Having a role model
-
Chapter 2: How to use bad code to learn how to write great code
- Don’t like the code? Elaborate, please.
- The vaccine against bad code is bad code
- Be aware of what good code looks like
-
Chapter 3: Why reading good code is important (and where to find it)
- The importance of reading good code
- Where to find good code
- Become more efficient with legacy code
-
Chapter 1: The right attitude to deal with legacy code
-
Part II: 10 techniques to understand legacy code
-
Chapter 4: 3 techniques to get an overview of the code
- 1) Choosing a stronghold
- 2) Starting from the inputs and outputs of the program (and how to find them)
- 3) Analysing well-chosen stacks
-
Chapter 5: 4 techniques to become a code speed-reader
- 1) Working your way backwards from the function’s outputs
- 2) Identifying the terms that occur frequently
- 3) Filtering on control flow
- 4) Distinguishing the main action of the function
-
Chapter 6: 3 techniques to understand code in detail
- 1) Using “practice” functions to improve your code-reading skills
- 2) Decoupling the code
- 3) Teaming up with other humans
- It gets easier with practice
-
Chapter 4: 3 techniques to get an overview of the code
-
Part III: Knowledge
-
Chapter 7: Knowledge is Power
- Where did the knowledge go?
-
Chapter 8: How to make knowledge flow in your team
- Writing precious documentation
- Telling your tales: acquiring knowledge in Eager mode
- Knowing who to ask: getting knowledge in Lazy mode
- Pair-programming and mob-programming
- External sources of knowledge
- Make the knowledge flow
-
Chapter 9: The Dailies: knowledge injected in regular doses
- What are Dailies?
- Monthly sessions
- The major benefits of Dailies
- There is plenty of content out there
- Be the one who spread knowledge
-
Chapter 7: Knowledge is Power
-
Part IV: Cutting through legacy code
-
Chapter 10: How to find the source of a bug without knowing a lot of code
- The slowest way to find the source of a bug
- The quickest way to find the source of a bug
- A binary search for the root cause of a bug
- A case study
-
Chapter 11: The Harmonica School: A case study in diagnosing a bug quickly in an unfamiliar code base
- Lesson subscriptions
- Let’s find the source of that bug, quickly
- The more time you spend in the application, the less total time you spend debugging
-
Chapter 12: What to fix and what not to fix in a legacy codebase
- Legacy code is a bully
- The value-based approach (a.k.a. “Hit it where it hurts”)
- Where does it hurt?
- Use the value-based approach
-
Chapter 13: 5 refactoring techniques to make long functions shorter
- The birth of a Behemoth
- Identifying units of behaviour
-
1) Extract
forloops - 2) Extract intensive uses of the same object
-
3) Raise the level of abstraction in unbalanced
ifstatements - 4) Lump up pieces of data that stick together
- 5) Follow the hints in the layout of the code
- 6) Bonus: using your IDE to hide code
- The impact on performance
-
Conclusion: The legacy of tomorrow
- The bigger picture of writing code
- How to deal with legacy code
- But you’re also person A
- Parting words
- References
-
Chapter 10: How to find the source of a bug without knowing a lot of code
- Notes
The Leanpub 45-day 100% Happiness Guarantee
Within 45 days of purchase you can get a 100% refund on any Leanpub purchase, in two clicks.
See full terms...
