Poems && Programs

Thoughts on Go

Wed, 25 Mar 2020 14:00:00 +0000

What I Like

I actually like Go just fine, despite the bulk of this post being about my gripes with the language. Go was designed by Google to build scalable web services that would be worked on by large teams with wide ranges of experience and skill, so it’s no surprise that the things I like about Go are the things its designers set out to do well: concurrency and optimizing for reading code over writing it.

I’m a big fan of CSP, so Go’s channels and goroutines feel very natural to me. The general approach is summed up in the Go community as “don’t communicate by sharing memory; instead, share memory by communicating,” which I think is capital-C Correct and is well explained in this Go Blog post and this related Codewalk.

While I don’t particularly like Go’s style conventions, I really like that those conventions are enforced by go fmt. There are some minor annoyances (such as unused imports and variables being errors during development), but generally, I’ve found Go’s opinions to be reasonable and informed by hard-won experience. I don’t hate the err != nil idiom as much as I expected: I prefer errors as values, and I’m willing to trade the boilerplate typing for the requirement that I think through and explicitly handle each error.

The rest of this post is about the things I dislike about Go (which are, unsurprisingly, features that exist in other languages but were intentionally omitted by the Go designers¹). These are, in rough order of decreasing dislike: the lack of parametric polymorphism (generics), the lack of algebraic data types, and the lack of functional constructs like map/filter/reduce. Part of this is my superhuman ability to attract off-by-one and nil pointer errors; the rest is probably that I’m used to having these constructs (I really like writing Clojure, Elixir, Haskell, Ruby, and TypeScript). If any of this resonates with you, read on!

Parametric Polymorphism

Parametric polymorphism really just means “generics” (I’ll use the two interchangeably); if you’re familiar with Java or C^#, you’ve likely come across this idea. If you haven’t encountered generics before, the idea is to parameterize your type system so that instead of specifying that a certain function works on, say, “list of integer” or “list of string,” you can write that function to work on “list of A,” where A is whatever type you want; you get a common interface for multiple types (polymorphism) that takes the concrete type as a parameter (parametric).

Go doesn’t have parametric polymorphism, so if you want to write a function that operates on slices of n arbitrary types, you have to write your function n times. For example:

type IntList []int

func (list *IntList) Contains(desired int) bool {
	for _, element := range *list {
		if element == desired {
			return true
		}
	}

	return false
}

type StringList []string

func (list *StringList) Contains(desired string) bool {
	for _, element := range *list {
		if element == desired {
			return true
		}
	}

	return false
}

// &c, &c

In a language that does have parametric polymorphism, such as Haskell, you can write contains like so:

contains :: Eq a => [a] -> a -> Bool
contains [] _ = False
contains (y:ys) x
  | y == x    = True
  | otherwise = contains (ys) x

The type parameter is a in this example, and this version of contains will work on any type where instances can be equal or unequal to each other: integers, characters, booleans, and so on. This syntax might look odd if you’re unfamiliar with Haskell, so let’s walk through it. The first line is the type signature, which says:

This function is called contains;
It has a certain type (:: is read “has type”);
That type includes a variable, a, which implements the typeclass Eq (this means “whatever a is, instances of a are equal or unequal to one another”);
Given [a] (a list of a) and some candidate a, the function returns a Boolean.²

The next few lines pattern match on the parameters. contains [] _ = False means “If you get the empty list, return false”; the _ character means “I don’t care what a you provide, since by definition, the empty list can’t contain anything.”

The final lines destructure the list into a head (y) and a tail (ys); if the head of the list equals what we’re looking for (x), we return True, otherwise, we recurse on the rest of the list. (The base case is the empty list: if we get to an empty list, the list must not contain x, so we return False.)

If you’re familiar with Java, a generic contains method looks like this:

public static <T> boolean contains(List<T> list, T desired) {
    for (T element : list) {
        if (element.equals(desired)) {
            return true;
        }
    }

    return false;
}

This strikes me as verbose compared to the Haskell version (the Haskell types are inferred, and while I included the type signature for clarity, it’s optional). In many ways, the Go designers were trying to build a better Java, so in this sense, Go is unquestionably an improvement; however, from the point of view of languages with more powerful type systems (like Haskell), it’s a bit lacking.

I’ll touch on TypeScript a few times in this post, so here’s what contains looks like in TypeScript:

function contains<T>(list: T[], desired: T): boolean {
  for (let element of list) {
    if (element === desired) {
      return true;
    }
  }

  return false;
}

