Book Review, Eloquent JavaScript

Introduction:

When I first decided to learn JavaScript, two books kept appearing everywhere: "Eloquent JavaScript" and "JavaScript: The Definitive Guide".

The former felt more approachable. Lighter. More “beginner-friendly,” at least according to the internet.

So I picked up Eloquent JavaScript by Marijn Haverbeke.

What followed was a difficult journey, with a happy ending.

First Impressions:

At the beginning, things felt manageable. Since I had a bit of background in C, the early chapters were not particularly intimidating. Variables, control flow, basic structures. They made sense.

But very quickly, something strange began to happen. The book started to feel ...difficult.

Not in an obvious way. Not the kind of difficulty where you can point to a concept and say, “this is too advanced". Instead, it was a quieter resistance. You read a chapter, and it feels heavier than expected. You understand parts of it, but not completely. Something doesn’t fully click.

My Experience with this Book:

This is where my relationship with the book became complicated.

On one hand, it is clearly written for beginners. It does not assume deep prior knowledge. On the other, it demands effort in a way that most beginner resources do not.

Sometimes the examples feel slightly more complex than they need to be. Sometimes the explanation feels just one step ahead of your current understanding.

But this is also where the book reveals its strength. It forces you to slow down.

• You read a section once -> It's unclear.
• Twice -> Slightly better.
• Three times -> Still not quite there.

So you step away. You search, struggle, spend a few days understanding the idea elsewhere. YouTube, MDN, Reddit, etc. And then you return.

And now finally! It makes sense.

That moment, when the text that once felt dense now feels obvious, is where this book quietly rewards you.

The Beauty in Its Explanations:

Once you do understand that concept you've long been stuck with, you begin to notice something interesting:

The way it was explained by the author is actually quite elegant.

Haverbeke has a way of framing ideas that stays with you. One example that never left me is how he describes functions. Not just as reusable code, but as a way of defining new vocabulary within a program.

He explains this using an example of writing a recipe.

He asks the reader which version is easier to follow:

1. "Put 1 cup of dried peas per person into a container. Add water until the peas are well covered. Leave the peas in water for at least 12 hours. Take the peas out of the water and put them in a cooking pan. Add 4 cups of water per person. Cover the pan and keep the peas simmering for two hours. Take half an onion per person. Cut it into pieces with a knife. Add it to the peas. Take a stalk of celery per person. Cut it into pieces with a knife. Add it to the peas. Take a carrot per person. Cut it into pieces. With a knife! Add it to the peas. Cook for 10 more minutes."
2. "Per person: 1 cup dried split peas, half a chopped onion, a stalk of celery, and a carrot. Soak peas for 12 hours. Simmer for 2 hours in 4 cups of water (per person). Chop and add vegetables. Cook for 10 more minutes."

Well, obviously the second one. The only catch is that you should know what "soak", "simmer", "chop", & "vegetables" mean. This is how the author introduces functions in this book.

It's not the most beginner-friendly way, but once you get the metaphor, it's beautiful. It is a simple idea, but it changes how you think.

Programming stops feeling like writing instructions and starts feeling like building a coherent & manageable system.

These kinds of metaphors are scattered throughout the book. You may not appreciate them immediately, but once you do, they stick.

The Exercises in this Book:

The "Exercises" at the end of each chapter deserve a separate mention.

Caveat: They are not easy.

They demand thought, patience, and often multiple attempts. At times, they can feel frustrating. But they are not difficult for the sake of it. They are designed to stretch your understanding.

If you engage with them earnestly, they transform the book from something you read into something you work through.

A Gradual Climb:

As the book progresses, it becomes increasingly demanding.

Later chapters introduce deeper concepts: Objects, Prototypes, Asynchronous Programming, Canvas, & so on.

The cognitive load rises steadily. This is not a book you casually finish.

It is closer to a long journey. One that requires revisiting chapters, rereading sections, and occasionally stepping away before coming back again.

What This Book Gives You:

Eloquent JavaScript does not aim to make you productive quickly. It does something far more valuable.

It gives you structure.

It shows you:

• What to learn.
• In what order (roughly).
• What “Understanding JavaScript” actually means.

Over time, it becomes less of a book and more of a benchmark.

If you can work through it - and I mean truly work through it - you begin to feel a certain confidence. Not because you memorised syntax, but because you’ve wrestled with the fundamentals.

It even helps, in a quiet way, with something many beginners struggle with: the feeling that they don’t really belong.

How to Approach It:

This is not a one-time read.

You will likely go through it multiple times (three, four, maybe more). And that is okay.

The best way to treat this book is not as something to “finish quickly”, but as something to keep with you.

Return to it. Revisit it. Let your understanding grow into it.

There is also a free online version, which makes it even easier to come back to it whenever you need.

But I recommend getting a hard-copy. Make it yours. Scribble your doubts. Highlight what clicks & piques. Turn it into a conversation, not just a book.

Conclusion:

Eloquent JavaScript is not an easy book.

But it is not inaccessible either.

It sits in a rare space: challenging enough to push you, but grounded enough to guide you.

If you commit to it, patiently and honestly, it rewards you with something deeper than surface-level knowledge: a sense that you understand what you are doing.

And that, in the long run, is far more valuable than speed.