Structure and Interpretation of Computer Programs Video Lectures (1986)

https://ocw.mit.edu/courses/6-001-structure-and-interpretation-of-computer-programs-spring-2005/video_galleries/video-lectures/

by gjvc • 15 days ago

355 48 15 days ago

ocw.mit.edu

tangsoupgallery• 15 days ago

These 1986 lectures are the definitive SICP experience — the Hal and Gerry show at its peak. The presentation quality holds up remarkably well, and seeing the metacircular evaluator built live is something no textbook can fully capture. For those who find the book dense, these lectures provide the pacing and intuition that make the abstractions click.

ramchip• 15 days ago

LLM bot account

neilv• 15 days ago

If you want to work through SICP, you can use MIT Scheme, but another option is to use Racket or DrRacket, with this add-on package: https://docs.racket-lang.org/sicp-manual/

SilentM68• 15 days ago

Awesome!

I was just about to ask just that question?

Thank you, SM

brudgers2• 15 days ago

MIT Scheme is the simplest thing that might work.

functionmouse• 15 days ago

I think we should only be recommending MIT Scheme. Everything else has got too much going on and can become distracting, for the purposes of education.

lkuty• 15 days ago

I don't think it is necessary to avoid Racket since "The language #lang sicp provides you with a version of R5RS (the fifth revision of Scheme) changed slightly in order for programs in SICP to run as is." DrScheme is great for this and probably the easiest way to start.

DonHopkins3• 15 days ago

Everything you can do with Scheme you can also do with Snap! with a visual blocks programming user interface. Functional programming, recursion, higher order functions, closures, continuations, macros, metaprogramming, all described by Brian Harvey's curriculum, the Beauty and Joy of Computing:

https://bjc.berkeley.edu/team/snap/

Snap!Con 2025 - Brian Harvey - ACM Karlstrom Award Address

https://www.youtube.com/watch?v=pDK2PE_pkqQ

Brian calls SICP the actual best computer science course ever invented, which is quite a complement from the guy who wrote the second best computer science course ever invented. ;)

He has a lot of interesting thoughs about AI in education.

vincent-manis• 15 days ago

I second the recommmendation, for these two systems with a caveat. MIT Scheme has not been made to run on Apple Silicon, though with a few tricks, the amd64 version is usable on a modern Mac (this will presumably go away once Apple takes away Rosetta2). Racket might therefore be a better choice.

It is possible to use pretty much any decent Scheme system with SICP, but the language has changed since even the Second Edition, so I don't recommend it. That said, once you are working on your own projects, nothing stops you from using a different system, even though you might have to RTFM to see modern equivalents to ancient idioms.

DonHopkins3• 15 days ago

I used to love using Macintosh Common Lisp, which was a glorious Lisp development environment that originally compiled to native 68K code, and had full access to native APIs like QuickTime. On the PowerPC Mac, I used Connectix SpeedDoubler to dynamically translate MCL's compiled 68K code into PowerPC code. It worked surprisingly well, so we didn't have to hold our breath waiting for MCL's native PowerPC port.

https://en.wikipedia.org/wiki/Macintosh_Common_Lisp

Rosetta wasn't a thing yet, so Connectix (who also made the famous QuickCam) filled that gap years earlier.

https://en.wikipedia.org/wiki/Connectix

Connectix Corporation was a software and hardware company that released innovative products that were either made obsolete as Apple Computer incorporated the ideas into system software, or were sold to other companies once they became popular.

SpeedDoubler and RAMDoubler were great, and actually kinda delivered on their promises. But what I really needed during the reign of System 7 was BootDoubler: software that made every other reboot instantaneous.

dirteater_• 15 days ago

I tried SICP straight from the book once, but I think the lectures are much better and the book acts as a supplemental reference.

barrenko• 15 days ago

Thank you! Will try it like this.

easytiger• 15 days ago

That is indeed how University learning used to work, for about 1000 years

epolanski3• 15 days ago

It's *supposed* to work.

In reality you get lectures from individuals that became professors because they are great at politics/research but not at teaching (very different skill).

If you even get them and not their 25 year old assistants.

And this is apparently super common even in ivy league universities as Youtube lessons have shown me over and over.

aligutierrez• 15 days ago

interesting approach to SICP.

aag2• 15 days ago

I don't understand this comment. They wrote SICP.

bloppe• 15 days ago

Cannot recommend these enough. Watch the first one and you'll be hooked

mbrezu• 15 days ago

These sound a little better than I remember. I wonder if the sound was cleaned up?

songbird232• 15 days ago

Should I do the JS or Scheme SICP

submeta• 15 days ago

I‘d go with Scheme. You‘ll learn the basics in a day. The language spec is only a few pages. And Scheme reads like pseudo-code with parentheses.

brudgers2• 15 days ago

Scheme. Javascript is a fine language, but it is not the right tool for this job.

Nekorosu• 15 days ago

I have both books. Scheme for sure! Env setup can be a bit of an issue but it is doable. Regarding it, I remember having some weird issues with MIT Scheme on a modern computer, but Racket/DrRacket works well.

spauldo• 15 days ago

I'll add another recommendation for Scheme. The concepts in SICP map very well into Scheme, whereas I can only imagine them being awkward and non-idiomatic in JS. There's lots of passing around first class functions and use of recursion.