If you try to call contains(contains([1, 2, 3], "quux"), the TypeScript compiler will yell at you: Argument of type '"quux"' is not assignable to parameter of type 'number'.

To round out our examples: if you’re coming from a language with duck typing, like Ruby, contains looks something like this:

def contains?(collection, desired)
  collection.each do |element|
    return true if element == desired
  end

  false
end

We don’t explicitly parameterize the type here because we don’t need to: the idea of duck typing is that if it walks like a duck and quacks like a duck, it must be a duck; similarly, if element and desired both respond to the == message³, then that’s good enough.

Okay! Back to Go. Some developers argue that the workaround for the language’s lack of generics is to use the empty interface: interface{}. The implementation for contains could then be written like this:

package main

import (
	"fmt"
)

type Collection []interface{}
type Element interface{}

func (list *Collection) Contains(desired Element) bool {
	for _, element := range *list {
		if element == desired {
			return true
		}
	}

	return false
}

func main() {
	list := Collection{1, 2, 3}
	desired := "quux"
	fmt.Printf("%v\n", list.Contains(desired))
}

By doing this, however, we’re effectively opting out of type checking. The equivalent TypeScript makes this more explicit:

// Note the replacement of the type paramater `T` with
// `any`. You can make a list of any random combination
// of types and look for an element of literally any type!
// There are no rules! Human sacrifice, dogs and cats
// living together... mass hysteria!
function contains(list: any[], desired: any): boolean {
  for (let element of list) {
    if (element === desired) {
      return true;
    }
  }

  return false;
}

The TypeScript compiler no longer complains here (simply returning false), and the same is true of the Go compiler: it can no longer help us if we choose to use interface{}. Indeed, list := Collection{1, 2, 3}; list.Contains("quux") compiles, and at first blush seems to work:

$ go run List.go
false

…but what if we want to add a function that appends a new Element to our Collection?

// ...
func (list *Collection) Append(item Element) Collection {
	return append(*list, item)
}

func main() {
	// ...
	fmt.Printf("%v\n", list.Append(desired))
}

Our program cheerfully prints [1 2 3 quux]. While we’ve gained the ability to write single, generic functions for slices, we’re no longer able to to guarantee that slices only hold a single type (as opposed to our Haskell contains, which would fail at compile time if we were to try to append a "quux" to a [Integer]).

There’s been some discussion around adding generics to Go, but as far as I know, there’s no plan to include them in upcoming releases of the language. For the time being, we’re stuck either writing code generators to handle the “n implementation” problem or opting out of compile-time checks entirely via interface{}.

Algebraic Data Types

Languages like Haskell and TypeScript have algebraic data types. If you’re not familiar with the idea, ADTs are a kind of composite data type that come with certain rules for their manipulation (hence “algebraic”). They’re most commonly found in two kinds: product types and sum types.

Most languages have product types, and depending on your background, you might know these as records, named tuples, or structs. (They’re called product types because the set of possible values for a given product type is the Cartesian product of the sets of all possible values of its composite field types.) In Go, they take the form of structs, and they look like this:

type User struct {
	Id        uint64
	FirstName string
	LastName  string
	Email     string
}

The other algebraic data type, the sum type (also known as a discriminated union, tagged union, variant, or coproduct), doesn’t exist in Go. The closest analogue would be enums using iota, which is unbelievably clumsy compared to true sum types. Either way, the goal is the same: to specify a type that can only take on a fixed set of values. (They’re called sum types because the set of all possible values is the sum of all possible values.)

For example, not too long ago I was working through the “Sublist” problem on Exercism, which involves determining whether one list is a sublist of another. The Go version expects the programmer to define a Relation, but just as an alias for string, with the implicit expectation that said string is one of "equal", "sublist", "superlist", or "unequal". The type system can’t help you here if you somehow pass in another string: any valid string is a valid Relation. In Haskell, we might define Relation as a sum type like this:

data Relation = Equal | Sublist | Superlist | Unequal

Here, the Haskell compiler enforces the possible values of Relation: it can only be Equal, Sublist, Superlist, or Unequal. They’re not strings whose values we try to constrain with comments, test cases, or other hints to the programmer: any other value than the four delineated will cause a failure at compile time.

The Functional Approach

As I mentioned earlier in this post, I’m a magnet for off-by-one errors and null pointer exceptions. While the range operator does obviate indexing errors, Go still has classic for loops, in which cases you have to be careful not to accidentally introduce a negative index or an index greater than len(list) - 1. Functions like filter, map, and reduce allow you to pipeline list operations (or operations on arbitrary collections—at least in languages with generics) without the risk of going out of bounds. This is especially nice when munging text; for example, here’s a function that canonicalizes an article title into a URL path in Go:

// Converts an article title (e.g. "A Fine Mahok to
// You All: The Robert U. Terwilliger, Jr. Story" to
// a URL path (e.g. "a-fine-mahok-to-you-all-the-
// robert-u-terwilliger-jr-story").
func ToURLPath(title string) string {
	title = strings.ToLower(title)
	var path strings.Builder

	for _, character := range title {
		if unicode.IsLetter(character) ||
			unicode.IsDigit(character) {
			path.WriteRune(character)
		}

		if unicode.IsSpace(character) {
			path.WriteRune('-')
		}
	}

	return path.String()
}

…and the same function in Clojure:

(defn- url-printable?
  [c]
  (or (Character/isLetterOrDigit c)
      (Character/isSpace c)))

(defn to-url-path
  [title]
  (->> title
       (lower-case)
       (filter url-printable?)
       (replace {\space \-})
       (join "")))

Here I don’t think there’s much cost savings in either lines of text/cognitive load or time to compose (each implementation took me a couple of minutes), so it comes down to ease/familiarity and style. If you’re not familiar with Clojure, the syntax (especially the threading macro, ->>) can be disorienting; if you don’t know Go or Java, the string builder pattern might be foreign to you.

Conclusion

Overall, Go is fine. While I wouldn’t necessarily pick it for small personal projects, I can see its merits as a production language for large teams building web services, and I think it’s a language worth knowing.

When I’m feeling charitable, I think of this as removing footguns (obvious and non-); when I’m feeling less generous, I’ve got to admit it kinda feels like catering to the lowest common denominator.
You might wonder why the function takes two arguments and returns a result, but is written as [a] -> a -> bool (rather than, say, ([a] -> a) -> bool). The reason is that all functions in Haskell are automatically curried, so a function that appears to take two arguments is actually a function that takes a single argument, which returns a function that takes a single argument and returns the end value. The major theoretical advantage is that it makes formal proofs easier; the major practical advantage is it aids composition via partial application.
Ruby is heavily influenced by Smalltalk.

On Leverage

Sat, 29 Feb 2020 14:00:00 +0000

Leverage, Learning, & Caveat Lector

I’ve been spending a lot of time at work thinking about leverage: areas where a small investment can result in a large return over a reasonable amount of time. A classic example is writing a library—for the cost of extracting, testing, designing, and implementing library code, you reduce bugs, duplicated effort, and time to delivery for all teams that use that library for as long as they use it.

Applying this concept to my own workflow, I’ve identified learning (absorbing, remembering, and applying information) as an ideal area to exert leverage. In so doing, I’ve settled on a set of tools that I’ve found drastically improve my ability to learn and share what I’ve learned, which is what this post is all about!

NB: These are some of my preferred tools (or, in a more general sense, wetware optimizations). None of these is an endorsement for anything other than my personal use (and I guess your personal use, if my reasoning and use cases resonate with you). I haven’t received any money, free products, or other compensation for writing about any of the below.

Reading

I spend most of my day reading—code, slide decks, e-mails, Slack messages, academic papers, and so on—and while I read fairly quickly (roughly 550 words a minute¹), I receive more material to read per day than I can comfortably read in a standard eight-hour workday.

I’d previously not put much stock in the idea of speed reading, but I came across Tina Konstant’s Speed Reading in a Week at my local library and figured the potential leverage (a more-or-less permanent 4x to 8x multiplier on my reading speed in exchange for a week of learning and a few months of practice) was worth exploring.

There are several aspects to successful speed reading, but for me, the two most important keys to reading more quickly were:

Turning off subvocalization;
Using more of my peripheral vision when reading.

Subvocalization is the “voice in your head” you “hear” while reading, and it’s how we naturally learn to read as we progress from reading out loud to reading silently. The problem with subvocalizing while you read, though, is that you’re constrained to reading roughly as quickly as you could read the words aloud² (modulo the latency involved in your brain getting your tongue and jaw to move). It was honestly a huge surprise to me that it was possible to read without subvocalizing, but I’ve been able to do it with the help of a pacer: a visual guide for tracking words on the page.

I tend to use my finger or the eraser end of a pencil for pacing, but you can use any tool you like so long as you use it to physically mark where you are on the page as you read. Moving the pacer at a steady clip (as well as the sound of it moving across the paper) is enough to turn off my tendency to subvocalize; this alone allows me to reliably read non-fiction³ roughly twice as fast as I could before.

As I’ve stopped subvocalizing, I now realize that I see words rather than hearing them when I read, which makes it easier for me to parse them in blocks. By using more of my peripheral vision, I don’t have to scan all the way to the start of the line and all the way to the end in order to read. If you’ve ever observed experienced speed readers, you might have noticed they move their pacers almost vertically down the page; this is due to their using much more of their peripheral vision to scan each line.

I’m hoping to get to the point where I can read 2,000 to 3,000 words per minute! I’ll share updates as I improve.

Writing

This section’s more a mix of tools and practice.

Before I wrote software, I wrote poems, and I’ve always loved to draw, so I have Some Opinions™ about writing implements. I also take a lot of notes for work, so here are some of the tools that work well for me.

If you’re writing with a pencil, you want a Ticonderoga #2 pencil. It’s got everything: a balanced lead (not too hard, not too soft), erases cleanly (rather then somehow turning your mistake into a Schrödingeresque superposition of greasy smear and burnt hole in the paper), wide availablility, and low cost (roughly $0.20 each). (If you’re an artist, you may have harder or softer leads that you prefer; go with what you like!)

For writing in ink, I used to really like Sharpie 0.8mm marker pens, but somewhere in 2016 I lost my enthusiasm, so since then I’ve been relying on my trusty Lamy Safari fountain pen.

Sometimes I like to write code or architecture diagrams out on a larger scale. As ubiquitous as whiteboards are in tech offices, I actually really prefer blackboards; I eventually want to get a good slate one for my home office, but for now, I’m making do with a blackboard decal on the wall. Luckily, I’ve managed to get my hands on some Hagoromo Fulltouch chalk. Note that this is not the Japanese original; this version is made in South Korea, but using the exact same equipment—shipped from Japan—and manufacturing process (the Japanese proprietor taught the South Korean company how to produce it). The box arrived in perfect condition (not a single broken stick!), and each stick has a thin coating that starts about two-thirds of the way down that prevents you from getting chalk on your hands. It creates clear, bright lines, erases easily, and doesn’t create a lot of dust. Mathematicians have even ascribed supernatural properties to it! 😂

Moving on to writing systems (rather than pure tools), I’ve recently started learning Gregg simplified shorthand using this book. One of my responsibilities at work is to take notes during technical discussions, and even though I type very quickly (between 100 and 130 WPM), it’s not quite fast enough to keep up with real-time discussion. Learning Gregg shorthand (which I expect to take me about six months) is another high-leverage opportunity, eventually allowing me to write up to 300 WPM (much faster than my handwritten 30 WPM, and faster than most people speak).

Finally, when writing by hand, I’ve found I really like Leuchtturm 1917 notebooks; the dotted pages make it much easier for me to ensure the proportions of my shorthand are correct (and therefore legible). The special edition with red dots is my favorite.

Typing

I spend a lot of time typing at work, and in order to avoid repetitive stress injuries, I’ve recently switched over to an ergonomic split keyboard (the Ergodox-EZ) with my own haphazardly implemented Vim layer (mostly for navigating using J-K-H-L). I opted for Cherry clear switches because I type like the Incredible Hulk and don’t want to drive my coworkers insane, along with the tilt/tent kit and wrist rests for comfort (though without glow or shine). I’ve been using it for about six months and love it so far; I’m considering getting the Planck for travel/conferences. (They don’t offer the clears for the Planck, so I’ll probably go with Cherry Browns, or maybe Blues if I’m going to be by myself.) As mentioned, I use Vim extensively (not just for programming), and I’ve found it makes editing everything from code to book manuscripts to blog posts like this one much faster and more comfortable.

In Conclusion

I hope some of these thoughts/recommendations have been helpful to you. I learned long ago to invest in the tools and processes I use frequently, and by making small, deliberate investments early, I hope to continue to reap long-term rewards for years to come.

The majority of sources I consulted suggest the average adult reads roughly 200 to 300 words per minute.
This is no surprise to anyone who’s heard me talk (spoiler: super quickly!). If you’re like me, you might also benefit from watching YouTube videos on double speed, particularly for recordings of conference talks or lectures.
There’s nothing special about non-fiction, it’s just that I tend to read non-fiction for information, rather than enjoyment.

Reading List 2020

Fri, 31 Jan 2020 14:00:00 +0000

Time for the ol’ annual blog post! (Well… more on that below.)

Goals

I added this section to my annual reading list blog post last year, and I feel like it’s provided some much-needed structure to my self-directed learning. Let’s see how I did!

Math

I set out to cover two broad, somewhat meandering topics in mathematics in 2019:

The foundations of mathematics (logic, proofs, set theory)
Select topics in abstract algebra (primarily group and category theory)

I think this was the goal I made the most progress toward: I deepened my understanding of logic and now have a firm grasp of set theory and reading/writing proofs (at least for someone who isn’t a practicing mathematician). The books I found most helpful for exploring these topics were Set Theory and Metric Spaces, A Programmer’s Introduction to Mathematics, How to Prove It, and, weirdly, The Elements of Real Analysis. I hadn’t really planned to do real analysis this year, but this book offered an overview of set theory (covering the algebra of sets, functions, and finite and infinite sets), the real numbers (including the Cantor set), and topology of Cartesian spaces. I skimmed the sections on convergence, continuous functions, and infinite series, and left the bulk of the book (infinite series, differentiation, and integration) for whenever I review calculus.

Most of my group theory self-study was pretty ad-hoc and cobbled together from online sources (such as Wikipedia and Math Stack Exchange); I’d like to find a more structured resource in 2020. For category theory, I started digging into this book and these lectures by Bartosz Milewski, and I’m loving it so far (I got about halfway through in 2019 and am nearly done now). I wasn’t quite ready for the Mac Lane book, but I’m excited to dig into it this year. The mathematical topics I’d like to cover in 2020 include the Curry-Howard-Lambek correspondence (the “Lambek” bit is new to me), mathematical logic, boolean algebra, and discrete math.

I’m disappointed I didn’t get around to creating any math ‘zines in 2019, but it turned out I didn’t need to create them to get the level of understanding I was looking for. (I tend to do this by explaining topics to myself on my walk to and from work, filling in holes in my understanding when I get back to a book/computer; I later found out this is a variation on the Feynman technique.) I may still create ‘zines in 2020 if there’s interest, but it would be more for teaching/sharing than cementing my own understanding (though arguably I’d still derive value from structuring and ordering the topics for someone else).

Foreign Languages

My audacious (and fuzzy) goal in 2019 was to somehow make progress on all the languages I want to speak (some are languages I’ve learned and want to brush up on; others are pretty much new to me). As expected, an overly ambitious, blurry goal resulted in not much measurable progress, though I did get a ton of value out of Justin Searls’ KameSame and will be using it in earnest this year.

Learning from last time ‘round, this year I have two specific foreign language goals: to get to a Spanish B1/B2 and a Japanese JLPT N4/N5 by the end of the year. Also ambitious, but much less so than “master five languages lol” and much easier to measure. In the meantime, I’ll continue to read French and German and ideally participate in conversation (e.g. our informal French group at work) in order to keep my existing abilities up.

Okay! On to the new goals.

Programming

I’ve tried to make note of the times in my career I’ve gotten dramatically better as a programmer (e.g. attending the Recurse Center, moving from a customer-facing application development team to an SRE team, designing my first major cross-team service), and I’d like to try to deliberately recreate that on my own in 2020. I’m still sort of putting together a self-study curriculum, but here are the broad topics (divided into 12-week deep-dive “batches,” similar in length/scope to a Recurse Center batch):

01/01 - 03/25: Programming theory: Haskell, category theory, and the lambda calculus (the Destroy All Software series on the lambda calculus is excellent). 04/08 - 07/01: Programming environment: Go, Docker/containers, Kubernetes/container orchestration, and the Linux kernel. 07/08 - 08/30: Databases: PostgreSQL, the relational calculus, and query optimization. 09/07 - 12/30: Optimization problems: the Bellman equations (reinforcement learning, MDPs, dynamic programming), game theory, and statistics.

I may change the content/order of these deep dives as I go along, but I tried to find topics where I have basic to advanced intermediate knowledge and really want to dig deep to learn more.

Finally, as I hinted earlier, I think I could be more disciplined in my approach to tracking my learning progress and synthesizing new ideas, so in 2020, my goal is to blog on technical topics at least monthly.

Whew! Okay. On to the reading list.

Books

I mostly read what I set out to read in 2019 (see below for the ones I’m rolling into next year). Here are a few extras I read:

The First 90 Days

Michael Watkins

This was a re-read, but I always learn something new each time I come back to it. I joined ZipRecruiter as director of engineering earlier this year, and this time around I found the sections on matching strategy to situation and achieving alignment especially valuable.

Unsolved!

Craig Bauer

I’ve been interested in classical cryptography and historical oddities like the Voynich manuscript for awhile now, so I really enjoyed this as a kind of survey course of unsolved crypto-mysteries (ranging from undeciphered ancient writing systems to the cryptograms of the Zodiac Killer!).

Patterns of Enterprise Application Architecture

Martin Fowler

While I read this more or less cover-to-cover, I think its real utility will be as a reference guide (especially the chapters on concurrency and distribution strategies).

Never Split the Difference

Chris Voss

I honestly didn’t expect to like this book (I was worried it would have too strong a “bro” vibe), but I actually really enjoyed it (less so for the war stories and more for the negotiation tactics and strategies). There was still a bit of swagger, but overall, I found it down-to-earth and self-aware.

Getting to Yes

Roger Fisher, William L. Ury, and Bruce Patton

I picked this one up specifically because Chris Voss references it in Never Split the Difference (generally in contrast to his own approach, which is derived from his years of training and experience as a hostage negotiator). I did find Getting to Yes to be very academic and process-oriented, though I did glean some interesting insights (particularly around separating people from problems).

The Leadership Pipeline

Ram Charan, Stephen Drotter, and James Noel

I read this on the recommendation of a friend and colleague of mine, and I particularly liked the idea that the pipeline zig-zags, illustrating that often during advancement, “what got you here” (the skills that made you stand out in your prior role) “won’t get you there” (are not necessarily the ones you need to excel in your new role). Speaking of…

What Got You Here Won’t Get You There

Marshall Goldsmith

…I picked this one up to dig further into the new skills I might need to acquire in order to succeed at increasingly higher levels (both personal growth level and company growth level, as covered in The First 90 Days and The Leadership Pipeline), but instead, this was more about identifying the weaknesses and bad habits one might have succeeded in spite of thus far and addressing them. Still useful, but not quite what I was looking for (luckily I borrowed it from the library).

The Elements of Real Analysis

Robert G. Bartle

This was just a general overview of real analysis; I found the early, foundational chapters on the algebra of sets, finite and infinite sets, and the topology of Cartesian spaces the most applicable.

Solving Mathematical Problems

Terence Tao

This was a quick read (absolutely doable in a single sitting), and I particularly enjoyed the general strategies for problem solving and the examples from number theory. Hard to believe he wrote this when he was just fifteen years old!

Software Design Decoded

Marian Petre, André van der Hoek, and Yen Quach

I was hoping to glean some real insights from the experiences of seasoned developers, but was disappointed to find a Page-A-Day calendar of statements ranging from obvious (“Experts prefer solutions that they know work,” “Experts go as deep as needed,” “Experts know how things work”) to vaguely patronizing (“Experts focus on the essence,” “Experts use design methods (selectively)”).

Accelerate

Nicole Forsgren, PhD, Jez Humble, and Gene Kim

This book was the result of several years of studies conducted on the effect of lean, agile, and DevOps strategies/mindsets as applied to software engineering teams, with the aim of identifying what distinguishes high-performing teams from low-performing teams. These studies mostly affirmed my experiences and instincts around testing (such as who should write tests, their correlation with success, &c), architecture, management, and the role of DevOps/SRE in an organization, but it was good to see these beliefs backed up by concrete data. I particularly liked the section on servant leadership vs. transformational leadership.

Strategize to Win

Carla A. Harris

This was a selection for our tech management book club at work. The “Starting Out” section was less relevant for me (choosing a career, acquiring necessary skills, and so on), but I found the “Stepping Up” section very useful—particularly the ideas of performance currency and relationship currency, which put into words an idea I’d formed years ago: high performance gets you your initial recognition, but relationship-building is what opens the door to advancement (whether networking for your next job, raising money for your next venture, or rising through the ranks of executive leadership).

A Philosophy of Software Design

John Ousterhout

I technically finished this one in the first week of 2020, but started and read most of in 2019. I thought this was a thoughtful, well-structured approach to software design, and I agreed with most of it (particularly around the role and handling of errors and the preference for “deep” modules whose simple abstractions/API provide high-leverage access to powerful internal logic), but I wasn’t sold on the author’s opinion of TDD (that it’s “tactical-only” and tends to incur debt). I view tests not only as indications of correctness, but as living documentation and powerful design tools, and I’d like to see that viewpoint expressed more widely. (Maybe this is an instance where I need to be the change I want to see in the world.)

Deaf Republic

Ilya Kaminsky

These poems are astounding. You should read them.

Here are the books I want to read in 2020, starting with the four books I’ve rolled over from 2019:

Categories for the Working Mathematician

Saunders Mac Lane

As I mentioned last year, I want to more deeply understand the relationships between category theory and programming, and I think this book will help me better grasp the theoretical foundations I’ve started building with Bartosz’s lectures.

Abstract Algebra

I. H. Herstein

Groups, rings, and fields have come up in my category theory reading, so I’d like to take something of a side-quest into various topics in abstract algebra to better understand how these objects interact.

Machine Ethics

Michael Anderson and Susan Leigh Anderson, Editors

I’ve read through a few of the papers in this anthology (and even gave a talk on machine ethics a couple of years ago), and I think this text will be really generative (with regard to my interest in the intersection of human and machine problems).

The History of Western Philosophy

Bertrand Russell

I’ve read bits and pieces starting in college (I think sections of it were required reading for one of my philosophy courses), but in 2020 I’d like to finally read the whole thing.

And here are the new books I want to read in 2020:

The Oxford Handbook of Philosophy of Mathematics and Logic

Stewart Shapiro, Editor

I’m particularly interested in the chapters on Wittgenstein, intuitionism in mathematics, and higher-order logic.

An Elegant Puzzle: Systems of Engineering Management

Will Larson

I’ve read probably around a dozen books on engineering management, but this is the first one I’ve encountered that meshes the challenges of people management with systems thinking. I may end up writing a full blog post about this book later this year!

Elements of Clojure

Zachary Tellman

I cheated a bit and read the first several pages, and I’m already hooked. I get the feeling I’m going to learn a lot more about software engineering than just Clojure programming.

Naming and Necessity

Saul Kripke

This has been on my philosophy “to-read” pile for awhile, and given that it’s mentioned in the first chapter of Elements of Clojure, I think it’s time I read it.

The New Peoplemaking

Virginia Satir

This is the first of several books (ending with The Mismeasure of Man, below) recommended to me by Rein Henrichs, with whom I worked when I was consulting with Test Double. The New Peoplemaking is about communication and interpersonal dynamics in the context of a family, but I get the sense it has a lot to teach about other domains as well (work, friend groups, other local communities).

Computer Power and Human Reason

Joseph Weizenbaum

This is very much in the machine ethics/intersection of computation and philosophy area of my reading, and I’m particularly interested to see how prescient the author was in his arguments about the nature and future of AI (Computer Power and Human Reason came out in 1976).

Having Thought: Essays in the Metaphysics of Mind

John Haugeland

More philosophy! Having browsed the table of contents, I’m particularly interested in the chapters on Hume, supervenience, Dennett, and Searle.

Sources of Power: How People Make Decisions

Gary A. Klein

In particular, this book is on how experts make decisions (rather than how someone makes decisions in a domain that’s brand-new to them).

The Mismeasure of Man

Stephen Jay Gould

One of the Amazon reviews on this one describes it as “an important reminder of what IQ measurement really is and the ugly racist history that has long plagued the field.” 💯 💯 💯

The Anatomy of Peace: Resolving the Heart of Conflict

The Arbinger Institute

This one was recommended to my by my friend and former colleague Michael Schoonmaker. Like The New Peoplemaking, its focus is on family but I think it’ll be applicable in a wide variety of situations.

Managing Up

Mary Abbajay

This will be our tech management book club pick for February, and I’m interested in reading it not just as an employee with a boss, but as someone who serves as someone else’s boss (and in that capacity, have my own habits and predispositions that others might need to manage).

The Making of a Manager

Julie Zhuo

I’m particularly interested in this book because the author emphasizes her ramp-up into management, whereas most management books I read are more retrospective (written by leaders after they’ve worked as managers for many years, if not decades).

The Art of Readable Code

Dustin Boswell and Trevor Foucher

Dustin did a lot of foundational work on our search team at ZipRecruiter, so I’m interested to get his general take on writing maintainable software.

Database Internals

Alex Petrov

I’m especially interested in this one as the informal textbook for my third Recurse Center-style deep-dive (see Programming, above).

Designing Data-Intensive Applications

Martin Kleppmann

I’ve heard nothing but great things about this book, which covers all sorts of tradeoffs, considerations, and challenges encountered while scaling distributed systems, and I am probably unreasonably excited to read it.

The Left Hand of Darkness

Ursula K. LeGuin

I really enjoyed Cixin Liu’s The Three-Body Problem, and I realized I’ve been neglecting my fiction reading for way too long. While poetry books aren’t super long, I tend to bucket my fiction and poetry reading together, so this year, I’m going to intentionally not commit to reading any particular poetry collections in order to focus more on fiction. Further, none of this fiction is actually new—these are books I’ve been meaning to read forever and haven’t gotten to (and LeGuin is at the top of that list).

Riddley Walker

Russell Hoban

Modern dystopias call for dystopian science fiction!

Ringworld

Larry Niven

I’m actually pretty sure I read Ringworld in high school, but I remember pretty much none of it, so I’ll give it (another?) go.

Snow Crash

Neal Stephenson

This is one I’ve been meaning to read since I first heard about it (which I think was something like 15 years ago).

Papers

I did indeed read fewer papers in 2019 than when I was in grad school, though I managed to read all the ones I set out to. Here are the additional papers I read beyond those:

The Part-Time Parliament

Leslie Lamport

This paper was actually pretty entertaining, though I have to admit I don’t understand the protocol well enough to implement it based on this paper. (Having the Raft paper, below, and talked with some of my coworkers, it sounds like I’m not alone here.)

Paxos Made Simple

Leslie Lamport

This paper makes good on the promise of the title (at least, made simpler).

In Search of an Understandable Consensus Algorithm (Extended Version)

Diego Ongaro and John Ousterhout

AKA the Raft paper. This consensus algorithm was much more approachable than Paxos, and I thought the writing was particularly clear for an academic paper (one of the co-authors is the same Ousterhout as the author of A Philosophy of Software Design, above!).

Dynamo: Amazon’s Highly Available Key-Value Store

Giuseppe DeCandia et al.

The title pretty much says it all. (I’ll be pretty brief with my descriptions of these last several papers, since they’re more or less just descriptions of the underlying data models/algorithms, but I’ll note any surprising insights or interesting tradeoffs.)

Cassandra - A Decentralized Structured Storage System

Avinash Lakshman and Prashant Malik

Cassandra’s data model is derived from Google’s Bigtable (see next paper).

Bigtable: A Distributed Storage System for Structured Data

Fay Chang et al.

This powers a bunch of core Google services, including search and Gmail!

Kafka: a Distributed Messaging System for Log Processing

Jay Kreps, Neha Narkhede, and Jun Rao

We’re starting to adopt Kafka for more and more use cases at work, so I thought it’d be a good idea to refer back to the paper (especially regarding delivery guarantees).

MapReduce: Simplified Data Processing on Large Clusters

Jeffrey Dean and Sanjay Ghemawat

I think I expected this paper to be more groundbreaking/illuminating, but that’s likely because the general pattern for parallelizing computations over huge datasets isn’t really “new” anymore (this paper is over 15 years old!).

Spanner: Google’s Globally-Distributed Database

James C. Corbett et al.

I thought it was pretty cool that Spanner instances are Paxos state machines, and I particularly appreciated the details around the specifics of Google’s Paxos implementation.

The Google File System

Sanjay Ghemawat, Howard Gobioff, and Shun-Tak Leung

First, component failures are the norm rather than the exception.

This paper really drove home for me the inevitability of failure in large, distributed systems, and part of the reason why our move to Kubernetes at work hasn’t been as conceptually difficult for me as it otherwise probably would be. (This is probably true of many of the distributed systems papers I’ve read, but few call out failure as the norm quite so explicitly.)

Amazon Aurora: Design Considerations for High Throughput Cloud-Native Relational Databases

Alexandre Verbitski et al.

The paper is a good overview of Aurora, though there are a couple of areas that I would have preferred be more explicit. For instance, while the paper notes that:

The database engine is a fork of “community” MySQL/InnoDB and diverges primarily in how InnoDB reads and writes data to disk

…it doesn’t explicitly mention that it disables InnoDB’s change buffer (though a careful reader can infer this). As a result, it’s very possible to read the paper and not realize the performance penalty for tables with lots of secondary indices (normally, MySQL uses the change buffer to lazily merge updates to these indices, but without the change buffer enabled, these updates have to be write-through).

Finally, here the papers I want to read in 2020 (hopefully I’ll pick up a few more along the way):

Making Reliable Distributed Systems in the Presence of Software Errors

Joe Armstrong

This was Joe Armstrong’s doctoral thesis, and at almost 300 pages it’s probably more of a book than a paper, but I’ll include it here so I have an excuse when I only read one paper this year!

Similarity of Neural Network Representations Revisited

Geoffrey Hinton et al.

These last three papers are all machine learning papers by Geoff Hinton’s team; this one’s on about comparing different neural network representations.

When Does Label Smoothing Help?

Geoffrey Hinton et al.

Label smoothing is a common tool for improving generalization in multi-class neural networks, but it’s not really well understood why it works. I’m hoping this paper sheds some more light on the topic.

Lookahead Optimizer: k steps forward, 1 step back

Geoffrey Hinton et al.

Finally, this paper is about a new optimization algorithm for improving stochastic gradient descent in deep neural networks.

Off we go!

Reading List 2019

Thu, 03 Jan 2019 14:00:00 +0000

It’s that time of year again!

Goals

This is a new section in my annual reading list blog post (see 2018, 2017, and 2016). I’ve realized it’s a really valuable way to structure my overall yearly reading (which in turn provides me with a metric for quitting books I don’t find useful—something I’ve always struggled with—as well as adding books as I discover new interests). This year, my goals are to (re)learn the following:

Math

While finishing my master’s degree in computer science at Georgia Tech, I realized that 1.) I really enjoy math, and 2.) most of why I believed I didn’t enjoy math was because I don’t like how it’s taught in American schools, so I’m starting a self-study course in mathematics. This year I want to cover:

