#12 overallClassic
CS61A: Structure and Interpretation of Computer Programs
UC Berkeley
31 recommenders · 31 threads · recommended in 17 years, 2008–2026 · score 52.3
CS 61A is UC Berkeley's introductory computer science course built around the textbook Structure and Interpretation of Computer Programs (SICP), covering programming abstraction, recursion, interpreters, and related topics, historically taught in Scheme and later in Python. Commenters also point to its self-paced Scheme-based variant (CS 61AS) and to lecture archives from Brian Harvey.
Commenters call it the best introductory CS course and praise its SICP-based approach and Brian Harvey's lectures.
Recommendations by year
20062026
Brian Harvey was really great as a professor. I loved his personality and demeanor that he brought to class. I came to cs61a for a SICP experience, and I'd say he delivered exceptionally well -- maybe more relaxed but equally engaging as lectures I've seen from Abelson and Sussman. It was very fun and rewarding; the course notes and assignments were great. To much regret, I only made it to his office hours a few times (was living in The City, and not an AM person), but I think he really cared for the students, and felt like a wise uncle that I wish I had.
bh's cs61a lectures from some years later:
https://archive.org/details/ucberkeley_webcast_itunesu_43829...
I did not appreciate it at the time but CS 61 abc absolutely transformed by foundational understanding of computer science and the concepts they push are absolutely and non-negotiably important for someone to learn.
My only recommendation is to learn programming in a more useful and productive language like C++, as the thing you do not want to do in CS61A is to simultaneously learn to program and learn the concepts in those courses. The right way to think about it is those courses are trying to make you go “ohh that’s how things actually work”.
It, obviously, depends. If you went through really good courses and extraordinary teachers, like old-school scheme-based Berkeley CS61A, then, perhaps, some AIMA based course with CL code, leave alone original SICP courses at MIT, then it definitely worth it. Berkeley CS188 (Python-based) is very good one too.
But if you just passed through some crappy courses which ends with "in Java" in some third-rate school, then you have, probably, wasted your time and money.
Good schools which still taught fundamental principles, like MIT, will always worth it.
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.
I am one of Brian Harvey's student progeny. I still consider the SICP as my favorite computer science book, and in retrospect CS61A one of my favorite and most important courses. There is something amazing about a course that takes one from "square can be defined as (define (square x) (* x x))" to writing an interpreter, and be something a mere mortal can work through in a few months. And that's just chapter one to four out of six in SICP, if memory serves.
I like Python, and use it in industry. Ruby, Go, and C also. In the past, I wrote Common Lisp professionally as well. I do not pine for Scheme or CL, although both had some of their own unique charm. Nevertheless, I think Brian's sentiments about Scheme's clarity in stripping away what can seem to be the 'magic' in programming while maintaining an absolutely rigorous representation that can actually be executed are spot-on. There will be plenty of time in practical work to reintroduce some magic to make practical tasks easier, but there is but a precious few years -- or indeed, just a semester -- to examine the structure of abstraction at its very core.
Already posted this in longer form as a reply [1], but the UC Berkeley CS courses that are available online are really great, and you can usually find ALL the material for the course online.
If you want to learn Scheme (Lisp), I highly recommend CS61A [2]
[1] http://news.ycombinator.com/item?id=2103949 [2] http://www-inst.eecs.berkeley.edu/~cs61a/su10/ Lectures on iTunesU
Also another good "beginner" (was already a programmer, and it was still a great course) course that actually has everything - lectures, notes, textbook, assignments, tests and answers! - available free online is the UC Berkley CS61A course.
The course teaches the fundamentals of Computer Science with Scheme (Lisp) and the book is SICP (a really great all-around CS book). I watched all the lectures, and did most of the assignments over a month or two last year and learned a lot. Sometimes you have to Google around for old tests/answer keys, but resources for the entire course are online. I highly recommend it if you are remotely interested in programming.
Multiple Semesters of Audio/Video Lectures are on iTunesU
Resources from the Summer 2010 Course:http://www-inst.eecs.berkeley.edu/~cs61a/su10/
Edit: Formatting
Just an anecdote.
I took CS61A by Brian Harvey in 2009. I loved the course and I actually spent very little time learning the syntax and most of the time learning the concepts.
So I fully agree with Prof. Brian Harvey here.
I was a CS61A lecturer for 3 semesters. I thought that we covered very valuable content, but also did not think that it was appropriate for new programmers. I encouraged students to enroll in a true intro class, like CS10, before embarking on the 61A journey.
Here’s my post about how to audit 61A : http://blog.pamelafox.org/2022/07/how-to-audit-cs61a.html?m=...
By no means are you dumb. Some corollary of Dunning-Kruger Effect -- your frustration is probably proportional to your ability to think and to operate in this domain.
My summer project for myself last year was making a big working desk and a rack-mount setup for a workspace at home. I listened to Hal Abelson and Gerry Sussman, recording from 1989 (I think), when they taught on site for HP engineers; SICP in a week. I still had some surprises, things clicked for me.
https://overcast.fm/+Do0X1PN6k
https://groups.csail.mit.edu/mac/classes/6.001/abelson-sussm...
I was very fortunate to have been in the first or second batch of CS61A students that Brian Harvey taught at Berkeley. It's still my favorite class, and although it was challenging, I had far more difficult experiences with calculus.
Calculus almost broke me. The first time.
I completed some of the SICP exercises on morning train commute. Four years after seeing them for the first time. Five years after that, I returned to college for another try at linear algebra, having actually flunked it the first time.
All these people seemed to just cruise on by. But actually, everyone hits the wall at some point.
Structure and Interpretation of Computer Programs, by Abelson, Sussman, and Sussman.
Also known as "The Wizard Book" or "SICP".
The full text is legally available online[1], but I found it worthwhile to buy a copy.
There are at least two really good sets of video lectures to go with it if you are so inclined. Personally I enjoyed the ones from Berkeley.
[1]: https://mitpress.mit.edu/sites/default/files/sicp/index.html
For formal resources:
You might like the Princeton Algorithms Coursera course: https://www.coursera.org/learn/algorithms-part1
SICP is an amazing book, but I HIGHLY recommend you follow along with a lecture video as the textbook was designed to go along with lectures for electrical engineering computer science students. Brian Harvey's lectures are fantastic: https://www.youtube.com/watch?v=4leZ1Ca4f0g&list=PLhMnuBfGeC...
And maybe some math? All of this is kind of abstract to start out with. It might be useful to combine this with youtube videos on your project, because you may be discouraged with doing a lot of abstract work and not concrete work on your project.
Also, freecodecamp and youtube in general is an excellent resource if you're stuck on any particular part of CS. Freecodecamp has compiled a lot of the best videos across the internet on particular concepts and you can get a deep dive into a topic if you're ever stuck. Nowadays, if you're stuck, often viewing someone else's explanation can get you unstuck fairly quick.
If there's any programming-adjacent technology that is practically guaranteed to make you want to pull your hair out, it's CSS :-) I don't find web dev appealing in general either, so lots of sympathies there.
It's nice that you've tried Java and computational stuff and found those more appealing. Re: CS50, my understanding is that while the course is well-structured, they do start with C, which is better suited for people who really like learning from the "bottom up", rather than those who learn better "top-down". You might be in the latter group.
If all that sounds about accurate, it's probably better to focus on courses that start with higher-level technologies like Python, C#, or Java in the beginning (but stay away from web dev). Python is the most likely to feel "natural", so that's what I recommend to people just starting out. You could check out Berkeley's CS 61A for example (though I think MIT/Harvard have Python-based courses too). If you stayed on Windows, I'd recommend Visual Studio 2019 (not to be confused with Visual Studio Code), since it has everything well-integrated together. But courses focus on UNIX-based tools, so you'd indeed want a Mac if you're following anything that uses the terminal. And if iOS app development is your goal then you definitely don't want to go with Windows, though I don't have any experience with that so I can't give you pointers (hah) there.
CS in general isn't about just coding though; the algorithms and data structures are extremely important, and they aren't necessarily easy to pick up, so that's normal. And self-guided courses in general definitely need a lot of motivation, and that's easier said than done for most people, so don't feel like it's just you. You probably want to pick something where you have a good dose of interest & curiosity to drive yourself instead of just relying on the course, regardless of what you're doing.
Not sure how helpful this is but best of luck trying it with a Mac!
To disagree with you, I took the Python version of UCB's CS61A and I learned quite a lot (especially coming from a non-programming background). Perhaps other forms of SICP are better, but CS61A was a really enjoyable course overall and was part of the reason I decided to switch majors to Computer Science.
I really like the resource but some of the courses I prefer some alternatives.
1. Programming - IntroCS by princeton - available on coursera with videos and graded assignments. If you require a slightly easier course, then you can check out CS61A from Berkeley or MIT's Intro course in python.
2. Algorithms and Data Structures - Princeton 2 courses in algorithms - coursera. Alongwith their book and booksite this was a very good resource for me with their graded assignments. I also would suggest CS61B from berkeley.
3. Databases - I started learning from Stanford Widom's course, but now I actually recommend CMU's course. I have heard good reviews for berkeley's course CS186 as well.
Side Note:
https://bradfieldcs.com/courses/ These are the makers of https://teachyourselfcs.com/. I notice that there are many courses, but at the same time $1800 per course is a bit too much considering USD conversion. So, I am looking for reviews if anyone has taken it, and whether the cost is justified. On the fence of joining it because of the cost.
The website actually recommends using SICP accompanied by Brian Harvey's CS61A lectures. Highly recommended and then read The Little Schemer to get a strong grasp on recursion.
I'd suggest instead taking Brian Harvey's lectures on same.
The switch occurred while I was at Berkeley and it also made me sad. I loved that course so much I decided to TA for the self-paced version which kept SICP and Scheme.
Brian Harvey explained the decision to switch here:
"But, as I keep saying, the choice of programming language isn't the main point. I get upset when students, even the students who like 61A, refer to it as "the Scheme course." It's not a course about Scheme! It's a course about programming paradigms. MIT, where SICP was written, no longer includes that course in its lower division core sequence, not because they wanted to change programming languages, but because they changed the entire sequence from courses organized around big groups of ideas to courses organized around application areas: first "let's build and program a robot" and then "let's build and program a cell phone." That's a brave and thoroughgoing attempt to, among other things, attract non-nerds to computer science. To say, as some people do here, "MIT switched from Scheme to Python" completely misses the point of what MIT did; nobody is proposing any change half as profound at Berkeley." [1]
[1] https://people.eecs.berkeley.edu/~bh/61a.html
Did SICP at Berkeley. Really awesome course. Thanks MIT for not teaching it anymore. Makes me a better programmer than your new grads now. Hah!
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).
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).
Pretty much any UC Berkeley course is like this; check out the archives for the intro CS class, cs61a: http://inst.eecs.berkeley.edu/~cs61a/archives.html
Here's a listing of all the different classes and their archives: http://inst.eecs.berkeley.edu/classes-eecs.html
I loved his CS 61A online lectures. Glad they are available to the world.
I am really suggesting to try some classic Scheme course first, like my favorite CS61A by Brian Harvey, or that wonderful Racket-based course (what's the difference?) on Coursera by Gregor Kiczales (which is worth watching even if you are mere a brainwashed Java dev).
Another way is through pg's books, especially, of course, "On Lisp" and Arc tutorial and then arc.arc (original version from the 2009 arc3.tar which isn't cluttered with silly docstrings and other nonsense).
There is also the way of CL. For that there is pg's ANSI CL, but before that a much better "CL Language Concepts" from Symbolics (pdfs are available from bitsavers).
Then, perhaps, one will have slightly different view of what Clojure is really. Yes, it is a real marvel of software craftsmanship, especially that it was originally a solo effort, but no, there is no miracles in it.)
Also, you can go through the UC Berkeley SICP course for free: http://www-inst.eecs.berkeley.edu/~cs61a/fa13/
I'm going through it now, on my own, and it's an awesome course.
This is excellent review, no doubt, by a well known scholar.) The only problem is that there are so many books and so little time.
So, to get a quick and productive crash-course I would recommend just a few selected resources.
* SICP based course CS 61A by Brian Harvey (Youtube)
* HtDP2 and a wonderful course based on it - Introduction to Systematic Program Design by Gregor Kiczales (the author of The Art Of Metaobject Protocol)
* Armstrong's thesys armstrong_thesis_2003.pdf and his Programming Erlang book.
* Programming Languages course by Dan Grossman (also on Coursera)
* Two Scala courses Martin Odersky
* The classic Haskell tutorial http://www.haskell.org/tutorial/
* ANSI CL and On Lisp books by pg.
This is a very decent start in my opinion. "To learn quickly read only the best ones".
CS61A is one of the best courses I took in college and Brian Harvey was one of the best lecturers I had.
So whatever he uses, I'd say it works.
The way is Scheme -> Common Lisp -> Arc.
Scheme comes first because it is more refined and there are excellent courses and books.
CS61A probably the best introductory course. After that it is good to watch original SICP lectures by the two magicians and read the book. Then it is necessary to take a look at what HtDP team is teaching.
After this there will be no trouble with Common Lisp. Classic books are these by pg and Norvig. CLtL is just a reference.
Then, with all the knowledge so far one could understand arc.arc and appreciate what have been done there.)
With this background you will understand what Clojure really is and why, or what is Haskell, and why there is nothing special in it.
btw, there is a brilliant course by Dan Grossman on coursera covering FP. He is very clever and consistent. After this you will smile at Haskell guys.)
Update:
I forgot Emacs Lisp. An Introduction to Programming in Emacs Lisp is an excellent book that covers all the basic principles and gives a perspective how to use lisp in a real-world project.)
I went through a wonderful course based on SICP and really loved. Partly, no doubt, this was due to my professor (Brian Harvey) who was a brilliant lecturer and very good at designing the course. However, largely, this was due to the textbook, the material and the language.
I think Scheme's fundamental advantage over Python is simplicity. There is, essentially, no syntax. Even the fundamental language features are not accorded any especial syntactic status. This makes it clear that the course is about computation rather than any particular facet of it.
Moreover, Scheme is truly paradigm. Language like Python and Java are staunchly imperative--they might pay lip service to functional programming, but it's clearly an afterthought. Things like loops and assignment are deeply embedded into those languages.
Scheme, on the other hand, is just as happy with procedural code as with functional code. Moreover, it introduces OOP not as a built-in language feature but as a set of useful patterns. This really helps broaden students' perspectives. You can even reuse exactly the same syntax for non-deterministic and logic programming.
SICP is an advanced text, and using it to teach amateurs how to program is, probably, a mistake.
Brian Harvey have done a great job to simplify and make it more freshman-friendly. I think his CS61A is the best intro course available (but I don't think that the sentence ADT is a such great idea, and it make things little messier, not more clear).
The HtDP2 approach is also remarkable, but problem is it is part of Racket promotion (word dr.racket is used hundred times in the first chapter). The idea to make changes in a program visible, via using graphical primitive functions is brilliant, but controversial one - it is too soon (but it kicks and makes a progress visible)
I think that functions with multiple arguments, first-class "citizens" (values has a type, everything is a pointer), pairs, lists, then generic functions and environments must be taught first, and visualized interactively, similar to that python tool. Then, after, you can teach parts from HtDP and then SICP.
People who really enjoyed this initiation will go through whole books themselves.)
It's a shame that Berkeley dropped Scheme in favour of Python. In the words of the former CS61a teacher, Brian Harvey, who's retiring [1]:
"In an ironic development, while the Berkeley CS faculty pretty clearly regard the Python-based course as the future of 61A for Berkeley CS students, both the UC Online people and the team at Stanford developing technology for massive online courses are excited about adapting 61AS to their formats. So, down the road, it may be that everyone except Berkeley students can study SICP."
An also[2]:
"You can learn to program in any language. But it’s not just an accident that the authors of SICP chose Scheme as their teaching language. The big ideas in the book — the ones that alumni in the real world tell us they’re using in their work — express themselves best in Scheme. Indeed, saying it that way puts the matter backward. Gerry Sussman (with Guy Steele) invented Scheme before he turned (with Hal Abelson) to expressing the ideas behind Scheme in a course. SICP is Scheme, in tutorial form."
BTW, if you have some free time and want to learn Lisp, do yourself a favour and go watch the old Scheme-based lectures on Berkeley's webcast; they're awesome.
PS. I do most of my professional work in Python.
[1] http://www.cs.berkeley.edu/~bh/retire.html
[2] http://www.cs.berkeley.edu/~bh/proglang.html
A better alternative (also from Berkeley): http://inst.eecs.berkeley.edu/~cs61as.
It's the self-paced, Scheme-based version of the course. The website is currently for last semester; I have some friends working on it and they promise the next iteration (should be up soon) is going to be really awesome. I believe them.
Also, since it's a self-paced course, it's probably a much better option if you want to work along on your own in your free time. I think some other institutions might be using the materials from this class as well, but am not sure about that.
Here are the rather insightful thoughts about using Scheme vs Python for this course from its old professor (who was really awesome): http://www.cs.berkeley.edu/~bh/proglang.html
There is a big difference between a new (so-called must-have) skills and essential skills.
All knowledge that you really must have is already developed long ago (look at things like SICP or Mythical Man Month, or XP Explained) and remains unshaken.
In contrary, this or that new cool tool to make a dynamic web-pages, or a brand new pile of a useless abstractions in the next revision of J2EE or .NET are third-rated knowledge. Google search is enough in this case.
Take a look at Berkeley's CS 61A course (with that honorable old-school lecturer and a nostalgic 80x24 text-mode console on Solaris 2.7) - all the essential knowledge is here.
The video lectures and problem sets from the UC Berkeley course (CS 61A) taught by Harvey are very good (and freely available), although you will need to use Berkeley Scheme to get the most out of it. Two months is ambitious, but you can get a lot out of it in that time even if you don't finish.
I took CS61A with one of the authors of the book, Brian Harvey (CS61A is the introductory computer science course here at Berkeley). While I loved the class and enjoyed having Harvey as my professor, I found Simply Scheme a bit too limited and simplistic. SICP covers more material in greater detail.
http://mitpress.mit.edu/sicp/
wow, I had no idea. SICP is sitting on my shelf, I had no idea there was a lecture series that went along with it. I'll take a look at the first few. I will say, I suspect the fact that Harvey's lectures gain currency with the video viewer simply because some of his examples, like map reduce, are very current and topical. I'll check out the first few. But even now I can tell you I prefer scheme from Harvey over Python from How to Think Like a Computer Scientist (http://openbookproject.net/thinkCSpy/index.xhtml), although thinkCSpy is still on my to do list. I can't help but wonder if my physics background is finding functional programming more attractive. However, I still haven't gotten comfy with Emacs, still using Vi and the REPL. BTW, the torrents don't seem to be seeded.
Is this their first time programming? If yes, the approach to learning computer science is more important than the particular language used.
There's something to be said for David Malan's approach in Harvard's CS50 [0]. He and his team work very hard to make computer science exciting and get the students to have some results quickly. The production values are incredibly high. He takes the class through C and Python.
Coming from a very different approach, you have Matthias Felleisen at NorthEastern University and his How to Design Programs (HtDP) book [1]. Matthias has written extensively on the decisions behind HtDP [2][3]. HtDP uses teaching languages built into DrRacket (which was originally based on Scheme) to gradually introduce new concepts to students.
HtDP is based on the classic Structure and Interpretation of Computer Programs (SICP) from MIT [4], but it addresses some criticisms of SICP as an introductory text. Namely that SICP leans too heavily on domain knowledge outside of computer science.
The course webpage [5] for Fundamentals I from NorthEastern is not very useful for self-study. Instead check out the EdX course "How to Code: Simple Data and Complex Data" [6] by Gregor Kiczales at University of British Columbia.
Unfortunately the course has been branded as "how to code" for marketing reasons, but overlook that because it is a very solid offering that is directly based on HtDP. In fact, Gregor's page outlining and summarizing the HtDP design recipes for How to Design Functions, How to Design Data, and How to Design Worlds, is significantly clearer and easier to comprehend than the original explanation from the book.
The only limitation with the EdX How to Code course is that for some reason they are only "open" for enrollment once pear year. Fortunately the first course is currently open at the moment. Obviously don't bother with the verified certificate/MicroMasters stuff, the content is the only important thing.
Also of note if you're still looking for Python based, is the newish Berkeley CS61A course taught by John DeNero [7]. It is the most all-in-one option for self-learners as the book, the course assignments, and the videos, are all freely available online, and well organized. Similar to HtDP, DeNero's CS61A is also based on Structure and Interpretation of Computer Programs. I have not yet gone through this course so I can't speak to the content first-hand. Of historical note, the course was taught by Brian Harvey using SICP and Scheme up until he retired a few years ago. Brian wrote his thoughts on the change and there was a discussion here on HN [8].
DeNero has written his own book called Composing Programs [9]. Additionally the couse uses Phillip Guo's pythontutor.com for visualizing assignments.
All in all I would say if you are good at self-teaching and don't mind the lack of videos or course materials, check out SiCP. Otherwise, if high production values are appealing then check out CS50. And if you want an all-in-one package that has some of the same solid foundation as SiCP, then go for Brian Harvey's CS61A.
Hope this is useful to someone.
[0] CS50 at Harvard: https://cs50.harvard.edu
[1] How to Design Programs book: http://www.ccs.neu.edu/home/matthias/HtDP2e/
[2] Essay by Matthias on The Philosophy of HtDP: http://www.ccs.neu.edu/home/matthias/OnHtDP/turing_is_useles...
[3] Essay by Matthias on Growing a Programmer: http://www.ccs.neu.edu/home/matthias/Thoughts/Growing_a_Prog...
[4] The Structure and Interpretation of the Computer Science Curriculum: http://www.ccs.neu.edu/racket/pubs/jfp2004-fffk.pdf
[5] Fundamentals I at NorthEastern: https://course.ccs.neu.edu/cs2500/
[6] EdX course based on How to Design Programs: https://www.edx.org/micromasters/software-development
[7] John DeNero's CS61A at Berkeley in Python: http://www-inst.eecs.berkeley.edu/~cs61a/fa16/
[8] Brian Harvey: Why SICP matters https://news.ycombinator.com/item?id=4784827
[9] John DeNero's Composing Programs Book: http://composingprograms.com
Interesting point from that page is that Brian Harvey (http://www.eecs.berkeley.edu/~bh/), one of the last hold-outs who was teaching intro Computer Science with Structure and Interpretation of Computer Programs (at Berkeley), is involved as a contributor.
Here are the materials from his excellent SICP course:
* Videos - https://www.youtube.com/watch?v=zmYqShvVDh4
* Supporting docs - http://inst.eecs.berkeley.edu/~cs61a/sp11/
* SICP textbook - http://www.mitpress.mit.edu/sicp/full-text/book/book.html
I cannot look at it from a freshman's point of view, so I'm biased, but I definitely don't want it to be my only CS course.
This is because I just know, that to understand, say, SQL (and NoSQL) there is excellent Database course from Stanford and it worth taking because it will pay back later. To understand programming you need CS61A (because it teach you whys) and then Data Structures and Algorithms. Then you can pick up everything you need from books.
So, let's say that this is an Introduction To Coding (without deep understanding).
Course material (lecture notes, projects, some have links to videos of lecture, &c). for every undergrad berkeley cs course is available for free if you know the website!
http://inst.eecs.berkeley.edu/classes-eecs.html has links to all course websites and archives.
you can look at what courses descriptions here: http://sis.berkeley.edu/catalog/gcc_list_crse_req?p_dept_nam...
the main courses are:
/cs61[abc]/ # intro cs
/cs70/ # discrete math
/ee122/ # networking with a cs bent in fall and an ee bent in spring
/cs160/ # ui
/cs161/ # security
/cs162/ # systems and os (not recommended right now; the class is going through a restructuring and completely sucks)
/cs164/ # compilers
/cs169/ # software engineering
/cs170/ # algorithms, this class usually doesn't have a website aside from homework assignments; i'd recommend just buying the textbook since its only $30 and the course very closely follows the entire text (save for the quantum chapter at the end)
/cs172/ # Computability and Complexity
/cs174/ # Combinatorics and Discrete Probability
/cs184/ # graphics
/cs186/ # databases
/cs188/ # AI
Lower division classes are numbered between 0 and 100, upper division classes are 100 to 199, and grad classes are 200 and up. A tens digit above 4 indicates a cs class, and a tens digit below five indicates an ee class.
To get to the archive for a class without having to navigate to the first link first, go to inst.eecs.berkeley.edu/~<class>/archives if you want to go to the most recent website, just remove the /archives.
EG, cs61's website archive is at http://inst.eecs.berkeley.edu/~cs61a/archives and http://inst.eecs.berkeley.edu/~cs61a will redirect to the most recent course's website.
A good CS degree will force you to do some things "for your own good" that will be valuable later. Working on the problems with others makes a difference, especially since you'll generally be working with others in real life projects. Just totally immersing yourself in the subject for a solid 3 years is significant, as is being around people who are doing serious research in the field (and ideally joining in). Having someone with a clue on tap to help you through difficult stuff makes a big difference. You need people to tell you what you don't even realize you're not getting.
On the other hand, the CS degrees at many, probably most schools aren't worth much. E.g. look at Joel S.'s essay on Javaschools, he makes the point that if you aren't taught both pointers and recursion you're wasting your time. But of course you have to learn a lot more.
To address the one school I'm familiar with:
MIT's old (and much better, in my personal opinion) curriculum is all on line at OpenCourseWare. At the very least you should do 6.001/SICP and then go from there (and you should do as much of the book as you can, the single semester course can't cover it all, especially after they had to add trendy OO to it). UCB is still teaching SICP and as I recall the lectures by Brian Harvey are on-line (and up to date, unlike the ones by Ableson and Sussman (for a class at HP), although learning 6.001 from Sussman is ... very good).
On the other hand, MIT teaches CS combined with EE; if you have no interest in or need for the latter, you can skip courses like 6.002-4 without too much harm (you do need to learn some basics, and there would be serious value to doing 6.004, it's just going to be a lot of work including the prerequisites, which include differential equations). But do 6.001/SICP first and then see what you think.
One major factor I think is what we study. We do not have SICP course in comp sci, instead we study C, C++, java. I had not even heard of lisp, till I came across SICP course from Berkeley web casts. Of course I do not think even in US, they teach ROR, but as PG says, startups and latest and greatest of technology comes around places where there are good universities. I am in no way suggesting that places like IITs are not good, but most of Indian IT industry is not from IITs, that reflects in percentage