Why You Must Read 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:
Overview of You Don’t Know JS Yet: Get Started
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
varshould be avoided in favor of
const!), generally because of perceived confusion over how the scoping behavior of
varhas 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
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
thisbeing dynamic is a critical component of allowing prototype delegation, and indeed
class, to work as expected!
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
Get Started also shares that
object with the
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.
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.
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”
Conclusion: “Icon Out Your JS Kinks”
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
thisworks, how object prototypes support delegation, and how prototypes enable the
classmechanism 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.
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! 🎉