EDIT: yes, it is. He has a very important point there. I recently went on Twitch to see what young devs where coding. One (rather smart, I must say) young lady was creating a simple sign in/sign up page, but there's a twist: with React. Upon me asking, why wouldn't she just code it in plain HTML, she responded with a question: "but how would it connect to the API?". So there you go, ladies and gentlemen. I don't really know what to do about it, but I don't believe we're a bunch of old men yelling at a cloud (quite literally - AT A CLOUD), especially that I don't think we're that old.
Seriously, it's okay that people don't know the ins and outs of every little detail. Abstractions are useful, until they're not. And then when they're not, you go figure out the level below.
Even the most advanced, most skilled front-end devs spend 99.99% of their time not caring that the browser loads an HTML page.
If I may, a truly similar experience regarding keyboards would be this:
I had a similar experience with a coworker. When I asked him how the code that he types appears on the IDE on his screen and not on that of any of our colleagues' screens, all I got was confused looks. When I showed him that his keyboard is wirelessly connected only to his computer, which runs the IDE, and his computer is then specifically connected to his own monitor via a cable, his mind was blown.
Sometimes it becomes necessary to know how the level below works. That doesn’t mean it’s a requirement to be affective at the level above.
Not necessarily, but it did have a material effect in the original example. A web developer drug in a complex, unnecessary framework because she didn't realize that HTML forms have the ability to submit post and get data natively.
To me that's like a civil engineer building a suspension bridge over a tiny creek because they never heard of an arch design.
You're making a massive assumption that she didn't already need to use React and may have been confused at how she would make the two systems work together correctly.
So that's what's really troubled me. The companies responsible for producing this piece of garbage are actually getting into the heads of the younger generation, rendering them helpless without said garbage. I repeat, this is indeed garbage, especially React: in early 2000s we used to laugh at people mixing JavaScript and HTML, but some of them, apparently, decided it was their time to strike back.
The more important issue is, of course, that we have a generation of young people working with these "tools" which isolate them from learning things that actually matter. These levels of abstraction DO NOT add any value. These are "cargo cults" of abstractions, which without their authors knowledge (because those who invented them weren't very smart anyway) serve the purpose of keeping potentially talented and intelligent people ignorant and average. This is probably good news for somebody out there, but certainly not for us as a society.
Man I think you're thinking wayyyyy to deep into stuff.
I would add that even good old, rock solid assembler isn't a straight entry point into controlling the CPU, but is now just an abstraction over µOPs. Abstractions surround us these days, and for each of us, we find differing levels of what's tolerable vs what should be known about the next layer below.
I'm personally (kinda) ok with not knowing too much about the sub-assembler processes that happen inside the literal black box called a CPU, but I know that for branch optimisation, it's important.
* Why does a key appear on the screen when I push a button on my keyboard: no
* How is an HTTPS connection created: generally no
* How is the JavaScript library deployed: 100% yes
You might be able to throw something together that works without understanding that it is a JavaScript library with a bootstrap HTML page but if no one on your team understand that you will eventually need to find someone that does to solve a problem.
I would think that people doing web development probably benefit from a working knowledge of DNS, TLS, and PKI. Without those, I would expect a lot of readily avoidable problems with HTTPS.
In general I advocate that software engineers should have a functional, if abstract, understanding of how computers work on various levels. They might not need a detailed understanding, but people often benefit in unexpected ways from understanding the systems they work with.
[1] Not like they literally don’t know but that their code has no interaction with it.
How can she not be curious, Angular is so wrong and magical, it blows the mind to understand how it builds all that magic. Maybe your sister in law is the kind of persons who laughs at magic tricks ? I d be raging mad myself, I prefer to avoid them or Ill just be obsessed until I understand them
So yes, maybe being able to implement a form tag in HTML is the mark of a senior dev.
The accessibility issue is, of course, a solid counter-argument to running too far with that line of reasoning, and is part of why I'd much rather we put 1/10 the effort we do to constantly re-implementing basic HTML features into unfucking HTML standardization so we can finally have elements good-enough that we don't need to pile JS on top to get what ought to be built-in functionality. But, that's a whole different skillset from programming, and requires far more organization than thousands of devs all independently, or in small teams, working on yet another NIH version of an image upload input. :-/
System programming also has its warts, but at least most of the time you don't feel like you're working against the machine.
Suddenly she needs to change stuff on both backend and frontend, and she might only be allowed to touch one of those ends.
[1]: https://m.signalvnoise.com/integrated-systems-for-integrated...
In this case though, I believe she isn't confused as to how to call the APIs, maybe not even as to how to handle the response with JS and update the DOM. I think the question sounded more like you're not allowed to use Javascript at all.
Thinking React is essential to make an API call is a bit scary, but a future where we just click a few buttons and connect to a hot reloading syncing dev env with all the dependencies and transpiles obfuscated, seem inevitable, and it will be so reliable that we forget or never even learn how it works under the hood.
I don't think that being "in the cloud" makes abstraction that much more pronounced. You can have manually configure dev VMs in the cloud or automatically configured dev VMs locally, the later will probably use more abstraction.
I'm working on it: https://github.com/cheatcode/joystick.
The tl;dr is that I'm offering a full-stack framework that takes advantage of vanilla JavaScript and HTML in a front-end framework combined with a plain ol' HTTP back-end using Node.js. The APIs abstract just enough to make you productive but not so much that you can't reason about how it'd work without the framework.
The long shot of the project being to keep the mental model of "how the web works" intact while reducing the burden of doing everything from scratch.
It's an unpopular opinion, but I view TypeScript in the same light as I do the OPs assertion about cloud-only development. It's adding yet-another-layer that has some merits but often leads to overcomplicated messes that reduce productivity/add confusion.
I'd rather petition for some sort of structs/arg typing to be included in ECMAScript proper (in a similar fashion as to what happened with a lot of Jon Resig's jQuery DOM selection APIs making their way into ES6).
At least Android and iOS taking over the consumer computing world has given me job security until I retire!
The video is great too; I hadn’t seen that before, and it gives some examples of what happens when that generational transfer of knowledge is not carried out, not just within a discipline but also across a civilization.
"Brevity is for the weak." - Maciej Cegłowski
I am sure one can find good and efficient devs that know very little about the underlying system and are very capable of using the available abstractions and frameworks. I just happen to find the first group better.
In effect, you're giving a third-party absolute control over your code and your ability to work on it. You're also disconnecting the developer's mental model of how all of this stuff works (arguably why there's so much bad code floating around). Eventually, that will devolve to people not knowing how any of this works and the industry will collapse.
It's an abstract line of argumentation related to this, but Jonathan Blow nailed it on this idea a few years back: https://www.youtube.com/watch?v=pW-SOdj4Kkk