(Part 2) Best products from r/javascript

Head First HTML5 Programming is a very visual book with a ton of review and quizzing and uses practical examples to teach Javascript, it's a little dated at this point, but a really great resource for book learners .

The Odin Project spends a lot of time in the beginning on teaching helpful tooling that a lot of other learning resources leave out, like git, developer tools, debugging and testing, it takes a little while to get to the Javascript part, but everything before that ends up being very useful .

Brad Traversy's Modern Javascript from the beginning Udemy course is a fantastic and thorough introduction to Javascript . Javascript has seen a lot of cool updates in the past few years, and this is one of the only courses that starts out with the "modern" approach, so you don't end up having to relearn a bunch of things . A great course for video learners .

Practical Javascript,A great course that teaches entry level javascript with practical examples that build on top of each other to form a full project . The paid subscription is a fantastic course that goes into a lot of important subjects often skipped in other courses, but can at times be very boring .

Other resources you're likely to be referred to that I somewhat disagree with

Free Code Camp & Codecademy, if you were instead learning to draw, the teaching methods of these courses would be the equivalent of tracing pictures you liked . Free Code Camp has a really great and helpful community built around it though .

You don't know Javascript & Eloquent Javascript really are some great books and deserve their praise, they're just not the friendliest introductions to Javascript if it's you don't already have some knowledge of Javascript or other programming languages .

Javascript & jQuery by Jon Ducket, this book is fine, but I just don't feel it's as good of an introduction as any of The Head First books, while still being just as dated. It is a lot more comprehensive though, but it doesn't build to a project, use as practical of examples or do as much hand holding .

Congratulations! That's a big step. Be proud that you were able to make the switch. Not many people manage to transform ideas into results.

I think there are four areas on which you need to focus, in order to go from mediocre to great. Those areas are:

1. Theoretical foundation.
   
2. Working knowledge.
   
3. Software engineering practices.
   
4. Soft skills.
   
   Now, these areas don't include things like marketing yourself or building valuable relationships with coworkers or your local programming community. I see those as being separate from being great at what you do. However, they're at least as influential in creating a successful and long-lasting career.
   
   Let's take a look at what you can do to improve yourself in those four areas. I'll also suggest some resources.
   
   ​
   
   1. Theoretical foundation
   
   Foundational computer science. Most developers without a formal degree have some knowledge gaps here. I suggest taking a MOOC to remediate this. After that, you could potentially take a look at improving your data structures and algorithms knowledge.
   
   

• CS50: Introduction to Computer Science
  
• Grokking Algorithms
  
• Algorithms by Sedgewick
  
  ​
  
  2. Working knowledge.
  
  I'd suggest doing a JavaScript deep-dive before focusing on your stack. I prefer screencasts and video courses for this, but there are also plenty of books available. After that, focus on the specific frameworks that you're using. While you're doing front-end work, I also suggest you to explore the back-end.
  
  ​
  
  
• FunFunFunction on Youtube
  
• You Don't Know JS
  
• JavaScript Allonge
  
• JavaScript Design Patterns ​
  
  3. Software engineering practices.
  
  Design patterns and development methodologies. Read up about testing, agile, XP, and other things about how good software is developed. You could do this by reading the 'Big Books' in software, like Code Complete 2 or the Pragmatic Programmer, in your downtime. Or, if you can't be bothered, just read different blog posts/Wikipedia articles.
  
  ​
  
  4. Soft skills.
  
  

1. Actively seek to mentor and teach others (perhaps an intern at work, or someone at a local tech community, or create blog posts or videos online).
   
2. Get mentorship and learn from others. Could be at work, or open source.
   
3. Go to programming meetups.
   
4. Try public speaking, go to a Toast Masters meetup.
   
5. Learn more about and practice effective communication.
   
6. Learn more about business and the domain that you're working in at your company.
   
7. Read Soft Skills or Passionate Programmer for more tips.
   
   ​
   
   Some closing notes:
   
   - For your 'how to get started with open source' question, see FirstTimersOnly.
   
   - If you can't be bothered to read or do large online courses, or just want a structured path to follow, subscribe to FrontendMasters and go through their 'Learning Paths'.
   
   - 4, combined with building relationships and marketing yourself, is what will truly differentiate you from a lot of other programmers.
   
   ​
   
   Sorry for the long post, and good luck! :)

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.

Use ESLint with recommended settings, so your code editor will yell at you for a lot of mistakes you'd make. They provide plugins for most code editors and IDEs, configuration is a matter of having .eslintrc-file in the directory your code is in. Some rules that you might want to enable that aren't in the recommended set are "eqeqeq" and "no-unexpected-multiline", this allows you to avoid many problems related to features like Automatic Semicolon Insertion (ASI) and type coercion.

Later on when you've got some more advanced stuff like a build process with transpiler going (or you don't have to worry about how your code runs in older browsers), you'll want to enable ES6 rules like "no-var" and "prefer-const" to also get rid of some potential hoisting issues and accidental reassignments. But that's likely a story for another time that can be ignored for now.

The ESLint's constant nagging about everything can be annoying at first, but after you've seen and fixed the same red squiggly lines a hundred times, you no longer get them and avoid the problems by default even if you don't have linters somewhere.

Some people will tell you to read "JavaScript: The Good Parts" book, but that's outdated and you'll avoid many pitfalls by default with the recommended ESLint settings. If you want books, check out things like You Don't Know JS (free) and Eloquent JavaScript.

Also, the next time you are about to loop through an array, take another look through the array iteration methods at MDN.

You'll probably see a method that is made exactly for what you are doing and allows you to describe what you want, instead of doing bunch of step-by-step instructions that don't describe your intention and are just noise among the logic.

Edit: Oh and get familiar with chrome developer tools and debugging. Writing code is like 10% of the job at best, figuring out why problems happen is like 90%. Spending a few hours getting familiar with the debug tools beyond console.log is one of the best things you can do with your time and will save you so much trouble in the future you can't even imagine it.

If you aren't a new programmer, but just new to JavaScript itself, it's also definitely worth it to read Mostly Adequate Guide to Functional Programming (free) and learn how to really take advantage of JavaScript being a functional language.

Edit2: Tried to make the post a bit more straightforward.

Yup, you're right! It looks like MDN recommends + over concat for performance reasons, but both are functionally equivalent.

And thanks for the kind words, they mean a lot!

The one book that really helped me was Functional Programming in Scala, I can't recommend it enough. It takes a very 'exploratory' approach, and has lots of exercises which are very helpful.

Scala was probably the best language for me to learn fp in, since I had lots of experience with JS & the syntax is very similar to it, hope that helps!

Read this book.

Then, after reading the whole thing cover to cover, start working on your proposal.

From some of the questions you're asking about jQuery integrating with a framework, it's clear that some more basic concepts of how to isolate legacy code and migrate piece-by-piece would be very helpful.

Also, just a suggestion, but I'd highly recommend doing the new development in TypeScript. It'll compile to play nice with any other code you might need it to, but will offer you some awesome tooling that will help in maintaining your project moving forward.

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.

Great question. I think about this a lot as well. As someone who was previously really bad at design and has gradually gotten a little bit better:

1. The book that really got me into this was Information Dashboard Design by Stephen Few: https://www.amazon.com/Information-Dashboard-Design-Effective-Communication/dp/0596100167. Tufte has some really great work as well.
   
2. Any time I find a design that I like, I take a full-page screenshot and save it to a folder in my notes system. I have about 40 full-page screenshots that I turn to.
   
3. Five Interface Laws Every Software Designer Should Know: https://speakerdeck.com/roundedbygravity/5-interface-laws-every-software-designer-should-know
   
4. This great Quora Post on color science: https://www.quora.com/Is-there-a-science-to-picking-colors-that-work-well-together-or-is-it-just-subjective/answer/Colm-Tuite
   
5. Ian Storm Taylor - Never Use Black: https://ianstormtaylor.com/design-tip-never-use-black/

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.

Not a magic bullet but these helped me:

• Study the structure of big popular open source projects like lodash or JQuery that have been around for awhile, learn how they structure and organize their code and borrow from it.
  
  
• A book like Clean Architecture might help too.
  
  
• Understand how JavaScript works under the hood and computers in general so you have a better understanding of the whole system, this involves learning low level documentation.
  
  
• Get really good with OOP.
  
  
• Code->Refactor->Code->Refactor, apply and reiterate all the stuff you've learned and see if it works.
  
  Disclaimer: I'm a pretty terrible programmer, but I used to be a lot worse.

> 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

As weird and outlandish as it seems, FP provides some great benefits to JS, and the best introduction to it (in my own experience) has been Real World Haskell.

If you'd like to view some active approaches to FP in JS, i'd suggest starting with pull-streams and Functional Programming in Javascript

I'm self taught as well and decided to help bridge the gap in 2 ways:
Read this book...Its not gospel for how every interview will go, but will give you an idea of how a CS heavy interview might go:
https://www.amazon.com/Cracking-Coding-Interview-Programming-Questions/dp/098478280X

If you have enough time, follow the videos in this course and also get the pdf of the book. The topics will be quite dense at first, but keep at it and they will eventually make sense:
http://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-006-introduction-to-algorithms-fall-2011/calendar/

To reiterate the same as others, its meant to weed out people who don't have a CS background; but don't be afraid to say you don't know something. Use that as an advantage and come prepared with situations where you didn't know something, but were able to read up/comprehend it and then applied the knowledge as a new skill :) Its impossible for everyone to know everything as a developer, we can only keep learning :)

Not a direct answer for your question, but I recently started reading JavaScript Application Design: A Build First Approach. What I've read is pretty sound and seem like you are the target audience.

The framework in the book is Backbone.js so you won't really get the reactive / shadow-dom stuff that React gives you, but you will have a nice stepping stone to get there.

Absolutely. I'd say learn programming first via Scheme or Ruby, then go back and learn JavaScript.

Though actually, "JavaScript, The Good Parts" is a pretty tough read even with a computer science background. Good book, but extremely terse. Expect to take half an hour to understand some of the pages...

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/

The Pragmatic Programmer. Here is a quick ref that gives a good overview of the contents.

I am a fan of JavaScript Application Design: A Build First Approach - a few years old but still very relevant.

Also pragmatic programmer - distilled experience over time.

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

I think its called HTML5 but there is a big emphasis on javascript
https://www.amazon.com/Head-First-HTML5-Programming-JavaScript/dp/1449390544

edit: theres actually one just for javascript but i've never read that one

https://www.amazon.de/Working-Effectively-Legacy-Robert-Martin/dp/0131177052?ie=UTF8&tag=googdemozdesk-21&hvadid=323934261977&hvpos=1t1&hvnetw=g&hvrand=10757532144450521743&hvpone=&hvptwo=&hvqmt=b&hvdev=c&hvdvcmdl=&hvlocint=&hvlocphy=9072483&hvtargid=dsa-19959388920&ref=pd_sl_35q8ibnq4w_e&language=en_GB

Javascript Allonge

Functional Javascript