Berkeley CS 61AS – Structure and Interpretation of Computer Programs, Self-Paced

http://berkeley-cs61as.github.io/

by danso • 11 years ago

223 48 11 years ago

berkeley-cs61as.github.io

closetnerd• 11 years ago

The best CS course I've taken yet.

lstrope• 11 years ago

Easily one of the most valuable. I agree.

saboot• 11 years ago

This is great, just started reading SICP on my own last week. These lecture notes will help a bunch as well.

suyash• 11 years ago

Is the class using only Racket? Wonder what made them chose that language? Also what is the language used in MIT these days?

seiji• 11 years ago

SICP has always been based on Lisp/Scheme. DrScheme/DrRacket/Racket is purpose-built to be easily deployable and usable in educational environments.

logicrime• 11 years ago

The original SICP used MIT/Scheme, a fantastic language. Racket is a continuation of the ideas of MIT/Scheme with more focus on technical computing and a heavy focus on langdev and PLT theory.

Not to make the language seem daunting, it's really quite easy to pick up, maybe if you find yourself with a few spare weekends you should give it a try!

It comes with a builtin IDE and profiler and everything else, so you just gotta dig in and learn.

kmill2• 11 years ago

As another commenter mentions, MIT used MIT/GNU Scheme [1] for the introduction to CS class 6.001, so if you're following SICP, this is probably the least-friction distribution of Scheme to be using (hints: use rlwrap, or use scheme-mode in emacs, or figure out how to use its built-in scheme-based emacs clone "edwin").

MIT ran(/runs?) a one-month short course covering material from 6.001, and they used PLT Scheme when I took it (now Racket). I seem to remember needing to go into one of the rnrs language modes to get things like mutable cons cells. (How impure.) From what I understand, MIT Scheme is much more in the Maclisp tradition, vs. Racket being more from programming language theory (though both are firmly rooted in the Scheme standard), which reflects in their extensions to the core language.

Nowadays, there is no equivalent to 6.001 at MIT, except maybe 6.945 can substitute. They have a survey course sequence 6.01/6.02 which covers EECS in general, using Python when programming is needed. As a challenge exercise you can make an interpreter for a language, though that's not very metacircular.

[1] http://www.gnu.org/software/mit-scheme/

hga• 11 years ago

The languages used at MIT nowadays in EECS undergraduate education are Python and Java.

cs61as4• 11 years ago

Racket gives us a superset of Scheme that gives us more expressive power. Modularity (good programming practices), built-in loops (for mucking with vectors), structs (for data abstraction), built-in OOP, and extensive libraries are all things we'd like to take advantage of in the future in our lessons.

narsil• 11 years ago

While the non self-paced version of this class (CS 61A) uses Python, it's great to see Racket used here.

rel2• 11 years ago

As much as I love racket/scheme/lisp, I truly believe that the 61A (sans-s) where python is taught, helped me much more for my career/future just because it was taught in python. For programming fundamentals, either works great, but I think working with python is more helpful for future environments.

One example of this is when a classmate of mine was taking an artificial intelligence class at Berkeley (Cog Sci 131) and was at a loss because she was taking 61as which was taught in strictly scheme, and the artificial intelligence class was taught in strictly python.

Both classes are wonderful and I can proudly say that it has made me a better computer scientist. http://cs61a.org/

thomyorkie• 11 years ago

I too took CS61AS in scheme and AI in python, but my experience was different than that of your friend. I didn't find it difficult to pick up python, and learning it after scheme made me appreciate python all the more.

Unless one plans on developing mostly in python during his or her career, I think its beneficial to be forced to learn multiple languages.

iaw• 11 years ago

I've found that each incremental language I've learned typically improves my ability to write code in the languages I already 'knew'

rel2• 11 years ago

It is definitely beneficial to learn multiple languages. I felt bad for my friend because she had taken the two concurrently.

dasil003• 11 years ago

I don't understand this mindset. You only have 4 years to learn whatever they teach in college, compared with 40+ years if you go into industry. To me, the value of my CS degree was the exposure to a breadth of important ideas across the entire field of computing—thing that I would never have the luxury of exploring while under a deadline. None of the particular tools and workflows I used in college were of any meaningful value after 6 months in industry where the workflows are invariably more sophisticated to cope with the messy nature of long-lived real-world projects.

bunderbunder2• 11 years ago

