How to become great at Sports:
- Read books about sports.
- Watch other people play sports.
- Read in-depth analysis of past sports games.
How to become great at Playing Violin:
- Read books about playing violin.
- Real sheet music by the great masters.
- Listen to many concerts.
It's inherently obvious that the above approaches are totally and completely wrong. How do you become good at anything? You practice it. You do it. You have a coach or teacher or mentor who can give you pointers, but lets you make mistakes. You have someone who lets you get things wrong the first time, so that you can see the consequences.
There is a time and place for theory, for reading, for analysis, and this is too part of the learning process, but this is not at all the most important tool for becoming great at something.
Theory, analysis, critique, history, and context all matter when learning any skill, but first, you must build the fundamentals. First, you must do the thing and once you reach a level where you really understand the thing, then and only then can you begin the more introspective task of theory and analysis. Even without these steps, the best way of becoming great is to DO.
How to become great at Chess: - Read books about chess. - Watch other people play chess. - Read in-depth analysis of past chess games.
How to become great at Math: - Read books about math. - Watch other people perform math. - Read in-depth analysis of math.
But you're right, nothing beats digging in and creating something.
On chess, from a GM: "The key to their success is that they kept playing a lot, and learning from stronger opponents. Don't get me wrong: I am not suggesting stone age technologies in studying. Of course, you should take advantage of the best modern learning methods. However, the most important component of success (at least at weak GM and below level) is practice."
Math is similar. You really have to do math. Reading books and watching other people do math is not the critical part.
From "Andrei Istratescu's top 10 reasons for stagnation:"
1) Too much play
Playing chess - practice - is very important for improvement. When you play chess (over the board, at tournaments), you put into practice what you have learned, you use your brain to think chess, you are in the testing environment, you test your accumulated knowledge and skill against another person.
However, too much play and too little study holds you back. You can repeat the same mistakes over and over. You will tend to follow your own old patterns and not have time to develop a different, correct thinking process, and to learn proper strategy and new ideas.
In this case, you should take a long break from playing and concentrate only on study for several months. You will make a significant improvement.
In my experience, the first chess book I read (Logical Chess, Move by Move) probably bumped my rating by 400 points. Then, more specialized openings and tactics books another couple hundred. After that, simply playing got me mostly nowhere.
As to becoming great, after years of running chess camps for young players IM Greg Shahade formed his somewhat famous hypothesis:
There is one very reliable sign to how much potential and how strong a young chess
player is or is going to be, and it’s probably not what most people would think.
It’s not how quickly a student solves tactics or sees combinations (although
these two things always seem to be correlated with the main point of this article).
It’s not the student’s positional understanding. It’s not even how much they
claim to study chess.
Instead it is “How likely is this student to recognize a famous game/position
and know the players involved?” 
"I like chess, I like chess books. You'd be surprised – I do read
as much chess as I can."
Editing for formating: how do block quotes work here?
Maybe some people can read a book and just know how to do things based on that. I used to be very caught up into thinking I needed a book to learn things. But that's not really me. I have to do. Most books aren't written in that regard. The authors want to pontificate on minutia. Now, I know I just need to jump in the deep end of making something and--somehow, be it through Wikipedia or Wolfram Alpha or StackOverflow or MSDN or MDN or what have you--I will learn what I need to get it done. Give me a cheat-sheet, some pliers, and a bail of wire any day. Until then, it's all just noise.
I think it ties in naturally to the Lean Startup ideology, i.e. the whole "release early, release often" thing. Using the example of chess, if you're just reading books on chess and are not playing games, then you're no better off than a startup who is working out of someone's basement, no marketing plan, no market feedback, just coding away based on some blue-sky ideology. "Release early, release often" isn't so much about success as it is about getting out of the basement, seeing the flow of things, and opening your eyes to reality.
When I was in "prépa" (see https://en.wikipedia.org/wiki/Classe_pr%C3%A9paratoire_aux_g... ) my English teacher, an American told us that the way he saw the system was to train us at math, just as a way to discriminate us between those who'll get to pick the best school and those who will take what's left. And he said, they might as well train you to do chess for 2 years and let the strongest one pick his school.
He also told me that back in the US where he came from, with his local chess club he went to a prison play with the inmates. They got destroyed, because the inmates played chess all day long so they were all very good.
Frankly, now that I'm experienced, if someone were to agree to be my mentor when I was a beginner, I should have been suspect of their expertise, because I don't know anyone who is actually any good at what they do who has time to do anything called mentoring.
Where does this idea of mentorship come from? I have never seen it. I've had examples in my life of people to look up to, but when people talk about mentorship they seem to be talking about some sort of creepazilla relationship where the student sits at the feet of the master and receives wisdom. Yeah, no, that doesn't exist in the real world, at least not for the vast majority of people.
If that's what it takes to be successful, to be reallly good at anything, then buddy, we're all in a world of hurt. It's an appealing idea, but who the hell does it ever actually happen to? I'm convinced it's a fantasy.
As a mentor, I have found that is mostly about reviewing others work and thinking and giving feedback. For instance, you don't really need a mentor to get better at solving problems. You may need a mentor to help you communicate details about the solution.
Somewhat related: http://jeffrey.io/writings/apprentice.html
They play thousands and thousands of hours and, yes, also spend quite a bit of time reading, thinking, analyzing (both their own and others') games and learning from mentors/teachers. However, practice is king and all the reading/analysis would be worthless in its absence. They would have no anchors to grab onto in your brain - no way to really become operational.
A chess "player" that mostly reads, studies and analyzes with a little bit of practice sprinkled in between would indeed be hilariously weak.
The biggest part is the ability to move a large part of the necessary skillset to your unconscious mind. As a joke Capablanca said "I only see one move ahead, but it is always the best one", this is how every strong chess player thinks, they can instantly evaluate the position. It is just like once you have learned to drive well, you would recognize a potentially dangerous situation(a child playing with a ball on a sidewalk) without actually thinking about it consciously.
I believe this is how the best programmers work too, they have an immediate grasp of possible techniques they can apply without necessarily thinking about them or looking them up in google.
You become great at your craft when you internalize/obtain unconscious mastery of a large number of techniques in your craft. You become truly great when you can combine these techniques in novel ways.
I will mostly speak about chess, because I am an average programmer and average mathematician but am a pretty good chess player near IM strength FM (2350) and have spoken to various strong chess players (up to 2700) on this subject.
There have been players who have become very strong with very little reading (GM Flohr is a famous example from 1930s) but with a lot of playing, however I am not aware of anyone who become good without practice.
So let's start with a simple example. You must absolutely learn how the pieces move, this would be equivalent to what loops and conditionals are in a programming language. If you have to think how the horsie jumps when playing, you are not going to get very far.
A more complicated example, it is very useful to be aware of the standard h7/h2 sacrifice. As you get stronger, you develop a better sense on when this sacrifice will be strong and when it will be likely fail, even before starting to calculate consciously.
How do you obtain this knowledge, the best way is iterative by playing and applying in practice what you learned.
You must work and do to become great at something.
What that means is that the point of practice is to reset habits to the best possible technique, so that when the athlete is under duress, they are habitually as efficient/effective as possible. Any practice done with poor technique is basically wasted time, and potentially counterproductive. This is true at any point in the athlete's development, from day one to just before the title game (or match or whatever).
The best way to achieve greatness is to have a great coach (or teacher, or mentor). That person can help one shortcut to the best technique, and they can catch and correct one when one strays from that.
But if one does not have that, then disciplined self-study of known great performers is an ok substitute.
Much better to just jump in and start figuring things out. Google your questions, find Stack Overflow questions. Fiddle with CodePen (etc) examples to see what variables and functions do what. Once you're well versed, read the occasional blog post about emerging techniques and patterns.
I work in JS day in, day out, and this approach hasn't seen me wrong. But we're all different.
Obviously, practice is also critical, but my point is most people who love to program love the act of programming, so they obviously already do a lot of that.
It only takes being bitten a few times by rushing into a new tech and doing everything completely wrong from the start. The smart learn from their own mistakes, but the truly wise learn from others'.
I hope this situation seems familiar to programmers because we see it every day -- programmers who write code that "works", but is tortured in its design. We can see people who can not express themselves in code because they are not fluent enough to do so. We can see people who can not understand common idioms because they never have read other people's code (in quantity). They ivent their own idioms, just like baby talk, and often decide that their baby talk is superior to the living language around them.
The biggest difference between a human language and a computer language is that most people aren't exposed to incredibly fluent users of the language in great quantity. It is really easy to fool yourself into thinking that you are a great programmer, when actually you can just barely make the code work. The same happens very frequently to learners of a foreign language that are rarely exposed to native speakers. You have no yardstick to measure your progress other than your textbooks.
Although I agree with your assesment that you must DO, but even more so you need to seek out communities of fluent users of the language and interact with them. That means reading their code, writing code, having them correct it, etc, etc.
One example from my own experience is Estimating.
It's something we all do, week in, week out. Yet there are still plenty of developers with years of experiences who delivery poor estimates week in, week out. I was one of these poor souls when I started developing. I would spend countless nights up late trying to finish a feature I promised someone else would be delivered yesterday.
So I did what my grandpa always recommended and I picked up a book, Steve McConnell's Software Estimation : The Black Art. And it taught me all types of tricks like making sure to break tasks into the smallest possible pieces.(Along with many other things. Seriously by this book, and every book Steve McConnell has written)
Maybe I would have eventually figured out tips like these on my own. But instead of having to wait to practice breaking up tasks into smaller more estimatable chunks, I got a 5 year head start and quickly was able to surpass many coworkers who had more years of experience but had spent less time in a book.
And now I can spend those late night posting on hacker news and not writing code trying to catch up for work :P.
TL;DR : Books are awesome. I read one once and I am a better estimator for it. And being a better estimator lets me spend more time on Hacker News. So if you wanna spend more time on hacker news, read a book.
Also, the kinds of things I tried out on my own while reading were unique and new. Not the kind of things I would necessarily run into in my job.
Doing is one thing, but if I just keep doing with my current knowledge then it's easy to fall into a situation where improvement is minuscule.
All of these are emergent problems that only occur when you work with large, long-lived software systems. You won't get them out of a book.
As a martial artist and weight lifter that totally makes sense - practice, sparring, doing the actual activity is what will make you good. The more you do it, the more you train your subconscious to intuitively know what to do.
As an engineer and tutor it only applies in a limited way. I have taught people who want to learn programming but lack all sorts of fundamentals. What they need to do is just go back to basics - read a book - do the exercises. I find that as an adult learner missing the basic background on things just makes everything hard. You will need to ask questions every step of the way. Who will be on hand to answer those questions? People like me, who have sat down and studied the basics and learned from first principles, i.e. worked through the books.
Coding is like math. Both practice and theory are important. If you don't read the chapter first and try to jump right into the exercises, you will not be able to do them properly. If you read the chapter but do not do the exercises, then you will forget everything you've read.
So what to do without a coach? Find something that will direct your practice. For this reading quality code is indispensable as it shows you the range of possibilities of what you can do with certain technology.
Considering your example of sports: past certain level it is essential to meticulously study video footage of yourself and your opponents in action as it provides insight into your weaknesses and your opponents' tricks which you can then adopt or learn to counter. Also when someone comes with spectacular advancement in technique (think Fosbury flop) it is quickly analyzed and adopted by others. So watching others is sometimes very useful.
What do you think about Platonic teaching ? asking question to direct exploration without giving 'free' (~bad) knowledge.
In Java, you'd typically create a separate class for such an object, create fields, assign types to them and document them, and have a constructor which populates the fields with sensible defaults if not provided. Sometimes it's an overkill to do it this way, but often it pays off with a better understanding of the data model. In JS you have a lot of freedom, but too much freedom leads often to a mess when enough people are working on the code.
That said, JSDoc helps a lot: make a @typedef comment for parameter objects at the top of a file, then use the type in the @param annotations of the relevant functions. Makes understanding the JS code in an IDE much easer, as well as having something worth generating HTML documentation from.
It just doesn't make any sense.
In light of that, definitely seconded. Using Clojure (and watching Rich Hickey's amazing talks) made me a much better developer, and especially a better JS developer.
JSON starts to look like funny s-expressions.
JS brings a lot more to the table than just a scripted version of "C++ for retards" (aka Java), as it also lets you make use of many FP concepts like higher order functions and functional (vs object) composition.
For example, using currying (aka "dependency injection for functions") lets you often do with a single function what would take a silly-long class to do in Java. Use currying to inject leading parameters to a function that would normally be in the constructor (or setters, ugh) in a Java class, then the remaining "short arg list" function acts like the oh-too-common one actual "we're ready, now do something" method in a class.
Downside is that after using a proper functional language (clojure[script]) you end up wanting some really basic things such as immutable core data structures.
If you've only been exposed to OOP, and you don't have the bandwidth for learning an unrelated language, then start using a functional library like Underscore. Just use it everywhere, even if you think it's ridiculous. Don't use for-loops, use _.each. Try to think of every problem in terms of chaining map, reduce, zip, pluck, groupBy, etc. Do whatever you can to avoid side-effects.
You'll quickly develop a taste for when OOP or functional is appropriate, but I think the best way to get to that point is to immerse yourself in functional programming first, which might mean writing some ridiculous functional stuff, but the long-term payoff will be worth it.
I've found JS to be a nice middle land where I can get productive functionally without too much hassle. It's like a good friend who understands my way of thinking without being in the way too much. Underscore.js hits the sweet spot for me: _.chain(...).map(...).filter(...).value() is verbose but surprinsingly readable. I'm not a fan of Python map() syntactically, and I absolutely hate C++11's std::transform.
If you're a new developer coming into JS from a more tabula rasa situation (possibly these days), I'd still say that most of those books are wasted, and you'd probably get a better mileage out ouf SICP or the GoF book than most Ninja/21days/Dummies tomes.
The core of JS is small enough, and the rest is highly dependent on your task, scope and framework. No jQuery book will help you with your intranet extjs app or your state of the art fluxified React SPA. You'll have to wade through code to get there, preferably as much of your own as possible.
And the most important thing: Pick something and stick with it. No mid-project framework/build tool/library changes. Even "obsolete" tech still works better than falling into the Duke Nukem hole. So don't get nervous about still using "grunt" when all the cool kids are using "gapoodle".
// Statements can be terminated by ;
// ... but they don't have to be, as semicolons are automatically inserted
// wherever there's a newline, except in certain cases.
// Because those cases can cause unexpected results, we'll keep on using
// semicolons in this guide.
Only ever leave the semi-colon out at the end of a line when you are explicitly using a multi-line statement to make your code more readable.
This makes your intent unambiguous in both cases; to the interpreter/compiler, to other tools, and to other humans.
Instead of being told there's some problem with the code, it inserts a semi-colon into an arguably ludicrous location, and then gives you a differen error.
Would probably make compiler writers' jobs easier if they just spit out errors.
In addition to that, the return statement is 'restricted production' where the line break itself is a terminator, this has nothing to do with semi-colons or ASI.
If this is your preference, JSLint has you covered. Really, every JS developer should be using a linter and tweak it to fit their coding preferences.
Having said that, your argument could also apply to operator precedence and parentheses. Yet most languages implement this, and most users don't add them unless they're in doubt (more often with e.g. logical operators than arithmetic ones).
Think of semicolons in JS like colons in BASIC: they let you stack multiple statements on a line. Then, go learn what the language REALLY thinks is the end of a statement, which is not "I put in a semicolon".
Too bad JS doesn't use (an explicit) backslash for line continuation, rather than guessing when a line/statement was done :-(
x = y
x = y(z).whatever()
Although to be fair:
The sad reality, taking the second link to its satirical conclusion, is that all JS should be written on one line, with semicolons between statements. No guessing about the effects of line breaks if there aren't any. "I say we take off and nuke the entire site from orbit - it's the only way to be sure." :-)
-- Don't get me wrong, those are good cases to know what is going to happen. But I think you are making the case that semicolons provide a false security blanket, since the language can complete a line you meant to wrap, or, alas, merge 2 lines you meant to have separate.
I think shell (and a few other languages) actually got it right: 1 line = 1 statement, unless there is an explicit continuation.
Of course, it's not a good thing to stop there, but in my experience it often acts as a gateway for beginners to start actually learning 'proper' programming.
(The problem of course is that often times we don't take the time to make the necessary evaluation and want to make a change just for the sake of learning the new shiny)
Also, I hope that the first project a JS newbie does isn't a 100'000 line app, but something more bite-sized, and thus you really don't have to wait months to get to use the new stack or tool. Quite often this kind of decision making happens when the project is 80% done and you have to face a few things that aren't that easy or your code has become a bit too complicated. And yes, the new tool could solve that and you might even end up re-implementing bits and pieces of that. This might not be the most effective use of your time, but it's a good learning experience.
If you doubt this argument, consider the fact that the horrible scoping, the weak typing, the insane casting rules are still here to this day; empirically you're wrong.
This is a thought more than a full-fledged argument, but perhaps little issues with the language actually can and do make people better developers when they are aware of them. My friend started driving a scooter. Dallas isn't particularly conducive to that. My friend says he has since become a better driver because he knows one little screw up by him or someone else can end his life. Similarly, you'd better be aware of weak typing and casting and code accordingly or you might get hurt. Of course, you shouldn't have to...but that doesn't make people worse developers.
But the truth is, JS has a lot of features which make it great for becoming a good developer. It's less class-based than Ruby and has better lambdas than Python which I would argue make it better for functional programming than either.
And yes, JS support for lambda expression is surprisingly nice, but that is basically the only nice surprise.
The language itself? I honestly can't say that. Lua is a way better ECMAScript than ECMAScript itself, and the focus should have been on trimming it down to a smaller but easily extensible core, as opposed to the feature piling that's going on.
If you build a church from chewing gum and then get Gustaf Eiffel to design a few towers to it from steel with furbishments by Antonio Gaudi the fact still remains there is a heap of melting gum at the bottom.
Stuff that needs to be designed up front cannot be fixed after the fact regardless of the amount of ducktape and personell applied.
Without the follow-through I found that I could keep up in a conversation but still had doubts and issues when it came to implementation. Doing it in anger, delivering a product, as many times as possible helps a good deal in moving toward greatness.
The turning points for me:
- modularity - npm has really changed the way I program, for the better
- Node.js tooling (including a Browserify, Babel, Webpack) will greatly improve your experience with the language
- live reloading, zero compile time, instant visual feedback
- the breadth of Browser/Node/npm APIs can make it a ridiculously productive language to work in
- IDE plugins and linters can catch a lot of errors as you type
- above all else; it has an amazing community of enthusiastic developers, tinkerers, scientists, artists, etc.
Besides, nobody ordained the author to be an authority on the subject. He was just a guy who wrote a book. It's zero indication of the quality of the content.
Just write code. Practice, practice, practice.
Writing code without guidance is probably the slowest way you can learn something. A good book or class will save you countless hours living with the consequences of your naive mistakes. Good writers and trainers forewarn people about pitfalls by providing fair warning about common mistakes. Better writers and trainers instill good mental models that timeless help the reader solve problems.
I'll agree that there are plenty of bad books that give bad advice. The solution isn't to say books are a waste of time. The solution is to recommend better books.
Writing code without any guidance can only get a developer so far. He needs examples of good solid idiomatic code to progress. A good book, often by "just a guy", can provide that.
Because there is no objective way to evaluate the quality of a book before reading it, and because any useful information in most of the few good technical books is of limited lifespan, books are a waste of time. It's not just that books can be bad. It's that most books are bad, and having to wade through them is what makes them a waste of time.
Here are a few books that I see at the top of the lists almost every time this topic comes up:
The Mythical Man-Month
The Pragmatic Programmer: From Journeyman to Master
One exception is more abstract thinking -- algorithms, general design principles, etc. I think a book can be handy there sometimes.
Read "The C Programming Language", by Kernighan and and Ritchie. Written decades ago, still accurate and relevant today. "The Mythical Man-Month", "The Pragmatic Programmer", "Design Patterns"... books like this will always be relevant.
Maybe a good rule is to stick to CS books that have been in continuous print for at least ten years.
I only got this project too because the dev previously in charge of the project left the company and I asked about it. It's another lesson to new developers: never let an opportunity pass you by.
The inclusion of Backbone seems a bit odd. Isn't that also frontend-ish (like the pick one of Ember,React,Angular). I'd rather substitute it for Express.
For books the main problem is that they are getting obsolete quickly (JS is a rapidly-changing technology) and, except for very basics, somewhat opinionated and task-dependent.
I have a hard time thinking of "web programmer" as "polymath" and worrying that it's not specialized enough.
Also, it seems like a big jump to go from doing exercises to giving lectures.
You have to find out what you don't know that you don't know, and it's really hard to do that on your own.
No. underscore does it wrong (check https://www.youtube.com/watch?v=m3svKOdZijA) Check some of the real functional libs like Ramda and Pointfree Fantasy
- Read books
- Learn libraries ( author seems to like node.js and recommends libraries associated with that )
- Do exercises
- Learn how classes work in JS ( Note this is amusing to me since JS does not have classes in the typical sense [ they are implemented via libraries with prototypes and closures ] )
- Learn what Es5, Es6, ES7 are ( There are good things here, but be aware that most of these features are not implemented in most browsers and will requires shims and/or translators to even function. Be careful as they may work in your browser but not others. Test! )
- Read JS blogs and watch JS educational videos
It's an okay article. If you are clueless how to start learning seriously this should help. Some decent books and websites are mentioned by name.
I think the "every JS developer needs to learn XYZ" is a bit off though. This is one man's perspective.
This kind of derision is typical of people who try to force prototypal inheritance to work in the same way as classical inheritance. I suggest learning the details of the prototype chain and how it works - you'll discover it is about as powerful as classical inheritance, but in different ways.
- Learn what Es5, Es6, ES7 are ( good for confusing yourself and writing code that won't work cross-browser... )
Babel means you can write ES6 and ES7 code and make it cross browser: https://babeljs.io/
Do you know what classes actually do in a real OO language, or are you just a fanboy of JS?
Also, using shims or translators proves nothing. I can write in C++ and use translators to convert that to JS. What is the point here exactly?
Adding extra confusing junk onto a weak language does not make the language "better", especially when the standards you are recommending people to learn aren't even finalized.
Where is the Acid test for ES5, ES6, and ES7 features? Hell where is the Acid test for HTML5?
Oh that's right; all of this is just a pile of nonstandard junk that people are begging for and isn't really implemented.
ES6 classes are sugar over prototypes, not closures. Insisting that ES6 classes aren't classes requires at the very least a basic understanding of how they are implemented.
> Do you know what classes actually do in a real OO language
> are you just a fanboy of JS?
Surprising vitriol here and makes you lose all credibility. Why does stating a couple of facts imply that you are a fanboy of JS?
> Also, using shims or translators proves nothing. I can write in C++ and use translators to convert that to JS. What is the point here exactly?
The point is that you stated that ES6 and ES7 code don't work cross-browser. Using Babel means that they do.
> Adding extra confusing junk onto a weak language does not make the language "better", especially when the standards you are recommending people to learn aren't even finalized.
Where exactly did he make this argument?
Using the prototype may be the way that things get copied from the base definition to an instance, but generally closures are what allow things to have the proper scope. Arguably the scope is far more important for using something like a class than the copying. Additionally, without closures there is no way to pass of anonymous function pointers calling back into the class.
If you think you are demonstrating that I have a lack of knowledge of how this shit works, you are mistaken. But by all means, continue disregarding my points and nitpicking details instead.
You will note that here on hacker news I don't really give a shit about my credibility; I care about providing the most accurate information I can to the benefit of others.
You haven't invalidated my statement about translators at all. ES5, ES6, etc are not cross-browser compatible. Using a translator to "make it work" doesn't count. If you wish to say that C++ is cross browser compatible too then fine, but it is obscuring the root issue that those features do not exist in all the browsers, nor even the whole set of them in any one browser. This is misinformation and will mislead developers.
My last paragraph is in reference to the fact that JS/Ecmascript have never truly been "fixed". It is just a constant hodgepodge of whatever vendors decides to add on to the language.
Yes, and jQuery doesn't implement classes.
> I care about providing the most accurate information I can to the benefit of others.
By calling other people fanboys after they provided a link?
> ES5, ES6, etc are not cross-browser compatible.
I guess it depends on your definition of cross-browser compatible, but ES5 is what, 5 years old now? I guess it doesn't work on IE8, but by that definition ES3 isn't cross-browser compatible because it doesn't work on IE1.
As for ES6, it's cross-browser compatible in the same way that CoffeeScript is, with the added benefit that it'll work natively in most browsers in a few years.
> My last paragraph is in reference to the fact that JS/Ecmascript have never truly been "fixed". It is just a constant hodgepodge of whatever vendors decides to add on to the language.
That's really not the case anymore.
Are you claiming that CoffeeScript is cross browser compatible? If so you are just going further down the rabbit hole. To my knowledge there is not a single browser than itself is capable of parsing CoffeeScript without a helper library that doesn't come installed by default. ( Firebug comes to mind, and if I recall correctly there is a helper tool for that. I'm also aware of source mapping for debugging things such as JS in both Firebug and Chrome )
You can learn so much from patterns and techniques others are using, but that may have not been documented in the other listed resources.
There's one important thing I've already learned though and I'll do you a solid - be a total nazi to your code.
At the start, it's easy to get impression that it's all loosey-goosey-everything-works kinda thing, and it actually is...at small scale! When you get to medium-sized thing, all hell starts to break loose, and I'm not talking just callback hell. You can avoid all that with modest amount of discipline.
I'm aware many people have qualms with JSLint, some even with JSHint. But it doesn't matter what you use as long as you keep consistency. Those two tools help you with that. If you can be disciplined without it, sure, go for it. Just reading on possible configuration options for JSHint already made me consider many potential pitfalls I wouldn't have even thought of otherwise..
 I wanted to go with "anal" instead of "nazi". But you get the idea.
 ...by some amazing dude though.
That and just building a lot of things with it.
Once you have developed an eye for good code, find better code to read, write better code. Repeat.
This is the key. You need to move from "practice makes perfect" to "perfect practice makes perfect."
Should I jump into ES6 directly or learn ES5 and learn ES6 when it is implemented across all browsers ?
Babel is a great tool to let you use some of ES6's features now, but it will still help in debugging to know ES5 syntax since Babel transforms it at runtime.
Is there a 'Genius' (nee 'Rap.Genius') type resource that annotates well known open source code?
Docco Source: http://jashkenas.github.io/docco/
Backbone Source: http://backbonejs.org/docs/backbone.html
CoffeeScript Source: http://coffeescript.org/documentation/docs/grammar.html
Generally I think that a linear step-by-step description is often not the best way though, often you would have to explain concepts or the bigger picture first.
Build general purpose libraries, plugins, micro-framework or personal projects. Follow-up by validating your work with your community or sample audience. I have been taking the later route.
When it's done. Read some more and build some more. Put it on a repeat loop. Look for some variation as it brings different perspectives.
I would argue that JS should be handled analogously to Assembler: Good for you if you understand it, but only highly trained field specialists in protective suits dare to write production code in it. Go and get a decent compiler if you can't avoid using that technology.
If you can't write good code in JS, it's because you're a bad programmer.
But academically being able to write in a certain language is still not the same thing as productivity combined with certain quality guarantees.
I remember thinking it was easy like VB but was easier to show to other people. I still think of it in similar terms: easy to write like Python but a hell of a lot easier to deploy and show off.
I'm sorry, but that's just an absurd statement. JS isn't that bad or confusing.
Do you write that manually, too?
2. Switch to TypeScript