Hacker News new | past | comments | ask | show | jobs | submit login
Tell HN: UC Berkeley's CS61A/B/C are the best courses to learn CS and coding
243 points by ggr2342 on Aug 31, 2023 | hide | past | favorite | 72 comments
I have dabbled with many resources before in hope of learning to program and learn basics of CS. I have looked at intro course sequences of schools like MIT, CMU, Stanford, etc. Most have partial resources locked down. I have dabbled with books and they felt like shit. Even the book Think Python by Allen Downey was all over the place.

The books and blogs at least taught me basic syntax constructs like variables, function definition, loops, etc. But I couldn't understand how to package them up (compose) to use them in solving problems.

Then I started studying through Berkeley's 3 course intro CS61A, CS61B, CS61C. They have all materials in the open and if you are following the most current iteration of the course, they even post solutions to the problems. It was godsend for me.

Now, I am confident to learn more CS topics using courses from CMU, MIT, Berkeley, Stanford, etc. The thing that was holding me back was the lack of confidence of programming and understanding really what a program was doing.




Going to hard disagree here and say this is extremely person-specific. I already knew how to code in C++ and Python from high school AP classes. CS61A was awful for me and made me hate computer science. I tested out of 61B. 61C taught me how computers actually work and simultaneously made me quit the major.

Here's my take: if you are interested in computer science, the combination of these classes is great. If you are interested in being a software developer or building things quickly to solve problems there are far better resources out there.


I would contend that you can't be great at being a software developer or building things quickly to solve problems if you don't understand the computer science taught in these courses.

You might be good, you might get some stuff done, but you won't be great.

I say this as someone who has been around this industry a while. You don't need a fancy degree from a fancy school, but you do need a solid basis in theory. Some of the best developers I know never went to college, but they did learn the theory on their own.

And some really poor developers did go to college, but their college didn't emphasize theory, and so they aren't very good when something happens just outside of what they learned, or a new problem presents itself.


Yeah it’s important to point out that programming is not software engineering is not computer science.

Computer science mostly requires a pencil and a piece of paper.

Programming is the act of making a computer do what you’ve written down on that paper.

Software engineering is figuring out what do you need the pencil for and once you’ve done it, making sure computers are doing what programmers think they told them to.


> Software engineering is figuring out what do you need the pencil for

Could you please elaborate on this? :)


Programming is like 20% of senior+ software engineer time, on a good day. The rest is spent all sorts of communicating - emails, presentations, specs, docs, figuring out incidents, in general trying to make sure the team is building what should be built - or efforts which support the business and/or the team, like fixing or optimising CI/CD, monitoring, hiring, reviewing backlogs (note plural), mentoring juniors, helping out sales or support with customer issues, working with support of your service providers, etc. This is especially true in big orgs with many teams, in smaller ones you might see a bigger share of pure coding-related work depending on a week... or coding overtime because there simply isn't enough hours in a day to open the IDE normally and these guys still like to code something every now and then.

