Structure and Interpretation of Computer Programs

Upcoming Course Dates:

June 2-6, 2025 (live-taught online).

Course Hours:

This is an immersion course.
9:30am-5:30pm US Central Time/Chicago

Cost:

$1500

Registration (no payment required now):

Instructor: David Beazley

Other Courses | FAQ

Overview

One of the most known textbooks in computer science is "Structure and Interpretation of Computer Programs" by Abelson and Sussman. This is the book that was long taught to undergraduates at MIT and it's notable for offering insights to programmers at all levels. At a basic level, the book introduces concepts about computational thinking, design, algorithms, data structures, and complexity. At a more advanced level, the book explores the nature of computation itself, programming, and abstraction as it builds the foundation for creating your own programming language.

In this intense week, we cover SICP with the goal of developing a system of computational thinking and ultimately using it to implement a LISP/Scheme interpreter.

Why would you take this class? Because it's challenging and fun of course! Plus, you'll walk away understanding programming with a new level of awareness.

"David Beazley's courses are always mind-expanding, mind-bending, and mind-exploding. The SICP course is no exception. If you want to learn the foundations of functional programming while having a fun week of intellectual exercise, look no further than this excellent course."

Target Audience

This class is for experienced programmers who feel up to the challenge of going through a rather challenging computer science textbook. For self-taught programmers, this course provides exposure to wide range of deep ideas from the core of computer science. This includes algorithmic thinking, computational complexity, and different programming models (e.g., functional vs object-oriented programming). This course could also serve as a springboard for further study of functional programming languages such as Clojure, Erlang, Scala, or Haskell.

It's worth noting that many attendees of past SICP courses have previously attempted to work through parts of the book on their own. Although it is possible to self-study SICP, doing so is known to be difficult and to require a substantial time investment. Frankly, it's a much better experience if you can do it with a group of other enthusiastic programmers. One goal of this course is to put a narrative structure to the text that will help you navigate the book in a more focused manner.

Instruction Format

This course is fairly faithful to the overall structure and organization of the SICP book. This includes the use of the Scheme programming language. Each course day consists of a mix of prepared presentation, live coded demonstrations, discussion, reading, and time to work through selected book exercises. At various points, the course explores some side projects including the implementation of a small Scheme interpreter in Python. The last day of the course is mainly concentrated on implementing a Scheme interpreter in Scheme itself. Throughout the course, there is a significant amount of group discussion.

Prerequisites

This course is best suited for experienced programmers. No prior experience with Lisp or Scheme is required, but familiarity with programming concepts in another language is assumed. You should also be comfortable working with recursive functions and simple data structures such as linked lists.

Note: some of the examples in SICP involve symbolic algebra and calculus. Although the focus of this course is not on mathematics, be aware that certain exercises might involve calculus, numerical methods, and other mathematical topics as a motivating example (even though the discussion might apply equally well to something more familiar such as writing a decorator).

Syllabus

SICP consists of 5 chapters. This course aims to cover the first four chapters up to, and including, the metacircular evaluator. This is typically the same material that gets covered in a single-semester college course.

Chapter 1: Procedural Abstraction. This chapter provides the foundations for functional programming. Scheme programming is introduced and we discuss evaluation models, computational processes, and higher order procedures.

Chapter 2: Data Abstraction. This chapter introduces the problem of data structures and data abstraction. Some major themes include encapsulation, generic functions, types, and objcts.

Chapter 3: Modularity, Objects and State. The general problem of decomposing complex problems into smaller, more manageable components is discussed. One solution is to introduce the concept of objects and mutable state. Another solution is to introduce the concept of delayed evaluation and streams. We talk about both of those approaches and the ramifications of introducing mutability.

Chapter 4: Metalinguistic Abstraction. This chapter teaches you how to build your own domain specific language. We primarily focus on the implementation of the metacircular evaluator--a Scheme interpreter implemented in Scheme itself. Time permitting, we'll then attempt to modify the interpreter to support lazy evaluation.

SICP in 5 days, are you crazy?

By the authors' own admission, there is simply too much material in SICP to cover all of it in a single course. When I taught SICP at the University, the goal was to cover the first three chapters and part of chapter four over a 10 week quarter in a class meeting 3 days a week, 50 minutes each session. That's about 25 hours of class time. Throw in a midterm, quizzes, waiting for people to show up, and everything else that goes along with a class and maybe it works out to about 20-22 hours of classroom material.

This course is taught to more experienced software developers over five days (40 hours). Everyone will be so worked up that they'll go home each night thinking about it and working on it even more. On the whole, it's possible to cover most of the big ideas, code a wide variety of exercises, and do some neat projects.

One notable difference between this course and a university course might be a narrowing of the overall focus. SICP has a number of sections involving "puzzle problems" that stretch your computational thinking (e.g., solving the 8-queens problem, making change, etc.) and extended examples that expose students to various topics in engineering and computer science (e.g., digital circuit simulation). These are great if you want to further explode the head of an undergraduate after hours, but not so practical in a week-long setting. We primarily focus on the topics that are directly related to evaluation models, data structures, and objects needed to implement the Scheme interpreter in chapter 4. This makes the course more closely aligned with topics that might be covered in a "programming languages" class.

About the Instructor

This class is led by David Beazley. Although most known for his work in the Python community, Dave was formerly a tenure-track assistant professor in the Department of Computer Science at the University of Chicago where he once taught a SICP course along with a variety of other topics in systems and programming languages. You might also know Dave from this somewhat infamous bit of live coding. More recently, he gave a tutorial on lambda calculus at PyCon 2019. In 2023, he co-taught Programming Languages at Brown University with Shriram Krishnamurthi.