Review of Interactive Visualization and Plotting with Julia by Zea
I submitted this review to Amazon, as arranged with the publisher, on the date of publication, August 29th, 2022. It appeared on September 1st.
This review is based on a pre-publication PDF supplied to me, free of charge, by the publisher, along with an amusing set of guidelines for what they “expect”.
The book under review benefits enormously from the expertise of the author, Dr. Diego Javier Zea, who is intimate with the powerful and sprawling (and fragmented) plotting ecosystem of the Julia programming language (he’s a contributor to plotting packages, as well as an experienced scientific user). The technical information is accurate (a virtue not as common as you might expect), thoroughly detailed, and carefully tailored for the target readers of the book, who are not expected to know Julia, nor too much else about programming or the use of plotting libraries. I am familiar with these things, yet still picked up many useful new nuggets of information from perusing Interactive Visualization and Plotting with Julia.
Unfortunately, the book is marred by poor editing.
We confront frequent appearances of the wrong or non-idiomatic word, such as “temporal” for “temporary” (this is not something that just happened to slip by the copy editors: this particular misuse appears 13 times, demonstrating pretty convincingly that Packt Publishing relied on editors who lacked a native familiarity with English). The book flaunts this shortcoming even on some chapter titles: “Getting Interactive Plots with Julia”.
The language issues are absolutely not the fault of the author. When publishing a book in English drafted by a non-native user of this peculiar language, a publisher who cares about quality will invest in competent copy editors to produce a clear and idiomatic result. Packt is not such a publisher.
Indeed: when an author who grew up speaking something as rational as a romance language produces a draft this good in the lawless and treacherous medium that has achieved hegemony over technical publication, and his publisher allows “temporal” to stand in for “temporary”, that author is a victim, not a perpetrator.
In fact, upon recalling my own experience writing a book for Packt, I can not discount the possibility that many of these mistakes and infelicities were in fact inserted by copy editors eager to reinforce the impression that there was some purpose they were laboring in service of. It may very well be that the author wrote “temporary” and a deadly serious editor dutifully “corrected” it to read “temporal”. Thirteen times.
An outfit called Safis Editing is credited with copy editing and proofreading. A look at their website, where one may presume that they have taken pains to apply the highest level of linguistic polish of which they are capable, reveals plenty of prose in desperate need of burnishing (or simply burning). It also contains the bizarre claim that they have “Peer-reviewed many academic papers for publication”. I don’t know if whatever they think this means will harmonize with what it will mean to anyone familiar with the activity of peer review.
It’s not that we need our computer books to be written by Vladimir Nabokov. It’s that this level of linguistic awkwardness and imprecision distracts and slows down the reader, makes the book harder to use, and causes a constant, low background level of dyspepsia.
Unfortunately, the poor editing, whether a result of negligence or vandalism, extends to the organization of the aforementioned excellent technical content.
The reader is blindsided by unexplained abbreviations and technical terms. We’re told that Makie will display a plot in a “GLFW” window, an abbreviation that’s used repeatedly, but remains mysterious to the end.
When reading the very good sections on how to create interactive plots with Makie and Pluto, we’re suddenly using the JSServe package with no introduction to what it is. There is no entry for it in the index. I had to search the web to find out what it does and why we’re using it.
There sometimes appear code or commands without any rationale: in a section introducing the Dash package, we encounter the import of specific versions of several packages, with a sensible note explaining that more recent versions didn’t work with the example under discussion. However, the code listing showing how to start using Makie also imports specific versions of backends, but we don’t know why. Are the current versions buggy? Incompatible with something?
Fig. 9.1 is supposed to show us how a branch sorting command changes the plot of a phylogenetic tree, but the “before” and “after” plots are identical.
The author lists VS Code as a “technical requirement” in Chapter 1, but it’s not: as he makes clear throughout, that’s only one of several convenient coding environments.
All of these are examples of the standard glitches that are impossible to avoid in the first draft of a book of this type. The reason we are willing to pay for books is that they are supposed to have gone through several rounds of actual editing and checking by a handful of skilled, competent, detail-oriented professionals who will track down and vanquish most of these demons. That didn’t happen with this book.
Nevertheless, I can recommend it as a valuable reference that conveniently brings together a mass of details available in no other single volume. It’s unusual in teaching readers how to plot and analyze data with Julia even if they’ve never seen the language before; and they’ll learn the basics of Julia programming as a side-effect. Such beginners, as well as experienced Julians who do a lot of plotting and data analysis, should benefit from having this book on their shelves or tablets. Rather than beginning with chapters introducing the language, Dr. Zea explains syntax and language features as they arise in the plotting examples. This approach seems largely successful, and has the advantage that the reader is presumably motivated to understand these nuggets of syntax (destructuring, for example) when they are encountered.
The author is careful, in his step-by-step instructions, to include everything. Advanced readers may experience impatience when encountering steps instructing them to leave package mode by pressing backspace, and the like, but this level of detail helps the beginners that form part of the book’s intended audience.
All the code samples are available in a public repository.
Figures such as 12.5, which summarizes the effects of the various legend positioning keywords, are useful and convenient.
The chapter on plotting recipes is one of the clearest treatments that I’ve seen, containing a good treatment of the four classes of recipes. This is welcome addition to the literature, as this important subject confuses many users, and the existing documentation leaves too much to the imagination (here, too, the proofreading is deficient: “plotting backed” instead of “backend”). I would have liked an example of how to use a series recipe.
For a book about making plots, more figures—more example plots—would be nice. The most interesting ones are in the biology chapter, as one might expect given the author’s background.
The choice of Courier Standard for code listings is less than ideal. I find, for example, the huge spaces around the underscore to be distracting in snake-cased variable names.
The author deserved a more conscientious publisher. I imagine, with some sadness, the book that this could have been. Perhaps one day we’ll see a second edition (things move fast in the Julia plotting world), put out by a house that can distill the writer’s extensive knowledge and experience into a fine reference and learning text.