[Best Beginner Book] You Don't Know JS Yet: Get Started


It’s real! The 2020, 2nd edition of You Don’t Know JS Yet: Get Started is here. See this tweet from February 1st proving its realness:

The title of the entire Javascript series resonates with me. The new “yet” appended to the title has the perfect amount of snark: of course we can all say that we used Javascript and achieved the result we wanted, but we can’t all say that we know Javascript — yet.

That’s because the way Javascript thinks is complicated and not consistent with other programming languages. In my career, I deal with this insecurity about Javascript. Truly knowing Javascript is a touchy subject for many of us.


Overview of You Don’t Know JS Yet: Get Started

You Don’t Know JS Yet: Get Started should not be called Get Started. Its truer title is “Under the Hood,” since the entire idea behind book one of the series is to lift the hood, point out the components, and highlight idiosyncrasies in Javascript.

The book works to prep you thoroughly on how Javascript really thinks. The author, Kyle Simpson, imbues his writing with the principles in the famous programming book The Pragmatic Programmer: the book empowers all beginning software engineers with the root concepts so that they can think for themselves.

This is the opposite of the cowboy approach to learning Javascript programming. I can sense the You Don’t Know JS Yet series comes from a deeply-felt place of having experienced mistakes Javascript developers make in thinking about the fundamentals of Javascript programming.

As a front-end web developer, I am hungry for this knowledge, and I am grateful for the information this book provides.

A great quote highlighting this idea comes from Chapter 2:

It's very common to suggest that var should be avoided in favor of let (or const!), generally because of perceived confusion over how the scoping behavior of var has worked since the beginning of JS. I believe this to be overly restrictive advice and ultimately unhelpful. It's assuming you are unable to learn and use a feature properly in combination with other features. I believe you can and should learn any features available, and use them where appropriate!

These principles puts me in a place of trusting the book and the wisdom it has to impart. Everything is about why and how elements exist, which is why I am here. It’s what I live for in software development.

And if it’s what you live for too, please read on and learn more about what You Don’t Know JS Yet: Get Started is all about.


Three Takeaways of You Don’t Know JS Yet: Get Started

The following are three key takeaways that I found while reading You Don’t Know JS Yet: Get Started.


Takeaway #1: Execution Contexts

One of the greatest concepts all Javascript developers need to wrap their minds around is the this keyword.

Unlike other programming languages, this is dynamic. Get Started takes time with this, since getting clarity around it is a challenge.

Get Started takes the time to explain not just how this behaves, but why:

Indeed, one of the main reasons this supports dynamic context based on how the function is called is so that method calls on objects which delegate through the prototype chain still maintain the expected this.

Unlike many other languages, JS's this being dynamic is a critical component of allowing prototype delegation, and indeed class, to work as expected!

Instead of seeing Javascript’s strange this handling based on context as a negative or a mistake in Javascript, Get Started clearly explains the thinking behind this, which can inform our thinking when we program.

Takeaway #2: Objects in Javascript

Get Started takes the time talking about what objects are in Javascript so that I can fully understand.

Objects are one of the most baffling things for me in Javascript, since the wisdom I commonly receive is “Everything is objects.” It only makes me go cross-eyed and brings me no closer to a Javascript god.

Get Started’s greatest strength for me was bringing objects to clarity. It even acknowledges some strangeness up front. For example, yes, functions are objects, but when you use the `typeof` operator on a function, it will return function but when you use the typeof operator on an array, it returns object.

Get Started also shares that null returns object with the typeof operator, which is a Javascript bug to be cautious of. The book also warns about equality mistakes that Javascript makes.


Takeaway #3: Take Your Time

Each chapter gets started with a bit of a warning: slow down and take your time.

Here is one such example from Chapter 1: About this Book:

I emphasize the word journey because knowing JS is not a destination, it's a direction. No matter how much time you spend with the language, you will always be able to find something else to learn and understand a little better. So don't look at this book as something to rush through for a quick achievement. Instead, patience and persistence are best as you take these first few steps.

Which is iterated again in Chapter 2:

Please don't expect this chapter to be a quick read. It's long and there's plenty of detail to chew on. Take your time.

And again in Chapter 3:

Don't run so quickly through this material that you get lost in the weeds. As I've said a dozen times already, take your time. Even still, you'll probably finish this chapter with remaining questions. That's OK, because there's a whole book series ahead of you to keep exploring!

And it’s true. With Get Started, you do need to slow down to get the maximum benefit from the book. This can be true of many books. But for those who have taken my Get the Most From Technical Books free email course, you know that I am also about speed and extracting the most value from the time you invest. This does not mean extracting everything from the book that it has to offer.

The passages above give me mixed feelings, but I will start with the good:

I agree that when learning, it’s absolutely essential to slow down to absorb material, and there are tactics that can help you absorb material better. That’s why I also built my free Instant-Learner Guide, which you can get from the Books on Code homepage.

Some great tactics to slow down and get the most from the material is by self-quizzing and taking notes by hand (in fact, I made flash cards for Chapter 2 on Cram.com).

Making yourself use and manipulate the information solidifies the connections in your mind. In my Instant-Learner Guide, I use the metaphor of relational database, since ‘learning’ ought to be reframed as making retrieval easier and easier. You need to optimize your brain’s search algorithm.

Many great technical books on programming also tell you to slow down. The Head First series (that I always rave about) makes clear that all of the games and Q&A sections are mandatory activities. When the book poses a question, answer the question. Get out a pencil. Write directly in the book, because that’s how you’re going to learn.

