
Berkeley CS 61AS – Structure and Interpretation of Computer Programs, Self-Paced - danso
http://berkeley-cs61as.github.io/
======
thegainz
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
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).

~~~
bunderbunder
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

~~~
thegainz
That's a good point. I like the fundamentals and really digging in, and for my
friends who don't I ask why learn less about the fundamentals of what you're
doing!? Those same friends seriously questioned their life choices during the
theory/core classes. They later found their calling when they had a chance to
explore things like web dev or mobile dev and they're happy now.

Different strokes for different folks.

------
cs61as
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

------
rel
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/](http://cs61a.org/)

~~~
thomyorkie
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
I've found that each incremental language I've learned typically improves my
ability to write code in the languages I already 'knew'

------
farslan
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/](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](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...](http://ocw.mit.edu/courses/electrical-engineering-and-computer-
science/6-001-structure-and-interpretation-of-computer-programs-
spring-2005/video-lectures/) 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](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).

------
Zezima
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](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.

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

~~~
jathak
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/](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).

------
bcg1
Also:

[http://ocw.mit.edu/courses/electrical-engineering-and-
comput...](http://ocw.mit.edu/courses/electrical-engineering-and-computer-
science/6-001-structure-and-interpretation-of-computer-programs-
spring-2005/video-lectures/)

[https://github.com/sarabander/sicp](https://github.com/sarabander/sicp)

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

------
justinsingh
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.

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

~~~
kmill
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/](http://www.gnu.org/software/mit-
scheme/)

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

------
akhilcacharya
Just as I decided to learn a LISP! Great!

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

------
closetnerd
The best CS course I've taken yet.

~~~
lstrope
Easily one of the most valuable. I agree.

