SICP - Storage Allocation and Garbage Collection

Last lecture in the series, talk about garbage collection. Apparently LISP uses a mark and sweep algorithm. Or maybe a related algorithm developed by Minsky in the sixties. Toward the end of the lecture Sussman talks about the halting theorem, basically proving that there is not procedure that can generally check whether or not a given procedure is safe to run. Interesting stuff.

SICP - Register Machines

In this lecture Sussman covers register machines, and we walk through the operation of a couple of very simple programs. We look at an embedded register machine language.

SICP - Compilation

Shorter lecture on the way a compiler for LISP might function.

SICP - Explicit-control Evaluator

This lecture looks at implementing the LISP meta-circular evaluator as a register machine.  Very interesting to see the process actually play itself out and how this looks to the hardware.

SICP - Logic Programming Part 2

In this lecture we took a high level view at implementation, though we didn't actually write the pattern matching or any other LISP code, which I'll admit was dissappointing.  I guess if I want to try this out I'll have to read the appropriate section in the book.

SICP - Logic Programming Part 1

In this lecture we start looking at a Logical Programming language that differs quite a lot from the way we have been programming thus far. This lecture is about looking at the language and seeing how it is used, the next lecture will actually implement the language.

SICP - Metacircular Evaluator Part 2

Just like the last lecture, this one was a head scratcher for me. I'm going to have to break down and read the appropriate chapters in the book for this to make any sense. My notes are mostly just copying the overheads, most of the theoretical stuff was pretty lost on me. I'm going to keep muscling through for now in the hopes that just being exposed to it will allow me to put the peices together later on down the road.

SICP - Metacircular Evaluator Part 1

I had a real hard time following this lecture, I'm not even gonna lie.  Here are my notes:

SICP - Streams Part 2

I don't know if it was the material or just lack of sleep but this lecture whipped my ass. Though I must admit seeing the "infinite streams" in action made me very curious, it might be time to drop the lisp from the last two lectures into the Scheme interpreter and play around a bit. [hour of frustration later] ... ok the fact that apparently the MIT/GNU Scheme interpreter doesn't work the way Edwin working in 1986 is causing me a huge amount of headache, so I'll revisit it another day...

SICP - Streams Part 1

This was an interesting lecture.  More and more I find myself at a loss to come up with a good post-lecture summary for the top of these blogs, probably because like any programmer I hate needless repetition and everything about the video that matters is alread in my notes. So here ya go:

SICP - Computational Objects

This lecture used digital circuits as the primary example, and went over a lot of LISP code. As part of building the primitives for an embedded language in LISP for describing these circuits, we did some interesting things with assignments and creating lists for agendas and queues.  Indirectly touches on the subject of pointers and reference variables. I took a few screen shots this time to capture some of the diagrams.

SICP - Assignment, State, and Side Effects

This lecture is done by Jay Sussman and he really seems to dislike assignment. It muddles up all this very pretty functional code.  It's a bit of an anachronism that he talks about Fortran, BASIC and Pascal, though the setting is half the charm here. Mullet about made my head explode again, oy vey.  Overall a very valuable look at some fundamental programming concepts like variable scope and environments. He didn't talk about side effects directly but it did make me think of a word... what was it [navigates to Google...] idempotence, thank you Wikipedia. 

SICP - Generic Operators

This lecture was ostensibly about generic operators, though much of the lecture ACTUALLY dealt with typing.  I took a TON of notes this time around because the lecture was nearly an hour and a half long. I'm really starting to get annoyed with Mr. Stache-Mullet, he sometimes asks good questions but more often than not he gets hung up on stupid crap.

SICP - Pattern matching and rule based substitution

I'll have to admit this lecture was harder to follow, though I think I did a better job following along than the mustache guy who spent five minutes beating the same question to death.

SICP - Symbolic differentiation and quotation in LISP

This lecture looks at producing derivatives using algebraic notation and calculus rules rather than the numeric estimation we looked at in an earlier lecture.  One interesting point made was that LISP expressions actually exhibit a list structure.

This was a shorter lecture (45min instead of the usual 75min), so the notes are a bit shorter:

SICP - Lists in LISP and the Henderson Escher functional geometry language

Today's lecture built on some of the concepts we already learned regarding combinations, introducing the concept of lists in LISP.  About half the lecture dealt with a language implemented in LISP that describes Escher like tiling pictures.  It was an interesting segment but because I can't really reproduce the graphics I didn't take very thorough notes on it.  The University of Oxford Computing lab has an exercise on their website that looks at the same Escher fish tiling problem in their own language called GeomLab. It doesn't appear to be implemented in LISP, but it does follow the same principles discussed in today's lecture. An example of the complete "Functional Geometry" language developed by Henderson implemented in LISP can be seen here.

SICP - Compound Data and Data Abstraction

Due to ongoing technical issues with my work computer, I'm shifted gears from .NET and back to the MIT lecture series. Today's lecture dealt with data abstraction.  I found this to be an interesting lecture, particularly the discussion of constructors and selectors. I couldn't help but mentally connect it constructors and properties in a .NET context.  Some more LISP today though I didn't get a chance to try and run it as I haven't installed the LISP interpreter on my laptop, and I am not in the mood to deal with installing it in linux. If I still don't have my PC back from IT tomorrow I might think about installing it.

SICP - Higher order procedures

After a brief break to go play in Visual Studio I'm back at it with the MIT lectures. This one looked at passing and returning procedures from other procedures.  Talked about the square root procedure again, how it is really just a fixed point for a function. Then we looked at Newton's method and built up a rather elaborate program for computing square root based on derivatives. Fun stuff.

SICP - Procedures, Processes, and the Substitution Model

I was skeptical about learning in LISP, but after reading Paul Graham's letter regarding the use of LISP in his start up Viaweb, I was intrigued. So I'll muddle through this lecture series and see what I learn about LISP, and about computing fundamentals.  Covered a couple interesting topics today, including the substitution model, and covered some real basic concepts related to time and space complexity.  I had been thinking that I might want to learn more about recursion and it seems like I'm going to get the opportunity in this class.

Introductory Comp Sci class 1986 Style...

Wow, I didn't realize that this series from MIT was recorded in the stone age. I'm going to stick with it for now, partially out of morbid curiosity and partially because I figure maybe if I'm using a more basic tool set I can focus more on the concepts and not get so distracted by the gadgetry.  On the flip side, the chances of me ever using LISP for anything are basically NIL. For now I'll take a wait and see approach.  I think the format I'm going to use for these lecture video posts is to post a few thoughts and then dump my notes.

Couple notes on the use of MIT/GNU Scheme: Ctrl+x then Ctrl+e to evaluate a line of code in the interpreter... had a hell of a time finding that in the documentation.  Also, if you want decimals, put a period at the end of a number. Notice the difference here: