Steven Diamante gave a great presentation on Legacy Code at the Seattle Crafter meetup. Let's dive into it!
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.
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.
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 best learn out of refactoring exercises, depending on your level of experience.
A look into Catherine Hicks' white paper "It’s Like Coding in the Dark: The need for learning cultures within coding teams" (Catharsis Consulting).
Does your codebase feel like a tote bag of "shared" and "utils" folder? Git may help you find a better structure.
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 assistants like ChatGPT refactor existing code without introducing bugs? Let's figure it out with an actual codebase.
People are using tools like ChatGPT to write tests on existing code… But how reliable is this? Let's find out!
A pragmatic way for you to start automating deployments of a Legacy system.
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!
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.
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.
My recap of the most common and useful advice one can give to tackle Legacy codebases.
Watch Gregor Riegler refactor code with this coding exercise. Learn useful techniques from it.
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!
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.
4 great talks on Legacy Code that I had the pleasure to host. This edition particularly focuses on testing and refactoring.
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…
Some thoughts about refactoring and the opposite operation: defactoring.
A reflection on coaching, facts, and pragmatism. Which testing framework would I recommend to devs who are not familiar with testing?
5 great talks on Legacy Code that I had the pleasure to host. This edition raises new topic such as documentation and legacy pipelines.
How do you refactor a complex legacy application when you can't rely on automation tools?
4 great talks on Legacy Code that I had the pleasure to host. A focus on empathy and getting into complex codebases.
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.
You may have heard one or the others. Now you're confused: is there a difference? Nope! Let me explain…
My recipe for recovering from outdated dependencies and keeping healthy habits
5 great talks on Legacy Code that I had the pleasure to host. Learn how to prioritize Tech Debt and rewrite systems incrementally.
It seems necessary to start adding tests on this code… but what if it makes things worse?
When work looks trivial from the outside, but you know it will actually take much longer to do.
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.
Here's an interesting book on approaching Legacy Software. Here's my summary of its salient points.
Working on Legacy systems can be extremely beneficial to your career… If you can explain why it matters to the business!
5 great talks on Legacy Code that I had the pleasure to host. Learn how to progressively migrate existing codebase towards a better state.
This book is filled with practical strategies to apply on Legacy systems. Here's my summary of its salient points.
Should you plan time for refactoring during Sprints? Refactor before you release new features? After? Here's my suggestion…
A technique you can resort to when you need to make risky changes.
Should you write E2E tests to cover more cases faster? Or is there a better approach?
5 advice you can try when you feel paralyzed with a change that's too risky to merge, but too long to verify.
This book is full of tips to get into an unfamiliar codebase. Here's my summary of its salient points.
5 great talks on Legacy Code that I had the pleasure to host. Learn how to test existing code and approach unfamiliar codebases.
A personal story to illustrate how good habits can save your day when things turn bad.
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!
What you should be looking for to build a great and useful documentation.
Building the habit of small refactorings as you go will make a difference in the long run.
Learn to draw a Knowledge Map of your codebase within minutes, and find out who owns what!
Here's a technique that leverages how your brain works to make any code easier to work with.
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.
Working with Legacy Code is no fun… unless you know how to approach it and get your changes done, safely.
Is this the real code? Is this just fantasy? Let's discuss the problem with unit testing Legacy Code and an approach you can take.
How to come up with a plan that will resonate with non-technical people, in 7 concrete steps.
When you're stuck trying to understand some code, it pays off to spend some time with a different approach.
Code handovers are critical moments in the lifetime of a project. Make the most out of it with these advice.
You don't need fancy tools to start making a dent on a scary method. Simply take a step back.
You need to fix a bug, but you can't spend a week on it? Here's a technique to isolate problematic side-effects and write tests within minutes.
What's the best way to deal with these annoying global variables? Make them explicit.
With Legacy Code, there is never any good documentation. Hopefully, there's a simple way for you to stop that trend.
Finding a better name for a function is hard, especially when people have contradictory opinions on what a good name looks like…
Tips and advice on dealing with Legacy Code from 5 great speakers at this remote conference I organized for the community.
Here's a way to prioritize refactoring when you have to deal with a large, unmaintainable codebase.
If you worry that following clean code practices create more code to maintain, here's a way out.
Let's see how you end up with these while trying to refactor Legacy Code and what you can do about that.
And 4 ways to fix their usage in Legacy Code.
Feeling overwhelmed by your legacy codebase? These katas will help you learn how to tackle it.
Do you feel paralyzed, wondering how to approach a legacy codebase? Try to start from the system edges.
This book is a reference. Here's my summary of its salient points so you understand why it's so recommended.
If you think that management wouldn't let you refactor Legacy Code, use these 5 arguments to convince them.
When an application becomes impossible to maintain, a rewrite is very tempting. But it could make things worse.
And what you can do about it if you find yourself in such situation.
When a codebase is large and complex, it's risky to big changes. Here's a structured way to approach the problem.
Here's a recipe you can follow when you want to add tests on Legacy Code, but you don't have much time to do so.
Here's a useful definition of "Legacy Code" you can refer to.