One of the most well-known textbooks in all of computer science is "Structure and Interpretation of Computer Programs" by Abelson and Sussman. This is the same book that was long taught to undergraduates at MIT and it's notable for offering deep 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 the first four chapters of SICP with the goal of implementing our own LISP/Scheme interpreter. This involves a mix of problem sets from the book, coding in Scheme, and writing at least two different Scheme interpreters (one in Python and one in Scheme itself). We 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 one of the most well-regarded textbooks in computer science. 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). If you've attempted to read SICP yourself and been stymied by its difficulty, this course will help you navigate the book in a manner that puts it in a more focused context. This course could also serve as a springboard for further study of functional programming languages such as Clojure, Erlang, Scala, or Haskell.
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 extended side projects including the implementation of a Scheme interpreter in Python. 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. Most of the exercises and projects are implemented in Scheme/Racket, but a number of side-projects involve Python programming as well. No prior experience with Lisp or Scheme is required, but some familiarity with Python is strongly advised.
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.
SICP consists of 5 chapters. This course covers the first four.
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. Add 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 material.
This course is being taught to just 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 some 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) 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 those topics that are directly related to the evaluation models, data structures, and objects needed to implement the Scheme interpreter in chapter 4. This makes the course most 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.