Does the software industry learn?

The problem is not with developers, it's in crappy foundational computing layers.

NPM is somewhat the result of JavaScript itself being so bare bones. The cost of this community-based pseudo standard library is enormous: fragile, insecure, unstable. This doesn't mean we have to drop it, it means perhaps we do need a JavaScript standard library. Possibly mixed with NPM vendor packages that take responsibility of large clusters of functionality as a single dependency that is maintained over time.

Almost all software now requires very frequent security updates and we even dispose physical products like smartphones because they no longer get security updates. Instead of accepting this reality, why is nobody working on a foundational software stack that isn't this damn insecure to begin with?

Almost all websites on the web do not meet accessibility standards. And then we beat developers over the head in needing to learn proper accessibility best practices. Which doesn't work. Progress is near zero. So we might as well ask: why are our tools so primitive and bad, why do they not lead to accessible UX by default?

We complain about performance, or the lack thereof. But the problem is mostly in the stack itself, crappy and slow abstraction layers.

I could go on, but I hope you catch my drift. In development, you need to take the lowest common denominator. An average "bread programmer". We expect this person to personally dodge the many gaps in our crappy computing layers and it's far too easy to go wrong. This single individual is expected to be a top engineer, architect, security expert, performance expert, accessibility expert, and so on. And they also need to ship tomorrow.

We basically expect 28 million software developers to all be super heroes. They're not, they keep making the same mistakes not because they suck, instead because we have computing layers that suck. No amount of "awareness" will fix that.

People in our industry need to know how to make the fundamentals from almost-scratch. In electronic engineering I learned how to bias transistors and build RC-filters. Heck, in chemistry class we even learned how diodes and resistors are made. When I studied music I learned scales, chords and rhythm... why should I, if I could just download some WAV loop off the internet, or sample some old song?

I don't see why software has to be special. Haven't we commoditised the profession enough?

And why are moving to apps that only work online? Networks are slow compared to desktops. Programming seems to be the art of doing the worst thing possible. Our computers are getting faster and faster, but we're relying on communications that are vastly slower.

And another thing: Windows updates, or even Firefox for that matter. Software shouldn't be so full of problems that you need to constantly update it. Just update it every 2 years. Sure, you get the supposed latest and greatest, but updates are a messy process.

Perhaps the difference between programming and "real" engineering is this: parsimony. In engineering, you have to do more with less. In programming, the attitude seems to be to shovel more spaghetti onto the plate.

Update: I'll add a further point. It's not just parsimony, it's also cost of errors. In physical products, a flawed design that makes it into production is costly. So you have to get it right. With software, you can afford a slap-dash approach. And that's what we see.

So, disclaimer, I am new to Typescript-NodeJS and the npm world but have a significant background in the JVM / Spring backend world with Kotlin and Java. I am also too young to be this cynic but I am honestly just baffled.

To me the entire NodeJS backend movement seems like they are "Java sucks!" hipsters jumping into the trendy JavaScript ecosystem of the modern web era just to show how cool and progressive they are (???) - all while rediscovering and reinventing backend features that have been invented and in widespread and battle-hardened use for 2-3 decades now.

Wow we are using NestJS, Jest, annotations, a dependency injection module and Typescript... congrats, you just rediscovered type systems, mocking, Maven and Spring Boot as they are very handy for backend development.

All while bloating your fresh hip ecosystem to an even uglier Frankenstein monster than you can find anywhere in the Java enterprise, transpiling back and forth with 10,000 config files to make framework XYZ interact with each other.

And then, JavaScript is running underneath with all its limitations and quirks that will reach feature parity with Kotlin with ES2048. But yea, I guess now you can send JSON natively between systems because it's first-class.