I built a visual tool for the Mikado Method
The Mikado Method helps you tackle big changes safely. But drawing graphs on paper doesn't scale. I couldn't find a satisfying tool… so I built one: Nikado.
Understand Legacy Code
Change Messy Software Without Breaking It
Latest posts
The Legacy Code Survival Guide: Add Features Without Fear
Steven Diamante gave a great presentation on Legacy Code at the Seattle Crafter meetup. Let's dive into it!
The key points of Refactoring at Scale
Maude Lemaire wrote a great book rooted from her experience in the trenches, at Slack. Let's see how it may help you lead large-scale refactoring projects.
The key points of Refactoring
This book is a catalog of the bread-and-butter moves that can improve your coding game. Let's see what makes it a reference for any professional developer.
The key points of Kill It with Fire
Let's rewrite the whole thing on a modern stack! Or should we? Marianne Bellotti offers a lot of wisdom in her book. Here are some examples…
How to efficiently practice refactoring katas
How to best learn out of refactoring exercises, depending on your level of experience.
It's like coding in the dark!
A look into Catherine Hicks' white paper "It’s Like Coding in the Dark: The need for learning cultures within coding teams" (Catharsis Consulting).
Find how to (re)organize code with git
Does your codebase feel like a tote bag of "shared" and "utils" folder? Git may help you find a better structure.
Delete unused code (and how to retrieve it)
Dead code adds noise to the codebase and should be deleted. Yet, deleted code feels harder to retrieve. Here's how to find such code easily with git!
Can AI help me refactor legacy code?
Can assistants like ChatGPT refactor existing code without introducing bugs? Let's figure it out with an actual codebase.
Can AI help me write tests on legacy code?
People are using tools like ChatGPT to write tests on existing code… But how reliable is this? Let's find out!
Fake it until you automate it
A pragmatic way for you to start automating deployments of a Legacy system.
Comparing 2 approaches of refactoring untested code
You need to change code that's not tested. How do you know you didn't break something? Let's compare 2 ways of doing that!
Another way of refactoring untested code
You need to change code that's not tested. How do you know you didn't break something? Here is ANOTHER concrete way to tackle the problem.
One way of refactoring untested code
You need to change code that's not tested. How do you know you didn't break something? Here is one concrete way to tackle the problem.
7 advice to help you inherit a legacy codebase
My recap of the most common and useful advice one can give to tackle Legacy codebases.
Improve your refactoring and testing skills with the Expense Report kata
Watch Gregor Riegler refactor code with this coding exercise. Learn useful techniques from it.
3 must-watch talks on Legacy Code
I have hosted more than 37 speakers to talk about Legacy Code tips and tricks. Here is my top 3 of the talks you should probably watch!
The key points of The Programmer's Brain
This book analyses how your brain works and gives concrete advice to help you work with Legacy Code. Here's my summary of its salient points.
Testability, Empathy, and Safe Refactorings
4 great talks on Legacy Code that I had the pleasure to host. This edition particularly focuses on testing and refactoring.
Can AI-based test generation help you test Legacy Code?
I experimented with tools that can generate tests for you, leveraging AI. Here is what I learned, along with some thoughts about testing unfamiliar code…
Refactoring vs. Defactoring
Some thoughts about refactoring and the opposite operation: defactoring.
What unit test tool should I bring to my JavaScript team?
A reflection on coaching, facts, and pragmatism. Which testing framework would I recommend to devs who are not familiar with testing?
DevOps, Living Documentation, and Hexagonal Architecture
5 great talks on Legacy Code that I had the pleasure to host. This edition raises new topic such as documentation and legacy pipelines.
4 tips to refactor a complex legacy app without automation tools
How do you refactor a complex legacy application when you can't rely on automation tools?
Design Patterns, Empathy, and Reading Complex Code
4 great talks on Legacy Code that I had the pleasure to host. A focus on empathy and getting into complex codebases.
Should we stick to old patterns or sacrifice consistency?
Consistency is great! But over time, it's hard to keep a codebase consistent. Here's my approach to adopt changes without creating a mess.
What's the difference between Regression Tests, Characterization Tests, and Approval Tests?
You may have heard one or the others. Now you're confused: is there a difference? Nope! Let me explain…
Keeping dependencies up-to-date
My recipe for recovering from outdated dependencies and keeping healthy habits
Technical Debt, Rewrites, and Refactoring
5 great talks on Legacy Code that I had the pleasure to host. Learn how to prioritize Tech Debt and rewrite systems incrementally.
Is it OK to change code for the sake of testing?
It seems necessary to start adding tests on this code… but what if it makes things worse?
How to tell your client how bad their codebase is?
When work looks trivial from the outside, but you know it will actually take much longer to do.
Safely restructure your codebase with Dependency Graphs
Even drawing them by hand can help you make sense of a tangled codebase! Let's see how they can help, and what tools you can use to generate these.
The key points of Re-Engineering Legacy Software
Here's an interesting book on approaching Legacy Software. Here's my summary of its salient points.
Does refactoring Legacy Code pay off in your career?
Working on Legacy systems can be extremely beneficial to your career… If you can explain why it matters to the business!
Refactoring, Unit Tests, and Symmathesy
5 great talks on Legacy Code that I had the pleasure to host. Learn how to progressively migrate existing codebase towards a better state.
The key points of Beyond Legacy Code
This book is filled with practical strategies to apply on Legacy systems. Here's my summary of its salient points.
When is it the best time to refactor?
Should you plan time for refactoring during Sprints? Refactor before you release new features? After? Here's my suggestion…
Work faster and safer on untested code with Overcommitting
A technique you can resort to when you need to make risky changes.
The best way to start testing untested code
Should you write E2E tests to cover more cases faster? Or is there a better approach?
What you can do when code is really hard to review
5 advice you can try when you feel paralyzed with a change that's too risky to merge, but too long to verify.
The key points of The Legacy Code Programmer's Toolbox
This book is full of tips to get into an unfamiliar codebase. Here's my summary of its salient points.
Approval Tests, TCR, and Menders
5 great talks on Legacy Code that I had the pleasure to host. Learn how to test existing code and approach unfamiliar codebases.
When should you stop refactoring Legacy Code?
A personal story to illustrate how good habits can save your day when things turn bad.
4 developers working their way through Legacy Code
Practice working with code you've never seen before helps make it easier. Here's my selection of videos that will expose you to seasoned developers doing that!
Where should you put the documentation?
What you should be looking for to build a great and useful documentation.
Start cleaning your Legacy codebase with The Daily Refactoring Hour
Building the habit of small refactorings as you go will make a difference in the long run.
Identify who to ask for help with Knowledge Maps
Learn to draw a Knowledge Map of your codebase within minutes, and find out who owns what!
Quickly improve code readability with Proximity Refactorings
Here's a technique that leverages how your brain works to make any code easier to work with.
The key points of Software Design X-Rays
This book is a gold mine. Yet, it's not a famous one. Here's my summary of its salient points that can help you deal with large codebases.