Logic, proofs, and set theory
Abstract algebra, group theory, and category theory

After that (this is a fuzzier list, since it’s years-long and I haven’t gotten far enough into these topics to build out a solid self-study curriculum; topics and ordering may change):

Mathematical logic and boolean algebra
Number theory and ring theory
Field theory, algebraic topology, and point-set topology
The “rest of” discrete math (combinatorics, graph theory, tree theory, and finite state automata)
Real numbers & real analysis, complex numbers & complex analysis
Geometry and linear algebra
Functional analysis
Differential equations
Probability and statistics (review)
Game theory (review)
Single-variable differential and integral calculus (review) and multivariable calculus (some review, some new)

I imagine these as sort of self-driven survey courses, though I expect to do a deep dive on one or two topics that I find particularly interesting (I think I’m already inclined toward set theory, model theory, and other areas of mathematical logic). In order to solidify my learning (and prove to myself that I have some sense of what I’m talking about), I’ve made a New Year’s resolution to create Julia Evans-style ‘zines that teach the math topics I’m learning about! Specifically, I’m committing to quarterly ‘zines, tentatively on basic set theory, quantified predicate logic, group theory, and category theory, but hopefully I’ll get the chance to do more.

Foreign Languages

A good friend of mine pointed out last year that I “half-speak” several languages, so I want to dedicate 2019 (and onward!) to fully speaking the languages I want to speak. Those languages are:

French (at my peak, I was probably at a C1 level; I’d like to regain that)
German (I was probably at a B1 level at my best; I’d like to get to a B2 or C1 level this year)
Spanish (I can read/understand a lot of Spanish, but have never studied it formally)
Mandarin (my wife and I took a class a couple of years ago and I continue to hover around HSK 1; I’d like to get to HSK 3 this year)
Japanese (I can slowly read hiragana and katakana, but my grammar and vocabulary are super, super basic)

This seems like a super tall order, mostly because it is. I think the goals for French, German, and Chinese are fairly clear and attainable; for Spanish, I’d like to take an introductory course sometime this year, and for Japanese, I’d like to be able to communicate with Japanese speakers at the next RubyKaigi. (Like my math self-study program, this language learning will probably be a years-long effort that evolves over time.)

Whew! Okay. On to the reading list!

Books

I mostly read what I set out to read in 2018 (see below for the ones I’m rolling into next year). Here are a few extras I read (as you can see, I took an interest in financial markets):

Bible of Options Strategies (2nd Edition)

Guy Cohen

I’ve been interested in derivatives markets for a bit, but 2018 was the first time I learned about (and traded!) options.

The Little Book of Currency Trading

Kathy Lien

I initially picked this book up to better understand crypto markets (which I think are more akin to currency markets than equity markets), but ended up learning a lot about (and gaining an appreciation for) ForEx trading. I also learned some techniques to apply to equity and derivates markets (e.g. time spent in range vs. in trend, setting stops, having exit strategies, knowing my psychological profile).

What I Learned Losing a Million Dollars

Jim Paul and Brendan Moynihan

I wasn’t a huge fan of this book (I was turned off by Jim Paul’s folksy, swaggering, frat boy persona), but it did have some interesting takeaways: don’t internalize/personalize losses, cut losses quickly and let winning trades continue, your entry point should be a function of your exit point and not vice-versa (both were also mentioned in The Little Book of Currency Trading), don’t overvalue low-probability, high-return opportunities, and don’t undervalue high-probability, low-return opportunities, get fresh/outside perspectives, and preoccupation with being right means you’re betting, not investing. I really liked this quote (clearly written by Moynihan rather than Paul):

“To repeat the leitmotiv of the book thus far: people lose (really lose, not just have occasional losing trades) because of psychological factors, not analytical ones. They personalize the market and their positions, internalizing what should be external losses, confusing the different types of risk activities, and making crowd trades.”

When Genius Failed

Roger Lowenstein

This was a great account of the meteoric rise and brutal fall of Long-Term Capital Management, and I wholeheartedly recommend it (not only for Lowenstein’s writing and storytelling, but to understand the extent to which Wall Street will let medium-talented white dudes repeatedly fail, burning horrifying amounts of time and money in the process).

Flash Boys

Michael Lewis

I read a few of Michael Lewis’ books last year, and I’ve been interested in high-frequency trading since taking Machine Learning for Trading as part of my master’s degree, so I figured this would be a good read. This is another one I’d recommend, especially having just read When Genius Failed (spoiler: you can crash and burn in spectacular ways as a trader and still be able to convince people to give you capital to manage, but back up the wrong file as a lowly software engineer and the Feds will be at your door).

Digital Gold

Nathaniel Popper

I started a blockchain company in late 2017, so I’ve read a bunch of financial and cryptocurrency books/papers over the past year. Most of my work has been in Ethereum, and Digital Gold is almost exclusively about Bitcoin (specifically, its rise and the cast of characters that powered it). This was an entertaining read, but I’m not sure I learned much.

Blockchain Revolution

Don Tapscott and Alex Tapscott

Even though this is the updated 2018 edition (covering the ICO wave of 2017 and the rise of non-fungible tokens), again, I didn’t feel like I learned a ton from this one (though it could be that running the tech org for a blockchain startup forces me to stay hyper-current). I did like that this one focused on a range of crypto-assets, not just Bitcoin, and explored the broader implications of blockchain technology.

The Five Rules for Successful Stock Investing

Pat Dorsey

Although Dorsey strikes me as something of a value investor (I tend to be more interested in growth stocks), I found a lot to like in this book. I particularly liked learning about the various accounting statements, the figures that appear on them, and their implications for company health (e.g free cash flow divided by revenue tells us what proportion of each dollar in revenue the company is able to turn into excess profits).

Here are the books I want to read in 2019, starting with the eight books I’ve rolled over from 2018 (I rolled over more than usual; it turns out having a baby, finishing grad school, and starting a company really eat into your free time):

Type-Driven Development with Idris

Edwin Brady

I did some reading and work on Idris a couple of years ago, and I’m finally starting to hit my stride as a Haskell programmer, so I’m really excited to finally read Edwin’s book this year.

First, Break All the Rules

Marcus Buckingham and Curt Coffman

As mentioned before, I’ve heard good things about this book at each of the last four places I’ve worked, so it’s probably high time I read it.

A Billion Voices: China’s Search for a Common Language

David Moser

This book was recommended by my Mandarin teacher, and I think it’ll be really interesting to see how modern Mandarin arose from a highly fragmented set of spoken languages and traditions.

The Three-Body Problem

Cixin Liu

I’m also including the two sequels, The Dark Forest and Death’s End!

English Grammar for Students of German

Cecile Zorach et al.

As mentioned, my German has gone a bit downhill since I first started learning in high school, and while my pronunciation is still pretty good and vocabulary comes back to me quickly, I don’t feel I have as firm a grammatical footing as I’d like. Hopefully reading this book and practicing my spoken German helps with that!

Working Effectively with Legacy Code

Michael Feathers

Last year, I said that “this book has been recommended to me by too many people for me to continue not reading it.” This is still true.

High Output Management

Andrew S. Grove

This was recommended to me at a conference I attended last year. Andrew Grove was employee number three at Intel and has built some really impressive teams in the course of his career, so I’m looking forward to reading his story and learning from his mistakes.

Consciousness Explained

Daniel Dennett

I’ve been a big fan of Dennett’s work since college (I focused on philosophy of physics and theory of mind), and I’m particularly interested in this book and its view of consciousness as a continuum.

How to Prove It, 2nd Edition

Daniel J. Velleman

The first of many math/logic books! This one is an introduction to basic set theory and proofs.

Introduction to Logic, 12th Edition

Irving M. Copi and Carl Cohen

This isn’t a cover-to-cover read so much as a review of propositional and predicate logic (this was the textbook for my undergraduate logic coursework).

Set Theory and Metric Spaces

Irving Kaplansky

This was recommended to me as a good introduction to naïve set theory, which I plan to augment with How to Prove It and A Programmer’s Introduction to Mathematics (specifically, chapter four, “Sets”).

Gödel, Escher, Bach: An Eternal Golden Braid

Douglas R. Hofstadter

This is technically a re-read, but doesn’t really feel like it because my first read was so long ago (high school, I think). This book is about strange loops (cycles in which continued ascent eventually leads one back to a point in the cycle that’s already been visited), tangled hierarchies (hierarchies that include such loops), and three intertwined areas of art and science where these self-referential topologies appear: the music of Johann Sebastian Bach, the drawings of M. C. Escher, and Kurt Gödel’s incompleteness theorem.

A Programmer’s Introduction to Mathematics

Jeremy Kun

This is another one I may not read cover-to-cover (well, I probably will, but not in order). I want to start with sets and groups, but later move on to other topics in the intersection of math and programming: polynomials, graphs, linear algebra, and calculus.

Categories for the Working Mathematician

Saunders Mac Lane

My first (passing) exposure to category theory was via Haskell, and now I’d like to set up a firmer foundation for myself (including functors, monoids, and monads).

Abstract Algebra

I. N. Herstein

This was a recommendation from Luke Underwood! I’d like to use this to finish firming up my foundation in set theory, then do a bit of a survey of groups, rings, and fields.

Coding the Matrix

Philip N. Klein

This is the first of three recommendations from Brandon Weaver (the next two are the others). I taught myself basic linear algebra prior to doing my master’s degree, and I got to use a fair amount of it while studying machine learning (e.g. linear regression, regularization, principal component analysis, neural network architecture). I saw a Coursera course a couple of years ago that used this book as a topic and was disappointed that it didn’t fit in my schedule, so I’m pleased to be able to tackle this material in 2019.

The Art of Logic in an Illogical World

Eugenia Cheng

One thing I struggle with is squaring rational arguments (mine and others’) with emotional responses (mine and others’), especially in this age of propaganda, “fake news,” and anti-intellectualism. This book is billed as “a lifeline to readers drowning in the illogic of contemporary life,” which sounds… pretty awesome, actually.

Beyond Infinity

Eugenia Cheng

I’ve struggled with the idea of infinity ever since I was introduced to transfinite arithmetic and the work of Georg Cantor, so I’m excited to dig into this one.

Artificial Intelligence: A Modern Approach

Peter Norvig and Stuart Russell

This is another partial re-read—I think I first picked this up during my Recurse Center batch (summer 2013), but I’m delighted that my in-laws gifted me this book so I can work through it on my own.

Machine Ethics

Michael Anderson and Susan Leigh Anderson, Editors

I gave a talk on machine ethics at RubyConf this year, and I spent a lot of time thinking about the moral and ethical implications of AI (not just for human agents building artificial intelligences, but for the artificial intelligences themselves) during my master’s degree. I’m excited to see what professional ethicists have to say on the subjects I’ve been mulling over (as well as learn about brand-new areas of study).

Four Dimensionalism

Theodore Sider

I’ve skimmed through this book a couple of times over the past few years, but I want to read it cover-to-cover in 2019. One of my main philosophical interests has to do with the mereology (study of parts and wholes) of spacetime, as well as whether three-dimensional objects endure in time, or perdure through it (that is, actually have temporal extent, and are therefore really four-dimensional); I suspect the latter.

Space, Time, and Spacetime

Lawrence Sklar

This is mostly re-reading, but I’m actually not sure I’ve read this one in its entirety, so I want to commit to doing that this year. Like Four Dimensionalism, this one is on the philosophy of physics, but is more of a survey of multiple topics than a meditation on perdurantism.

The History of Western Philosophy

Bertrand Russell

This is a classic that I haven’t read in its entirety yet (I think I read chapters here and there as assignments in college).

Turing’s Cathedral: The Origins of the Digital Universe

George Dyson

This was recommended to me on Twitter when I asked for a “multibiography” of 20th-century math and logic. I’m excited to read it!

Mr. Wilson’s Cabinet of Wonder

Lawrence Weschler

My friend Maggie gave this to me as a gift after we talked about how cool the Museum of Jurassic Technology is.

Friday Black

Nana Kwame Adjei-Brenyah

I haven’t read a short story collection in awhile, and I’m particularly excited about this one (blurbed by both George Saunders and Roxane Gay!).

The Book of Joshua

Zachary Schomburg

I’ve been reading Zachary Schomburg’s poems for awhile now (I often think about “The Fire Cycle”), and given the parallels between Schomburg’s poetic interests and my own (as well as the title of this book; my younger brother, Joshua, passed away in 2016), I’m interested to see how this book moves me.

Surrounded by Friends

Matthew Rohrer

I’ve known Matthew since 2010, and I’m always delighted to read his work.

Magical Negro

Morgan Parker

Morgan and I did our MFAs together at NYU, and I really enjoyed There Are More Beautiful Things Than Beyoncé. I’m excited to pick up her new book when it comes out next month!

Subcritical Tests

Ailbhe Darcy and SJ Fowler

I frequently think about Darcy’s poem, “Ansel Adams’ Aspens”, so when I saw this title (I’m always excited to read poems about the intersection of human experience and science), I knew I had to read it.

Mortal Republic

Edward J. Watts

Now is probably the right time to read about the factors that contributed to the fall of the Roman Empire.

Fear: Trump in the White House

Bob Woodward

This oughtta be good. And terrifying. Here’s to that fatuous orange clown getting kicked to the curb in 2019.

Papers

Spring 2018 was the last semester of my master’s degree, which meant I once again read a bunch of papers. While I may read fewer papers in 2019 without grad school to provide a framework, I hope to instead read different papers: in this case, extending beyond computer science to include mathematics, language/linguistics, and philosophy (primarily ethics, theory of mind, and logic). But! We’ll get to those in a minute. Here are the additional papers I read in 2018 beyond the ones I set out to read:

The Anatomy of a Large-Scale Hypertextual Web Search Engine

Sergey Brin and Larry Page

This is the “PageRank” paper (which I assumed only had to do with ranking pages, and not also a play on Larry Page’s name).

Understanding Resiliency of Internet Topology Against Prefix Hijack Attacks

Mohit Lad, Ricardo Oliveira, Beichuan Zhang, and Lixia Zhang

I read this for my Computer Networks class at Georgia Tech, and it was really eye-opening (both in terms of the relationships between network topology and prefix hijacking as well as the relatively unmitigated security horror that is BGP).

ASwatch: An AS Reputation System to Expose Bulletproof Hosting ASes

Maria Konte, Roberto Perdisci, and Nick Feamster

This is a really cool paper: it proposes an autonomous system reputation system, ASwatch, that only uses the control plane (that is, routing behavior) to preemptively identify malicious/criminal ASes, rather than using data plane monitoring to identify malicious behavior after the fact. I definitely recommend this one (the authors report a 93% success rate and 5% false positive rate!).

Sizing Router Buffers

Guido Appenzeller, Isaac Keslassy, and Nick McKeown

