There is a difference between people who can write code and people who understand what code is, and it shows up the moment something goes wrong in an unfamiliar way. CS61A is the course that closes that gap, and Berkeley publishes every part of it for free, which remains one of the more generous things any university does. The lineage matters. This descends from Structure and Interpretation of Computer Programs, the MIT course and book that shaped how a generation thought about programming, rewritten to use Python instead of Scheme.
The Python choice is the right one for a modern learner. The ideas are unchanged and the barrier to entry is much lower, and you will still meet Scheme in the back half because some of the ideas are easier to see in a language with almost no syntax. The free textbook, Composing Programs, is the written form of the course and it is superb. Clear, precise, extremely well organised, and it treats you as someone capable of following an argument.
It is available online at no cost and it would be worth buying. Anyone who wants to know what this course covers should read the first chapter and see whether the way it explains functions as abstractions clicks with them, because that is the whole approach in miniature. The structure builds carefully. Functions and abstraction first, then recursion in genuine depth, then higher order functions and the idea of functions as values, then data abstraction, then object orientation, then interpreters, then a lighter treatment of state, streams and databases.
Each section rests on the previous one and the progression is deliberate. The recursion material is the best I have seen anywhere. Most courses teach recursion as a trick for a handful of problems. This teaches it as a way of thinking about structure, and by the time you finish tree recursion and mutual recursion you will stop finding it uncomfortable, which is a real change.
The interpreter project is the centrepiece and the reason to do this rather than something easier. You write an interpreter for a subset of Scheme. In Python. And when it works, something shifts, because you have now seen the whole thing from the inside.
Evaluation, environments, scope, closures, tail calls, the reason a variable resolves the way it does. Every language you use afterwards is slightly less mysterious. I do not know of another free resource that produces that effect. All the assessment infrastructure is public.
Problem sets, labs, homework, the projects, the autograder, and solutions. That means you can work through it exactly as a Berkeley student does and know whether your answers are right, which is the thing most self study collapses without. The projects are well designed and progressively harder, and they are the course. Reading the textbook without doing them gets you a vague feeling of understanding and no actual ability.
Now the honest warnings. This is hard. It is Berkeley's introductory course and Berkeley's introductory course is more demanding than most universities' second year. People arrive expecting a gentle beginner experience and hit the recursion material and conclude they are not cut out for programming.
They are wrong, and the course is genuinely difficult, and knowing that in advance helps. Budget more time than you think and expect to be stuck regularly. Being stuck is the process rather than a sign of failure. There is no AI or machine learning content.
None. If you came here from a site about AI courses wanting something to put on a CV next week, this is not it. What it is, is the foundation that makes everything else easier. People who struggle with machine learning frequently struggle because their programming is shaky, not because the mathematics is hard, and this is the most reliable fix for that.
Self study loses a lot. Berkeley students get lab sections, office hours, a discussion section and peers who are stuck on the same thing. You get a website. The materials are complete enough that this is survivable, and it means when you are genuinely blocked at eleven at night, there is nobody.
Find a forum, find a study partner, or accept that some problems will take a couple of days. The final section on streams, declarative programming and databases is the weakest part for a self studying learner. It is interesting and it is less immediately applicable than everything before it, and by that stage most people are tired. Doing the first three quarters properly is worth far more than skimming all of it.
My four point eight is for a course that is free, complete, rigorous, brilliantly written and unusually well designed, and that will make you measurably better at the job. The only reasons it is not a five are that nothing replaces the human support a real cohort gets, and that the difficulty will lose people who deserved a warning. This is the course I recommend most often and the one people thank me for a year later.