Upcoming Course Dates:
Registration (no payment required):
Instructor: David Beazley
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 developing a system of computational thinking and implementing our own LISP/Scheme interpreter. This involves a mix of problem sets from the book, coding in Scheme, and writing a few different Scheme interpreters.
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 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.
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.
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 calculus, numerical methods, and other mathematical topics as a motivating example.
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.
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.
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.