Another cool one: this paper demonstrates that the old heuristic for buffer sizing (B = RTT * C, where B is the buffer size, RTT is the average round-trip time of a flow passing over the link, and C is is the link’s data rate) is outdated: in reality, B = (RTT * C) / sqrt(N), where N is the number of flows over the link (since there’s now a much larger number of TCP connections multiplexed over individual backbone router links).

The Crossfire Attack

Min Suk Kang, Soo Bum Lee, and Virgil D. Gligor

Another Computer Networks paper (I’ll note when I pivot from networking to another topic). This one illustrates the crossfire attack, which allows a relatively small number of bots to undetectably take down server targets by flooding just a few links (using low-intensity flows that are indistinguishable from normal network traffic) to cut off the target server(s) from the rest of the Internet.

CUBIC: A New TCP-Friendly High-Speed TCP Variant

Sangtae Ha, Injong Rhee, and Lisong Xu

In this paper, the authors present CUBIC, a TCP congestion control protocol that improves TCP scalability by replacing the previous linear window growth function with a cubic function. (As far as I know, CUBIC is currently the default TCP algorithm for the Linux kernel.)

How Hard Can It Be? Designing and Implementing a Deployable Multipath TCP

Costin Raiciu et al.

This paper aims to answer the question: “Is it possible to extend TCP to enable it to support multiple paths for current applications on today’s Internet?” (Short answer: yes, but it’s not trivial.)

The Performance Impact of Buffer Sizes for Multi-Path TCP in Internet Setups

Feng Zhou et al.

This is another paper on MPTCP, and I found it interesting because of the results the authors obtained with regard to buffer sizing (in particular, due to packet reordering over various paths, the buffer size requirements are actually fairly small—see Table III in the paper).

Hold-On: Protecting Against On-Path DNS Poisoning

Haixin Duan et al.

I first became familiar with DNS vulnerabilities through Dan Kaminsky’s work on DNS cache poisoning (Black Hat 2008), so I was particularly interested in this paper. The authors argue that DNS resolvers should wait after receiving an initial reply (what they call the “hold-on” period) in order to allow legitimate replies to also arrive (since DNS injection attacks often rely on malicious responses arriving at the resolver before legitimate ones).

Jellyfish: Networking Data Centers Randomly

Ankit Singla, Chi-Yao Hong, Lucian Popa, and P. Brighten Godfrey

I thought this paper was really cool because it demonstrated that a random graph topology (the “jellyfish”) is more cost-effective than a fat tree topology, supporting roughly 25% more servers (though at the cost of routing and wiring complexity).

PortLand: A Scalable Fault-Tolerant Layer 2 Data Center Network Fabric

Radhika Niranjan Mysore et al.

This was one of the few papers I read for Computer Networks that I didn’t find all that compelling (though the authors do a good job of describing a “plug-and-play” connection fabric comprising Ethernet-based routing and address resolution protocols for modern data centers).

The Road to SDN: An Intellectual History of Programmable Networks

Nick Feamster, Jennifer Rexford, and Ellen Zegura

This paper is a history of software-defined networking, which wasn’t mind-blowing but was a good introduction to the topic.

How Secure are Secure Interdomain Routing Protocols?

Sharon Goldberg, Michael Schapira, Peter Hummon, and Jennifer Rexford

Hint: not very.

Application Flow Control in YouTube Video Streams

Shane Alcock and Richard Nelson

This paper is a case study on the flow techniques used by YouTube. Super interesting!

Formulas for Bancor System

Meni Rosenfeld

Okay! Moving on from computer networks to cryptocurrencies and game theory. This paper details the math behind Bancor’s autonomous converter contracts.

First-Price Auctions, Dutch Auctions, and Buy-It-Now Prices with Allais Paradox Bidders

Daisuke Nakajima

I read this paper shortly after we started AUX to better understand the game theory underpinning first-price, Dutch (descending price), and “buy it now”-style auctions. (For a general text on auction theory, I highly recommend Krishna’s Auction Theory.)

Snowflake to Avalanche: A Novel Metastable Consensus Protocol Family for Cryptocurrencies

Team Rocket

This paper was a good overview of several non-proof-of-work Byzantine fault tolerance protocols—I absolutely recommend it for those interested in the Byzantine generals’ problem and/or consensus algorithms as implemented in various cryptocurrencies (the paper demonstrates a Bitcoin-like system that can achieve throughput of 1300 transactions per second!).

Finally, here the papers I want to read in 2019 (starting with one rolled over one from 2018):

Polynomial-Time Algorithms for Prime Factorization and Discrete Logarithms on a Quantum Computer

Peter W. Shor

Quantum computing sort of fell off my radar last year, and given all the activity in cryptocurrency markets over the past several months, I figure now’s the time to read up on the sorts of technology that would turn those markets upside-down…er.

A Tutorial Implementation of a Dependently Typed Lambda Calculus

Andres Löh, Conor McBride, and Wouter Swierstra

I’ve been interested in dependent types ever since I first started programming in/contributing to Idris, so I’m excited to work through this paper (including understanding when/whether type checking in dependently-typed programs becomes undecidable).

Safer Smart Contracts Through Type-Driven Development

Jack Pettersson and Robert Edström

I’ve written about safety in smart contracts, and I’m interested to dig deeper into the intersection between smart contract design and dependent types.

On the Practical Nature of Artificial Qualia

Raúl Arrabales, Agapito Ledezma, and Araceli Sanchis

On to theory of mind! One of the things I find myself thinking about with regard to machine learning and AI is the nature of an artificially intelligent agent’s “inner life”: would a machine have experiences and sensations in a way we would recognize (e.g. the color red, the taste of salt)? Hopefully this paper gives me something of a jumping-off point for investigating artificial qualia.

Turing Machines

Hilary Putnam

This paper (and the next one) are from Introduction to Philosophy, Third Edition by Perry and Bratman (continuing my reading on computability and the relationship between machinery and mind).

Minds, Brains, and Programs

John K. Searle

I first encountered Searle’s work in the context of his “Chinese room” thought experiment, and I’m interested in a more explicit treatment of functionalism and artificial vs. natural intelligence.

Off we go!

Complexity, Completeness, and Smart Contracts

Thu, 12 Jul 2018 14:00:00 +0000

Some Background

Over the past several months, as the team at AUX has been building out the AUX Platform, I’ve had the opportunity to read and write several smart contracts. Smart contracts for the Ethereum blockchain can be written in a few different languages, but the most popular one is Solidity, which looks a little like a cross between JavaScript and C++ (with a little payment-specific DSL thrown in). Here’s an example from OpenZeppelin’s ERC721 basic token contract:

function approve(address _to, uint256 _tokenId) public {
  address owner = ownerOf(_tokenId);
  require(_to != owner);
  require(msg.sender == owner || isApprovedForAll(owner, msg.sender));

  tokenApprovals[_tokenId] = _to;
  emit Approval(owner, _to, _tokenId);
}

This approve function is called in the process of transferring an ERC721 asset from one owner to another. Owners are identified by their addresses, which in Ethereum are forty-character hexadecimal strings; non-fungible tokens are tracked in registry contracts by their ID numbers (usually in a 256-bit address space).

First, the function looks up the owner of the token via the ownerOf function (not shown here). Next, it ensures that we’re not attempting to transfer the token to the person who already owns it (the first require statement) and that the person doing the transferring is either the item’s owner or someone who’s approved to transfer it on their behalf (the second require statement). After that, it goes ahead and updates its mapping of which token is owned by which address. Finally, the contract emits an Approval event to signal that the approval has taken place.

While I find Solidity contracts relatively readable, I’ve come to believe that Solidity is not an ideal (or even a very good) language for smart contract development. I have three fundamental problems with it:

Fallback functions scare the hell out of me;
I don’t think the type system does enough to protect programmers from silly errors;
I fundamentally don’t think Turing-completeness is necessary or desirable.

Fallback Functions

Fallback functions are anonymous functions that can accept no arguments and can have no return value. They’re called when a contract receives a function call for which there is no matching identifier (that is, someone called a function that the contract does not implement). An example might look like this:

function() payable { }

In this case, the contract is designed to accept ether sent to it, even if no data are included or the intended function signature is incorrect. (Without this fallback function, the contract would instead throw an error and return the ether.) While contract writers might prefer this behavior, I think it’s surprising and confusing to users interacting with it (whether honestly maliciously), and this sort of behavior is ripe for abuse/misuse, as can be seen in the “King of the Ether Throne” examples found here. Generally speaking, I agree with PEP 20 that explicit is better than implicit, and these kinds of implicit behaviors are especially thorny when contracts and payments are involved.

The Type System

I think the only thing I like about the Solidity type system is that it’s static. String modifications almost always require casting to bytes (including string concatenation: yes, this has to be done manually). While Solidity supports enums, the ABI does not. As of this writing, Solidity still does not support fixed-point numbers, in which it is much easier to reason about arithmetic operations like addition and subtraction. This seems like it would be a good feature for a language designed to handle financial transactions. Even if you argue that money shouldn’t be modelled this way, there are many non-currency values for which this kind of arithmetic would be really useful (risk modelling, logistics planning, and so on).

While some of these problems will probably eventually be fixed by improvements to the EVM and/or Solidity language, I think they’re always going to feel like exactly that: fixes rather than core design decisions. To my mind, a language built to enforce smart contracts should prioritize correctness and security, and a more powerful type system would help further that goal. I think a dependently-typed language like Idris could be ideal. (NB: I really like Idris and have made small contributions to the language.) A type system that can enforce invariants like “non-negative integer” or “list of string where each member is at least three characters long” means more correctness can be confirmed by the compiler, leaving less to ever-incomplete testing and well-meaning but error-prone wetware. (Idris also has excellent tooling for formal verification and theorem proving; more on this in the next section.)

Turing Completeness

Solidity is Turing-complete, meaning that a Solidity smart contract can simulate any Turing machine. While this makes a rich universe of contracts available to Solidity programmers, this necessarily includes programs that are valid but undesirable, such as those that loop forever (at least until they run out of gas), only throw exceptions, or don’t do anything at all. It’s hard enough to write correct, performant programs as it is, and I think that by excluding valid but useless programs, especially when coupled with a more powerful type system, we get a simpler language in which it is harder to make mistakes and lose people’s money.

While it has been argued that eliminating Turing completeness is not necessary to achieve provable correctness, it certainly makes things simpler, and since I’ve yet to see any compelling argument for why it’s necessary, I tend to think it’s better to exclude it until proven a requirement. Theorem proving and formal verification can be more easily accomplished in a less expressive language, and if there is no demonstrable, practical downside to that tradeoff, I think it should be made without hesitation.

In Conclusion

While I find Solidity readable because I’m used to ALGOL-family languages like C++ or Java, I don’t think it’s a particularly good choice for developing smart contracts. So what is?

There are a few newer languages that I think are promising. As mentioned, I think Idris or an Idris-like language with a powerful, dependent type system could be ideal. It’s also possible that such a language could be useful for proving the correctness of contracts written in existing languages like Vyper or Kadena’s Pact, both of which aim to improve on existing smart contract language designs (and the latter of which is intentionally Turing-incomplete). Although I do worry that Pact’s LISP-inspired syntax raises the barrier to entry, as someone who picked up Clojure after learning JavaScript and Ruby, I think that barrier is very surmountable.

Ultimately, I think smart contracts are a fascinating area of software development, and the languages used to construct them, while imperfect, will have to improve as adoption increases. I’m really excited to see that evolution take place, and I’m lucky to witness it firsthand while building AUX.

Reading List 2018

Sat, 23 Dec 2017 14:00:00 +0000

It’s that time of year again! (Man, I really need to blog more.)

Books

I managed to get to most of the books I wanted to read in 2017 (see below for the ones I’m rolling into next year). Here are a few extras I read:

Hillbilly Elegy

J.D. Vance

This book came on my radar not long after the 2016 presidential election. While I did gain some valuable insights into Appalachia through the lens of Vance’s personal experiences, I felt like some of the explanations he provides (basically that hillbillies—his term—have brought their misfortune on themselves through “learned helplessness” and a cultural opposition to education) are unnuanced and overly simplistic.

The Cuckoo’s Egg

Cliff Stoll

I found this one after reading the Wikipedia article about Markus Hess. It was a fascinating look into the state of computer security and the Internet in the 1980s, and the writing and pacing made for a really good detective story.

What Hedge Funds Really Do

Philip J. Romero and Tucker Balch

This book was required reading for Machine Learning for Trading (also part of my masters degree program at Georgia Tech). It’s a pretty quick read (one afternoon/sitting) and provided me a decent overview of hedge funds’ history, how they work, and the theory behind risk mitigation. (Spoiler: the only decent way to make money with hedge funds is to run them.)

A Random Walk Down Wall Street

Burton G. Malkiel

This is sort of a classic in terms of literature on investing in the stock market, so I figured I’d pick it up. It’s surprisingly long—a little over 450 pages—and I got tired about three quarters of the way through. The general sentiment is to invest in a diverse portfolio early in your career and invest as much as you can over time, adjusting your portfolio to become more conservative as you age. Nothing really groundbreaking, but his asides, anecdotes, and worked examples are worth slogging through the more repetitious parts.