My CS program was taught in Scheme (the version that's now Racket), and I think I kind of understand it. Shortly after graduation I felt like I had this gap in my resume due to spending all this time learning a language that nobody uses in industry instead of something marketable like Java.

Nowadays, though, I feel like my time spent getting used to functional programming in school has given me a secret weapon. It's something much more subtle than the ability to bandy about obscure words that probably start with M. I really do think I'm just fundamentally better at dealing with abstraction, both using it and creating it, than my peers who haven't had such an experience. And that's not small beans considering that, to an approximation, working with abstractions is what I do all day every day.

dylz• 11 years ago

I took 61A in python and loved it too. I do a lot of personal projects in django/flask now too, something I probably wouldn't really have thought of before.

amatsukawa• 11 years ago

2 cents from someone who took CS61A in scheme and had a hand in creating the new python version of the course and subsequently was a TA for the class for a few semesters on this debate:

In any class of reasonable difficulty/usefulness, there will be students who do great, ones that do okay, and ones that struggle. What we should aim to do as the very first intro course is to help as many of those people from all of those groups to do as well as possible in their future classes/careers.

For the great students, I actually believe we did them a disservice. CS61A in scheme was truly beautiful. It was amazing, given how simple the language was, how much you could achieve. All pieces of the puzzle fit together perfectly. Trying to do the course in python, on the other hand, we had to compromise a little bit. We didn't want to just teach the exact same content in a different language. We wanted to teach the "Pythononic" way of doing things. To give a few examples: - The first 1/3 of CS61A in scheme had no mutation. That is almost impossible in Python to do, and is not the way the language is used in industry. I personally believe functional programming and immutability is The-Way to program, so I see this as a huge loss. - We teach recursive lists (linked lists) in order to teach recursion, but I feel like having both the default Python mutable lists (which are array lists) and linked lists is confusing to students, since we do not teach their performance tradeoffs (that is in 61B). - Mutual recursion was almost useless to teach. Where it was most commonly used in Scheme, you achieve the similar thing using list comprehensions in Python (the language feature essentially took away your need to construct the list in a recursive fashion). - The very interesting bits of the old class about metacircular evaluators, we simply could not do in Python. - Python also has tons of quirks (magic methods, for instance) and lost some of the elegance we saw in scheme.

But for the okay and struggling students - 70-80 percentile and below, the students who understand most of the material, but perhaps fail to grasp some of the more complex concepts - I think Python was the correct way to go for a few reasons: - It is a much more commonly used language. It sets you up to go for internships, research, hackathons, whatever you please, straight from what you learned in class. - The language is way more similar to Java, which allows students to translate what they learned easier to the next course in the series, CS61B. - 80% of the material hasn't changed but you've gained the above benefits. Remember, we are talking about students who probably would have struggled to grasp those last 20% anyway (maybe they are completely new to programming and they already have their hands full with the 80% to begin with).

I think therein lies the difference in opinion. If you took CS61A in scheme and understood it very well, then you don't understand the change. If you understood the intricacies of what was taught in CS61A, you will find it very easy to generalize those concepts to new languages - and new concepts. In fact, you will find that much of what you learn in the rest of your undergrad career will be "CS61A review". However, for students who may not have had the CS maturity or time to grasp all the concepts, they find that the Python course is much more useful.

dmeb2• 11 years ago

How is it that python is less amenable to functional programing? (Functional in the sense of referential transparency and immutable data-structures, rather than map-filter-fold). Through my limited exposure to python, I agree that immutability isn't idiomatic python, but I don't think there's anything stopping you from implementing those ideas in any language.

wfunction• 11 years ago

As much as I love racket/scheme/lisp, I truly believe that the 61A (sans-s) where python is taught, helped me much more for my career/future just because it was taught in python.

It's not what you learned that's the problem, it's what you didn't. You almost certainly missed out on things that you could very well never see again, or even know the existence of (at least for a very long time) unless you were motivated enough to go discovering stuff by yourself.

Did you ever learn about macros in Python? I doubt it, because they don't exist. Did you get introduced to metaprogramming -- the idea that you can write programs that generate more powerful programs? I doubt it, because it's hard to do that in Python. But The old 61A, which used Scheme, did just that. They added an OOP system --- yes, that's classes, inheritance, methods, constructors, etc. --- to a language that never had one, and they even taught you the basics of how it was done. [1]

This is something you can't even dream of doing in most (all?) languages that aren't dialects of LISP. You won't even realize it's a possibility, unless someone teaches it to you or unless you're lucky enough to stumble across it and realize its importance.

i.e., you won't know what you're missing out on.

Whereas with Python, there's not much you're missing out on: there are a ton of languages like it that you're bound to see them later in industry, if not Python itself, and learn what you would have learned anyway.

[1] http://www-inst.eecs.berkeley.edu/~cs61a/reader/belowline.pd...

bcg1• 11 years ago

Also:

http://ocw.mit.edu/courses/electrical-engineering-and-comput...

https://github.com/sarabander/sicp

abraham_s• 11 years ago

Is there any way get access to the homework auto-grader they are using?

ghufran_syed• 11 years ago

I doubt it, but you can probably just google for sicp answers, there's a lot of github repo's out there :) The scheme programs referred to in some of the notes look like they are available here if you want to try running them yourself: http://wla.berkeley.edu/~cs61a/sp09/lectures/

