SICP taught by Abelson and Sussman [video] | Hacker News Reader

SICP taught by Abelson and Sussman [video]

ocw.mit.edu

197 pointshardwaresofton74 comments

I only watched the first 12 minutes or so (thus far!), but ... just wow! I originally took a course at the U of Mn where SICP was taught as intro to programming and intro to OO programming (yep, OO programming with Scheme, I have a very lucid memory of some dude standing up and complaining about learning OO programming using Scheme vs. C++ (circa 1992 mind you) because "who will ever use Scheme in their programming career" and the professor (Dr. Maria Gini) had to ask the student to "keep an open mind" and all I could think was "hey, why not?").

This class was the most mind expanding class I've ever taken. I have read SICP three times since the early 90's and use it as a reference to this day (who else was re-reading the SICP streams chapter when Java 8 was recently announced? /raise).

Anyway, I'm way off track here, but whatever. Having watched only the first 12 minutes of this video ... if Dr. Gini had this influence on me and now seeing this ... it's a huge step up! Listening/seeing Hal Abelson talk about programming and referencing the Egyptians ... I was just shaking my head, he's right to cross off computer science, it's not about that, it's bigger.

I can't wait to watch the rest. And I'm going to make my team watch this. As much as I loved SICP as taught by Dr. Gini, this is way beyond her abilities as much as it pains me to say that.

Yes! I also was exposed to SICP by Maria Gini! Great class, great professor.

Thought others might also enjoy watching the series instead of reading it -- I personally greatly enjoyed the lectures, and they serve very well as an overview before a deep dive into the book (at the very least).

Always amazes me how slowly computer science moves, despite how fast technology is moving

well why things that were relevant 20+ years ago would not be today?

SICP is still the best introduction to computer science. The problem is the reliance on scheme/lisp languages to explain stuffs. it could be taught in almost anything that supports basic FP,it's even taught in JS !

http://www.comp.nus.edu.sg/~cs1101s/sicp/

Why would reliance on Lisp be an issue? It's a basic requirement. Lisp can be learned in 2 hours. If you can't spend 2 hours learning some basic rules, you have no business dabbling in computing.

Lisp resistence is a phobia, a problem of the afflicted person, not the wider computing community as a whole.

> Why would reliance on Lisp be an issue? It's a basic requirement. Lisp can be learned in 2 hours. If you can't spend 2 hours learning some basic rules, you have no business dabbling in computing.

Yeah right, first you dont know me you are assuming I dont know LISP while i have GCL opened on my computer right now. Second, your kind is the problem, computer science has nothing to do with being able to learn LISP in 2 hours or not.that's good if you did. You must be the smartest computer science guy in the world.

I dont know you, but your message makes me say you are arrogant and bigheaded and i'm not interested in people like you. I'm interested in making knowledge accessible, even for those who "cant learn lisp is 2 hours therefor they have no business dabbling in computing".

You may be smart but i pity your coworkers that need to endure your arrogance.

For such a relatively innocuous and general comment, you're taking this very personally.

Well at least i'm sure this mahmud guy has better things to do than trolling me on HN now.

I did not come here for a fight just to suggest an alternative version of SICP.

I just dont like trolls and I responded appropriately.

You read way too much into my comment. I wasn't trolling.

My position is that if you're involved in computing in any capacity, you will have to learn countless formalisms and languages. And S-expressions are on the more accessible end of the spectrum.

If you and I learned it, so can others. Exclusively seeking out C-like syntaxes will only hinder you, professionally.

P.S. SICP introduces all the Lisp you will need as it goes. Really.

> You read way too much into my comment. I wasn't trolling.

yes you are trolling,now go back to wherever you come from,because you're not contributing to any constructive discussion.

Please do not address another user this way on Hacker News.

I'm going to support mahmud here, and suggest that your behavior is the least constructive in this particular sub-thread. He's absolutely right that Lisp is simple and the basic rules can be picked up in an hour or two. He's also right that over the course of a career in computing, you'll have to pick up countless formalisms and languages. Additionally, SICP is not for the faint of heart. It is not an easy text, and the use of Lisp is fairly central to its main point. This is not to say that computing shouldn't be accessible. It definitely should be. That being said, SICP covers intrinsically "difficult" material. There's no substitute for an iota of determination here. If you don't have the determination (not intelligence) to be bothered to learn Lisp, you're not going to be able to complete SICP. It's not going to happen.

