Thankfully I found a good mentor who helped steer me away from all the terrible specifics and trying to learn the full stack and only learning what I needed
Not "perfect" but sure its good
If I made a chart like this one, I would take out CSS preprocessor section completely, replace the whole Build Tools section with "create-react-app", remove PropTypes and Flow in favor of TypeScript, move the State Management into a separate de-emphasized chart, and a bunch more.
Then you add the fact that learning something similar to what you already know is much easier than going from scratch (eg: learning a state management pattern/library if you already know another is much easier than if you have no experience with them).
You're totally right that learning everything up front is a waste of time, but you do need SOME foundation, especially as more and more people enter the market and you start competing with candidates (the days of infinite entry level positions are coming to an end, if they ever existed). That map looks like it's a lot, but it really isn't, especially if you think of it as "things you should have cursory knowledge of" rather than "things you should be expert in". Eg: I've never built a production app with the CSS libraries mentioned (even Bootstrap I've only used in throwaway projects for a few hours), but I've taken a peek at the doc of most of them, so I at least know where to start if it's ever necessary.
My family doctor constantly has to learn about new things, but he needs to have a basic foundation so he doesn't have to learn everything every time a new patient comes in the door. If he did, I'd go see someone else.
Still I totally agree that getting paralyzed is a big problem, it's way better to program something "the wrong/inefficient/bad way" rather than to program nothing. A big part of my learning and growth as a programmer has come from coding something terribly, realizing "hey, this kinda sucks, I bet there is a better way to do this.." and googling a bit until I learn a new/better method of doing X.
I'd argue that this depends on the situation. If you're writing code that needs to meet a deadline but also needs to be supported months/years from now, there are considerations and the possibility that you'd have been better off not writing the code before learning about at least the reasonining behind the existing alternative
Still, I'm with you on GTD being my personal preference in most situations.
I saved a few brain cells by not bothering with GWT, CoffeeScript, mootools, YUI, prototype...
It's OK to have skipped CoffeeScript, but you don't want to skip TypeScript in 2018. The past couple of years have been good as it has increasingly harmonized with ES6.
Not everything on the web has to use the normal stacks. I used TypeScript in the past but didn't enjoy the complexity of most JS libs, even with typings. Clojure was a breath of fresh air, and still is.
No thanks :D
GWT was a solid platform for quite a large number of years, and is still used in quite a large number of enterprises. Also, there are a lot of good ideas in there that the JS community is only just catching up to, like dead code elimination.
A lot of modern javascript/typescript syntax is inspired by CoffeeScript. And CS is so trivially easy to learn that "saved a few brain cells" sounds like intellectual laziness.
There's a fair argument to be made for not jumping on the bleeding edge. But your examples are all mature technologies that had good solid lifespans during which people used them to build successful products. If those are fads to you, I'm guessing you must still do most of your work in C?
I'm not saying that job offers requiring e.g. coffeescript don't exist, I'm asking how much more likely you are to find a job that suits you because you know coffeescript?
Since 1993, C only when not allowed to use C++ instead.
I strongly disagree there. The only way for an engineer to make good decisions as to what tools / framework to pick from is to know and understand as much tech as possible.
It is fundamental for an engineer to do this job of tech-watching in order to not become religious and blinded by the tool it's currently using.
React is good , but it has it's own issues. If you don't do the effort of learning other tech ( Angular , Vue ) you have absolutely no idea what those issues are, and you will just learn how to work with them ( Atomized ecosystem , Heavy Boilerpate ) and basically accept them as a normal thing.
They aren't.
Learning other tech makes you more encline to try new things and to criticize the tool you are working with and how to improve them.
Knowing how a technology works is important. Knowing technologies needed to accomplish tasks to be done is important. Knowing seven different technologies that accomplish the same thing is at best a marginal benefit.
There seem to be a lot of people thinking front-end is just a mess of different options all doing the same thing. And the same people show little understanding of the complexities and nuances of front-end solutions.
I work primarily in Django. I could have given the same comparison of Django vs Flask. The pedant would say flask doesn't have an ORM, and would be correct.
Given the context of this article and HN in general I thought the shorthand referring to React generally would be understood.
Learning happens contextually as you figure things out. I see no use to learning half of the things on here that you'll never use. You do risk, however, in the confusing and complex JavaScript landscape, getting paralyzed by choice and never getting off the ground. I shutter thinking about how large some peoples' `package.json` files are.
There will always be a better way to build and some better technology. Build based on what you know and know how to pick tools when you run into a wall. When you need to refactor, you'll have a much stronger appreciation for /why/ you need some tool anyway.