jathak• 11 years ago

It looks like 61AS still uses the old glookup system that's restricted to enrolled students, but you could go through the regular 61A course (which is taught mostly in Python but covers most of the same material as 61AS) which started using the new OK autograder for all assignments last semester (http://inst.eecs.berkeley.edu/~cs61a/sp15/). The tests are all run locally, so just add the --local flag to the command you run to prevent it from sending data to the server (which requires a Berkeley login).

cs61as4• 11 years ago

We're looking into releasing a standalone version of the autograders (in response to this comment, actually). No promises yet. I'll reply here if there are interesting developments.

cs61as4• 11 years ago

The autograder instructions on homeworks 0-5 have been updated to include running tests locally. Note that this is an experimental feature. If you run into bugs, you can hit up Rohin and Andrew (find their emails on the staff webpage)

thegainz3• 11 years ago

Thank you for sharing! I've been looking for a well structured course to help me navigate through SICP.

It's kind of funny how at my university (one of the better public unis in the world, or so they say), there is no rigorous introduction to computer science. Sure, we have our architecture, and our data structures, OS, and algorithms, and even a "here's how to Java" introductory course. Yet there is no "This is the way to think like a computer scientist and how to understand as a computer scientist would" class.

The result? You can clearly tell there are a lot of people in the cs program who just sort of go by and learn all these periphery (but still important!) topics without ever touching the core principles. I've even seen seniors who are just clueless! I guess the idea is they're meant to figure it out for themselves through a eureka moment? That doesn't seem like a sound structure to me. I'm realizing that I, myself, fall into the lacking-understanding camp and I'm doing my damn best to rectify that. When I get my degree I want to be able to say I'm a computer scientist, and I want those words mean something. I'm hoping that SICP will truly help me understand the core principles.

bwy• 11 years ago

My impression is that computer science education is light-years behind things like physics and math.

I feel a lot of it has to do with the amount of money you can make straight out of college even as a mediocre coder, compared to the low-paying, unrewarding mess that education currently is.

Good on you for trying to do things right :) I was lucky to take the non-self paced version of CS61A, and I do think the class is top-notch. But even then there's tons of room for improvement, but no one has the time. We're all too occupied with our start-ups here (professor was amazing, but it says a lot that he was a full-time employee of Google while he taught our class).

thegainz3• 11 years ago

You can definitely tell that a number of people are in it without necessarily being dedicated to cs. A bunch of people want our cs program to basically be a vocational school, and in some ways it kind of already is. We learn a trade that we can practice even while students, and people pay us students good money at internships! That's a pretty special opportunity. But the amount of disdain the average student here has for a topic like operating systems is kind of surprising to me.

I could be wrong, but as a casual observer who isn't yet in the workforce it seems to me that the people who put up with the rigor of the more difficult and less sexy topics (e.g. a solid understanding in algorithms à la CLRS) are not only just as well compensated as those who prefer to focus on what they think are marketable skills that industry is looking for, but they grow faster and further. These sorts of people (again, in my casual observer's eye) don't get pigeon-holed into a technology stack, but can easily jump into new topics if they think they're sufficiently interesting.

It's at least true for my friends in compsci who I have the most respect for as programmers. They seem like they can do anything!

bunderbunder2• 11 years ago

I don't know if it's that, or if it's just that it's muddled.

Physics is really two different fields: There's Physics for people who want to a rigorous understanding of the underlying theory, and possibly also want to become research scientists or academics within the field. And there's engineering and all its subfields for people who are primarily interested in applying that knowledge to make stuff.

There's the potential for CS to be broken up along similar lines, but it hasn't happened. I'd argue that this does students a great disservice, since it's hard for someone getting in at the ground level to tell what a program's real focus is just by reading the course catalog.

I took the SICP route and I'm very glad I did. But plenty of my classmates hated it, and I don't see a problem with that. It's terribly dry stuff, and there are plenty of people who've got only a high level grasp of the theory and still make amazing software and make it well