As someone lacking a solid scientific background, reliance on math was much more of an issue. I managed to get through Chapter 1 very slowly because I had to learn math concepts to understand what the code was about (Khan Academy helped a lot). Some sections took me up to 3 days to complete ! The beginning of Chapter 2 which is about data manipulation was actually much easier for me. Then I got to the section on the picture language which I found boring and I was also having less time to devote to my study, so I've given up at that point. But I'm really glad I made it so far. What I've learned so far is very precious and one day I'll carry on with the rest of the book !

Compared to the math, Lisp was a non-issue. I didn't even notice I was learning it. But I'm a "practical" coder lacking formal training, not a science student learning to code.

Skip the picture language section. Better to go through the book skipping a few parts then to stop because you can't do every single exercise the first time through! I just started chapter 4, and judicious skipping has thus far been the right choice. If the options are "skip a little and gain the value of the rest" or "try do it all, but get stuck and quit" choose pragmatism!

Also, a trick I like to do with the exercises is struggle with one for 20 minutes or so, and if I am not making progress, look up the answer. Usually that helps me understand what I was missing enough to then do it myself. That happens maybe 1/5th of the time, and usually because the question was vague or oddly worded, or most commonly, I didn't know how to test that it was correct.

And yet Sussman and Abelson themselves were behind the switch from Scheme to Python at MIT. I don't hold them out as infallible, even about their own course, but it should give us pause, yes?

They have a lot of data, we have ... opinions. And the data was saying that students were having trouble learning to do practical engineering problems after this course. So, 2 hours or not (and I say not), the reality is that really bright students had trouble with it, and their professors and designer of the course, co-inventor of the language, and author of SICP thought Python a better choice than Scheme for this course.

Empiricism trumps all.

I don't know about you, but Lisp's uniform syntax makes it really to just dive in and explore the concepts of computation. The only problem I see is that the number of implementations in the Lisp family can be daunting to some people, especially those used to languages with a canonical implementation.

Scheme syntax and main semantics are taught by the first couple of lectures IIRC. The main issue for me with the book and to some extent these videos is the assumption of the student being fairly comfortable with certain (fairly basic) mathematical ideas and techniques. This motivated me to pick these up as I went, but meant that the workload was fairly hefty. I still have not made it all the way through!

Tools and environment were another matter, getting MIT Scheme installed and running was a bit of a pain. Next time I'll probably try with Racket and Neil van Dyke's SICP support package :

http://www.neilvandyke.org/racket-sicp/

From the looks of it support for the 'Picture Language' is supported, looks like fun. :-)

There's something reassuring about these vids, possibly the timelessness of what they attempt to convey. The enthusiasm, Sussman's especially for me, shines through well. They were filmed at HP in the 1980s, there's some great examples of 80s fashion going on there at points :-)

> Tools and environment were another matter, getting MIT Scheme installed and running was a bit of a pain. Next time I'll probably try with Racket and Neil van Dyke's SICP support package

I followed along with the video lecture in Racket using van Dyke's SICP package, and it went just fine. For all practical purposes I don't know scheme.

It was nice trying to run the sqrt procedure that I had built up, be told that the 'average' procedure was not defined, quickly define it and successfully run sqrt. Such a simple thing, but ... it just worked.

Interesting seeing fractional results displayed as actual fractions.

I think it's very helpful, having programmed for >25 years, that I knew where the lecture was heading. Nevertheless, it was a wow experience. I wish I'd been exposed to this in my early years.

The picture language is supported, BUT includes different primitive images.

SICP uses 'wave' and 'rogers'. The package for racket includes only 'einstein'. FYI.

I think it's the simplicity.

Towards the end, when they start building the machine simulator lisp, you get a very natural transition to machine-level thinking -- they build up to it with simple constructs, just like everything else in lisp, and I think that's beautiful. You can clearly see how you could wire up some buffers and wire up an ALU, and wire up some circuits and end up with a completely generic calculating computer.

The bottom-up approach a lot of classes take is somewhat more burdensome to pull together and hold in your head

> SICP is still the best introduction to computer science. The problem is the reliance on scheme/lisp languages to explain stuffs. it could be taught in almost anything that supports basic FP,it's even taught in JS !

The fact that Scheme uses Lisp is what makes SICP work at all. The course would be difficult or impossible to complete using most other languages. The keyword is: homoiconicity, the "code=data" property of Lisp.

Most of the course focuses on writing interpreters and compilers for Lisp and making variations on it (lazy evaluation, non-deterministic). This would be very painful if a non-homoiconic language is used.

