Review: Learning React, by Alex Banks & Eve Porcello

Russ Allbery eagle at eyrie.org
Sat Apr 24 22:16:17 PDT 2021


Learning React
by Alex Banks & Eve Porcello

Publisher: O'Reilly
Copyright: June 2020
ISBN:      1-4920-5172-1
Format:    Trade paperback
Pages:     287

My first JavaScript project was a React frontend to a REST service. As
part of that project, I read two books: JavaScript: The Definitive
Guide to learn the language foundation and this book to learn the
framework on top of it. This was an unintentional experiment in the
ways programming books can approach the topic.

I commented in my review of JavaScript: the Definitive Guide that it
takes the reference manual approach to the language. Learning React is
the exact opposite. It's goal-driven, example-heavy, and has a problem
and solution structure. The authors present a sample application,
describe some desired new feature or deficiency in it, and then
introduce the specific React technique that solves that problem. There
is some rewriting of previous examples using more sophisticated
techniques, but most chapters introduce new toy applications along with
new parts of the React framework.

The best part of this book is its narrative momentum, so I think the
authors were successful at their primary goal. The first eight chapters
of the book (more on the rest of the book in a moment) feel like a
whirlwind tour where one concept flows naturally into the next and
one's questions while reading about one technique are often answered in
the next section. I thought the authors tried too hard in places and
overdid the enthusiasm, but it's very readable in a way that I think
may appeal to people who normally find programming books dry. Learning
React is also firm and definitive about the correct way to use React,
which may appeal to readers who only want to learn the preferred way of
using the framework. (For example, React class components are mentioned
briefly, mostly to tell the reader not to use them, and the rest of the
book only uses functional components.)

I had two major problems with this book, however. The first is that
this breezy, narrative style turns out to be awful when one tries to
use it as a reference. I read through most of this book with both
enjoyment and curiosity, sat down to write a React component, and
immediately struggled to locate the information I needed. Everything
felt logically connected when I was focusing on the problems the
authors introduced, but as soon as I started from my own problem, the
structure of the book fell apart. I had to page through chapters to
locate some nugget buried in the text, or re-read sections of the book
to piece together which motivating problem my code was most similar to.
It was a frustrating experience.

This may be a matter of learning style, since this is why I prefer
programming books with a reference structure. But be warned that I
can't recommend this book as a reference while you're programming, nor
does it prepare you to use the official React documentation as a
reference.

The second problem is less explicable and less defensible. I don't know
what happened with O'Reilly's copy-editing for this book, but the code
snippets are a train wreck. The Amazon reviews are full of people
complaining about typos, syntax errors, omitted code, and glaring
logical flaws, and they are entirely correct. It's so bad that I was
left wondering if a very early, untested draft of the examples was
somehow substituted into the book at the last minute by mistake.

I'm not the sort of person who normally types code in from a book, so I
don't care about a few typos or obvious misprints as long as the
general shape is correct. The general shape was not correct. In a few
places, the code is so completely wrong and incomplete that even
combined with the surrounding text I was unable to figure out what it
was supposed to be. It's possible this is fixed in a later printing (I
read the June 2020 printing of the second edition), but otherwise
beware. The authors do include a link to a GitHub repository of the
code samples, which are significantly different than what's printed in
the book, but that repository is incomplete; many of the later chapter
examples are only links to JavaScript web sandboxes, which bodes poorly
for the longevity of the example code.

And then there's chapter nine of this book, which I found entirely
baffling. This is a direct quote from the start of the chapter:

  This is the least important chapter in this book. At least, that's
  what we've been told by the React team. They didn't specifically
  say, "this is the least important chapter, don't write it." They've
  only issued a series of tweets warning educators and evangelists
  that much of their work in this area will very soon be outdated. All
  of this will change.

This chapter is on suspense and error boundaries, with a brief mention
of Fiber. I have no idea what I'm supposed to do with this material as
a reader who is new to React (and thus presumably the target audience).
Should I use this feature? When? Why is this material in the book at
all when it's so laden with weird stream-of-consciousness disclaimers?
It's a thoroughly odd editorial choice.

The testing chapter was similarly disappointing in that it didn't
answer any of my concrete questions about testing. My instinct with
testing UIs is to break out Selenium and do integration testing with
its backend, but the authors are huge fans of unit testing of React
applications. Great, I thought, this should be interesting; unit
testing seems like a poor fit for UI code because of how artificial the
test construction is, but maybe I'm missing some subtlety. Convince me!
And then the authors... didn't even attempt to convince me. They just
asserted unit testing is great and explained how to write trivial unit
tests that serve no useful purpose in a real application. End of
chapter. Sigh.

I'm not sure what to say about this book. I feel like it has so many
serious problems that I should warn everyone away from it, and yet the
narrative introduction to React was truly fun to read and got me
excited about writing React code. Even though the book largely fell
apart as a reference, I still managed to write a working application
using it as my primary reference, so it's not all bad. If you like the
problem and solution style and want a highly conversational and
informal tone (that errs on the side of weird breeziness), this may
still be the book for you. Just be aware that the code examples are a
trash fire, so if you learn from examples, you're going to have to
chase them down via the GitHub repository and hope that they still
exist (or get a later edition of the book where this problem has
hopefully been corrected).

Rating: 6 out of 10

Reviewed: 2021-04-24

URL: https://www.eyrie.org/~eagle/reviews/books/1-4920-5172-1.html

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


More information about the book-reviews mailing list