I can definitely relate, this sounds just like me last year! I've done things the hard way and it took me 5x longer. I also prefer screencasts to books. I always need to create a project to solidify those fresh skills, otherwise they'll be gone in a month. Also tutorials for things like Backbone assume you know how to use jQuery, Underscore, and things like REST, and JSON responses... this can quickly get confusing if your not familiar with all of these. My largest regret is not building enough practice apps in the last year. I really should have applied more by doing, instead of staying in the theoretical world.

Here are some insights that i've made and the courses/tuts/projects that helped me the most:

Learn the language first:

• https://tutsplus.com/course/javascript-fundamentals/
  
• https://tutsplus.com/course/object-oriented-javascript/
  
• https://tutsplus.com/course/advanced-javascript-fundamentals/
  
• http://eloquentjavascript.net/ If you feel you need more coverage of the same topics (interactive html like CodeCademy).
  
• Build something interesting, things like games seem to also challenge your programming skills at the same time. Something like Whack-a-Mole, Connect 4, etc... Don't worry too much about the looks, unless you want to practice that too. At this point you should be able to do basic dom manipulation, events, and basic logic.
  
• The tut-plus courses cost a little for a few months but they're really high quality... most of them also give you projects too.
  
  

  Set up a comfy environment
  

  
  Take some time to start optimizing your development environment, the Paul Irish explains it very well below, but some of the topics are a bit too advanced for now (modules, build tools, etc...).
  
  

• Javascript Development Workflow of 2013
  
• Setup a jshint plugin (~4min above), read the website/docs for all the options. http://www.jshint.com/
  
  
• A more entry level talk on setting up your environment Front-end Tools for the Young Developer
  
  
  

  Learn the native DOM and it's API
  

  
  

• http://domenlightenment.com/
  
• Create your own DOM manipulation library
  
• While this one is a book, it's small and has js-fiddle examples for every code block to try it out... i'm currently going through this and it's great! They have a free HTML version (not final edit) and a cheap softcover on amazon. This will make using jQuery much easier and less 'mysterious'.
  
  

  Learn jQuery
  

• https://tutsplus.com/course/30-days-to-learn-jquery/
  
• https://tutsplus.com/tutorial/jquery-anti-patterns-and-best-practices/
  
• http://fixingthesejquery.com/#slide1
  
• https://tutsplus.com/course/jquery-plugin-development-best-practices/
  
• Re-write one of your previous apps to use jQuery instead of vanilla.
  
• While I love vanilla, jQuery just saves time. Learn when you can easily not use jQuery to gain some easy performance.
  
  

  Read "The Good Parts"
  

  
  Though very cliche at this point, read through this classic. If you don't really understand it all 100%, make sure you hang on to it though as it gets better with age. Try and follow it as close as possible, then later feel free to break the rules. By then you'll know why you can break them.
  
  

• JavaScript the Good Parts
  
  

  Learn Underscore
  

  This is a great library that gives you a lot of cross browser ES5 features and features that should be in JS. Not a lot of tuts on this one, reading the docs and source helps a ton here.
  
  

• http://net.tutsplus.com/tutorials/javascript-ajax/getting-cozy-with-underscore-js/
  
• http://vimeo.com/60216668
  
• http://underscorejs.org/
  
• https://github.com/bestiejs/lodash
  
  

  Learn Backbone
  

  There are lots of these libraries but Backbone is the most popular and easiest to learn. Keep in mind this is a library, not an entire framework like ember. This means in a larger app you will essentially use Backbone to help build you own SPA framework for your app.
  
  

• https://tutsplus.com/course/connected-to-the-backbone/
  
• https://tutsplus.com/course/advanced-backbone-patterns-and-techniques/
  
• http://addyosmani.github.io/backbone-fundamentals/ Great book!
  
• Build a Todo app with backbone
  
• Build a backbone powered Reddit mobile web app, read the following posts for inspiration.
  http://cheeaun.com/blog/2012/03/how-i-built-hacker-news-mobile-web-app
  http://cheeaun.com/blog/2012/03/how-i-built-hacker-news-mobile-web-app_26
  
  

  Learn Node
  

  
  

• https://tutsplus.com/course/introduction-to-node-js/
  
• Build a command line app ( I built a scaffolding app to spit out my boilerplates, and a really janky language transpiler)
  
  

  General Front-End, Programming
  

• Baseline for front end developers
  
• So you want to be a front end engineer
  
• http://pineapple.io/wiki
  
• https://www.edx.org/courses/HarvardX/CS50x/2012/about
  
• I can't stress how helpful the CS50 course has been to me, even on the front end.
  
  

  Read a comprehensive JS book
  

  I really like Nicholas Zakas's book over the definitive guide. I find that he is able to tell more of a story and makes it easier for me to absorb.
  
  

• Professional JavaScript Development
  
• JS the Definitive Guide
  
• Re-read "The Good Parts", this should make much more sense than the first time you read it.
  
  

  Testing
  

  
  Make sure you're comfortable with everything before moving onto testing... this includes frameworks etc.. Learning testing will only slow down the learning process if you're not comfortable with the rest. Mocha is the newer test runner and is better with async. However, Jasmine is very popular and time tested. The "Lets code javascript" below is an awesome course. Don't let the first sections turn you off, they may seem tedious at first (integration server, etc...) so feel to skip to dom/browser testing and then loop back when testing is more normal.
  
  

• http://www.youtube.com/watch?v=eVpXkyN0zOE - Short intro to Jasmine and TDD
  
• https://tutsplus.com/course/javascript-testing-with-jasmine-2/ - Nice n Easy course to Jasmine & TDD
  
• http://www.letscodejavascript.com/ - epic comprehensive JS TDD course from server to browser
  
• 
  
• http://visionmedia.github.io/mocha/ - My favorite runner (with Chai)
  
• http://karma-runner.github.io/ - Test in mult. browsers from the command line (advanced)
  
• https://github.com/rmurphey/js-assessment - test your skills (no pun intended)
  
  

  --
  

  I just started sketching out a website to try and solve this problem. It has different paths to follow to fill in gaps of JS knowledge quickly (much like hackdesign.org)... unfortunately it's not finished yet! Watch LevelUpJS on Github in the future. I also have some more links on app architecture and things like modules but this list is getting a bit large!
  
  Cheers and good luck!
  

I stand by this roadmap, especially because I tested so many different free courses online (and subsequently wasted a bunch of time). Hopefully someone will find this useful.

