The interesting bit is that these people are often very eloquent and convincing in making others believe that they have an objectively better way to program, and that this is THE way to advance in the field, and not just some elaborate game created to stave off boredom. Never mind the fact that you're still just doing things like validating phone numbers and moving buttons slightly to the right. This is nothing less than the future of computer science!
So you end up with a herd effect where greener or less-capable developers follow these "thought leaders" blindly, resulting in the fragmentation we're in now. I find it interesting how "Five Whys" has made its way into dev culture as a line of questioning for business requirements, but never for tech requirements. "It's getting more and more popular every day," or, "It's going to look great on your resume," is often the end of the discussion.
This is the often-forgotten cost of competition (for all its merits) as opposed to cooperation: it wastes time and energy.
I do not buy that this is a problem. It's not an apples-to-apples comparison, but anyone can publish a 'book' on Amazon as easily as publishing an NPM module (and they do), however, no one is complaining that there are "too many low quality books". Why is it easy to ignore books but harder to ignore shitty projects? Similarly there are countless instances of bad poetry online, and very bad fan-fiction, but the sky isn't falling in the literary world. Can someone educate me: why do other people's shitty software projects elicit such strong reactions?
They also don't purport to solve a specific problem. (Like left-pad.)
And they're not boosted by a FOSS ideology which their existence a political choice and not just a practical issue.
So basically interdependence. You need at least some external code to finish most projects, and the chances are good it will be somewhere between overcomplicated, unreliable, poorly documented, poorly maintained, and unnecessary.
Maybe package managers need active best-of-breed curation and industry-wide coding and documentation standards. But professional standards are anathema to the move-fast-and-break-things crowd, so I doubt that will ever happen.
If you want to make a comparison you can equate things to hardware where things like quality control and yield is instrumental. If you buy a plastic case that after a year self-disintegrates because while it looked the same it wasn't manufactured to spec. When this could potentially happen to every part of your device this quickly becomes annoying.
Yet, this is how software is all the time and is further worsened by a lack of due diligence and quality control. How many developers can get the time to properly verify a technology or library. Not to speak of if it's even fair to expect developers to be able to reach those conclusions.
1: http://www.nature.com/news/there-are-fewer-microbes-out-ther...
Now I can assemble a website that works everywhere and has best practices, by expressing exactly what I want in high level code. When modeling a new app or talking to our developers about architecture, we can use a common language of users, communities, streams, access, realtime pushes and offline notifications etc. People know what I mean when I say "the Patients/account streams should be published by the community and have Patients/photo stream templates for the admin role, related to Patients/gallery category stream published by the logged-in user."
Everything is namespaced, reusable, interoperable and works on every device. It took a long time to make the system but now we can assemble apps like out of building blocks, and have anyone work on anything and know what the conventions are. So yeah, it's paid off!!
Now I have some choices: allow javascript in order to read plain text, or ignore your web framework.
Guess which one I picked.
It sort of succeeded, but only at the data structure layer. Perhaps the high point of reuse is npm-style dependency-orientated programming, where people really do reuse tiny functions like leftpad(). But it's not stable. Because nobody is interested in providing that stability, and there's no money in it. There can't possibly be, because nobody will pay for tiny software components like leftpad. The market doesn't exist.
You can't second-source leftpad(), and that makes it possible for one person to break a lot of random builds across the world.
But what is simple, really? Let's look at some past experiences:
1. At a very first gig, when I was doing my very little first steps in this software thing, I had to build a website prototype. Pure static html pages inside a folder, that were linked to each other, didn't need to deploy, it was just a demo. It didn't use CSS. It didn't use a template engine. Really simple. But, every change was a PITA, because the website had a header, so every change, meant you had to open the file, and rewrite the whole header... in all files, manually!
2. In another moment of my past, I had to do some changes in an app was built with JQuery. JQuery is a library, but it's pretty simple. Select dom elements, and apply changes and hook events up. Simple.
Only, following and understanding the flow of the app was hard as hell. Each page had a lot of code and it wasn't obvious at all what was happening. Complex transformations of the dom were daunting. Small changes would break in intractable ways.
3. PL/SQL Stored procedures + tables. Pure SQL + structured programming is simpler than objects, and way simpler than using ORMS. Of course we had no tests, so less stuff to look at. I'm not even going to describe the downsides because you all people surely know that.
My point is, let's always look at the other side of things, and really weight at all the tradeoffs. I get what you mean but when I read a line like:
> I want to get back to focusing on building logical models that fit the domain, solving problems, and simulating things.
I feel that it's really a little _naive_. I mean, of course you focus on that kind of things. You need to work on backend, solving some kind of problems. But in some other problems, like for example, visual interfaces, you better be reusing shit.
I'm not entirely against code reuse, sure, reuse bits like visual interface if they fit, but the idea that it can solve everything by just sticking existing bits together is a false lead. It takes much longer than expected and it makes an unmaintainable mess.
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.