Review: JavaScript: The Definitive Guide, by David Flanagan

[Russ Allbery]

JavaScript: The Definitive Guide
by David Flanagan

Publisher: O'Reilly
Copyright: May 2020
ISBN:      1-4919-5202-4
Format:    Trade paperback
Pages:     665

JavaScript: The Definitive Guide has been frequently revised for new
versions of JavaScript and therefore has multiple editions. This review
is of the seventh edition, first published in May of 2020.

Reviews of programming language books are challenging since people
learn languages in different ways. A short calibration for my
preferences may therefore be useful.

I'm both an experienced programmer in multiple languages (C, Perl,
Python, and some Java and Ruby professionally; Rust, some PHP, and a
few minor languages as a hobby) and I specialized in software theory in
college. I therefore like to learn languages comparatively and am
comfortable with a lot of up-front syntax and discussion of the unique
properties of the language. Introductory programs and practical
exercises doesn't matter as much to me; I'm happy to hold the syntax in
my head until enough of the language has been introduced to write
simple programs.

For me, this book is excellent. It's one of the best language manuals
that I've read, and that requires some work because JavaScript is a
sprawling mess with odd corners, deprecated features, and alternate
implementations of core constructs. Flanagan takes the syntax-first,
comprehensive approach that I prefer, working methodically through the
language (defining your own functions aren't introduced until chapter
eight) and discussing all of the quirks as he goes. I felt like I
thoroughly understood each portion of the language before moving on.

And this book is tight. Some comprehensive language introductions
sprawl, but the benefit of seven editions of iteration is a book that
has been honed to the most direct and effective explanation of each
concept. The section on type conversions with operators, for example,
was so good that I was able to immediately understand the unintuitive
result of [1] + 2 (the string '12'), despite this being one of the most
confusing parts of the language. The sections on JavaScript's
prototype-based object type system and its three concurrency models
(callbacks, promises, and async/await) were equally good. I came away
feeling like I not only understood promises and callback chains but had
a feel for how the same code would look when written in the different
systems.

The drawback in this approach is that if you instead want a language
reference that only tells you the parts of the language that you should
use and leaves out the legacy weirdness and obscure corners for later
(or never), this may not be the book for you. Flanagan labels the
obsolete constructs, but he's meticulous about explaining the entire
language, including such things as new Boolean or var variables that no
one should use. This is what I wanted; I prefer to have a thorough
grounding in language primitives so that it doesn't surprise me. But it
can be a lot to juggle and prune in your head.

JavaScript is a language used in some very different domains. The
approach Flanagan takes to that is to spend as long as possible on the
core language that's usable both in the browser and on the server
(while marking the pieces, such as the module system, that are markedly
different between Node and browsers). He then puts two monster chapters
at the back of the book that cover JavaScript in web browsers and
JavaScript as implemented by Node. Both are more of overviews than
orientations, since a comprehensive manual for either is probably as
long again as this book, but they were more than adequate for my
purposes. (I bogged down a bit in the web browser chapter, in part
because I didn't have an immediate use for most of the material.)
Flanagan wisely defers to MDN as the reference manual for the
JavaScript APIs available in web browsers.

I thought Flanagan also hit the right balance of explanation to
examples, and did a good job controlling the length of the examples.
Most of the code excerpts are short and to the point. The longer ones
have a high level of explanatory power per line, since Flanagan uses
them to pull together multiple concepts and show how they interact. I
was particularly impressed with the example that closes the chapter on
web browsers, which uses <canvas>, ImageData, generators, promises, web
workers, and other areas of the language Flanagan previously explained
to implement a Mandelbrot set explorer in eleven pages of code. I think
that's the longest example in the book, and it's well worth it.

This sort of introduction will always have limitations. Flanagan
provides a brief orientation to the ecosystem surrounding JavaScript in
the last chapter, but most JavaScript programmers will be working with
packaging tools and frameworks that could themselves be the topic of
another book and that he doesn't have room to cover. JavaScript, even
more than most languages, is commonly used via a heavy layer of
supporting libraries and abstractions, so you will probably not be able
to tackle a practical JavaScript project using solely the material in
this book. But if you're the sort of programmer who wants to start with
a solid syntactical and conceptual understanding of the language core
before starting on more applied topics, I've rarely seen it done better
than this book.

If you want a quick-start guide that will get you writing code quickly
and is opinionated about what parts of the language you should learn,
this may not be the book for you. But if you're comfortable with
comprehensive detail in your language guides, this was exactly what I
was looking for. Recommended.

Rating: 9 out of 10

Reviewed: 2021-03-28

URL: https://www.eyrie.org/~eagle/reviews/books/1-4919-5202-4.html

-- 
Russ Allbery (eagle at eyrie.org)             <https://www.eyrie.org/~eagle/>