There’s a pull in the software world towards re-use, and this is (mainly) a good thing: We use a third-party library, rather than re-inventing something that the library does. We pick a framework for larger features, services and layers that we need in our work, rather than building them from the ground up.
In general, this saves time and reduces the number of bugs we need to iron out. I still think it is usually the way to go.
However, I also think that we should re-invent wheels occasionally: Not use a library, re-build something from scratch… for the hell of it, so we understand the feature we would otherwise just have re-used, so we gain a better knowledge of the area the framework “just handles” for us. The additional work often leads to a better understanding and so, sometimes, I think it’s worthwhile.
In a previous job of mine, we used to ask interviewees “How would you design a web server?”. Our reason for this was that it demonstrated knowledge of basic HTTP, and an understanding of the kinds of issues you might encounter when using an existing web server. That “under the bonnet” knowledge is often useful, even if we never expected anyone to need to build the thing from scratch.
It appears that what I’ve ended up with is a very usable framework, which does some things the others don’t (or at least does them in a way that I prefer). I’ll be using it for my own app, even if it otherwise never sees the light of day as a framework in itself. So perhaps the additional unintended consequence of reinventing wheels is that, just occasionally, you end up with a better wheel in the end.
I suppose that progress never occurs unless people dare to reinvent wheels occasionally, and it requires the audacity to do it anyway, even when intuition tells us not to.