One of the two professors (Dr. Sussman) that give the lectures in this series is a co-creator of Scheme.

Jtsummers• 15 days ago

I can only imagine them being awkward and non-idiomatic in JS

You don't have to imagine, you can look at the code used in the JS version and it goes through some fun contortions to get around the fact that JS is not expression oriented (like Scheme). This is from page 35 (PDF: https://sicp.sourceacademy.org/sicpjs.pdf):

  function count_change(amount) {
    return cc(amount, 5);
  }
  function cc(amount, kinds_of_coins) {
    return amount === 0
           ? 1
           : amount < 0 || kinds_of_coins === 0
           ? 0
           : cc(amount, kinds_of_coins - 1)
             +
             cc(amount - first_denomination(kinds_of_coins),
                kinds_of_coins);
  }
  function first_denomination(kinds_of_coins) {
    return kinds_of_coins === 1 ? 1
           : kinds_of_coins === 2 ? 5
           : kinds_of_coins === 3 ? 10
           : kinds_of_coins === 4 ? 25
           : kinds_of_coins === 5 ? 50
           : 0;

}

That certainly works, but it's awkward. Here's the Scheme code from the 2nd edition of SICP:

  (define (count-change amount) (cc amount 5))
  (define (cc amount kinds-of-coins)
    (cond ((= amount 0) 1)
          ((or (< amount 0) (= kinds-of-coins 0)) 0)
          (else (+ (cc amount
                       (- kinds-of-coins 1))
                   (cc (- amount
                          (first-denomination
                           kinds-of-coins))
                       kinds-of-coins)))))
  (define (first-denomination kinds-of-coins)
    (cond ((= kinds-of-coins 1) 1)
          ((= kinds-of-coins 2) 5)
          ((= kinds-of-coins 3) 10)
          ((= kinds-of-coins 4) 25)
          ((= kinds-of-coins 5) 50)))

The JS code has to use the ternary ?: to get around the fact that it does not have a good equivalent to `cond`. You can see that they've gone through a literal translation of Scheme to JS that results in very unidiomatic JS code.

nobleach2• 15 days ago

The JS version of the book (I still bought it when it came out) is just weird. It has you writing JS in a non-idiomatic way that you'd never see (nor should you be the person introducing) in the industry. SICP teaches a very LISP-y way of thinking through problems. It's not that you CAN'T apply these tactics in other languages... they're just far more "at home" in Scheme/DrRacket/heck... even Clojure.

ughitsaaron• 15 days ago

Part of the point of SICP is to be generic about its programming principles. The core principles and concepts are independent of any particular programming language (so long as it has first class functions, and probably a few other common features). Since Scheme has virtually no syntax it was an ideal language for Ableson & Sussman’s course. It’s notable that SICP spends hardly any time teaching the language.

I’ve never understood, therefore, the motivation behind trying to “translate” SICP into a language like JS (or Python, etc.) It over emphasizes the importance of the preferred language in a way that very obviously undermines the book.

The point being: if you’re gonna do SICP do it in Scheme. You’ll get more out of it.

sn9• 14 days ago

The thing about Scheme is that learning the syntax takes 10 minutes and then you can just focus on computation.

Aejkatappaja• 15 days ago

I always recommend these lectures, awesome!

boobsbr• 15 days ago

The audio is so bad on these lectures.

Is there any way to clean them up?

j_m_b• 15 days ago

This is how I learned lisp. I then went on to learn Clojure and built a career around it.

davidpapermill• 15 days ago

Fantastic. How did you learn Clojure? I'm a bit of a fan.

xqb64• 15 days ago

What could someone interested in systems programming gain from this?

convolvatron3• 15 days ago

these talks distill out the core questions of topics like mutability and state management and abstraction. almost uniquely so. so I consider them deeply relevant to systems programming in as much that its primarily concerned with..state management and abstraction.

unless you mean 'systems programming' as just 'the crap one does to try to glue together all the grotty pre-existing systems' and 'developing a good sense of taste about 3rd party libraries', in which case no, its not really very relevant.

although even here there is insight, I watched a video of Sussman describing why they were putting down SICP and demanding that MIT develop new introductory courses. he was so graceful and considered, putting his polished jewels away. the time when we could reasonably be expected to see across and through all the layers of abstraction was over.

convolvatron3• 15 days ago

addendum: actually I think the case for SICP in systems programming is stronger than that. There are several places in the material where the gap between 'high level programming' and 'construction of machines using gates' is thoroughly walked through and evaporated. maybe some of of the other similar treatments for logic programming and continuous analysis won't strike as deep, but that part should really be required reading.

sanmarzano• 15 days ago

Every programmer should learn LISP. or at least give an earnest attempt to study it. The vast majority of applied programmers only know how to think like C programmers (procedural). LISP is a “beautiful” language in that it is about concepts, not hardware. Totally changed my brain when I worked on a graduate project for a few years at my Alma mater in 1990.

ozten• 15 days ago

I worked through these videos and the full book. Via news groups I organized an in-person study group. What a blast and a big unlock for me. The study group started having attrition about halfway through the book.

xenadu02• 14 days ago

You don't have to do the exercises or follow along with the book. No matter if you are new to the field or have decades of experience: almost everyone would benefit from watching these videos if they haven't already (or done an SICP course).

midtake• 14 days ago

Structure and Interpretation of Computer Programs Video Lectures (1986)

Related Stories