And indeed, the "JavaScript version" you posted is very painful to read. It's difficult to understand how the data structures used by the interpreter are related to JavaScript code. And the code most definitely is not idiomatic JavaScript. I would not consider this an improvement over the original Scheme version.

> And the code most definitely is not idiomatic JavaScript. I would not consider this an improvement over the original Scheme version.

in javascript functions are data.While javascript doesnt allow lazy evaluation,it's good enough to teach most of SICP concepts.

For someone that knows basic javascript,it's good enough.

I dont agree with you saying it is not idiomatic javascript. There is nothing such as idiomatic javascript ,that's why people keep arguing on how to write javascript,javascript doesnt care. If javascript did care,it would be a different language.

Anyway my point is ,what matters are the concepts , not the language. Most SICP concepts can be taught in many different languages.It's not about LISP, or javascript. It could be Haskell,CAML,or even Python it doesnt matter.

> The course would be difficult or impossible to complete using most other languages. The keyword is: homoiconicity, the "code=data" property of Lisp.

But if that is the case, wouldn't SICP be less language agnostic since (most of) the concepts taught cannot be universally applied to non-homoiconic languages?

The problems can be solved in other languages, the tools are just clunkier. Lisp lets you solve the hard problems simply, and the solutions (not their expression) are what matters.

As I posted below, Abelson and Sussman have revamped the course to Use Python, and other notable schools have done the same, such as Berkley.

While possible to do in other languages, I think of it this way, "why NOT have it in a language new to people?"

I'd rather it in something new to me (scheme) than be shoehorned into a language I know already. That way I can gain additional benefit of seeing similar concepts in a new form.

Trying to protect someone from having to learn a new language just doesn't make sense, like protecting people from regular exercise. Everyone should have the benefit of knowing multiple tools, and a language should be no exception.

One of the main reasons SICP is still relevant today is _because_ it uses a timeless language like lisp(scheme).

If it was written using the flavour of the month language then, it would have disappeared into obscurity by now.

What is notable about this video series that these lectures were given to an audience of professional programmers (staff of Hewlett-Packard), not first year students taking their first baby steps in programming.

It's nice that the video moves at a comfortable pace and doesn't get stuck explaining some details which most of the audience finds dead obvious.

My understanding is that their lectures to MIT freshmen were substantially similar in pace and content, but just spaced out over a longer period of time.

Schools like MIT tend to assume that students are sufficiently mathematically sophisticated and technically competent, and willing to work hard to keep up.

http://www.youtube.com/watch?feature=player_detailpage&v=0m6... A great little moment from this class.

Thanks for the link. Last time someone posted about those courses i started watching them, but i didn't went up to there.

My problem now is that this really made me want to start coding my own Lisp.

Thankfully chapter 4 demonstrates how to do just that! Want to make it lazy like Haskell? Syntax different from Scheme? You are limited only by your imagination. Round that off with the last chapter from Let Over Lambda and you can add in "or make it like Forth"!

One thing i wonder though: i first wanted to code that lisp in haskell (learning two languages in one), but i'm not quite sure it's such a good idea, now that i've learned about homoiconicity.

Any advice ?

You are one courageous individual. But you are not the only one. https://en.wikibooks.org/wiki/Write_Yourself_a_Scheme_in_48_... has got you covered.

absolutely fantastic ! Thanks

No, no, don't spoil the best part!

There seems to be some psychological barrier that prevents people from learning Lisp (or Scheme for that matter).

i think that the problem is that of nesting parenthesis; Multiple nestings of parenthesis assume that the information hidden in the inner levels of parenthesis nesting is somehow different/or hidden from the outer levels.

I think that a complicated system must combine multiple level of 'truths'; a fact that is definitely true on a lower level might end up as being of less significance on a higher level (or vice versa - the process of debugging turns designs on to its heads; some philosophers (see Hegel) call that 'dialectics').

Now people who are used to censorship have no problem with that ! A person who is supposed to hide his stuff - he is a person who must be afraid of external censorship; this person is used to social hierarchy; he knows that the lower level (his personal self) knows things that are different from what is regarded as public truth.

Now assume that society opened up (somehow) since the fifties; people who grow up during later timers are less accustomed to multiple levels of truths; therefore this hierarchy of parenthesis will be regarded as oppressive/disconcerting to subsequent generations.

So North Koreans make the best Lisp programmers? Colour me doubtful.

North Koreans might be good Lisp programmers; however they might have other, more pressing problems - like staying alive under this monstrous regime.

