In my early days of programming, things began with realizing that I could use this wonderfully powerful system to solve problems (almost any problem you could m

In my early days of programming, things began with realizing that I could use this wonderfully powerful system to solve problems (almost any problem you could model!) and create things (almost anything you could want to simulate!). I just had to figure out how to model the domain problem logically in a useful way, or what aspects of something to simulate, and how to allow the user to interact with it. That soon changed. In learning about programming, one can't help but to come across the writings of those preaching the gospel of the holy virtues of 'reusable code'. Modular code, libraries, object-oriented code, design patterns, frameworks, plugins, APIs, services, stacks and toolchains! So programming is now largely about resolving a ton of dependency issues and getting scores of different modules, frameworks, libraries, APIs, etc. to play nicely with each other. Instead of using our brainpower to understand and model the domain problems that are ostensibly the reason for our software, we're using it trying to figure out how the heck to glom together all this generic abstract code and modify the output to vaguely resemble something in the domain, in a way that won't perform so horrendously that customers immediately give up on it. We write hooks, overrides, and underrides to throw out the work that the reusable code is doing and get it to do what we want (more-or-less). We write translation and adaptation and bridge layers to convert the data structures used by one module to those used by another (and vice-versa) and eventually to something roughly approximating the domain data. We set up elaborate clusters of interdependent modules, submodules, plugins for our plugins, all on top of a generic framework that wasn't even designed with the domain in mind. As a profession, we've gone way too overboard trying to do everything with reusable code. This is why it can take several hours to do something as simple as change a link (and that can completely break something seemingly-unrelated elsewhere in the system). And it's kind of amusing that we're now adding layers of complexity to manage the layers of complexity. I want to get back to focusing on building logical models that fit the domain, solving problems, and simulating things. For that we need a new doctrine of vertical development that doesn't just religiously say "Throw another layer of indirection and generic abstraction on it! Yay reusable code!" as a sacred solution for everything. Sure, code reuse can be good, but let's be sensible about it, not kid-in-a-candy-store crazy.