gshrikant• 11 years ago

> It's kind of funny how at my university (one of the better public unis in the world, or so they say), there is no rigorous introduction to computer science. Sure, we have our architecture, and our data structures, OS, and algorithms, and even a "here's how to Java" introductory course. Yet there is no "This is the way to think like a computer scientist and how to understand as a computer scientist would" class.

As an EE working with computers (albeit at a lower level), I'd think the topics concerned with implementation of computers (computer architecture, operating systems, algorithms etc) hold more 'fundamental' status in my book. I guess it depends on where you belong in the stack.

Having said that, I definitely feel that I could benefit from the knowledge of more abstract issues that SICP addresses.

thisisit• 11 years ago

A bit off-topic here but I think learning peripheral information has become a norm. Last year I was trying to learn Data Science and completed the "specialization" from Coursera. But then there were sometimes when I was unclear on certain topics being discussed by blogs I followed. So I tried googling to see how to really learn in-depth about Data science. I landed on this page: http://www.quora.com/How-can-I-become-a-data-scientist

The detailing given in some of the answers meant I had to go back and strengthen some of the basics and learn things in depth rather than peripheral information.

cs61as4• 11 years ago

Hi all. Glad you find our site useful. Just wanted to add some context that we just spun up this website this summer, and are currently porting all of our lessons to the Racket programming language. Since we're developing course material to work well with Racket, some lessons might be broken/have typos. This means that this summer, the website is mainly for supporting the students taking the live course. Thanks for understanding. :) -- CS61AS Staff

justinsingh• 11 years ago

It's great to see Racket being used for this course, as I'm sure many students will go on to explore the language more deeply and see that it has a lot to offer.

farslan• 11 years ago

These are great notes. Just bookmarked. I'm a self taught programmer (but have EE degree) and have just started to read SICP. I'm actually a Vim guy, but because it was awkward to use Vim, I've decided to use DrRacket. Why not MIT/Scheme? Because every single review would suggest me to use DrRacket, as it's more intuitive to use and it's still developed.

So what I'm doing is using DrRacket with this module: http://www.neilvandyke.org/racket-sicp/ This adds and makes the environment SICP friendly, and so far I didn't have any single problem (I'm at Chapter 1, page 67).

From Berkeley, the SICP lectures from Brian Harvey are highly recommended. You can watch them from: https://www.youtube.com/view_play_list?p=EC3E89002AA9B9879E And of course the lectures from MIT itself are good too: http://ocw.mit.edu/courses/electrical-engineering-and-comput... I'm going to watch those once I've finished Chapter 1 myself, to re-read and go over the chapter again.

Because it would be good to observe what I've done and track my progress I've setup a Git repo with my thoughts, notes and solutions about SICP and Scheme: https://github.com/fatih/sicp

This is the first time I'm exposed to Scheme/LISP and it's just wonderful. I really like the examples (though they to much based on mathematical proofs and functions).

akhilcacharya• 11 years ago

Just as I decided to learn a LISP! Great!

McElroy• 11 years ago

Is this a mooc also? If so, how and where does one sign up?

Zezima• 11 years ago

I'm a community college student in California looking to transfer to Berkeley.

I am currently two weeks into the CS 61A Summer Course here in Berkeley and I can confidently say that it is the best class I have taken in my academic career. A few reasons:

1. It follows the mentality of guided discovery. Topics are covered in class, and just enough is taught such that the basis of a solution can be formed, but the implementation requires each person to discover something new.

2. The breadth of topics. The course is 50% students who have never programmed before, I have been programming for 4 years, but still I am learning new things about optimizations, tail recursion, and Big-O notation. If you look at the calendar at http://cs61.org, it goes from "these are variables" to "AI" in 8 weeks.

3. Resources. CS 61A Staff during the summer course if legendary already. They're extremely knowledgeable and very welcoming to everyone. The main lecturers, Albert and Robert, both cover the material well and make themselves available to students of any programming knowledge. There are also dozens and dozens of TAs and Lab assistants which are actually useful, unlike some other courses.

4. Intrigue. I have never wanted to bunker down and learn everything there is to know about recursion, interpreters, and algorithms more than I have in the last two weeks. The way the course is structured, as mentioned above, actually inspires learning in a way that some other topics don't achieve because they follow archaic teaching methods.

Here's to an awesome 61A course.

Berkeley CS 61AS – Structure and Interpretation of Computer Programs, Self-Paced

Related Stories