Liar’s Poker

Michael Lewis

This one has actually been on my “to-read” list since the 2008 financial crisis. I’d heard a lot about the culture of 1980s Wall Street, and it sounds like most of it was true: unchecked greed, no-neck traders gleefully ripping off anyone they could, little (if any) true oversight. This was a good mix of horrifying and entertaining, but the more I think about it, the more I find it the former than the latter. (I doubt much, if anything, has really changed in the banking industry over the intervening years. Maybe there’s less cocaine now.)

The Big Short

Michael Lewis

I really enjoyed Liar’s Poker, so I figured I’d give this a shot as well. This book focuses on the forces that led to the 2008 financial crisis (specifically, the proliferation of credit default swaps and collateralized debt obligations). I highly recommend this book (I haven’t seen the film, but I’ve heard it’s good); however, if you just want the details of the crisis without the story elements, this video is a good TL;DR.

The Manager’s Path

Camille Fournier

I’d been meaning to read this since I first heard Camille (who was my CTO when I worked at Rent the Runway) was working on it, and I was not disappointed. I highly, highly recommend this book to managers in all industries, but especially those in tech (I found the chapters on managing more than one team and managing managers particularly relevant).

The First 90 Days

Michael D. Watkins

I moved from Hulu to Fox Networks Group in July, and I figured then was as good a time as any to re-read The First 90 Days. While I think some of the more salient points can be distilled into a blog post (which I’ll plan to tackle in early 2018), I think it’s still worth a full read, especially if you’re joining and/or leading a new team.

Practical Machine Learning

Ted Dunning and Ellen Friedman

This is really more of a long blog post/tutorial on PredictionIO’s universal recommender and its correlated cross-occurrence algorithm for making recommendations, but I still enjoyed it. It’s a very quick read (only fifty or sixty pages).

Here are the books I want to read in 2018, starting with the five books I’ve rolled over from 2017.

Type-Driven Development with Idris

Edwin Brady

I did some reading and work on Idris in 2016, so I’m really excited to read Edwin’s book this year.

Mindset: The New Psychology of Success

Carol S. Dweck

I mentioned this book in a talk I gave at RailsConf in May of 2016. I read a couple of Dweck’s papers while preparing for that talk, and I think there’s a tremendous amount I can learn from Mindset for my growth as both an individual contributor and as an engineering leader.

First, Break All the Rules

Marcus Buckingham and Curt Coffman

I’ve heard good things about this book at each of the last four places I’ve worked, so it’s probably high time I read it.

A Billion Voices: China’s Search for a Common Language

David Moser

This book was recommended by my Mandarin teacher, and I think it’ll be really interesting to see how modern Mandarin arose from a highly fragmented set of spoken languages and traditions.

The Three-Body Problem

Cixin Liu

This is the only novel on my reading list, but it’s been recommended to me by three completely separate groups of friends, so I’m expecting to really enjoy it. (It’s not that I don’t enjoy reading novels—I do—but they’ve been crowded out by my interests in poetry, philosophy, and computation over the past handful of years.)

The Practice of Programming

Brian W. Kernighan and Rob Pike

I’ll read pretty much anything by Kernighan and Pike, and I’m particularly hoping for some good insights on the tougher aspects of engineering (balancing tradeoffs, identifying the human roots of technical problems, &c).

English Grammar for Students of German

Cecile Zorach et al.

My German has gone a bit downhill since I first started learning in high school (wer rastet, der rostet, nicht wahr?), and while my pronunciation is still pretty good and vocabulary comes back to me quickly, I don’t feel I have as firm a grammatical footing as I’d like. Hopefully reading this book and practicing my spoken German helps with that!

Working Effectively with Legacy Code

Michael Feathers

This book has been recommended to me by too many people for me to continue not reading it.

High Output Management

Andrew S. Grove

This was recommended to me at a conference I attended earlier this year. Andrew Grove was employee number three at Intel and has built some really impressive teams in the course of his career, so I’m looking forward to reading his story and learning from his mistakes.

Eichmann in Jerusalem

Hannah Arendt

“A report on the banality of evil” seems particularly relevant in our current political climate.

What I Learned Losing a Million Dollars

Brendan Moynihan

I mentioned looking forward to learning from Andrew Grove’s mistakes in High Output Management, and that’s doubly true for this book. Most of the narrative finance books I’ve read are more analyses of other people’s realizations and mistakes; I’m hoping to glean something a bit more qualitative (in terms of the psychology of investing) from this first-person account.

Consciousness Explained

Daniel Dennett

Papers

In addition to the papers I set out to read in 2017, I picked up a ton more (grad school will do that to you). Omitting some of the less compelling papers, they were:

The Geometry of Innocent Flesh on the Bone: Return-into-libc without Function Calls (on the x86)

Hovav Shacham

I read this paper for my introduction to information security class, and it was a good introduction to return-to-libc attacks (I got to write my own exploit as part of my coursework!).

On the Effectiveness of Address-Space Randomization

Hovav Shacham et al.

Another InfoSec paper (which is true of the next several, so I’ll just note when we move on from that topic). This one focused on the benefits of address-space layout randomization, or ASLR, in preventing attackers from jumping to known points in memory.

ASLR-Guard: Stopping Address Space Leakage for Code Reuse Attacks

Kangjie Lu et al.

ASLR is only effective if the address layout is truly random and no information about the randomization or ensuing layout is leaked. This paper discusses the possibility of information leakage and proposes ASLR-Guard as a measure to mitigate it (by rendering leaked pointer information useless).

Code-Pointer Integrity

Volodymyr Kuznetsov et al.

This paper covers Code-Pointer Integrity (CPI) as an augmentation to tools like ALSR. By enforcing CPI, it’s possible to prevent any kind of control-flow hijacking by an attacker (such as ROP exploits).

Control-Flow Bending: On the Effectiveness of Control-Flow Integrity

Nicolas Carlini and Mathias Payer

Another method of preventing control-flow hijacking, but with somewhat higher overhead than CPI.

Mining Your Ps and Qs: Detection of Widespread Weak Keys in Network Devices

Nadia Heninger, Zakir Durumeric, Eric Wustrow, and J. Alex Halderman

I found this paper really fascinating. It explores RSA and DSA failures caused by malfunctioning random number generators, particularly devices that generate predictable random numbers due to insufficient entropy in the input pool during boot (see Figure 5 in the paper). As is the case with all good security papers: really interesting, really scary.

Q-Learning in Continuous State and Action Spaces

Chris Gaskett, David Wettergreen, and Alexander Zelinsky

Moving on from InfoSec, we now enter the realm of reinforcement learning! (I took Reinforcement Learning over the summer.) My first exposure to Q-learning was in Machine Learning for Trading (linked above), and that implementation relied on a Q-value table (requiring discrete action and state spaces). This paper covers Q-learning in environments with continuous action and/or state spaces.

Learning to Predict by the Methods of Temporal Differences

Richard S. Sutton

This is another paper I found kind of mind-blowing. The general idea here is to incrementally improve predictions not by comparing predictions to actual outcomes, but by comparing successive predictions. It’s the kind of thing that sounds like it shouldn’t work, but it absolutely does! It’s a bit long (36 pages), but definitely worth the read.

Knows What It Knows: A Framework For Self-Aware Learning

Lihong Li, Michael Littman, and Thomas J. Walsh

Knows-What-It-Knows, or KWIK, learning is a pretty cool idea, and the paper is a quick (pun super intended) read. The idea is to apply PAC (probably, approximately correct)-learnability to mistake-bound models, resulting in a learner that’s able to determine when it doesn’t know the answer. The example provided in section 2 of the paper is a great way to develop intuition around KWIK learning and is only about a page long.

Residual Algorithms: Reinforcement Learning with Function Approximation

Leemon Baird

Another cool one. The idea here is that there are reinforcement learning algorithms (such as Q-learning) that perform well using lookup tables, but perform poorly when direct function approximation is used. Baird shows that residual algorithms permit direct approximation while maintaining stability and convergence.

Stable Function Approximation in Dynamic Programming

Geoffrey J. Gordon

This is one of the papers that really underscored for me the interrelation of reinforcement learning and dynamic programming (which each rely on the same mathematical underpinning: the Bellman equations). Though the equations themselves are not referenced, the proofs of convergence for multiple temporal difference learning algorithms that rely on function approximation (see also Baird, above) are really cool.

Between MDPs and Semi-MDPs: A Framework for Temporal Abstraction in Reinforcement Learning

Richard S. Sutton, Doina Precup, and Satinder Singh

We read a few different papers on temporal abstraction in reinforcement learning for my RL class, but this one was my favorite. I particularly like the idea of options in this paper, which are temporally variable, closed-loop policies that agents may take in the course of learning a game (e.g. picking up an object, traversing a room). Abstracting time out in this way (rather than thinking in terms of discrete steps, each of uniform spatiotemporal duration) allows us to incorporate more intuitive, semantically valuable actions into Markov processes.

A Polynomial-time Nash Equilibrium Algorithm for Repeated Games

Michael Littman and Peter Stone

This is another cool one: determining a polynomial-time algorithm for finding Nash equilibria in general-sum games (e.g. multiplayer online games).

A Polynomial-time Nash Equilibrium Algorithm for Repeated Stochastic Games

Enrique Munoz de Cote and Michael Littman

Similar to the above, but for stochastic (non-deterministic) games.

Markov Games as a Framework for Multi-Agent Reinforcement Learning

Michael Littman

This paper extends Q-learning beyond MDPs (Markov decision processes) and into Markov games. (Another good paper on this topic, also by Littman, is “Friend-or-Foe Q-Learning in General-Sum Games”.)

Correlated Q-Learning

Amy Greenwald and Keith Hall

This is the last RL paper I’ll list here (and, I think, the last one I read for my class). Greenwald and Hall introduce correlated Q-learning, which is a Q-learning algorithm that relies on correlated equilibria to generalize both Nash-Q and Friend-or-Foe-Q (see Littman’s paper, above). I really enjoyed reading this paper, and it was a great place to end my reading for the course, knitting together Q-learning, Nash equilibria, MDPs, and Markov games.

Practical Network Support for IP Traceback

Stefan Savage, David Wetherall, Anna Karlin and Tom Anderson

This is the first of a few papers I read for Network Security (as before, I’ll note when we switch gears). This one focuses on identifying the source of packet flooding attacks without the cooperation of the associated ISP (and using a surprisingly elegant sampling algorithm that relies on very little edge data to reconstruct a packet’s path).

A DoS-Limiting Network Architecture

Xiaowei Yang, David Wetherall, and Thomas Anderson

This paper introduced me to the idea of capabilities, which are a method by which routers can identify desired packets (packets encoding this kind of information are said to employ a capability). While the overhead involved in adopting this architecture is nontrivial, implementing capabilities (or their functional equivalent) would be a huge step forward in securing computer networks.

ZMap: Fast Internet-Wide Scanning and Its Security Applications

Zakir Durumeric, Eric Wustrow, and J. Alex Halderman

This paper taught me about ZMap, which is, well, “a modular, open-source network scanner specifically architected to perform Internet-wide scans and capable of surveying the entire IPv4 address space in under 45 minutes from user space on a single machine.” It’s a really cool tool, and I encourage you to check it out.

Anomalous Payload-Based Network Intrusion Detection

Ke Wang and Salvatore J. Stolfo This was the first of two papers I read for one of my Network Security projects, which involved using PAYL to detect anomalous traffic. I particularly enjoyed this paper because it sits at the intersection of two of my main interests: information security and machine learning.

Polymorphic Blending Attacks

Prahlad Fogla et al.

This was the second of two papers I read for the Network Security project I mention above. In this paper, the authors discuss polymorphic blending attacks, which can be used to hide anomalous traffic from detectors like PAYL. I even got to try my hand at obfuscating malevolent traffic and getting it past a PAYL-based model I’d built!

Dynamic Routing Between Capsules

Sara Sabour, Nicholas Frosst, and Geoffrey E. Hinton

These next two papers are on capsule networks, which are an augmentation to more traditional convolutional neural networks. The idea is to encode positioning information in the networks themselves to make them more robust to affine transformations; this series of Medium posts is a really good step-by-step breakdown of the material.

Matrix Capsules with EM Routing

Geoffrey E. Hinton et al.

This paper is also on capsule networks, but focuses on the expectation maximization algorithm used to route signals between layers. This Medium post (from the same series as the post linked above) is a great explanation of (and addition to) the paper.

White Paper: The Universal Recommender

Jérôme Kunegis, Alan Said and Winfried Umbrath

