Before the Coding Train was a YouTube institution, Shiffman distilled NYU ITP’s Introduction to Computational Media into Learning Processing (2nd ed., 2015). It is the on-ramp book: how to program if what you actually want is interactive visuals, not a job interview about red-black trees. Processing (the Java-based creative coding environment) is the vehicle. The real subject is computational media literacy: pixels, interaction, data, and enough object-oriented structure to build projects that do not collapse under their own sketch.pde files.
There is no standalone “Daniel Shiffman ML book.” The neural-network and neuroevolution material lives in the 2024 Nature of Code. This volume is the earlier rung: get fluent enough in creative coding that Nature of Code’s simulations are readable. I am reviewing it here because that ladder is how a lot of people actually arrive at AI-adjacent work from art and design, and because the pedagogy still holds even if many readers today would do the same path in p5.js instead of Processing.
Chapter by chapter
Introduction
Shiffman frames programming as liberation from existing software tools, aimed at designers and artists who have been told code is “not for them.” The introduction sets the lab-manual tone: examples first, jargon second, projects that look like media rather than homework printouts.
Chapter 1: Pixels
Coordinate systems, color, drawing primitives. The screen as a writable grid. You learn that digital images are data before you learn control flow, which is the correct order for visual learners.
Chapter 2: Processing
The Processing IDE, reference, run cycle, first sketches. Environment comfort matters as much as syntax when the audience is new to programming tools entirely.
Chapter 3: Interaction
setup() and draw() loops, mouse and keyboard input. Programs as ongoing processes, not one-shot scripts. This is the fork in the road from “print hello” tutorials toward interactive systems.
Chapter 4: Variables
State that persists across frames. Types, assignment, the difference between a magic number and a named value you can animate. Small chapter, load-bearing.
Chapter 5: Conditionals
Branching, boolean logic, decisions in interactive sketches. UI-like behavior starts here: hover states, thresholds, simple rules.
Chapter 6: Loops
for and while, patterns across the canvas, repetition without copy-paste. The visual payoff (grids, repeated motifs) keeps loop semantics from feeling abstract.
Chapter 7: Functions
Encapsulation, parameters, return values, organizing sketch code so it can grow. The chapter is really about attention management in a codebase.
Chapter 8: Objects
Classes, instances, object-oriented structure for multiple on-screen entities. Without this, particle systems and agents (later, in Nature of Code) are painful.
Chapter 9: Arrays
Collections of data and collections of objects. Lists of balls, lists of colors, the move from “one thing” to “many things.” Prerequisite for almost every interesting sketch.
Chapter 10: Algorithms
Putting prior tools together into procedures that solve small visual/computational problems. Less “algorithms textbook,” more “how to think in steps when the output is graphic.”
Chapter 11: Debugging
Error reading, strategies for finding what broke, normalizing the emotional experience of broken code. Underrated chapter. Most beginner books skip the feelings and the practical triage.
Chapter 12: Libraries
Extending Processing with libraries. How to depend on other people’s code without treating it as magic. Same lesson Nature of Code later revisits with physics engines.
Chapter 13: Mathematics
Trig, curves, useful formulas in a visual context. Math introduced because a drawing needs it, not because a syllabus checkbox does.
Chapter 14: Translation and Rotation (in 3D!)
Transforms, push/pop matrix mental model, first steps into 3D space. Confusing for everyone the first time; Shiffman keeps it spatial and example-led.
Chapter 15: Images
Loading, displaying, manipulating raster images, pixel iteration. Digital images as arrays you can read and write. Quiet foundation for later computer-vision tinkering.
Chapter 16: Video
Live capture and playback, frames as image sequences. Performance and timing issues appear in a way textbooks about “variables” never force you to feel.
Chapter 17: Text
Typography in sketches, strings as data, text as a graphic element. Small bridge toward interfaces and data labels.
Chapter 18: Data Input
Loading external data into sketches. CSV-ish thinking, files as inputs, visualization beginnings. The chapter where Processing meets the rest of the world’s data.
Chapter 19: Data Streams
Continuous or networked inputs, sketches that react to changing outside state. Mentally adjacent to “sensors and feeds,” even when the examples are modest.
Chapter 20: Sound
Audio in interactive work: playback, synthesis hooks, syncing sound with visuals. Multimodal projects stop being theoretical.
Chapter 21: Exporting
Getting work out of the IDE: images, videos, sharing artifacts. Completes the loop from learning exercise to portfolio object.
Chapter 22: Advanced Object-Oriented Programming
Inheritance, more serious structure, patterns for larger sketches. Optional-feeling until your project needs it, then mandatory.
Chapter 23: Java
Processing’s relationship to Java, what lies under the friendly API, when you need to drop down. Honesty about the stack instead of pretending the IDE is the whole language.
Where I’d push back
The book is tied to Processing/Java in an era when many of the same students start in p5.js or Python. The concepts transfer; the copy-paste bits do not. It also stops before machine learning, which is fine for its mission and disappointing only if you expected the neural-net material (get The Nature of Code for that). Some chapters on data and networking show their mid-2010s age in tooling details.
Read it as the friendly first book, then The Nature of Code as the algorithms-and-simulation sequel that ends in neural nets and neuroevolution. Together they are still one of the clearest non-CS-department paths into computational work that eventually touches AI.
For designers, artists, and anyone who learns by making things move on screen, this remains a generous place to start.