There are other societies that had censorship, maybe to a lesser extent than North Korea; I guess that once upon a time people in the US did rely on the Tube for information (that was before the net) the tube is a centralized source of information, its editors were subject to some control; so I guess that censorship was quite real during that period.

You might listen to the following song for some more context: "White Houses" Eric Burdon & The Animals https://www.youtube.com/watch?v=mefFJFZydG4

I watched several MOOCs and OCW courses but this one was the first and the best I've ever came across. Most of the MOOC videos are still boring and I need to speed them up to 1.25x but SICP was so great, I could spend hours talking to my peers about every episode! My notes of it are here: http://devblog.me/sicp.html

For me Dan Grossman's course on Programming Languages takes the cake. Best course I've ever done. Taught SML, Racket and Ruby enough to touch on so many concepts (FP, recursion, algebraic datatypes, polymorphism,... the list goes on). For the assignments a small programming langauge was implemented in almost all of these, showing different ways of solving the expression problem. It was amazing.

Happen to have a link?

Here you go: https://www.coursera.org/course/proglang

"No sessions available."

I guess I expected a video archive, not unlike the SICP playlist as it exists on YouTube in various forms.

You can find the videos of the Programming Languages class together with the slides and handouts here:

http://courses.cs.washington.edu/courses/cse341/13sp/

You can email him and ask him to make them available. I've done that for other coursera courses that didn't publish the videos after the course finished.

Agreed, Dan Grossman's PL is in my top 3 of the best MOOCs with Yaser Abu-Mostafa's Machine Learning and Dan Boneh's crypto 1. (Though there are some pretty damn good runner-ups as well)

Completely agree. I've done Scala, Algorithms, and one other and Dan's course stands out for its interest, enthusiasm and clarity.

Plus it uses functional programming! What's not to like.

Haha exactly the same 3 courses I did last year. Doing any currently?

Nah, having a "summer break +" that's extended a bit longer ;). I plan to do a crypto course at some stage.

  + Southern hemisphere

> Most of the MOOC videos are still boring and I need to speed them up to 1.25x but SICP was so great

The audience in this video is professional programmers, so it isn't such a slow pace as most of the lectures in online courses, which were given to an undergrad audience.

