Infinite Reinvention

It’s really tempting to think you can redesign something and make it better. It’s worth a try, because you may actually succeed, or you may come to the realization that the thing you were trying to fix already solves countless problems you didn’t even consider.

I’ve been working on a JavaScript framework.

• Started as a response to things I find annoying in the design of React, which I use at work.
• Writing a complex app in the framework to test it in the real world.
• Rewrote and extended the basic idea many times as new needs arose.
• Got to the point where some things about the framework’s design annoyed me, and there were some major bugs in it, so I decided to start writing a second framework that fixes those things with a better design.
• Had a brief detour where we started rewriting the app from the ground up in the second framework.
• Realized how much work that would be a few days in, realized that most of this work was already done in the old framework and that new solutions to the problems were not necessarily better.
• Scrapped the rewrite, went back and fixed the bugs, and now we’re back on the path of finishing the app in the original framework.

Throughout this process I’ve struggled every time I’ve wanted to redesign something. Redesign is my typical reaction to encountering something I feel is less than perfect. Some redesigns have led to huge improvements in the framework, while some have been dead ends that got walked back after sanity returned. I find it hard to tell which one it is before exploring that path. It turns out one of two ways; either the redesign makes it back to the main branch, works out and then the app gets updated to work with the changes and things are better for it, or I get to a point where it just isn’t working and gets cancelled.

There have been so many revisions that I eventually started feeling guilty for deciding another was necessary, but I’ve now come to terms with the fact that this is the process. Failures are milestones on the path to success. If I never took a wrong turn at any point, I would have been stumbling toward success out of luck alone. The failed revisions making themselves known as wrong turns illustrates where the right turns were.

Programming is all about tradeoffs. React makes certain tradeoffs in order to gain certain advantages. Any framework that is better than React in one way is likely worse in another. And better and worse are subjective, so what feels right for one person or situation might feel wrong for another.

Lessons I’m learning:

• No framework is inherently better than any other when they solve the same problems in different ways.
• I have a cognitive bias toward starting over when something gets difficult to solve. It’s easy to forget all the problems that have already been solved when you’re focused on problems that haven’t.
• I have a huge amount of respect for all the time and effort that goes into making a framework. It’s so much more than you would think.