My previous review of Grokking Algorithms similarly encourages taking your time by answering the questions it asks throughout the book. It also provides many natural breakpoints through white space and illustrations, so that slowing down is natural.

But perhaps by now you’re sensing my gripe with Get Started: it tells you to slow down, but the book is not actively working to help you to slow down.

Ways the book can do this is by asking questions and providing bullet-pointed summaries and natural breakpoints. The book is dense in content and written mostly in paragraphs. Just by the nature of the structure, it’s harder to tell where the emphasis is and extract the key nuggets of wisdom from the text, since the knowledge is presented with equal emphasis.

Reading Get Started requires that you put forward more work to understand the material, but Get Started is so dense with wisdom, that is so hard-won and valuable, that the tradeoff can be worth it.

But before moving on to the next section, a little story:

I was recently at a week-long immersive training to use a complex piece of software. The instructors were fun and kind; they put a lot of love into the curriculum they produced for us, but there was a problem:

It was the documentation.

The students kept asking questions to which the instructors, frustrated, would say, “It’s written right here,” and point to the documentation. Then they would instruct us to “slow down” and “read it again”.

Since working in technical writing at a large software company, I can say definitively that it doesn’t matter if “it’s right there in the text”. The structure is everything.

Writers of technical documentation take great pains to do all of the thinking about and structuring the material so that the reader doesn’t have to suffer deciphering.

Hierarchy is important when thinking about documentation. When everything is equally weighted, with every piece of knowledge equally as loud, the reader is less likely to benefit fully from the text, dealing with that overwhelming ‘drinking from a firehose’ feeling.


Review Snapshot

This review snapshot covers all the basics you need to understand about this book: the audience that suits this book best, its affordability, how much value the book brings, and most importantly, how fun the book is to read. Since after all, books on programming ought to be fun to read.

Main Audience: “Javascript Beginner, ES5er, or Cowboy Coder”

While I can’t say this is my first rodeo with Javascript, I, like many, picked it up with the mindset at which it was marketed: a fun, ‘easy’ scripting language. It’s long overdue to overturn that false narrative and see Javascript for the powerhouse it is — as a legitimate programming language.

As a self-taught front-end web developer (with the help of some amazing mentors 👋😁), I felt inadequate next to my C++ and Java-slinging Computer-Science student peers. Their impression was that Javascript was not programming. That entered my consciousness early on. To learn a programming language, I took on C++ and Python to learn the roots of object-oriented programming, while completely missing that I could learn and apply these principles to Javascript.

The Get Started book serves those who have used Javascript but don’t feel that they know Javascript. For a total software developer beginner, the book might be daunting, as certain phrases (such as what a ‘shallow’ vs ‘deep’ copy is) is glossed over, assuming understanding.

The material is also dense and goes by quickly. If the material is torturing to understand, taking a beginning programming classes (such as Udacity’s Intro to Programming program) may be a better place to start to get context and understanding about programming in general.

Affordability Score: “Free or Inexpensive”

If you are happy with reading READMEs, you have complete, free access to You Don’t Know JS Yet on GitHub. But if you’re really cool and want to support the author, you can get it on Amazon, either the Kindle version or print version for $8 or $23 USD respectively.

Value Score: “A Mindful Meal”

This book packs a lot of value, but it definitely does take slowing down with the text and doing homework to get the most from the material. I recommend making flashcards based on what you learned and quizzing yourself.

Fun Score: “Scavenger Hunt of Exciting Insights”

I had fun reading this book for the main reason that I got insights I found incredibly valuable and insightful. I felt like I was truly being enriched and made into a better Javascript developer, which is one of the best feelings out there.

Conclusion: “Icon Out Your JS Kinks”

Read this book if you want to iron out your kinks with using Javascript. Also keep in mind that this book is the introduction to a larger series of Javascript books.

If you’re interested in the following books of the You Don’t Know JS Yet series, Get Started details a helpful order to read them in (though not required):

My suggestion for most readers is to proceed through this series in this order:

1. Get started with a solid foundation of JS from Get Started (Book 1) -- good news, you've already almost finished this book!

2. In Scope & Closures (Book 2), dig into the first pillar of JS: lexical scope, how that supports closure, and how the module pattern organizes code.

3. In Objects & Classes (Book 3), focus on the second pillar of JS: how JS's this works, how object prototypes support delegation, and how prototypes enable the class mechanism for OO-style code organization.

4. In Types & Grammar (Book 4), tackle the third and final pillar of JS: types and type coercion, as well as how JS's syntax and grammar define how we write our code.

5. With the three pillars solidly in place, Sync & Async (Book 5) then explores how we use flow control to model state change in our programs, both synchronously (right away) and asynchronously (over time).

6. The series concludes with ES.Next & Beyond (Book 6), a forward look at the near- and mid-term future of JS, including a variety of features likely coming to your JS programs before too long.

Since the books in the series are granularly broken out, the series enables focus and prevents overwhelm to know that we can chunk and isolate areas where we can gain expertise.

I am excited about Sync & Async and look forward to reading Scope & Closures as the next book.

Luckily, there’s a great group of software developers reading these books every Sunday. Check out CodeBookClub on Twitter for more information.

If you like this article, share it with the Javascript developer in your life. Let’s spread the word about being the best software developers we can be. 💪

And if you want to improve your study habits and become a learning monster, sign up for my free email course, Get the Most From Technical Books.

Until next time! 🎉


Miranda Limonczenko

Miranda is the founder of Books on Code, with a mission to bring book-lover culture to programmers. Learn more by checking out Miranda on LinkedIn.


The Pragmatic Programmer Book 2nd Edition Differences


Why You Should Stop Freeloading and Pay for Your Programming Books