As a developer who likes to build new things and enjoys facing new challenges, I have a strong bias toward building new software rather than maintaining software that has been around for a couple of years or longer. A fresh start means a lot of things like being able to adopt new standards and tools, not having technical debt and not dealing with existing bugs or poorly written code. The bias is especially strong when the codebase is not my own. For this reason, I find it difficult to make the argument for maintaining a project that is due for a major upgrade.

Since the JavaScript ecosystem is constantly changing it can be hard to keep up. A lot of what's new is just noise but buried within that noise is the promise of innovation and radical improvements to how you write code. Unfortunately, you don't always know the difference between the good and the bad until you've tried it, and trying things takes time.

This brings out the pragmatist in me and the pragmatist acknowledges that code is a cycle of consumption. Like a box of cereal on a grocery store shelf it has a "best by" date. Eventually it become stale.

Code is more ephemeral and less permanent than I used to think. Change happens so fast in the world of technology and it's like it's just part of the natural progression. If you don't adopt change you get left behind and the whole process of becoming out-dated happens faster than it did 10 years ago. The cycle is shorter now than ever.

This is what I've come to expect from the web development industry.

It would be different if code was written in vacuum, but it's not. Much of modern code has dependencies. When I started writing code, I shunned dependencies. I avoided frameworks. I wanted to keep things simple and pure. Then I realized to make anything meaningful I had to adopt tools created by other people. Now instead of having zero dependencies I aim to have few dependencies, but even this is misleading when I realize that even when I have a few dependencies, they each have their own dependencies, and those dependencies have their own dependencies.

It's the cycle of continuous change that might be the biggest motivator behind my drive to rebuild rather than maintain an existing codebase. Optimistically, I want to believe that it's about making a better tomorrow, but in the shadow of my optimism lies the thought that all my efforts are to simply not drown under the rising tide of progress.