Math/CS books I read in 2017

Since I made this post for programming books I read last year, another year has passed. I’ve expanded this year’s title to be “Math/CS” books, since I think I read more math books than programming ones this year. This is meant to be a fun recap (for me), and perhaps a helpful introduction to good books, if you, like me, are a “book learner”.

Books are my main way of learning, and I often pick up books that I don’t finish, especially with technical topics. So this collection is kind of a best-of list, and I’m leaving off all the non-starts and “too hards” that I attempted and wasn’t ready for.

I find that what I value most in a technical book is its ability to carry me. I’ll read a kid’s book (and I do) if it means I am led along with clear exposition and find new analogies for exploring things. I feel that learning should be fun in general, and I hope this list reflects that.

## Who is Fourier?

How to explain how amazing this is…..

1. It is filled with cartoons.
2. It is written in a way that a 12 year old kid would understand. For example, it explains what sine and cosine are using a circle, and it explains integration with cut-out paper strips.
3. It teaches you about the Fourier series, Fourier transform, and fast Fourier transform.

Who is Fourier? was written by a group named the Transnational College of Lex, or rather a sub-group named the Hippo Family Club, who practice this approach toward learning new languages by constantly keeping ambient tapes going of those languages. The students are encouraged to babble the words they don’t understand, and they claim astonishing success with this method. Their criticisms of how languages are taught in schools resonates with me – starting with the grammar and working out toward conversation also strikes me as profoundly backward.

They take this philosophy and apply it to learning about the Fourier series and transform. Each chapter was written by the person in their group who understood that material least to start. The margins are filled with cute doodles, with a cartoon depiction of the chapter’s author popping in from time to time to encourage the reader through hard parts.

My kind of math book!

## Field Expedient SDR series

I worked through all three of these volumes with my new RTL-SDR dongle. When I first bought it, I found myself overwhelmed by all the different Internet tutorials, and struggling to filter them by quality. It’s much nicer for me to be led through the material by a single, solid teacher. It leaves you at a place where you’re familiar with all the concepts used in SDR, and especially GNU Radio Companion, that you can keep learning on your own.

The only criticism I have of the book is that the Python code, of which there is only a little, is unidiomatic and awkward.

## Statistical Rethinking

Richard McElreath is able to take statistical ideas and turn them into these wonderful analogies, so it’s still the book I would recommend the most since I read it half a year ago. Statistical models become “golems” from Jewish mythology, multiplication/counting problems become Borges’s Garden of Forking Paths, and the problems with “classical” significance testing lead naturally toward Bayesian modeling. The book simultaneously un-traumatized me from statistics while inoculating me to R. Incidentally, learning to draw diagnostic plots using base R has improved my matplotlib skills as well.

The book doesn’t quite deposit you at the end at a place where you can just pick up Stan and start modeling, and if that’s your purpose, you may be beyond most of this material. But it solidifies the groundwork and is wonderful as a tutorial in itself.

## R for Data Science

I have to confess that I’ve resisted jumping on the Hadley train for as long as possible, for no reason other than that other people are often too excited about the Tidyverse, but I’m going to drop a brand new insight for you all that you definitely have never heard before: the tidyverse is amazing.

I’ve found myself exporting data from Python just to load it in R to use ggplot. I’ve never felt plotting to be so “at the speed of thought” before. For example, the boxplot I drew for this article could have been done in seaborn, but I didn’t know ahead of time that it would be a boxplot:

.

First I tried a line graph, grouped by newspaper:

That was too messy, even though you can see the general differences between the Daily News, the Chicago Sun-Times, and the other newspapers right away. So I was able to immediately change that into a histogram, before recognizing that what I wanted was a boxplot:

## Introduction to Empirical Bayes: Examples from Baseball Statistics

This book got me to read R for Data Science since I was unfamiliar with the dplyr syntax, and he glossed over how to generate the graphs. There wasn’t much covered in this book that wasn’t also covered in Statistical Rethinking in more depth, except it introduced the empirical Bayes framework as a way to approximate/generate a prior from the data, if you have enough data (which you often do in A/B testing).

Until I read this book, I read several explanations of Empirical Bayes without being able to understand what the term meant. But a few pages in, it was clear to me: it’s a family of Bayesian methods where the prior is approximated from the data itself.

## Seven More Languages in Seven Weeks

I’m not done reading this book yet, but it’s already worth its weight in chocolate (especially since I picked it up randomly at the library – yay libraries!). It introduces programming languages at just the right level for the practicing programmer: you don’t want detailed instructions about how to install it, you just want an introduction to “why should I learn this?” and “what are the fun parts?”.

I’m a bit of a breadth-first-search learner so this type of “many mini deep dives” approach is totally up my alley. It’s like skimming 7 great books!

Here’s my favorite of the languages so far: Factor.

Factor is a concatenative language. This means instead of your typical applicative functions (`f(g(x))`), or even lisp-style functions (`(g (f x))`), you use postfix notation to write `x f g`.

In other words, `x` places the value `x` onto the stack, `f`, being a unary function, reads a value off the stack and operates on it, and writes the return value back onto the stack. Then `g` reads the value off the stack and places it back after operating on it.

This strikes me as a foundation for beautiful, easily tested code, and opens up space for tooling that can interact with you in novel ways, like telling you exactly what to expect on the stack at any given point.

I enjoyed Factor so much that I find myself wishing that concatenative languages had taken off in a bigger scale. And I read the chapters on Lua and MiniKanren at fortunate times with particular problems I was working on at OpenCounter.