Finally, I read the white paper on the Universal Recommender (used by PredictionIO, mentioned under Books). The underlying correlated cross-occurrence algorithm is interesting, and I think this is something of a must-read for anyone considering using the Universal Recommender (or honestly, anyone interested in building ML-based recommendation systems).

I also read a bunch of cryptocurrency and cryptographic token white/yellow papers (including those for Ethereum (white and yellow), Golem, Basic Attention Token, Civic, WAX, and EOS). Since these aren’t peer-reviewed academic papers, though, I haven’t broken them out as I have for the others (though I do find them extremely interesting).

Finally, here the papers I want to read in 2018 (starting with two rolled-over ones from 2017):

Mastering the Game of Go with Deep Neural Networks and Tree Search

Google DeepMind

I followed some of the news about AlphaGo’s victory over Lee Sedol last year, but didn’t get a chance to read the paper, so it’s on my to-read list for the new year.

Everything You Always Wanted to Know About Synchronization but Were Afraid to Ask

Tudor David, Rachid Guerraoui, and Vasileios Trigonakis

Synchronization is hard! Hopefully reading this paper makes it less so (for me, anyway).

Mastering Chess and Shogi by Self-Play with a General Reinforcement Learning Algorithm

David Silver et al.

A continuation of the type of work explored in “Mastering the Game of Go…” (above). In this case, AlphaZero attained a superhuman level of play in chess, shogi, and go after only twenty-four hours of self-play, with no prior domain knowledge.

Improving Elevator Performance Using Reinforcement Learning

Robert H. Crites and Andrew G. Barto

This is the only paper I didn’t read during my RL class, so I want to be sure to get to it.

The Max K-Armed Bandit: A New Model of Exploration Applied to Search Heuristic Selection

Vincent A. Cicirello and Stephen F. Smith

I became interested in k-armed bandits when we covered them in my RL class, and given that this won the best AAAI paper award in 2005, I figure this should be well worth the read.

Polynomial-Time Algorithms for Prime Factorization and Discrete Logarithms on a Quantum Computer

Peter W. Shor

Quantum computing sort of fell off my radar this year, and given all the activity in cryptocurrency markets over the past twelve months, I figure now’s the time to read up on the sorts of technology that would turn those markets upside-down.

Off we go!

How to Call Your Reps

Sun, 29 Jan 2017 14:00:00 +0000

Calling your representatives is one of the most direct methods you have for influencing US politics (this guide assumes an American audience). Aside from showing up in person (e.g. at a town hall meeting or protest), calling is the most important thing you can do. There is no form of communication I hate more than the telephone, but I’ve managed to call my representatives every weekday this month and I’m going to keep calling every weekday until Donald Trump is out of office. If I can do it, you can do it!

Know who they are

This step is the simplest: you can look them up! The ones you’ll call most often are probably your US senators (you have two) and your representative in the House (you have one of these). They can be reached by e-mail, Twitter, Facebook, and so on, but calling is the most effective. Like I said, I really hate talking to people on the phone, but this is important enough that I’ve gotten over it. I sort of even look forward to calling on my walk to work each morning.

Be persistent

Senators and members of the House are, like you, extremely busy, so they and their staff aren’t always available when you happen to call; you may have to try a few times in order to get through. Don’t give up! If you call a few times and there’s no answer, try again in an hour or two. If you call several times and still can’t get through, leave a message with your contact information. As for what you should say in your message…

Have a script

Many people I’ve talked to have expressed interest in calling their representatives, but hesitate because they’re not sure what to say. This is understandable, but can be fixed with a bit of preparation. Here’s a sample script for calling about Trump’s Muslim ban:

Hi, my name is (your name) and I’m a consitutent of (representative). I’m deeply concerned by Donald Trump’s executive order banning Muslim refugees and want to be sure (representative) is doing everything in (his/her) power to fight it and get it rescinded.

(Organizations like 5 Calls have sample scripts ready if you don’t want or have time to create your own.)

Congressional staff members are generally very polite and will usually promise to pass your message along; they may ask you for a few details, like your ZIP code, to ensure that your message is relevant to their boss. If you call with multiple concerns, feel free to ask the staff member to read your request back to you to make sure they’ve gotten everything. Which reminds me:

Be polite

Regardless of whether your representative shares your political views, it’s crucial to be polite: they (and their staff members) will be much less sympathetic to your viewpoint if you’re rude, combative, or abusive. If you’re calling a rep from your own party, feel free to mention that and reiterate how important your issue is to you (and, by extension, should be to them). If you’re calling a rep from another party, you can let their staff know how troubled you are by the direction they and/or their party is taking without directly stating your party affiliation.

One last thing: take the time to call when your representatives have done something you think is good! Positive reinforcement goes a long way, and people are much more likely to remain motivated when they receive it.

Get in the habit

Finally, it’s important to remember that civic engagement isn’t a one-time thing: it’s a commitment. Luckily, once you call your representatives one time, calling them repeatedly becomes easier. I recommend calling regularly (weekly or daily) and always calling at the same time of day. Calling only takes a minute or two, but the impact you have might be felt for years to come.

Reading List 2017

Tue, 27 Dec 2016 14:00:00 +0000

Books

I managed to read most of the books on my 2016 reading list (see below for the three that I’m rolling over into 2017), along with some new ones I picked up along the way:

L’Heure Bleue, or The Judy Poems

Elisa Gabbert I’ve come across Elisa’s poems over the past few years in DIAGRAM and coconut, so I ordered her new book as soon as I saw it come across my Twitter feed. The poems live partially inside the mind of Judy, a character in Wallace Shawn’s The Designated Mourner. They’re really extraordinary, and I’m planning to read the rest of Elisa’s books (French Exit and The Self Unstable) in 2017. Every once in awhile I read a book of poems that jump-starts my own writing, and this is one of them; I haven’t written a review of a poetry collection in awhile, but this one has been turning over in my mind enough these past couple of weeks that I may give it a go in the new year.

Sensual Math

Alice Fulton I picked this up shortly after my younger brother’s sudden death this summer. I enjoyed Fulton’s “fractal” poetry and found it really helpful, and this is another one that’s gotten me thinking about my own writing again (one of my goals for 2017 is to write more poems).

It Can’t Happen Here

Sinclair Lewis Except, as you know, it can and it did.

Machine Learning

Tom M. Mitchell This was required for the machine learning course I took at Georgia Tech this fall. The text is surprisingly clear and conversational, and I really enjoyed both the reading and the coursework.

Modern Mandarin Chinese Grammar

Claudia Ross and Jing-heng Sheng Ma Laura and I started learning Mandarin this year, so I picked up this book to go along with the texts assigned for the class we’re taking. I’m probably around an HSK2 level at this point (我会说一点点中文但是我的中文不好). I’m hoping to take the HSK4 exam in late 2017!

Here’s what I want to read in the coming year (starting with rolled-over books from 2016). As you’ll sort of see from my book and paper choices, my interests are mostly poetry (20th/21st century), philosophy (all kinds, though recently mostly ethics and philosophy of science), and computer science/tech (machine learning, information security, artificial intelligence, and programming languages, particularly functional and dependently-typed languages):

Structure and Interpretation of Computer Programs

Harold Abelson and Gerald Jay Sussman with Julie Sussman (Rolled over from 2016.) I wrote last year: “I’ve gotten about a third of the way through SICP twice; in 2016, my goal is to finish it.” Here’s hoping third time’s the charm!

Seven Concurrency Models in Seven Weeks

Paul Butcher (Rolled over from 2016.) For me, the hardest thing about learning Clojure was learning its concurrency primitives: atoms, agents, refs, and STM were unlike anything I’d ever used before. After writing Clojure for nearly four years and using it in a production web and iOS app, I’ve gained a deep appreciation for new ways of thinking about and writing concurrent applications. This book seems like it has a thing or two (or seven!) to teach me.

Purely Functional Data Structures

Chris Okasaki (Rolled over from 2016.) I read part of the paper (also on my 2016 list) before deciding to just focus on the book. While I was taking Algorithms: Design & Analysis, parts one and two on Coursera, I became interested in applying what I’d learned to functional programming languages like Clojure (as opposed to Java or Python, which I figure are the languages most students are using), which led me to Okasaki’s work.

Deep Learning: A Practitioner’s Approach

Josh Patterson and Adam Gibson We haven’t gotten too much into deep learning and deep neural network architectures in my coursework, so I’d like to dig into that in 2017. I gave a talk at this year’s EuroClojure that involved some work with DL4J, and I’d like to continue that kind of work in the new year.

Type-Driven Development with Idris

Edwin Brady I did some reading and work on Idris in 2016 (more under Papers, below), so I’m really excited to read Edwin’s book when it’s available next month.

Thoughtful Machine Learning

Matthew Kirk Ruby and ML are two of my favorite things! (I gave a talk on machine learning with Ruby at RubyConf this fall.) There’s not a whole lot of machine learning work being done in Ruby, so I’m interested to see what Kirk has in store.

Effective Java

Joshua Bloch As I’m getting the chance to write more Java at work, I’m re-reading this one to improve my code and better follow best practices. There’s a ton of great stuff in this book, and I wholeheartedly recommend it to anyone who writes Java (professionally or otherwise).

The Hacker Playbook 2

Peter Kim I’m taking an information security course at Georgia Tech in the spring, so I figured I’d do a little extracurricular reading (including this book on penetration testing). This is a bit of a follow-up to my earlier security reading (Hacking: The Art of Exploitation and Penetration Testing). My guess is that 90% of my interest in computer security has to do with the current political climate and 10% from watching too much Mr. Robot.

Ethical Hacking and Penetration Testing Guide

Rafay Baloch Another book on information security and penetration testing, though this one has a bit more in the way of process and ethics.

The Basics of Hacking and Penetration Testing (2nd Edition)

Patrick Engebretson The third in my trio of “how to hack stuff” books! There’s probably going to be a fair amount of overlap among them, but I want to be sure I have a thorough grounding in practice as well as theory.

Computer Security, Principles and Practice (3rd Edition)

William Stallings and Lawrie Brown Speaking of theory, this is the required text for my information security course.

Artificial Intelligence: A Modern Approach

Stuart Russell and Peter Norvig I’ve read bits and pieces of this as part of my machine learning and AI coursework, and I’d like to dig deeper in 2017.

Mindset: The New Psychology of Success

Carol S. Dweck I mentioned this book in another talk I gave at RailsConf in May. I read a couple of Dweck’s papers while preparing for that talk, and I think there’s a tremendous amount I can learn from Mindset for my growth as both an individual contributor and as a manager.

First, Break All the Rules

Marcus Buckingham and Curt Coffman I’ve heard good things about this book at each of the last three places I’ve worked, so it’s probably high time I read it.

Hume: An Intellectual Biography

James A. Harris I’ve been interested in Hume since I took an introductory philosophy course in college, and the reviews for this biography look pretty good.

The Culture Industry

Theodor W. Adorno I’ve also been interested in Adorno since college, and in fact read this exact book for a cultural studies class I took. This New Yorker article brought it back to my attention, and I think it’s overdue for a re-read.

A Billion Voices: China’s Search for a Common Language

David Moser This book was recommended by my Mandarin teacher, and I think it’ll be really interesting to see how modern Mandarin arose from a highly fragmented set of spoken languages and traditions.

Barely Composed: Poems

Alice Fulton Fulton is the author of Sensual Math, which I read this past year and really enjoyed. This is a more recent collection of hers, and I’m interested to see how her poetry has evolved over time.

The Nightingales of Troy

Alice Fulton This is a collection of linked short stories. I’m interested in this partly because I like her work, but also because I’m somewhat interested in writing short fiction, so I’m curious to see whether and how this will inform and provoke my own writing.

French Exit

Elisa Gabbert As mentioned, I read Elisa’s L’Heure Bleue, or The Judy Poems this year, and I’m excited to read her earlier work in 2017.

The Self Unstable

Elisa Gabbert These are lyric essays rather than poems. In the vein of my interest in Fulton’s work (that is, reading non-poetry as well as poetry by the same author), I’m curious to see how Elisa’s writing changes between these two modes and to discover what implications this could have for my own writing.

The Three-Body Problem

Cixin Liu This is the only novel on my reading list, but it’s been recommended to me by three completely separate groups of friends, so I’m expecting to really enjoy it. (It’s not that I don’t enjoy reading novels—I do—but they’ve been crowded out by my interests in poetry, philosophy, and computation over the past handful of years.)

The Voynich Manuscript

Raymond Clemens (Editor) The Voynich manuscript is a fascinating illustrated codex from the fifteenth century. I’ve been interested in ciphers and cryptography generally (more under Papers, below) and the Voynich manuscript in particular for years, and I’m so glad there’s finally an affordable reproduction. (Until Clemens’ edition, the only one available was roughly $250.00.)

Papers

I read almost all the papers I set out to read this year (see below for the two I’m rolling over into 2017). I was especially glad to have read all the Idris papers I set out to read in 2016. I even managed to become an Idris contributor!

