Programming

Rebuild from scratch gets a bad reputation sometimes because it's the go-to response of a junior programmer with a little experience. They know the system could be done better, and it seems like the fastest way to get there is to throw out everything.

What often happens next is the realization that the existing system was handling far more edge cases than it initially appears. You often discover these edge cases when the new system is deployed and someone complains about their use case breaking. As you fix each one, the new system starts to look worse than the old while supporting half its features.

This often leads people to prefer refactors rather than rewrites. Those can take a lot longer than expected and never quite shed what made the old system bad. Budget cuts can leave the whole project in a halfway state that's worse than if it was left alone.

There are no easy answers, and the industry has not solved this problem.

this is a big ol' "it depends"

if it's a hobby project, then by all means rewrite it if you want to.

if it's a commercial project of some kind - there's a business that's making money, and part of the business making money relies on this code working properly - then rewrites are almost always a bad idea.

read Things You Should Never Do, Part I, an almost 25-year-old blog post (man, that's a weird sentence to write) about why giant rewrites in a commercial setting are a bad idea.

in general, people greatly underestimate how much work is involved in a rewrite. it feels like it should be simpler to start from a blank slate, and tell yourself you're going to avoid all the mistakes that you hate with the existing codebase. maybe you're writing it in a new language, or at least a newer dialect/version of the same language.

if the current codebase is a mess...how did it get that way? lack of engineering discipline? a "just make it work now, we can go back and tidy it up later" attitude towards accumulation of tech debt? if those same attitudes are present on the team doing the rewrite, you're going to end up right back where you started after the rewrite is "done".

the main things you need for refactoring to be successful is a) tests, and b) a plan.

the tests allow you to refactor with the confidence that if you break something, the tests will point it out for you. trying to refactor something that lacks tests is the worst place to be in, because you'll want to add tests, and often adding tests requires refactoring the code to be more testable, placing you in a catch-22.

the plan allows you to make those refactoring changes gradually, over time, while still maintaining the system. in the context of a business that's paying developers to do this work, the businesspeople tend to look poorly on an engineer coming to them and saying "we're gonna spend the next year or two doing a big rewrite, so in the meantime you can't ask us for any new features or bugfixes to the existing system. but once it's done the new system will be really cool, trust me."

successful refactoring is a Ship of Thesus - you can replace the entire thing, but you have to do it one component at a time.

Refactoring is good work. Rewriting is shallow fun.

Do the math.

Exception: perl is write-only code. Always rewrite.

From a professional perspective I’d say: don’t rewrite if you’re unsure about it. Rewrite if there’s a particular problem you need to solve and a rewrite is the only way to do it.

For example, you need to make major changes in the tech stack. Like switching from PHP to NodeJS. This is difficult to do without a complete rewrite.

Rewrite for the sake of rewrite is usually a waste of time, and it’s not certain that the code will turn out better in the end. You might end up with a similarly convoluted system either way. And the worst part is: now you have two systems to maintain at the same time.

Likewise, refactor if there’s a particular problem you want to solve. Don’t refactor just for the sake of refactoring. If you don’t have a clear goal, then you’re just scrambling the code around.

From a hobbyist perspective: do whatever you feel like. A complete rewrite can be a good learning experience.

Responding as a java/kotlin maintainer of one single large system with frequent requirement changes. what i call "high entropy" programs. Other developers have different priorities and may answer differently based on what kind of system they work in, and their answers are also valid, but you do need to care about what kind of systems they work on when you decide whether or not to follow their advice.

In my experience, if the builder of the original system didn't care about maintainability, then it's probably faster to rewrite it.

Of course, then you'd have to be able to tell what maintainable code looks like, which is the tricky part, but includes things like,

• Interfaces
• Dependency injection
• Avoidance of static or const functions
• Avoidance of "indirect recursion" or what I call spaghetti jank that makes class internals really hard to understand.
• Class names indicate design patterns being used. Such as "Facade". This indicates that the original builder was doing some top-down software design in an effort to write maintainable code.
• Data has one, and only one, source of truth. A lot of refactoring pain comes from trying to align multiple sources of truth, since disgreements cause mayhem to the program state.

Bad signs:

• Oops, all concrete classes.
• Inheritance. You get one Base Class, and only one, before you should give the code the death glare. Its extremely difficult for a programmer to be able to tell a true "is a" relationship from a false one. For starters you have to have rock solid class definitions to start with. If the presence of Inheritance smells like the original builder was only using it to save time building the feature, burn it with fire! Its anti-maintainable.
• Too much organizing - you have to open 20 files to find out what one algorithm does. That's a sign that the original builder didn't know the difference between organizing for organizing sake and keeping code together that changes together.
• Too little organizing - the original builder shoved eveything into one God class so they could use a bunch of global variables. You'd probably have a hard time replacing a component so big. Also, it probably won't let you replace parts of itself - this style forces you to burn down the whole thing to make a change.
• Multiple sources of truth for data: classes that keep their own copies of data as member variables are a prime example of this kind of mistake.

Neither.

If you can code it in a week (1), start from scratch. You'll have a working prototype in a month, then can decide whether it was worth the effort.

If it's a larger codebase, start by splitting it into week-sized chunks (1), then try rewriting them one by one. Keep a good test coverage, linked to particular issues, and from time to time go over them to see what can be trimmed/deprecated.

Legible code should not require "reverse engineering", there should be comments linking to issues, use cases, an architecture overview, and so on. If you're lacking those, start there, no matter which path you pick.

(1) As a rule of thumb, starting from scratch you can expect a single person to write 1 clean line of code per minute on a good day. Keep those week-sized chunks between 1k and 10k lines, if you don't want nasty surprises.

Refactoring is always easier.

Both methods really need acceptance tests before you can start, but with refactoring you at least have a working system for the duration of development.