One of the most well-respected 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 interesting insights to programmers at all levels. For undergraduates, the book introduces important concepts about computational thinking, algorithms, data structures, and complexity. At a more advanced level, the book explores the nature of computation, 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 implementing our own LISP/Scheme interpreter and seeing how it maps to a machine. This involves a mix of problem sets from the book, coding in Scheme, and writing a few different Scheme interpreters. We'll also take a side-trip into the land of lambda calculus and explore the foundations of functional programming. Why would you take this class? Because it's fun of course. Plus, you'll learn a lot of neat stuff and understand the programming languages you use now with a new 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."
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 nothing that some attendees of past SICP courses have previously worked 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 help you navigate the book in a manner that puts it in a more focused context.
This course is fairly faithful to the overall structure and organization of the SICP book. 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 and lambda calculus. The last two days of the course are mainly concentrated on implementing a Scheme interpreter in Scheme itself. Throughout the course, there is a significant amount of group discussion.
This course is best suited for experienced programmers. No prior experience with Lisp or Scheme is required, but some familiarity with Python is strongly advised. 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 polynomials, root-finding, and symbolic differentiation as a motivating example.
SICP consists of 5 chapters. The course aims to cover parts of all of them.
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 being taught to six 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.
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 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.