Rithm (https://www.rithmschool.com/courses)

• Awesome for going from 0 to beginner/intermediate; possibly the best fundamentals I've found
  
  
• Doesn't hand hold so it teaches you how to think
  
  
• Writing is friendly and understandable
  
  Eloquent JS (http://eloquentjavascript.net/)
  
  
• Great for solidifying intermediate
  
  
• This is when you begin to learn "real" coding
  
  
• Can be difficult to grasp, but with a solid understanding of the fundamentals, you should be good
  
  Secrets of a JS Ninja (https://www.amazon.com/Secrets-JavaScript-Ninja-John-Resig/dp/193398869X)
  
  
• Great for going from intermediate to advanced
  
  
• If you've methodically mastered the previous two, you will be good. Really deepens your understanding and sharpens skillset
  
  Finally, if you supplement all this with Codewars (https://www.codewars.com/ , allows you a bunch of puzzles/katas to check your level as you progress; great because you can go back and see how your skills have actually improved, you'll definitely cringe at some of your old code, ha), it's a pretty fucking awesome roadmap to get you from 0 to advanced, though like most things it'll take a lot of work.
  
  I've also heard good things about Free Code Camp, though I've only checked it out briefly.
  
  Hit me up if you have questions, always down to help others get started.

This is kind of a side-answer, but it looks like you are just compiling a list of things that are super popular at the moment.

> React.js with Flux seems more hot than all other frameworks

What concerns me is that you seem to not be concerned with what is the best framework for your project(s), but rather what is "hot".

For a long-term career I would recommend focusing on improving your understanding of concepts and theory that these ever-changing tools are built on rather than trying to chase what people think is cool.

The people who spent time learning JavaScript rather than simply "mastering" jQuery were in a significantly better position when client-side frameworks came out because they knew the underlying concepts.

If you haven't mastered these things yet, I think they have more value than most of the list of specific tools I see listed:

• Eloquent JavaScript & JavaScript: The Good Parts - Master the ins & outs of the language
  
• Understand common design patterns - New frameworks are going to be building with these components, what better way to have a jump on the "next big thing" than by understanding the blocks that it's built with?
  
• Functional Programming - React (and to a lesser extent Angular) are increasingly utilizing this paradigm and it is a jumping off point for more advanced techniques like Reactive Programming that lets you leverage an incredible amount of power especially in the big data space.

Yeah JS:TGP is really required reading for professional Javascripters. I've also heard great reviews of Javascript patterns by Stoyan Stefanov. The sample chapter is good, I'm hoping to buy it later.

Felix's Node Style Guide is good too (basic style guide) and has some good rules to apply to your normal JS as well as NodeJS.

After that, browse through http://javascript.crockford.com/

Learn the module pattern and it's prettier sister the revealing module pattern and understand how it works. I use RVM everywhere by default, pretty much.

Once you've done all the above you should be able to say confidently:

• I understand event driven programming
  
• I understand scope
  
• I understand closure
  
• I understand prototypes
  
  More generally;
  
  
• I understand the importance of separation of concerns
  
• I can choose the appropriate level of abstraction for my objects
  
• My code is written with re-use in mind
  
  General tips:
  
  Install firebug, JSONView. Get a good editor; I've had good experiences with textpad (win), Komodo(mac) and sublimetext(x-platform). Worry more about readability and maintainability than performance in general.
  
  A nice phrase I came up with the other day: Simple code doing clever things is great, clever code doing simple things is bad.
  
  Read other people's code. Read the unminified jQuery source, and other libraries. Try writing pure JS before going down the heavy-reliance-on-jQuery route.

>At first I searched for a good guide for an average programmer, I found the [1] MDN JS Guide which is good, but I think not very good: At first I wasn't sure what is part of the language itself and what is only available at the HTML-DOM (they use a lot alert-dialogs - JS hasn't a Standard Library like Python or Java, has it?).

They use a lot of alert because it's the easiest possibility to show something for starters, you can however of course use console.log, console.warn and error. For the HTML DOM thing, well c'mon - at least try that examples in your console, will you? Just press [F12] or google for how to open the JS console for your browser.


>Is there a "JS Bible"? I know there is the tutorial for python ([2] click me) and as well there is the book/bible/reference for C (from dennis ritchie) and C++ (from Stroustrup). Does something like that exists for JS?

JavaScript: The Good Parts by Douglas Crockford


>Second Question: For my purposes, it is worth to use a Framework like jQuery? I'm using it right now, but I think it's not a big deal to code everything without using an 3rd-party framework.

I like to be able to swim, before I learn to drive a boat - and you? :)
Anyways, that depends - if you do this for clients, use jQuery, it's tested, on multiple browser, sure it has bugs, and plug ins should be reviewed by you before being used. jQuery helps to code less though, and has plenty of beginner questions already answered - just use it.

> Last Question: Atm I'm using Django as webframework and i'm very happy with it. But it looks like Node.js got lots of attention in the last couple of month, is mature enough to use it for real world problems?

It's "mature" enough yeah, but use what you need - not what is all the rage right now.

But for the love of God, please, please, learn JavaScript itself to a good standard before even touching jQuery.

Even though jQuery makes writing web apps a lot easier and saves you a lot of development time, it is still a JavaScript library and as such, if you don't have a good grasp of JavaScript, you're going to be writing jQuery code that may well work correctly, but you're not going to have any idea why it works correctly and as such, debugging and writing advanced jQuery code is going to be a nightmare.

I appreciate that you might not want to spend any money on learning JavaScript, but if you're really interested in the language and want to know it well (and you already have a solid foundation in programming), then I highly recommend getting JavaScript: The Good Parts and reading through that. It's short (176 pages), you can read it in an afternoon (though the first time round, some of the stuff might go over your head), and although it may be very opinionated, most of what Crockford says is pure gold and at the end of it you will have a thorough understanding of how JavaScript works and how you can write good JavaScript, which will aid you tremendously when you start using libraries such as jQuery.

Apologies for my rantiness, it's just that JavaScript is seen as a 'toy' language by many, a simple language that people can just jump in and use without learning it first, as evidenced by people suggesting diving straight into jQuery, which is a reputation that I think is undeserved. JavaScript may not be the prettiest of languages, but it's here to stay, and if you learn to use it properly, you'll find that beneath the design mistakes lies a simple and beautiful programming language that just wants to be loved.

If you associate test-driven development (TDD) with learning better code design, it might help fill in any gaps you feel you have. Best to have an understanding of SOLID principles, DRY, and KISS.

Red Green refactor is a good starting point.
http://www.jamesshore.com/Blog/Red-Green-Refactor.html

Though its not JS specific, anything by Sandi Metz is awesome, highly recommend her 99 Bottles book.
https://www.sandimetz.com/99bottles

Uncle Bob's Clean code is a great resource as well.
https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882

Books:

• Javascript: The Definitive Guide
  
  
• Javscript: The Good Parts
  
  
• Pro Javascript Techniques
  
  
  Sites:
  
  
• Quriksmode (great for figuring out what works in what browser and not limited to Javascript)
  
  
  
• eJohn - John Resig, creator of jQuery, usually has a lot of insightful information on jQuery and javascript in general
  
  
• jsLint - The most nazi Javascript parser out there and will let you know how bad your code is. Passing the lint will make you a better coder. Not all of the stuff Crockford says is bad is bad, but only if you know what you're doing so for beginners I highly recommend using jsLint to check your code often. It's also great for finding that elusive.
  
  Videos:
  
  
• The Javascript Programming Language 1/4 - Great talk on Javascript by Crockford (covers a lot of stuff that's in The Good Parts as well)
  
  
• The Javascript Programming Language 2/4
  
  
• The Javascript Programming Language 3/4
  
  
• The Javascript Programming Language 4/4
  
  
• Maintable Javascript - Great talk by Nicholas Zakas
  
  
• Javascript: The Good Parts - Crockford talk, covers a tonnes of stuff in his book.
  
  
• Advanced Javascript with Libraries 1/2 - John Resig
  
  
• Advanced Javascript with Libraries 2/2
  
  
• Writing Efficient JavaScript - Gopal Venkatesan
  

Personally, I find I learn best from books but only for two narrow facets: theory and reference.

The books everybody recommends are:

• Eloquent JavaScript - http://eloquentjavascript.net/
  
• JavaScript: The Good Parts - https://www.amazon.com/JavaScript-Good-Parts-Douglas-Crockford/dp/0596517742
  
  That first one can be read online.
  
  Once you get past the how do I write code basic literacy stuff and really want to step up into architecture you might want to get a little bit of Lisp and Scheme. The fundamental concept to learn in this language is scope. In my experience computer science grads tend to learn things like C++ and Java or C# and work really hard to get really good at OOP. Those techniques of inheritance aren't quite so helpful in this language if you never learn this language's scope model. If you fall in love with the scope model you might find you don't need the OOP/inheritance stuff.
  
  When you are ready to interact with the web here is a quick guide I wrote to teach DOM access: http://prettydiff.com/guide/unrelated_dom.xhtml Could you let me know where this guide fails you so that I can improve it for other people?

First, make sure that you've built some complex apps in vanilla JS, and have faced some sort of issue of scale (ie. problems that came up because your app has a lot of code). Maybe your code is really long and difficult to organize. Maybe you end up repeating the same code in a lot of places. Etc.

That way when you try a framework, you'll have some idea why it does what it does, and what problem it's trying to solve.

As far as specific libraries, I'd try these in this order:

• Lodash (or equivalently, Underscore). This is a really useful utility library, and can be used regardless of what fremework you're using.
  
• Backbone is the most barebones and vesatile of the popular frameworks, and is meant to be used in conjunction with jQuery (which you already know) and Lodash (which you will have learned). Backbone will give you a good sense for what MVC is.
  
• React is a level of abstraction above Backbone, and offers 2-way binding and component-level separation in addition to MVC (more acurately, MVVM). I'd encourage you to use it with Browserify, which lets you use NodeJS's syntax for injecting code, but in the browser.
  
• Angular is more opinionated than React, and introduces high level concepts like dependency injection.
  
• Optionally, also try out Meteor (which introduces full stack, 4-way binding), Ember (a super opinionated framework, most similar to Angular), and Polymer (a very future-facing framework, most similar to React).
  
  For general education, here are a few books I recommended in another thread:
  
  Design patterns:
  
  
• http://addyosmani.com/resources/essentialjsdesignpatterns/book/#designpatternsjavascript
  
• https://leanpub.com/javascript-allonge/read
  
• https://leanpub.com/javascript-spessore/read
  
  The JavaScript language:
  
  
• http://www.amazon.com/Effective-JavaScript-Specific-Software-Development/dp/0321812182
  
• http://www.amazon.com/JavaScript-Good-Parts-Douglas-Crockford/dp/0596517742
  
  Hope that helps, and good luck!

Take a look at the book Effective Javascript. It's a really excellent book that deep dives into specific examples and what to look out for.

Secondly, check out some of the tutorials on nodeschool.io. They get into some really neat and important Javascript things.

Thirdly, write some backend Javascript code in nodejs so you can use the skills you already have but apply them to backend concepts. Heroku has some really nice tutorials that will get you writing server code in just a few minutes. https://devcenter.heroku.com/articles/getting-started-with-nodejs#introduction.

Fourthly, use one or more of the popular frontend frameworks to build a simple Todo app. In fact, if you have the time, build the same Todo app in a few different frameworks, so you get an idea of how they work.

Also, when interviewing, just be honest. Tell them you have a number of years of experience but that you've worked for organizations that preferred quick and dirty over perfect. You can parlay that into a positive by showing how learned to get stuff done quickly without spending too much time on small details.

Books that helped me to get the hang of JS

John Resig's Secrets of the JavaScript Ninja and Douglas Crockford's JavaScript: The Good Parts are pretty much the only ones worth reading in my opinion.

Projects

The best thing would be to build something you want to use yourself. Maybe you try cordova and build a small app with the browser platform so that you can create a simple App that you can bring to your Smartphone.

More advise

Read a lot of code: TODO MVC is a good place to start, people try to write good code for this one because they want you to use their framework :-). The problem with the source code of many projects is that the JS ecosystem is in a constant flux and ES6 modules are skyrocketing right now. You may want to check out the jQuery source code - you can pretty much watch the evolution by looking at older versions of the source code and how it evolved.

If you feel really adventurous the NodeJS source code is a fun read - although it's a very big project that also got some C/C++ code sprinkled in - but that shouldn't be a problem for you :-).

I would advise you not to bother reading the Angular1 code for the time being, Angular2 maybe interesting but its written in Microsoft's TypeScript - which is a nice language on top of JS that is worth learning about.

For Javascript, I recommend "A Smarter Way to Learn Javascript" https://www.amazon.com/Smarter-Way-Learn-JavaScript-technology/dp/1497408180/ref=sr_1_1?ie=UTF8&qid=1473808304&sr=8-1&keywords=a+smarter+way+to+learn+javascript

It's a really good, QUICK, and straight to the point book on beginner Javascript. ~250pages

Then... If you want to round it out, I'd recommend Head First Javascript Programming https://www.amazon.com/Head-First-JavaScript-Programming-Freeman/dp/144934013X/ref=sr_1_1?ie=UTF8&qid=1473808479&sr=8-1&keywords=head+first+javascript+programming. While being full of fluff, as is Head Firsts way, is a much better book than their HTML5/JS one. With a lot of great examples ~600pages

After that, I'd recommend Learning Web App Development https://www.amazon.com/Learning-Web-Development-Semmy-Purewal/dp/1449370195/ref=sr_1_1?ie=UTF8&qid=1473808519&sr=8-1&keywords=learning+web+app+development ~300pages which will start to introduce the full javascript stack to you.

Javascript: the good parts -- Amazon

Eloquent Javascript -- free ebook

Javascript Allonge -- free ebook

Eloquent Javascript is a great introduction to JS. The Good Parts teaches about what parts of JS to use and good coding practices (though some JS devs disagree with Crockford, every place I've worked that started implementing all his recommendations immediately saw reductions in code issues). Javascript Allonge is the greatest intro to functional JS that I've seen. These three will take you from beginner JS dev to intermediate JS dev. Practice will take you to advanced JS dev and reading lots of nuts and bolts blog posts will take you to JS expert.

I am self taught and I have to say that the best way to learn is to have a very clear idea of a simple project that you can realistically complete. I learned javascript with "JavaScript: the good parts", and I built a page with a deck of cards that shuffled when you press a button. I still have it on github https://github.com/SpencerCooley/poker_project.

Both books you mentioned are probably good, but the real learning happens when you are trying to accomplish a specific goal and get stuck on something.

"Javascript the Good Parts" is definitely good, very light and to the point.
http://www.amazon.com/JavaScript-Good-Parts-Douglas-Crockford/dp/0596517742

In addition to the others mentioned, these are also well worth your time:

Eloquent JavaScript

JavaScrip: The Good Parts (This one is essential)

As far as functional programming goes, google "functional programming in javascript." There are several articles on the subject and you'll learn some very useful and interesting techniques. Using a functional style in JavaScript can be extremely rewarding and not to mention a lot of fun!

Everyone here is going to give you a bunch of 30-days or head-first books - many of which will have the ostensible impremateur of big names like Crockford and Resig.

Let me be the first to tell you to basically ignore this crap.

Read the standard, get a good reference on browser differences, then focus on real programming books that are not language specific. That's the way to rise above making jQuery plugins and "HTML5 Game Demos" of Atari 2600 games.

The standard:

http://www.ecma-international.org/publications/standards/Ecma-262.htm

Good reference on browser differences:

http://www.quirksmode.org/compatibility.html

The kinds of books you should be reading (notice the used prices please):

http://www.amazon.com/Introduction-Algorithms-CD-Rom-Thomas-Cormen/dp/0072970545/ref=sr_1_1?ie=UTF8&qid=1313160060&sr=8-1

http://www.amazon.com/Computer-Programming-Volumes-1-4A-Boxed/dp/0321751043/ref=sr_1_1?ie=UTF8&qid=1313160086&sr=8-1

http://www.amazon.com/Structure-Interpretation-Computer-Programs-Second/dp/0070004846/ref=sr_1_1?ie=UTF8&qid=1313160117&sr=8-1

http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612/ref=sr_1_1?ie=UTF8&qid=1313160130&sr=8-1

http://www.amazon.com/Refactoring-Improving-Design-Existing-Code/dp/0201485672/ref=sr_1_1?ie=UTF8&qid=1313160138&sr=8-1

I'd throw in a rickroll if I could.

A deep knowledge of CSS will help. If Javascript is your hammer, CSS is your screwdriver; the two are very related in most cases (sure there are exceptions, like node servers, but they're not common.)

Like JS, the best way to learn CSS is the standard.

http://www.w3.org/TR/CSS21/

Happy hunting.

I feel like this is a classic book for javascript programming. Even though it is very opinionated (parseInt), but none the less it is a great reference for quirky behavior of JS. Seconde watch this: http://www.youtube.com/watch?v=kXEgk1Hdze0 <-- Just a great list of really silly behavior of JS!

http://www.amazon.com/JavaScript-Good-Parts-Douglas-Crockford/dp/0596517742/ref=sr_1_1?s=books&ie=UTF8&qid=1370623429&sr=1-1&keywords=the+good+parts

------
One last thing, make sure you review how CommonJS works: http://dailyjs.com/2010/10/18/modules/

If you're picking up JavaScript as a first language, it might be a bit difficult. It's used so often for the web that you'll most likely be required to learn at least some HTML and CSS as well. But, if you're not discouraged by this there's a lot of resources out there.

The one stop shop that'll give you everything is MDN (https://developer.mozilla.org/en-US/docs/Web). Which has pretty much everything you'll need about JavaScript (https://developer.mozilla.org/en-US/docs/Web/JavaScript).

If you don't know anything about HTML or CSS you might want to at least go through the introductions before jumping over to JavaScript:
https://developer.mozilla.org/en-US/docs/Learn/HTML/Introduction_to_HTML
https://developer.mozilla.org/en-US/docs/Learn/CSS/Introduction_to_CSS

As for programs to use, to start, all you really need is a text editor (I recommend https://code.visualstudio.com/) and a browser. If you're using Chrome press F12 and that should bring up the developer console and type:

console.log("It is " + Date());

Congrats you just wrote JavaScript.

Once you feel more comfortable you'll definitely want to pick up JavaScript: The Good Parts (https://www.amazon.com/dp/0596517742).

Just to throw in my two cents here, I learned how to think in terms of "clean code" after watching a set of lectures by Robert C. Martin, AKA uncle Bob. He provides an conceptual framework for how to write "clean code" and is widely accepted as the subject matter expert in the software engineering community.

I highly recommend it -- He goes over things like "how to name variables", "when to split up functions into smaller ones", "how to structure programs", etc. I'm not kidding when I say that those lectures were the most meaningful improvement I have made as an engineer.


He also has a book too!

I've recently been working on my JS skills and heres a few resources I've found super useful:

Books:

Javascript Patterns

Javascript: The Good Parts

Javascript: The Definitive Guide (While an exhausive resource on the topic, this one is a bit verbose)

Web:

Mozilla's Javascript Guide (One of the best free online javascript guides/references.

How to Node (Tutorials on server-side Node.js)

Daily JS (Interesting JS related news)

Echo JS (Similar to above but updates less frequently)

Hacker News (This is more general tech news but there is a ton of useful web stuff, especially as node.js is currently a hot topic. Reddit actually spawned from HN)

Online Videos (free)

Douglas Crockford's Javascript Lectures (I would recommend these to anyone getting into javascript)

>What are some good guides/practices to unit testing?

Test Driven Development: By Example is a good book to get started with

>Say I have an app with dozens of functions, how do I choose which functions to write tests for, and are there preferred style guides for these tests?

Ideally, you would test them all and you would want to write unit tests and integration tests for them.

>If it helps I want to begin by testing the front end code, whether it's generated with a framework like React or more bespoke using template strings. How do you conduct "recon" on your code to pick the targets to write tests for first, and how do you choose your testing framework?

I've never used bespoke so I can't comment on it but for React I'd recommend jestand enzyme. Jest is a testing framework that was created by Facebook (the creators of React). It's not specifically designed for React but it works great with it. Enzyme is a library made by Airbnb specifically for testing React components. Enzyme is designed to work along side Jest.

>I know you need as much coverage as possible but since you gotta start somewhere, how do you pick the starting point in your code?

The most critical part of your application

I come from the same background. Lot's of good recommendations here. I read this book: http://www.amazon.com/Principles-Object-Oriented-JavaScript-Nicholas-Zakas/dp/1593275404, watched a video series version of Crockford's "Good Parts", and went through this Udacity course: https://www.udacity.com/course/ud015. Hope that helps. Good luck!

I'd go for method 3, though I'd write the functions differently (ex. currying a function that can return undefined is not a good idea). I'm talking about the overall approach here.

My reasoning (and some of this is subjective I know):

• If this isn't being called hundreds of times a second then performance takes a backseat to readability, maintainability and re-usability. I'll gladly sacrifice a few cycles per second to improve any of those things. Of course none of those are mutually exclusive, you can rewrite the code in Method 3 to be a lot faster than what's written in the OP without losing any readability.
  
  
• Each function is short, has a descriptive name and is easy to understand at a glance. When you're working alone maybe this isn't so important, but when you're working on code with 10 other people contributing it makes the whole process much easier. See Clean Code
  
  
• You can easily reuse parts of the algorithm in Method 3 (eg. isShortMessage could be part of an if statement somewhere). The other 2 methods solve one problem and one problem only. If you suddenly find you need a function like isShortMessage somewhere you're either left duplicating code or rewriting those functions to make them more generic.
  
  
• Method 3 is easier to debug. This is a pretty minor point and it's somewhat nullified by the function currying at the end, but it's something to think about.

> But co-writing with a book takes up a lot more time than co-writing with video.

If by co-writing you mean writing the examples from the book/video and making them work, well I never do that. I always read technical programming books as fiction and never try the examples. Sometimes I just return to particular parts in the books for reference, but that's it. For the practical part I do my own things. I don't have time to retype the examples from the books, my life is too short. I got plenty of needs that imply writing software to solve my own personal practical problems. If I think about it long enough, I always come up with some really small project that's (at least theoretically) possible to be made by an almost complete language newbie.

I don't know how useful my personal experience would prove to you, but here you go. My JavaScript journey started when I was living in a cave with no internet access and a very old computer with such a small amount of RAM that it could only run Opera. I found three books about JS on some old CD and picked the basics from them. Having a bit of prior programming experience helped, but I wouldn't overestimate that influence.

Here are the books:

https://www.amazon.com/JavaScript-Good-Parts-Douglas-Crockford/dp/0596517742/

https://www.amazon.com/JavaScript-Enlightenment-Cody-Lindley-2013-01-10/dp/B01FEKKCSA/

https://www.amazon.com/JavaScript-Bible-Danny-Goodman/dp/0764531883/

I found the first one most interesting and useful, the last one was good to use as reference and replacement for the lacking access to online searches.

As you can see, all of them are quite old (and maybe outdated already, since the JS ecosystem moves ahead so fast).

I'm pretty sure there are tons of newer books nowadays.

Very recently I was suggested to have a look at http://javascript.info/ but I didn't manage to get some time to have a closer look at it, so I can't comment on the content there.

HTH

The first thing that comes to mind is understanding scope. In particular, if you come from a C-esque language, this might be one of your biggest hangups. Understanding how the scope works before you write your code will inevitably lead to a better-written product.

(tl;dr for the rest of this: know the fundamentals)

The route I came up, I started as an OOP developer and thought JS was a toy language for much of my career. It wasn't until I took the time to understand the language that I came into my own as a JS dev, and it is currently my favorite language to develop for. If you're the book-reading sort, I would suggest the following resources in sequence:

• JavaScript: The Definitive Guide (David Flanagan)
  
• JavaScript: The Good Parts (Douglas Crockford)
  
• JavaScript Patterns: Build Better Applications with Coding and Design Patterns (Stoyan Stefanov)
  
  If you follow this link and look at the Frequently Bought Together section, you'll see that these three form a common trifecta. What you can expect:
  
  
• The first book will give you a fundamental understanding of the language (I would personally skip the DOM-related parts, since that's more framework/environment than language)
  
• The second book will tell you "Okay, we just gave you a drawer full of knives, here are the ones that won't send you to the hospital"
  
• The third book gives you a rationale for how and why to apply the language in certain ways. It deals with JS-specific issues, and also brings in some of the Gang of Four patterns and other best practices.
  
  (edit: added link to Amazon page for the first of the three books, fixed formatting)

IMO the best resource to learn the TDD mindset is still Kent Beck's TDD by Example.

I also like Joe Rainsberger's TDD Course.

I wrote a blog post with the 3 books about software design (very much related to TDD, IMO) I recommend the most. Hope it is helpful.

I agree that http://www.w2lessons.com/2011/04/you-dont-know-javascript.html is a pretty good read for a beginner to go through.

In there he uses this pattern, (function(){})() which is very powerful and useful. He is however using what Crockford calls, "The dogballs pattern", and suggests that you do this instead

(function(){}())

although that seems to be a minor style point. I would also recommend reading js patterns and the book Javascript Patterns, this is of course after a more in depth review of The Good Parts. There is some really good stuff on YUI Theatre. It isn't just about YUI, and has some really great talks and lectures. Also you don't have to join an open source project, but you do have to keep hacking. I would recommend you to get a github account and start working on some basic js demos to show off. Then maybe come back and make a post here with the link and ask some people to review your code. You can learn a lot by making mistakes and people telling you. PM me if you want me to look over anything.

Advanced

Medium

Old, but probably still relevant

Yet to be released, but you can get the in progress pdf from the publisher

Docs

The one that everybody recommends

HTML5 spec

HTML5Rocks

Latest Webkit News

Other than that build build build. Make demos and play. Ask questions here or on stackoverflow and read other people's code. Also, lots of great old JSConf videos out there.

Start here https://github.com/getify/You-Dont-Know-JS/ , but don't forget to check https://www.amazon.com/_/dp/0596517742?tag=oreilly20-20

The first one will help you to get started and the second one will help you to build a strong base on what's happening and why.

JavaScript is no longer considered a "toy language" and is become much more relevant and demanded due to server platforms that run it (node.js being the biggie).

You should really familiarize yourself with what's happening in the JS scene. To start, take a look at:

• Bower
  
• Grunt
  
• Nodejs obviously
  
  If you're gearing towards UI:
  
  
• Angular
  
• Backbone
  
• Ember
  
  Also, read:
  
  
• Eloquent JavaScript
  
• The Good Parts
  
• Functional JavaScript
  
  I was never a Java developer, but was a PHP developer back in the day. Things like NPM and Node (for building, or writing back-ends) have made my life a hell of a lot easier and less "hackier". You can primarily concern yourself with just integration/work code instead of busy stuff, like copying crap over or adding another lib to your VCS system. Just add it as a dependency and you're off and going.
  
  That being said, JavaScript is really hard to get good at. There is no "standard" way of doing anything, and everything has it's benefits and drawbacks. You need to know which is better and why, and when to break the rules. It's quirks can be tool for powerful code, but you need to know why it is that way.
  
  If you think I'm joking, take a look at this rant.
  

> Recently I have begun experimenting with Shiny, Bokeh, and Dash (which are interactive frameworks in R and Python for creating dashboards and displaying data interactively), and I have found most of these packages are actually just wrappers for Javascript libraries.

Actually Shiny and Bokeh are wrappers for D3.js. I don't know anything about Dash, though.

D3 is the gold standard for data visualisation in JavaScript. There is a really good book, Data Visualisation with Python and JavaScript, by Kyran Dale on O'Reilly. It's designed for devs who know a little of either Python or JavaScript, and the first few chapters go over the basics of both, comparing one to the other. Then it goes through a Python web scraping, data cleaning, web back end technology stack, then turns the data you scraped into something beautiful and interactive with D3.

Or if you'd rather just deep dive into D3, I can recommend Interactive Data Visualisation for the Web by Scott Murray, also on O'Reilly. Despite the title, the book doesn't spend long discussing web development, just the minimum HTML you need to make your D3 projects display. The book is an expanded tutorial on D3, from the very basics to some of the really far-out features.

Either one of these books will give you exactly what you're looking for, depending how much time you'd want to spend with Python before getting into visualisation. And by the way, D3 can also do maps.

I started out with going through the book Javascript: The Good Parts. It's fairly straight to the point and goes over the parts of Javascript that differs from other classical OOP languages pretty well. As the book title suggests, it doesn't go over everything in Javascript, but only the practical parts. Great short read.

This is a really big question, and not really specific to javascript. Architecting large applications, in my opinion, is kind of an art form. You can learn strategies by reading, but you're not going to get good at it without years of experience. Ideally you learn this stuff while working alongside strong senior developers who know what they're doing.

Read Design Patterns, if you haven't. I'd also recommend Javascript Alongé, but I'm a functional programming crazy.

Build something in a way that feels right, then evaluate what worked and what didn't. Which parts sucked to modify when requirements or assumptions changed? Which parts were hard to understand a month later?

In general, I have a few guidelines:

1. Definitely use some sort of module system (AMD, or ES6 modules) to aid in encapsulation and prevent global pollution
   
2. Keep similar code together and differing code apart.
   
3. Keep modules small, and single purpose
   
4. Prefer composition over inheritence
   
5. If you're doing web stuff, don't be afraid to keep the html, css, and js for specific pieces of UI together. Don't fall into the trap of conflating technology with concerns.

Don't listen to jakelear, w3schools is an excellent resource for beginners.

That said, once you are on your feet and getting deeper into JavaScript check out these books. They are wonderfully useful and informative.

http://www.amazon.com/gp/product/0596517742
http://www.amazon.com/gp/product/0596805527
http://www.amazon.com/gp/product/193398869X

Start with Beginning JavaScript with DOM scripting and Ajax: from novice to professional (pretty old skewl, but a it's a great intro and is library agnostic) and then move onto Eloquent JavaScript, The Good Parts and Pro JavaScript Design Patterns.

All I care about is clean code. Code that is easy to read and change. If a framework helps you do this fine.

If you haven't heard of Uncle Bob check this out: http://amzn.com/0132350882

Or if you prefer his goofy video's: https://cleancoders.com/category/clean-code

I really recommend a book Clean Code by Robert C. Martin. It can really help you understand how to write clean code, which you can use and improve right away.

For more advanced topics, "Secrets of the JavaScript Ninja" covers many of the advanced techniques popular libraries use (including prototype and jQuery), written by the jQuery creator.

It assumes you have an understanding of the fundamentals so it gets into the advanced topics pretty quickly.

http://www.amazon.com/Secrets-JavaScript-Ninja-John-Resig/dp/193398869X

Javascript: The Good Parts

and
Javascript: The Definitive Guide

I use the Definitive guide as a reference book, but if you have the patience and want to learn, definitely a good read.

Highly agree. Buy a kindle and read anything people you trust recommend.

I would recommend one javascript specific book, actually: http://www.amazon.com/Effective-JavaScript-Specific-Software-Development/dp/0321812182/ref=sr_1_1?ie=UTF8&qid=1414608930&sr=8-1&keywords=Effective+JavaScript%3A+68+Specific+Ways+to+Harness+the+Power..

I've been doing this a long time and there's still some stuff in there for me to learn every time I flip through it.

no problem, i strongly recommend that your read javascript the good parts by Douglas Crockford who is considered the god of javascript, it's a short read which will clear a lot of confusion and teach you what a powerful and nice language js is

There are a ton of online resources for learning JavaScript. Udemy.com has sales on their courses often, but even YouTube has a lot of good tutorials. But I really enjoyed reading this book: JavaScript and JQuery: Interactive Front-End Web Development https://www.amazon.com/dp/1118531647/ref=cm_sw_r_cp_api_ix2BxbGRFDH10

Just out of curiosity, what's the perceived benefit of logging every page in your history as a QR code of all things?

As for language - Chrome extensions are JavaScript, so if that's what you want to do, learn that. If you're looking for the very basics, Codecadamy is a good place to start. Beyond that, you're on your own (but maybe pick up a copy of the Good Parts )

The bottom line is that, whatever your rationale might be, this code is extremely difficult to read and understand for anyone who isn't you. I had to just skip over the entire tokenizer because I wasn't getting anything out of trying to read it, except for frustration. The algorithm portion isn't much better.

Good names are one of the best ways for an author to communicate how their code works to other programmers. They provide the foothold that the person reading the code needs so that they can begin understanding the algorithms. With what you've got here, the reader must already understand the algorithms before ever seeing the code, so that he can map the concepts he already has in his head onto the uninformative variable names.

I'll give you an example that I paraphrased from Code Complete, which, if you haven't heard of it, is one of the absolute classic works on the topic of how to construct good code. What do you think this code fragment is doing:

a = a - b;
c = d + sales_tax(d);
a = a + late_fee(e, a) + c;
a = a + interest(e, a);

Despite the good function names, it's still extremely difficult to figure out what this code is trying to accomplish; if I have to make a change in something that relates to this module, I don't know where to start. But, after we name the variables:

balance = balance - last_payment;
monthly_total = new_purchases + sales_tax(new_purchases);
balance = balance + late_fee(customer_number, balance) + monthly_total;
balance = balance + interest(customer_number, balance);

See how much easier it is now to see that this code is computing a customer's bill based on their outstanding balance and a set of new purchases from the current month?

Using good variable names allows anyone to just read your code and understand immediately what it is doing. Without good variable names, anyone reading your code has to already know what it is doing.

Get your hands on Douglas Crockford's book "Javascript the Good Parts" (http://www.amazon.com/JavaScript-Good-Parts-Douglas-Crockford/dp/0596517742).
That will help you get started with the language.

Here is a talk he did at Google:
http://www.youtube.com/watch?v=hQVTIJBZook

If your looking for some neat boundary pushing javascript check out the site: http://badassjs.com/

If you check out the first chapter on Amazon, the author says that's exactly why and who he wrote it for. He explains how to get the same OO features you're used to out of JS but also how to utilize the unique aspects of JS: http://www.amazon.com/Principles-Object-Oriented-JavaScript-Nicholas-Zakas/dp/1593275404

Hope it helps. It helped me out quite a bit as I transitioned towards more front-end work

If you're looking for a book I thought Secrets of the Javascript Ninja was a good read, but with Javascript it's really better to use YouTube as /u/theorizable mentioned.

Traversy Media has a few videos covering the basic that are typically short and cover the material well enough to pick up easily.

Traversy Media - Javascript Crash Course For Beginners

Read JavaScript: The Good Parts by Crockford. He goes over structuring JavaScript in an OOP fashion. More generally it's a great book that will bring your understanding of JS from intermediate to the beginnings of expert.

I was actually reading JavaScript Patterns before vither999 recommended the book he did. So i'll definitely check out the book you're suggesting too! Thanks!

I highly recommend checking out the You Don't Know JS book series by Kyle Simpson. It goes in depth into how the language works and all the quirks you might encounter: https://github.com/getify/You-Dont-Know-JS

If you'd like a shorter read and maybe have your opinions formed for you... checkout JavaScript the good parts: https://www.amazon.com/_/dp/0596517742

I always recommend Secrets of a JavaScript Ninja, which has been a great tool for me to learn some of the intermediate to advanced JS stuff. Covers some basics too, but is mostly for learning the deeper stuff. I like it a lot.

Highly recommend: https://www.codeschool.com/paths/javascript

Also in my opinion this is the best book to learn from :

http://www.amazon.com/Professional-JavaScript-Developers-Nicholas-Zakas/dp/1118026691/ref=sr_1_1?s=books&ie=UTF8&qid=1408964857&sr=1-1&keywords=javascript+for+web+developers

Clean code... you can find it on amazon or anywhere else. Pretty highly regarded.

Edit: http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882

This book is worth its weight in gold. It's partially written by John Resig the creator of JQuery and has a large section (possibly a chapter, I forgot) dedicated to es6 Promises

I know you specified PDF books, but this one gets pretty good reviews: https://www.amazon.com/Smarter-Way-Learn-JavaScript-technology/dp/1497408180/ref=sr_1_5?s=books&ie=UTF8&qid=1465666569&sr=1-5. I believe the book assumes no prior programming experience. You could also go through the JavaScript course on https://www.codecademy.com/learn/javascript

MDN Doc Center (or MDC) is indispensable.

If you're looking for a solid book to learn it quick, Stoyan's Object-Oriented JavaScript or Nicholas Zakas' Professional JavaScript are the easiest to read and hit the ground running (as opposed to Crockford's book).

I actually learned quite a bit from Crockford's older talks on YUI Theater — scroll around halfway down the page for his Advanced Javascript and The Javascript Programming Language talks.

Also, word of advice, JavaScript itself is really easy to pick up — especially if you've programmed before. The thing that is going to cause you the most trouble is interacting with the DOM (and browser quirks, etc). There are multiple libraries to help you out, and, while everyone has their own preference of which to learn, jQuery is probably your best bet. I'm not saying it's better than the others, but you will need to know it if you apply to front-end developer jobs.

Lastly, if you are willing to pay money, I really feel you can't go wrong with Stoyan's book.

Hey! I actually majored in Philosophy (Wittgenstein is my homie)!

I've got about 3 years of javascript career experience under my belt, tho this is all web-development centered... so I'm not able to give you any suggestions outside of web-development or native applications. Honestly, It's going to be a bit of a struggle finding data-viz javascript tutorials that are totally outside of those worlds tho.

Anyways... If you arn't against web dev, by far the most popular JS data visualisation library is D3 ( https://d3js.org/ ). It has a steep learning curve, but once you've mastered it you're really able to do quite a lot.

As far as tutorials, I'd suggest this ( https://www.amazon.com/gp/product/1491921285/ref=as_li_qf_sp_asin_il_tl ). But whatever tutorial you end up following for D3, just be sure it's for version 4.X.

It's a design mistake in the language itself, there are quite a few of them. I recommend Douglas Crockford's JavaScript: The Good Parts, he goes into a lot of good practice work-arounds for the pitfalls of the language.

i recently purchased JavaScript Patterns by Stoyan Stefanov and i'm quite satisfied with it. You should check it out too, think it will help you. Although author says it's not a beginner book, I think a person knowledgeable in other programming language(s) could make use of it.

my friend vows by the head first series. I never liked it, but might be good for beginners. http://www.amazon.com/Head-First-JavaScript-Programming-Freeman/dp/144934013X

JavaScript & JQuery: Interactive Front-end Web Development I have been working through this and its quite good. Well structured and designed, so it isnt just a wall of text.

Refactoring: Improving the Design of Existing Code

Clean Code

The Clean Coder

To learn JavaScript I'd recommend "The Principles of Object-Oriented JavaScript".

https://www.amazon.com/Principles-Object-Oriented-JavaScript-Nicholas-Zakas/dp/1593275404/ref=la_B001IGUTOC_1_2?s=books&ie=UTF8&qid=1497101229&sr=1-2

Zakas is a good writer and he knows JavaScript.

http://www.amazon.com/gp/aw/d/0735619670 code complete. One of the best books about coding in general that I've ever read.

I haven't got more that a handful of chapters in, but so far I really like Professional JavaScript for Web Developers

I think I finally understood this by using it a whole lot to find out how it worked, rather than reading any specific resource.

I recommend Professional Javascript for Web Developers by Nicholas Zakas.

Also check out Addy Osmani's blog, especially his piece on Javascript Patterns.

Would I hire you? If I was in a position to do so, sure! But I'm a contractor ;)

I would like to add JavaScript Patterns, which has several ways to structure your code like this.

You're probably going to get a myriad of reactions to this question, but usually the consensus is usually JavaScript: The Good Parts

i guess I do. I follow clean code principles which have a certain style.

http://www.amazon.com/gp/aw/d/0132350882/ref=mp_s_a_1_1?qid=1462071547&sr=8-1&pi=SY200_QL40&keywords=clean+code&dpPl=1&dpID=51oXyW8WQwL&ref=plSrch

Buy Clean Code (https://www.amazon.ca/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882). This book is my bible. Read it through once quickly, and refer back to it once in awhile, and I can guarantee you'll never write spaghetti code again.

This was an excellent book. Very thorough and got me learning my first few months of JS https://www.amazon.com/Professional-JavaScript-Developers-Nicholas-Zakas/dp/1118026691

Aside from Java, you could also start with python, a good introduction:
http://openbookproject.net/thinkcs/python/english3e/
Apparently the head first books are not that bad:

https://www.amazon.com/Head-First-Java-Kathy-Sierra/dp/0596009208

Since at this point I've noticed we're in the javascript sub:
https://medium.com/coderbyte/50-resources-to-help-you-start-learning-javascript-in-2017-4c70b222a3b9

https://developer.mozilla.org/en-US/docs/Learn/JavaScript


Muchos later, read these:

https://www.amazon.com/Pragmatic-Programmer-Journeyman-Master/dp/020161622X

https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882

https://medium.com/startup-grind/a-lifetime-of-learning-to-code-df1a9889c403

https://97-things-every-x-should-know.gitbooks.io/

Are you an experienced programmer already? If so, Javascript the good parts. http://www.amazon.com/JavaScript-Good-Parts-Douglas-Crockford/dp/0596517742/ref=sr_1_1?ie=UTF8&s=books&qid=1251072337&sr=8-1

How much raw JavaScript is it worth knowing? All of it.

Also keep in mind that JavaScript, while object-oriented, is a prototype based language (there are no classes like Java). You can emulate classes in JS using functions as constructors, but there are no classes (even though "class" is a reserved word in JS).

I really recommend these JS books (before jQuery):

JavaScript, The Definitive guide
http://www.amazon.com/JavaScript-Definitive-Guide-Activate-Guides/dp/0596805527/ref=sr_1_1?s=books&ie=UTF8&qid=1330708068&sr=1-1

Pro JavaScript Design Patterns
http://www.amazon.com/JavaScript-Design-Patterns-Recipes-Problem-Solution/dp/159059908X/ref=sr_1_1?s=books&ie=UTF8&qid=1330708101&sr=1-1

JavaScript Patterns
http://www.amazon.com/JavaScript-Patterns-Stoyan-Stefanov/dp/0596806752/ref=sr_1_2?s=books&ie=UTF8&qid=1330708101&sr=1-2

There are more than 356 people in the programming community. This isn't Mumps.

I agree most of the time that early returns are better. But this isn't proof that "most of the programming community agrees". You realize that there is a substantial amount of developers who believe in only 1 return per function, right? Something that is evangelized in Clean Code.

I would check out Secrets of the JavaScript Ninja

It's a great book if you are coming from a different programming language to JavaScript. The syntax of JavaScript may feel familiar but don't be fooled. Javascript has many different quirks, that you should wrap your head around in order to write "good" JavaScript.

My suggestion, go read Crockford's book JavaScript: The Good Parts and/or the JavaScript section of his blog. A lot of people have some really strong opinions on whether Crockford is right or not, but simply reading his book will explode your JS knowledge in a big way. Its a quick read and then you can start having your own opinions on Crockford.

Also, as someone else posted here, go build something.

Just read Jon Duckett's new Javascript book and this was a good gauge for how much I learned. Thanks!

There is also JavaScript: The Good Parts

Javascript: The Good Parts

The C Programming Language is a good one too. Although it's specific to learning C, reading through it and doing all the exercises is something every programmer should do at least once.

Also, Code Complete 2.

I would recommend https://nostarch.com/oojs or https://www.amazon.com/Professional-JavaScript-Developers-Nicholas-Zakas/dp/1118026691

I recommend you this book - http://www.amazon.com/Object-Oriented-JavaScript-high-quality-applications-libraries/dp/1847194141/ref=sr_1_1?s=books&ie=UTF8&qid=1319277048&sr=1-1

There are people who believe JavaScript does not favor good programming styles (I do not support that statement). In my university this semester, a group of graduate students presented a 12-hour course in Python. In many cases, they compared the language with other scripting ones, such as JavaScript, with not so friendly remarks about the language itself and its ecosystem in general. I can understand this claim: JavaScript was created to favor simplicity. Back in 90s, the WWW was still young. Eventually, there was a need to add interactivity to Web Pages. There were many choices, but all of those possible solutions had a stiff learning curve. JavaScript was introduced as a simple scripting language for the web that would target non-developers (there was not such thing as web developers in mid 90s). Unfortunately, the standardization process of the young language (ECMAScript) was not organized with every major browser implement different set of its features (hello IE!). There were not such thing as Design Patterns for JavaScript (until someone introduced them in the wide audience). Years, passed, the Internet evolved, so did the language. There are many things to like about JS today, but this is out of scope of this post. I cannot find a single point of reference about this debate, there are discussions all over the Internet. If your goal is to write a post about this debate, then you have to search for the main arguments of "JS haters" and "JS lovers" manually. Also you have to understand where the term "programmers" refer to. Who is your reference? The Senior developer at a big company, a Junior one, random people that do not know the real aspects of programming, etc. Then you can start researching about the different opinions. Feel free to update your post if like to, but answering "Why people in general hate JS" is quite ambiguous.

I try not to use square brackets when I'm not doing a variable lookup.
With $_GET['distro'] the string 'distro' never changes. So you can just use dot notation.$_GET.distro and cut out some characters.

Also if you're going to run a look up more than one, consider storing the results in a variable. For example you do distro[$_GET['distro']] a couple times. Instead store the result var distroValue = distro[params.distro]

This is especially important with jquery lookups like this $('#inner') because its a really heavy operation to execute a DOM lookup. Instead store the results of the lookup for later use. var $inner = $('#inner');


Heres an annotated version of your code with my notes.

Heres a more readable version of you code.

Also read Clean Code.

It's a little dated now but surprised Javascript for Web Developers by Nicholas Zakas isn't on there.

https://www.amazon.com/dp/1118026691/ref=cm_sw_r_sms_awdb_gSJEzb6NZC36P

Crockford, then Effective Javascript, then the Resig above, then you branch out into your interests.

Code Complete: A Practical Handbook of Software Construction is often recommended

A quick google search will turn up a PDF of it. I'm almost certain that it's a legit, free copy, but I'm not positive. You can get a used, physical copy for $9:

https://www.amazon.com/gp/offer-listing/0596517742/ref=dp_olp_used?ie=UTF8&condition=used

Books I like the most in no particular order.

http://www.amazon.com/gp/aw/d/1617290548

http://www.amazon.com/gp/aw/d/0321812182

http://www.amazon.com/gp/aw/d/193398869X

On this front... do everything you can on node school and on a somewhat unrelated note buy/download this book

My coworkers and I have been slowly going through this book for a while now and we've all learned a lot.

My recommendations for intermediate js devs:

• JavaScript Allonge (read free)
  
• JavaScript Spressore (read free)
  
• Effective Javascript ($27)

https://developer.mozilla.org/en-US/docs/Learn/Getting_started_with_the_web/JavaScript_basics

https://www.codecademy.com/learn/introduction-to-javascript

https://www.learn-js.org/

https://www.udacity.com/course/intro-to-javascript--ud803

https://www.udemy.com/beginning-javascript/

https://www.coursera.org/courses?query=javascript

https://javascript.info/

https://www.w3schools.com/js/

https://www.amazon.com/Eloquent-JavaScript-3rd-Introduction-Programming/dp/1593279507

https://www.amazon.com/JavaScript-Good-Parts-Douglas-Crockford/dp/0596517742

https://www.amazon.com/s?k=you+don%27t+know+js&crid=3CTP426AMFRY2&sprefix=you+don%27t+know+%2Caps%2C208&ref=nb_sb_ss_i_1_15

> https://medium.com/@nodebotanist/why-i-won-t-be-speaking-at-conferences-with-douglas-crockford-anymore-61bc29f028c8#.5da3ctvx3

ahem https://www.amazon.com/JavaScript-Good-Parts-Douglas-Crockford/dp/0596517742/ref=sr_1_1?ie=UTF8&qid=1472862267&sr=8-1&keywords=javascript+the+good+parts

It takes you an hour to read 176 pages?

http://www.amazon.com/JavaScript-Good-Parts-Douglas-Crockford/dp/0596517742

This is my favourite:

http://www.amazon.com/JavaScript-Good-Parts-Douglas-Crockford/dp/0596517742

JavaScript: The Definitive Guide. It's long, but very thorough.

JavaScript: The Definitive Guide

Douglas Crockford's JavaScript

https://www.amazon.com/JavaScript-Patterns-Better-Applications-Coding/dp/0596806752/ref=sr_1_1?s=books&ie=UTF8&qid=1511332535&sr=1-1&keywords=javascript+design+patterns

http://www.amazon.com/JavaScript-Patterns-Stoyan-Stefanov/dp/0596806752

This absolutely.

https://www.amazon.com/Head-First-JavaScript-Programming-Brain-Friendly/dp/144934013X

What really helped me get my head around js and oop was Resig's book

For day-to-day issues and stuff I also use w3schools.com, especially their Javascript Reference

Pro JavaScript Design Patterns

Pro Javascript Design Patterns

Secrets of the Javascript Ninja

http://www.amazon.com/JavaScript-Good-Parts-Douglas-Crockford/dp/0596517742

This book will save you MANY hours of pain.

JavaScript is not OO.

Good JavaScript is not imperative.

Good code period doesn't rely on mutating globals.

[JavaScript Design Patterns] (http://www.amazon.com/JavaScript-Patterns-Stoyan-Stefanov/dp/0596806752/ref=sr_1_2?ie=UTF8&qid=1342784762&sr=8-2&keywords=javascript+design+patterns) by Stoyan Stefanov. Covers more than just design patterns in a traditional sense, but JS patterns of all kind, highlighting and explaining syntax one might not be familiar with along the way.

Call me a heretic, but I found ...The Good Parts to be lacking. While most of the advice is sound, readers are expected to take it as gospel without much explanation. Patterns shown also lack concise implementation examples, and the ones that do tend to rely on utility methods developed in earlier chapters, making it more difficult to use as a reference.