I really enjoyed Programming Paradigms from Stanford (https://www.youtube.com/watch?v=Ps8jOj7diA0).

Totally agree. Gerald Sussman's enthusiasm not only for the language, but for teaching in general, goes a long way to making these so enjoyable as well.

Other MIT Open Courseware:

Recently my memories of the first time I saw linear programming were triggered- those few pages in an algebra book were the last time for many many years that I felt "wow this is so cool" about math and I think part of my loss of interest during high school and pretty much entirely by college was that the subject was never revisited and instead there was a lot of looking stuff up in tables and not much with systems.

Anyway, I've been watching Gilbert Strang teach Linear Algebra on OCW. It makes me wish Abelson and Sussman could remake the SICP videos with another 25 years of in the classroom experience - Strang's presentation is masterful. And linear algebra after all these years is still awesome

http://ocw.mit.edu/courses/mathematics/18-06-linear-algebra-...

I've been doing the same.

It really strikes me how amazing the MIT professors are. In contrast, most of the Coursera courses have me tearing my hair out. Pet theories on how to structure a course, mumbling, stuttering, essentially reading power point slides - I am so glad school is a few decades behind me.

But in contrast, Strang, Sussman, et. al make the topic come alive. Despite having taught the same course over and over they can put themselves into the mindset of the student. Beyond that, they find the beauty in the topic, and are able to communicate it to inexperienced freshmen.

Coursera tends to be less consistent, but I've had some really good classes...and one so bad that I was 'that guy' who stated everything they thought was wrong with the class.

Anyway, the big difference I see is that MIT OCW films instructors in their natural habitat and all the Coursera videos are shot up close and personal and this makes some professors unusually self conscious. Others are willing to not worry about production values and let their warts and quirks come across - they will be informative but not particularly entertaining...e.g. Ullman or Sedgewick both of whose courses are really good if a student is interested in the topic.

I mostly agree, but I want to give props to Dan Grossman's Programming Languages course on Coursera. It's the only Coursera course I was actually able to see through (out of 6 or so over the last couple years), and I learned quite a bit.

I took the second edition of Grossman's course and it was very good. Kickzales's Introduction to Program Design was also good as was Pascal Van Hentenryck's Discrete Optimization - his enthusiasm is infectious.

Odersky himself is teaching Functional Programming in Scala later this month, and I'm looking forward to that.

This is the set of lectures that made me fall back in love with computer science. The enthusiasm and "clever troll" attitude of Sussman is infectious.

This is our Principia.

I want to start working through SICP again beginning these Easter holidays. I tried it before using Vim and and ran the REPL in a different terminal. This really sucked and I gave it up as a bad job. I decided that Emacs is probably a better "development environment" to try and go through SICP so I did this:

Got Emacs "pimped" [1] enough to behave like Vim but Emacs enough to use Geiser and connect to Racket with Neil Van Dyke's SICP package. (Emacs prelude, Eviled, Solarized and installed packages: geiser, quack, sicp (M-x info-display-manual sicp)).

Gonna see how it goes this time round.

[1] https://github.com/humana/dotfiles/blob/master/emacs/persona...

You can always use Dr Racket. I'm a vim user but find DrRacket fine for doing iterative "practice" with a REPL.

DrRacket is not as easy to customize as Emacs is and it, by default, offers a different mode of exploratory programming than the one SLIME users expect. In DrRacket you don't evaluate a single form, you just execute a module and then are dropped into it's namespace. If you change a definition in your module you need to re-read all of it or alternatively copy-paste it into the REPL, which is not convenient. I found that the SLIME/Geiser/Emacs model is better for really tiny stuff, while DrRacket's is better for longer scripts, where there are many dependencies.

Anyway, while both ways are ok, they are not exactly equivalent - is what I wanted to say.

I'm not sure if this matches your exact needs, but there is a way to achieve this functionality in DrRacket:

http://docs.racket-lang.org/drracket/Keyboard_Shortcuts.html...

Emacs + Geiser is _the_ perfect setup for Scheme hacking. Geiser supports both Guile and Racket. It's simply an unparalleled development environment, imo.

Add ParEdit if you don't have it yet.

(Quick overview of most it's features here: https://www.youtube.com/watch?v=D6h5dFyyUX0)

For anyone interested, Paul Snyder and I are currently running a SICP study group. We have an online meeting and in person meetings in Philadelphia and King of Prussia. We are currently doing one minor section every month, which averages out to roughly one homework question every 3 days. For anyone interested we will help you get setup and started, no prior programming needed.

We are running section 1.3 this month, so there is not much to catch up! Also, anyone who wants to work it their own pace is welcome too!

http://www.meetup.com/Clojadelphia/events/172933722/

Paul hasn't put up the info for the 1.3 online session yet, join the Clojadelphia group to get updates when he does

I had to re-read the 'King of Prussia' several times (O_o) before Googling it up :)

Yeah, silly name, we also have a Bala Cynwyd, Conshohocken, and Bryn Mawr all right next to each other.

I am doing the chapter on register machines now. I love the diagrams that show the controller and the data path of the machine. See http://sarabander.github.io/sicp/html/5_002e1.xhtml#g_t5_002...

Scratch and Quartz composer show code in a graphical way. Are there examples of languages that show the data path in a similarly graphical way?

I would love to see how variables relate to each other and other functions (the data path) separated from the order in which these operations actually happen (the controller). It would be an interesting way to debug. For example, variables that get assignment but are never read would be glaringly obvious.

While it's very purpose specific, you might check out Unreal Engine 4's visual scripting in Blueprint.

https://docs.unrealengine.com/latest/INT/Engine/Blueprints/U...

For a quick primer: white connections represent the flow of execution, and have a variety of flow control nodes (Switch, Gate, DoOnce, etc) to direct execution around the graph. The other color coded lines represent the usual int/float/bool/string types, as well as some specialized things like rotators/translators/objects.

The debugging is fantastic, and sounds like something you might be interested in. You can set breakpoints on nodes and step through execution. Hovering the mouse over any variable will tell you what it's currently set to, or you can mark a value to be displayed next to its node in the graph. Take a look here for more: https://docs.unrealengine.com/latest/INT/Engine/Blueprints/U...

You'd need a $20/month subscription to get UE, but you can cancel it immediately if you don't mind not getting updates.

Watched the lectures a couple years ago while reading the book.. I highly recommend it to everyone looking to Be A Better Programmer. Ironically, people who would benefit the most from reading the book seem not interested by it.

Not sure if this could be useful to someone here, but just in case – I've created a Russian version of the first 1/5th of this course: https://hexlet.org/course/sicp/

This is the best course I've ever seen

Eyebrows for emphasis! :D

Reply on news.ycombinator.com