Here are some extra papers I read in 2016 (mostly as part of the Georgia Tech OMSCS):

MIMIC: Finding Optima by Estimating Probability Densities

Jeremy S. De Bonet, Charles L. Isbell, Jr., and Paul Viola This is a paper on the MIMIC algorithm, which is a randomized optimization algorithm that takes into account the structure of the solution as it searches for optima. If you’re familiar with other RO algorithms but not MIMIC in particular, I think you’ll really enjoy this paper.

A Direct Adaptive Method for Faster Backpropagation Learning: The RPROP Algorithm

Martin Riedmiller and Heinrich Braun We learned about backpropagation in neural networks in my machine learning course. I discovered RPROP while digging through the ABAGAIL machine learning library, and discovered this paper while researching how the algorithm actually works.

Beyond Backpropagation: Using Simulated Annealing for Training Neural Networks

Randall S. Sexton, Robert E. Dorsey, and John D. Johnson We also covered simulated annealing in the randomized optimization portion of my machine learning class, and I was fascinated to discover that it can be used to train neural networks. This is one of my favorite machine learning papers that I came across this past semester.

Towards Fully Autonomous Driving: Systems and Algorithms

Jesse Levinson et al. Before the semester started, I took Sebastian Thrun’s Introduction to Machine Learning course. This paper is a great introduction to fundamental challenges in autonomous vehicle design (though slightly dated—it’s from 2011).

Confident Reasoning on Raven’s Progressive Matrices Tests

Keith McGreggor and Ashok Goel This is the first of three papers I read for Knowledge-Based AI, a course I took this fall as part of my master’s degree at Georgia Tech. The primary projects for the course centered around designing an AI agent that could solve Raven’s Progressive Matrices. This paper is the most recent of the three (2012) and introduces an algorithm for solving RPM problems that includes a calculation of confidence in the answer.

Two Visual Strategies for Solving the Raven’s Progressive Matrices Intelligence Test

Maithilee Kunda, Keith McGreggor, and Ashok Goel This is the next most recent of the three papers (2011) and covers both affine and fractal methods for solving RPM problems. (This paper appears in the citations for “Confident Reasoning,” which is how I found it.)

Addressing the Raven’s Progressive Matrices Test of “General” Intelligence

Ibid. Finally, this is the earliest of the three papers (2009, though I read the other two first) and covers applying the authors’ affine-extended algorithm to RPM problems.

Decipherment with a Million Random Restarts

Taylor Berg-Kirkpatrick and Dan Klein This paper applies a randomized optimization approach to the unsolved 340-character Zodiac cipher. I’ve been interested in classical cryptography and ciphers for awhile now, and the Z340 is one of the most famous unsolved cryptograms (it’s one of the FBI’s Cryptanalysis and Racketeering Records Unit’s top unsolved cases). I especially liked the way this tied into my machine learning coursework (in addition to MIMIC and simulated annealing, we also covered hill climbing with random restarts as part of the randomized optimization portion of the class).

Efficient Cryptanalysis of Homophonic Substitution Ciphers

Amrapali Dhavare, Richard M. Low, and Mark Stamp This paper covers efficient cryptanalysis of homophonic substitution ciphers generally and attempts to decipher the Z340 in particular.

Bayesian Inference for Zodiac and Other Homophonic Ciphers

Sujith Ravi and Kevin Knight This is another paper attempting to crack the Z340, this time using a Bayesian learning approach.

Finally, here the papers I want to read in 2017:

Out of the Tar Pit

Ben Mosely and Peter Marks (Rolled over from 2016.) This is a Fogus recommendation. It seems to mostly be “mutable state is the root of all misery,” and I’m curious to see where it will go.

Fundamental Concepts in Programming Languages

Christopher Strachey (Rolled over from 2016.) Another Fogus recommendation. I get the feeling I’m about to have a ton of knowledge dropped on me.

Concrete Problems in AI Safety

Dario Amodei et al. Given the level of concern about accidents and liability regarding autonomous vehicles (and, looking further ahead, from folks like Elon Musk and Stephen Hawking regarding general AI trying to murder us), AI safety seems like a thing worth learning more about.

TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems

Google Research Like the Millwheel paper, this wasn’t written by Google research generally; there are just way too many names for me to list. I haven’t gotten to dig too much into TensorFlow this year, and I’d like to rectify that in 2017.

Mastering the Game of Go with Deep Neural Networks and Tree Search

Google DeepMind Ditto the above note regarding attribution. I followed some of the news about AlphaGo’s victory over Lee Sedol back in March, but didn’t get a chance to read the paper, so it’s on my to-read list for the new year.

Everything You Always Wanted to Know About Synchronization but Were Afraid to Ask

Tudor David, Rachid Guerraoui, and Vasileios Trigonakis Synchronization is hard! Hopefully reading this paper makes it less so (for me, anyway).

Twenty Years of Attacks on the RSA Cryptosystem

Dan Boneh I’d like to learn more about electronic cryptography as part of my infosec reading this year (most of what I know is classical cryptography).

The Moral Character of Cryptographic Work

Phillip Rogaway This seems like a nice intersection of information security and philosophy, and hopefully has some salient tie-ins with the Ethical Hacking and Penetration Testing Guide, above.

Reflections on Trusting Trust

Ken Thompson “To what extent should one trust a statement that a program is free of Trojan horses?” Another intersection of information security and philosophy.

Bitcoin: A Peer-to-Peer Electronic Cash System

Satoshi Nakamoto I’m taking Machine Learning for Trading in the spring, which has piqued my interest in the intersection between computation and finance. Also, apparently everyone else on the planet has read this paper, so I figure I might as well, too.

Practical Optional Types for Clojure

Ambrose Bonnaire-Sergeant, Rowan Davies, and Sam Tobin-Hochstadt I find that Clojure has very few pain points, but after working in languages like Haskell and Idris (and, to a lesser extent, Java), dynamic typing feels like it might be one of them. (I’m also curious to find out how ideas raised in this paper might interrelate with those behind clojure.spec).

RRB-Trees: Efficient Immutable Vectors

Phil Bagwell and Tiark Rompf This paper examines relaxed radix balanced (RBR) trees, a new data structure for backing immutable vectors in Clojure.

A History of Haskell: Being Lazy with Class

Paul Hudak, John Hughes, Simon Peyton Jones, and Philip Wadler I’ve been doing a fair amount of functional programming this year (mainly Clojure with some Haskell and Idris), and I’d like to better learn and understand the design behind Haskell in the coming year.

Advances in Quantum Machine Learning

Jeremy Adcock et al. I know nothing about quantum computing, so hopefully reading this paper partially rectifies that.

Towards Design for Self-Healing

Alessandra Gorla I really enjoyed Carin Meier’s talk at EuroClojure 2016, which covered genetic programming and self-healing code in Clojure; she referenced this paper, so I’d like to read it to better understand how these principles could be applied to eventually write code that repairs itself.

The Second Language

Tue, 12 Apr 2016 14:00:00 +0000

If you were to ask me to summarize software engineering in one word, “tradeoffs” is the one I’d pick. We make tradeoffs every day: we choose one language over another based on some requirement or constraint, we opt for fast and cheap even though we know sacrificing quality means we’re incurring technical debt, we select a technology that scales to the extent we need at the cost of a steeper learning curve or implementation overhead.

We don’t necessarily consider learning a new language to be a lesson in tradeoffs, but I think the second programming language you learn is exactly that. A programming language fundamentally represents how an engineer or group of engineers thinks about solving problems, and since solving problems is all about tradeoffs, it’s impossible for you to learn a language without coming to grips (consciously or not) with the tradeoffs its creators made (consciously or not).

If you ask your friend who writes Haskell what a monad is (as you eventually must), you might discover that a monad is a monoid in the category of endofunctors, or a programmable semicolon, or a burrito, or some similarly unhelpful combination of words. While any of these might be true, the fact is that none of them tells you what a monad is for. (If you’re curious, this post by James Coglan is the best explanation of what monads are for that I’ve ever read.)

My first languages were JavaScript and Ruby: dynamically typed, object-oriented with a strong functional influence, and nothing preventing you from doing whatever silly things with state you so desired. When I first learned Clojure, I thought the tricky part would be balancing parentheses and composing programs with functions rather than objects. In fact, the hardest part for me was keeping concurrency primitives (agent, atom, and ref) straight; I tried memorizing their definitions and reading documentation, but to no avail. Finally, one day, I made myself go through a couple of examples in The Joy of Clojure. Chapter 11 covers mutation, and in particular goes through the “ideal cases” for each state management primitive.

As I worked through the examples, I discovered that atoms were great for managing independent stateful events (which I later used when swapping a default image for a broken <img /> tag), refs were ideal for coordinating multiple events via transactions (think of transferring money from one bank account to another), and agents were best suited to asynchronous and I/O operations (say, firing an ad beacon). The kicker was that all this was clear as day when I went back and read the blog posts and documentation that had seemed impenetrable to me before, but I couldn’t wrap my head around it until I stopped caring about what things were and focused on what they were for. And once I understood that, I also began to understand the tradeoffs between these tools: the benefits and drawbacks of using each.

Learning a second programming language is useful for all sorts of reasons, but I think the main benefit is this: via an understanding of what things are for (rather than simply what they are), you discover why a language’s inventors and users do things the way they do, and in reaching that understanding, you gain a deeper understanding of the tradeoffs involved.

Dead Simple Reagent Components

Fri, 04 Mar 2016 14:00:00 +0000

I’ve been using ClojureScript + Reagent for a couple of years now, and I’ve found the combination (with Figwheel for live reloading) to be absolutely delightful. It’s been in production for the CityShelf web front end since May of 2015, and I’ve been continually impressed at how simple it is to write small, composable components that lead to code that’s easy to reason about and maintain.

A good example is the component CityShelf uses to wrap <img />s. The search API returns whatever cover image the bookstores in a given city provide, and occasionally these images are broken or missing. We felt it was a bad experience to pass a broken image along to CityShelf users, so I decided to make a lightweight wrapper around image tags to include additional behavior: specifically, an onError handler to swap in our preferred default book image.

The canonical JavaScript + jQuery solution to the problem looks something like this:

function handleImageError(img) {
  img.onerror = '';
  img.src = '/path/to/default/image.jpg';
  return true;
}

So you could do the following in your markup:

<img src="image.jpg" onerror="handleImageError(this);" />

This may not immediately seem suboptimal as compared to ClojureScript: JavaScript (and therefore ClojureScript) is single-threaded, and the lack of STM in ClojureScript means that state mutation isn’t really safer (read: transactional) as compared to plain JS. However, I think there are several disadvantages to the JavaScript approach:

Transient, mutable data structures. The HTMLImageElement we’re passing into handleImageError() is modified directly; we have no access to previous versions of the data structure. The ClojureScript implementation (see below) accepts a map of the form {:src (reagent/atom "image.jpg")} and returns a new map with the modified :src; because ClojureScript data structures are persistent, we only need to allocate space commensurate with the changed data (in this case, the new src attribute). POJOs are neither immutable nor persistent.
Trivialized state mutation. We so cavalierly mutate state in JavaScript that nothing about the language causes alarm bells to ring in our heads when we’re potentially doing something bad (i.e. mutating state and passing it around). In this case we’re not necessarily passing anything around, but ClojureScript’s atoms do make us (or at least, me) pause and think about what we’re doing.
Broken encapsulation. There’s an argument to be made here for separation of concerns, but I think separating markup and behavior via templating is actually an antipattern: in this case, we have to remember to set the inline onerror handler for every <img />. Reagent + ClojureScript (or plain React + JSX) has moved us closer to web components, which I ultimately think are the Right Way™ to think about and write web applications.

The ClojureScript + Reagent component (which I think addresses the above concerns nicely) looks like this:

(ns ^{:doc "Image component."
      :author "Eric Weinstein <eric.q.weinstein@gmail.com>"}
  cityshelf.components.image)

(defn image
  "Image component. Takes a map of options and creates an
  <img /> from the supplied :src; if the source is broken
  or missing, swaps in a default book image instead.

  Example:

  [image {:src (reagent/atom \"book-cover.jpg\")}]"
  [options]
  (let [src (:src options)]
    [:img {:className (:className options)
           :src @src
           :onError #(reset! src "/img/defaultbook_green.png")}]))

The production code actually works slightly differently than this—it uses a helper function to keep track of the root URL so we always serve the default book image correctly.

The nice thing about this component is that it can be used all over the application—for instance, we use it both for the search results gallery view and the individual product detail view. Even better, we could use it in a host of other scenarios where a default image is needed, since it would be trivial to parameterize the component with a custom default image. You can also include other default behaviors that you might want for all images, such as lazy loading, but it’s important to remember not to try to do too much in your components. The more they do, the more likely they are to become special snowflakes that never see significant reuse.