Computer sciency stuff is maybe 1% on a good year (obviously there will be exceptions depending on the products you're building).


SE is a project management discipline. CS is a logic/math discipline.

SE gets you to think about what the customer needs, what sort of performance or regulatory constraints may be in the loop, how you can design for teams and the future, etc (i.e., do you need a pencil or a pen, and how the factory is set up to make that happen at the rate and in the time required by the customer).

CS is about algorithms and logic, performance optimization, etc. It's the step where you build the machine that cuts the pencil blank, puts the graphite in, adds an eraser... and the conveyers/etc. that transfer the bits to the appropriate place for them to be useful.


I would assume they mean gathering requirements, aligning with other team goals, etc. before picking up the pencil. Which I agree, is a huge part of “engineering” vs. “programming”


> CS61A was awful for me and made me hate computer science.

Valid criticism. Think for most students, 61A has too steep of a learning curve for an introductory class. For people without any programming experience, it’s a bit too much too fast and with a class size of 2000+, you struggle for resources.

For those with prior experience, it feels like unnecessary training wheels. You learn a little bit of Python, SQL, and Scheme. You have to do environment diagrams (What Would Python Do) on paper, and learn how to use a debugger. Projects and tests have mad-libs style fill in the skeleton code.

In my experience, 61A is a tasting menu of computer science: you take it for the experience, and leave hungry and confused – but excited.

> I tested out of 61B.

OP, you really missed a lot by testing out. This class is half theory, half learn by doing. For example, you learn about red-black trees or Dijkstra's in lecture and then go to lab and implement it.

I know theory and algorithms seem bland at first, but look at the applications. https://www.cs.princeton.edu/~wayne/kleinberg-tardos/

Favorite aspect of this class was designing and then writing a smaller version of git. You had to write a design spec that was checked off, and then your implementation had to pass a test suite.

If that’s not software development, then I don’t know what it is.

> 61C taught me how computers actually work and simultaneously made me quit the major.

61C was not one of my favorite classes because of how low level it is (compilers, RISC-V, concurrency, etc.). But if you stopped taking classes before upper division, you missed out on a whole gamut of “practical” classes like algorithms (CS170) and operating systems (CS162).


> ...there are far better resources out there.

Such as?

Genuinely interested.


I think HtDP is really good: https://htdp.org

It's beautiful like SICP, without being too difficult or technical.

It teaches one thing well, functional decomposition.


Given your testimony, I trust you that it's person-specific – especially since my experience at Berkeley, back in the CS60A-CS60C days (with Scheme) was almost diametrically opposite.

My 80s high school had no programming classes to speak of, but in my own tinkering, I'd done a lot of BASIC & Hypercard Hyperscript tinkering, & I'd looked over enough assembly & Pascal to get the gist. I felt, "I'm good at computers, I can learn what I need there on demand, I've got to major in college in other deeper subjects that I can mainly learn from those departments." And, "being a software developer" alone seemd too narrow an ambition - I thought I'd instead be "someone-good-at-software" in some other kind of innovative industry.

Still, I took CS60A because I didn't want whatever watered-down stuff they'd provide to non-majors – Pascal, I think, at the time. Within a week or 2, CS60A convinced me: there's more interesting depth to 'Computer Science' worth learning.

That continued through CS60B, and by the time I'd done CS60C & the combined EE intro theory & lab course – EE1(?) then, I think, unsure its current equivalent – I'd felt like a circle had been closed on my understanding of how it all works, from logic gates (which I'd understood since a 5th-grade science project & then "Rocky's Boots") through to high-level stack-based languages.

I was hooked, & then knew CS would be at least one thing I'd major in. I ultimately double-majored it with Economics.

Then once out in paid employment, I'd work with people with Bachelors or even Masters degrees from schools not quite-as-famous for their Computer Science programs, and those people would be missing basic knowledge & intuitions about algorithms, data-structures, & OSes that'd been well covered way back in the Berkeley CS60A/B/C intro series.

Of course, the depth of tools & experience available to kids through high school age is wildly different, & better, now. And, if your highest goal is professional training as a software developer, college itself (& college-style courses) may not be ideal, compared to just doing as much as you can, as fast as you can, in the most-challenging workplace that'll take you, filling in gaps with self-study as needed.

But if you want a high-quality college-style education in Computer Science, with the breadth & depth for lots of possibility-frontier work – not just the surface stuff evident to a younger or outside view – Berkeley's curriculum was an excellent eye-opener for me. For precocious students, it should probably replace any "Python & C++" coding in AP high school classes.


> 61C taught me how computers actually work and simultaneously made me quit the major

I'm genuinely curious, why did the course make you quit? Was it the material or the professor, or something else entirely?


Not the guy you asked, but my guess is that they're are not interested in how and why the computer works [1].

They probably more interested on how the computers can work for them. These students most likely to work in the banking or finance sectors where the payments are good and bonuses are awesome. Don't got me wrong though, they are good students and engineers, but under-the-hood of computers are not their main interests or passions. For example, someone can become a car enthusiast but can't be bother to open the engine bonnet or pump the tires.

[1]CS 61C. Great Ideas of Computer Architecture (Machine Structures):

https://www2.eecs.berkeley.edu/Courses/CS61C/


It sounds to me like the original poster is saying they're the best courses for them because all the resources are available and up-to-date rather than because the content is superior.


One person's best learning resource is another person's nightmare.

We still have not understood how to tach coding. The subject seems to be completely non linear, and some people get stuck and cant move on and the teachers cant figure out why and they cant figure out why, it could last 1 month or could last 5 years, and at some point some random thing they read or watched completely unlocks them.

(For me the thing that helped me was Richard Buckland's Higher Computing lectures: https://www.youtube.com/watch?v=hE7l6Adoiiw&list=PL6B940F08B...)

The best way to learn is to keep trying and particularly trying to understand what you do not understand.

As Feynman said on his last board: What I can not create, I do not understand.

So if you are one of those people who is stuck, or you watch CS61A/B and it does not work for you, just keep looking and trying.


I think I generally agree. A student getting stuck on something doesn't mean they're not learning. To the contrary, those can be some of the times the student learns the most.

In the case of them not "getting" pointers, for example, getting stuck might reveal they need to go back and solidify their understanding of the memory model, or how data is represented. These are good things to know you don't know!

Even getting stuck on yak shaving can pay dividends – having the student carefully compare their command to the instructions, learning what does and doesn't work, and patiently building experience with their tools. Even if they feel like they're doing nothing, they're probably learning.

So I think the major problem with self-study using online CS materials isn't people getting stuck per se... it's that those materials are no substitute for teachers and a cohort of learners. Some people do just fine without that support! Others do not.


> To the contrary, those can be some of the times the student learns the most.

I agree, its like 'level up' in a video game :) but I think it is very hard to not despair when you are hitting your head against the wall for too long. If you check the learningprogramming[1] subreddit it is full of stories of people giving up.

It seems in programming, maybe because the pay is so high, the intersection between good teachers and good programmers is not very high.

I read a some of papers investigating `how to teach mastery` and was comparing tutors vs tools, and the very best results were from tutors + tools (sorry I tried to find links in my history but couldnt). Tutors beat tools, Tools beat not getting any help, but even the best tools were not substitute for a teacher.

Maybe now with chatgpt the tooling will greatly improve, for example having an random error most kids just give up and wait for next lesson to ask a question, but now they can just past it in chatgpt, and most importantly they can ask chatgpt the stupidest and most embarrassing questions that they would never ask in class, or to their teacher.

[1]: https://www.reddit.com/r/learnprogramming/


> The subject seems to be completely non linear

Is this not the nature of learning in general? Why is it supposed that learning things in the linear A-B-C-D fashion is even possible for most humans, rather than supposing that most people would need to revisit certain topics before learning new topics, e.g. A-B-A-D-C instead of A-B-C-D?


By linear I did not mean the order in which you study, but rather how your understanding builds up, as in, how much time you put in, and how much you grow.

For example if your native language is subject verb object (cows eat grass) it is quite linear to learn subject object verb (cows grass eat) languages (e.g. Japanese), you put in time, and you make progress. There are other subjects where when you get stuck you cant move on, and the pedagogy and androgogy systems we have came up with for math/physics and etc are getting better and better to understand what people don't understand and how to move them further. Which on its own is quite problematic when you have a class of 30 kids and you are moving with the 'average' kid which does not exist.

In the same time, programming is fairly new, and teaching it is still evolving, educators still disagree on what is important and in which order (reminds me a bit of this Feynman video about 'Greek' versus 'Babylonian' mathematics https://www.youtube.com/watch?v=YaUlqXRPMmY)

There was a great example someone used, the amount of people who get confused by the equal sign, and some actually never go through understanding references and values for many years:

    x=5 
    y=x
    x=6 
    print(y)
and

    a=[] 
    b=a
    a.push(1)
    print(b)
Now I am teaching my daughter and I spent about 3 days per week just on pointers and strings (We even made a card game we play from time to time https://punkx.org/c-pointer-game/), and I can see when she is stuck and what exactly she is stuck on, but how can you do that with 30 kids, when the most subtle nuance in the questions they ask can give you the deepest hint in what they are missing?


I still remember how confused I was in my 101 course at Clemson. I was certain I was going to have to change my major.

Then one night on a project I was just staring at the code at 3am…and it suddenly all made sense. Got A’s in all my CPSC courses after that too.


> We still have not understood how to tach coding. The subject seems to be completely non linear, and some people get stuck and cant move on

The same can be said about any subject or skill.

If you go to any class, you'll find some people are interested, others aren't. No matter the subject, be it sport, physics, math, chemistry, art, history, etc. Same teacher, same material, different reaction from students.

There's no artificial "ceiling" at play that's specific to coding.


I think the problem with coding is that people who are very interested still get stuck, I suspect this happens less often with people interested in chemistry/math etc. (possibly because of survivor bias because people drop out of it sooner, because there is no money in it)

There are countless reports of people 'not getting it' after studying for 4 years, they cant make fizzbuzz, and I dont mean they dont get some nuance of it, they literally cant even start typing.

I dont think there is artificial "ceiling" to coding, I think we still have to learn how to teach it, and particularly how to teach it to a mass of people.


It’s so true and refreshing to hear. If I had to characterize my own successes in learning, they come from very “honest” teachers, and those aren’t always in intro courses. A few examples, learning PowerShell from Snover, one of the creators via Microsoft Virtual Academy (probably a bit dated by now) or Calculus 3 from Professor Leonard on YouTube. I often have to go through a few dozen resources to find the one that works for me.

We also can’t teach math well for the masses, there’s a long history of failure. Like New Math or the STEM pipeline. Embarrassing stuff really and I don’t know what a good solution is. It’s one reason I don’t totally hate the new approaches to how math is taught that get lambasted on social media (this is not New Math which was much earlier) because the past isn’t working well enough.


Good point but I'd go further. When you're stuck and start to struggle and sustain through that, that's where real learning happens.


CS61A - https://cs61a.org CS61B - https://sp23.datastructur.es CS61C - https://cs61c.org


People like you are the best type of people out there.


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


Took CS61AL (Lab version) about a decade ago. Even knowing how to program and working in industry for several years it was not easy. I think my class was one of the last to use Scheme before they switched towards Python and was entirely taught with SICP Book. Probably the biggest difference between sort of traditional programming courses and CS61AL is you have to essentially understand and do recursion day one. It sort of blew my mind compared to the way I learned because generally you do simple statement programs, then functions, then for, while, do while, etc. Then finally around maybe chapter 10 in a traditional book you get to recursion. CS61AL, SICP, and its lots are great, but they very quickly touch on discrete math and calculus concepts and how they relate to programming/CS. Ditto for first-class functions and Lambda's, all introduced very soon in CS61A. Great course though, was a serious challenge from something I thought I would skate through. Definitely made me a better programmer.


CS61A in particular is important for understanding the nuts and bolts of how programming works. The people who tended to do well in the course had little prior exposure to specific programming languages outside the prerequisite class. I think that all the abstraction that other programming languages do get in the way of understanding why the languages made some of those design choices, which is why throwing all the abstraction out the window is important to understand what's really going on.

I'm reminded of an experiment I was told to do when I was learning how to be a better cook, and I complained that I didn't understand what bay leaf was adding to a dish. Someone suggested cooking some plain white rice with some bay leaf, and I could finally taste the peppery notes it added. Sometimes you need a neutral substrate to see the details of the thing you're trying to learn.


Before coming to college I had tons of programming experience and two interships. I wrote websites, backends, real life applications shipped to customers, school club websites, I even taught C++ in my high school's IEEE chapter. CS 61A completely changed my perspective on how to think about code, I found it so valuable that I could graduate just with 61A, study everything else (algorithms, data structures etc) myself and be fine with it (this is likely an exaggeration of course, there is some value to finishing a traditional CS curriculum).


I learned nothing in 61A — because I was a dumbass kid and didn’t take it seriously.

61B made me feel like I knew how to program.

61C taught me how computers work.

A decade or so later 61A is actually the most useful of the 3 courses now that I’m mid career.

I might recommend that you take 61b first before the other 2 if you’re just starting out


Agreed on 61A. I took it when it was still just SICP in scheme. I saw much of the rest of the curriculum as a variation on the themes I learned in 61A.


CS61A Lectures Playlist: https://www.youtube.com/@JohnDeNero/playlists


Different things workout for different people. I was overwhelmed by so many ways to do things in Python and everybody teaching their own favourite way of doing things. Similarly, all I was learning was the syntax and no problem solving skills.

Then I cam across the book How to Design Programs aka HTDP. I was skeptical at first. But I eventually started and worked through the second edition of the book available freely at https://www.htdp.org .

It was so beautiful. The teaching languages and writing examples before writing code. It made me really understand programming.

Now I can pick up any language (not that I become a language expert overnight) in a short time. I only need to map the concepts to this new language. And that's that. I can even pattern match my ideas from higher order functions to imperative looping constructs.

I have another book in to TDR list. It is Norvig's Paradigms of Artificial Intelligence Programming.


Disagree too. These courses were also known as “weeder” courses so less students do the major, which can’t support all the interested students, so they’re overly difficult. Anyone learning, I would start with JavaScript and make small fun stuff.


They weren't overly difficult. They were just the same difficulty as the rest of the CS classes at Cal. If you couldn't pass these you wouldn't pass any other CS course.


I don’t think they were the same difficulty at all as some of the upper divs. Classes like CS 170 (Efficient Algorithms), Cs 189 (ML) and CS 182 (Deep Neural Networks) were all significantly more difficult than any 61 series class.


Of course a computer scientist would call out my imprecise language. :)

What I meant was that it's difficulty was in line with expectations for a lower division course given the difficulty of the upper div courses in the same major.


The CS61 series was excessively difficult compared to the upper-level material, and it was absolutely because it was intended to weed people out of the major.

I got A's in all of my upper-level CS courses at Cal. Cryptography and compilers were a breeze compared to the CS61 courses. My average grade in the CS61 series was a B-. The semester I took CS61B (data structures), my grade on the final was 21, out of 100. The average grade was 16, and the highest score was 35. (The 35 is a VC now and is fairly active on HN.)


They aren't intended to weed people out through difficulty, they weed people out through honesty. They don't dumb it down or make it easy just because it's the intro course.

It's very clear in the catalog that the course is not for non-majors.

It sounds to me like you learned how to study after you did the 61 series, which is why you did better in upper div (I also did better in upper div for that reason).

Also, 61B was graded on a curve, and you did better than average. The tests were hard so that the people who truly grasped the material could demonstrate that. Profs hate it when a bunch of people get a perfect score, because then they don't know who the best is (and so do the top students). It's done that way not to be hard and make you drop, but so that talent can be truly differentiated.


1) I took several upper-division classes before I took the 61 series, which I took in my 3rd year. (For my CogSci double-major, I didn't take the pre-req until my final semester, long after I had taken all of the upper-division classes.)

2) It is my understanding that most of the weeding classes (CS61 and their counterparts in other majors) are now graded on a curve, but they weren't back then: your grade was your grade. Hilfinger and others like him are the reason for the change. Quite ironically, several of their colleagues noted at the time that these professors would not have passed their own exams if they hadn't written them. (The story making the rounds back then for the reason that Hilfinger agreed to curve his class: after arguing for a week that students deserved the grades they earned, he took a test prepared by a colleague trying to demonstrate that his test was too difficult, and failed.)


The semester I took CS61B (data structures), my grade on the final was 21, out of 100. The average grade was 16, and the highest score was 35.

Hilfinger?


Calls to mind a Hilfinger quote from my CS61A experience: "Mike Clancy makes the tests; I make them harder."


Lol yes, it was Hilfinger. He originally tried to flunk the entire class until the administration forced him to use a curve.


I took CS61B with Hilfinger in '96. That guy was a character. In one lecture he didn't let a person answer a C++ question because he said "no, you already learned C++ in highschool. I want a virgin". People tried to avoid his classes, but you learn a lot from Hilfinger.


I avoided his classes like the plague. His name was already a verb in the 80s.

Which is not to say that I ever held that against him personally. It was kinda cool that you’d be in Evans at 2am and he’d still be randomly wandering the halls.


I once saw a young lady in the lab in Soda hall getting obviously frustrated. A few moments later she exclaimed, "Why is it so f**ing hard!" and then as if in a cartoon slammed her forehead into the lab computers keyboard repeatedly before a TA noticed and came over to help. It was like something out of a cartoon. I've taken CS/Programming courses at a few institutions and never seen quite that level of despair/frustration. Maybe its just a CAL thing, I didn't end up transferring to CAL in the end so CS61A was the only class I did on campus, so can't really say.


I personally had a blast and absolutely incredible time in both CS 61A and 61B. That they're "weeder" classes can be considered true only from the perspective that they're challenging classes but note that almost all CS/Math classes in Berkeley are highly challenging and these weren't outliers at all.

Before coming to college I had tons of programming experience and two interships. I wrote websites, backends, real life applications shipped to customers, school club websites, I even taught C++ in my high school's IEEE chapter. CS 61A completely changed my perspective on how to think about code, I found it so valuable that I could graduate just with 61A, study everything else (algorithms, data structures etc) myself and be fine with it (this is likely an exaggeration of course, there is some value to finishing a traditional CS curriculum).


This. I went into the CS program cold, no prior programming experience at all. After CS3 and CS61A/B/C my relationship with my brain changed entirely. My approach to deconstructing and then solving problems, of any kind, radically improved.


Reading other projects code(especially their unit tests to figure out code) is an invaluable time tested skill I learnt. Once you have learnt the basics of coding getting into doing this is what I highly recommend.


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


Had a similar experience. Came in to college with very little programming background and wasn't sure if CS was right for me. Truly enjoyed CS61A and how simply it worked up from primitives to explain more complex concepts over time in an approachable way. The best part was no hand waving and everything was fully explained.

I had previously tried to learn Java as my first language and never could make sense of all of the "public static void main(String[] args)" and handwaving involved to write a simple hello world.


What about calc 1/2/3 ? I use those skills all the time in optimization work. Linear algebra? These are important skills that self teachers often forget


Try these:

An interactive website https://seeing-theory.brown.edu that takes you through some of the most critical probabilities and statistics concepts.

Statistics 110: Probability

If you want a more advanced overview of Probabilities and Statistics, this course from Harvard University is an excellent introduction:

https://www.youtube.com/playlist?list=PL2SOU6wwxB0uwwH80KTQ6...

This is MIT Course 18.06, taught by Professor Gilbert Strang.

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

One of the best linear algebra courses that you’ll ever find.

Essence of Calculus

This is Grant Sanderson’s excellent take on calculus:

https://www.youtube.com/playlist?list=PLZHQObOWTQDMsr9K-rj53...


Is Strang that guy that just retired?


yes


Professor Leonard on Youtube got me through calc 1/2/3 just last year.

I will forever worship the ground that man walks on for his mathematics help.


Someone shared a long list of visual explanation of math concepts a few days ago.

https://news.ycombinator.com/item?id=37305485

I haven't gone through all of them but I definitely recommend 3blue1brown and betterexplained


MIT 18.01, 18.02 and 18.06


and 6.007 and 6.041


I think that a pure programming course must be taught in Lisp since that is closest to the essence of computation with minimal syntactic overhead. once that is mastered, switching to an industrial language is just a matter of mapping a particular syntax to a subset of lisp concepts. The old MIT courses follow this approach and are on youtube.


mapping knowledge is a learning antipattern IMO. It gets you very far, a good primitive more-so, but you fundamentally struggle to learn new paradigms.


I went to Cal but for MechE. Im also a totally self taught full stack web developer, although just on a personal miniSaas with 34 paying companies.

I think you'll learn tons by starting a personal project, tiny, small, daunting, whatever your appetite for pain is, and just doing that.

I thrashed away on my crm like saas for 6 months before the first demo customers were using it. And then worked on it for another year till it was sellable to less friendly companies.

Recently I picked up a JavaScript book and read it. While I learned a few things, I was shocked how much I knew from what I learned from stack overflow and just random reading and thinking during the time of building that CRM.


Could you please post urls for the courses so it would be helpful to the community?


https://cs61a.org should get you started.


I agree although at the time these classes seemed so unnecessarily hard.

I was fortunate to take - - CS60A with Stuart Russell - CS60B with John Ousterhout (now Stanford) - CS60C with Paul Hilfinger - CS150 with Randy Katz

I believe (after watching videos online) that CS10 The Beauty and Joy of Computing is also a wonderful intro course to take before the CS61 series.

My daughter took CS61B with Paul Hilfinger and he was so gracious to take a picture with the 3 of us together. I have it here on my office desk!!!


I went to Cal, so I took these classes. 61A and B we’re both amazing, but I always felt like the material for 61C wasn’t laid out well.

I’ve heard a lot of good things about Harvards CS-50, not sure how that compares.


CS61A was great when they taught via LISP (Scheme). Have they switched to Python? Probably still good but would be nice to have LISP.


You probably know this already, but if anyone wants to learn “old-school” SICP with Scheme via video lectures, I recommend MIT 6.001 (taught by Abelson and Sussman themselves): https://ocw.mit.edu/courses/6-001-structure-and-interpretati...

The book is amazing, but it is also very extensive/overwhelming and I found that the lectures provide a better guiding structure for myself and the lecturers are also quite entertaining at times. The website also provides additional material related to the course such as exams, projects and lecture notes.


It now starts in Python and ends with Scheme (building a Scheme interpreter in Python).

Source: I lectured 61A in 2021


some people could not stand these classes (in a previous incarnation) and found an assembly language class at a community college instead, at that age.


Have you checked CS50?




Consider applying for YC's W25 batch! Applications are open till Nov 12.

Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact

Search: