Computer Science video lectures worth watching

In this post I'm going to list a few great courses from the world's top CS Universities that have video lectures of the whole course.

There are three excellent algorithm courses of this kind I'm aware of. First, there's the MIT Introduction to Algorithms course, thought by Charles Leiserson and Eric Demaine. Both these professors are great lecturers, with Eric Demaine being one of the best I've seen (it's really unfortunate that his other courses like Advanced Data Structures don't have video lectures). The course is based on the Introduction to Algorithms book, commonly known as CLRS (which are the initials of the authors). The L in CLRS is Charles Leiserson. As an aside, the R is Ron Rivest, who is also the R in RSA. I'll probably do a review of this book some time, but it is considered by many to be the best introductory algorithms book out there (and in this sense, introductory basically means general algorithm design and analysis). It is mathematically pretty rigorous, very well written with lots of great exercises and problems and is very comprehensive (for example, it describes pretty much all the "textbook algorithms" you'll ever need at TopCoder). The course doesn't cover the whole book, but gives a great introduction to asymptotic analysis, sorting, randomized algorithms, hashing, self-balancing tree structures, greedy algorithms, dynamic programming and shortest paths algorithms. There's also a nice introduction to amortized analysis (which is sort of an advanced topic). The course ends with a series of lectures about "hot topics" in algorithms today, namely caching and parallelism in algorithms. Only the 2005 course has video lectures, which is unfortunate since they change the topics of these last lectures every time (you can still find the lecture notes though). Also, recitation which covers some interesting stuff is also not available in video (although it used to be, but the files were removed a while ago).

As motivation for the course, prof. Leiserson mentions that it is believed that you can become a great programmer by programming for 10 years, or by programming for 2 years and taking an algorithms course. While this comment is a half-joke, there's no question that understanding algorithms makes you a better programmer. As far as the 10 years of programming, check out the classic post by Peter Norvig called Teach Yourself Programming in Ten Years (if you managed to miss it until now :). The number is pretty arbitrary, but it's probably not off by much.

The second, less known course about algorithms is Data Structures and Algorithms from IIT Delhi (the link is to the first lecture). The lectures are in clear English (except occasional burst of the local language :) and also follow CLRS. The course consists of 36 lectures and covers things from basic data structures like stacks and queues to hashing, sorting, self-balancing tree structures and graph algorithms. The lectures are for the most part pretty independent, and they cover some things that are not covered in the MIT course or in CLRS (for example AVL trees which are covered through exercises in the book).

The third algorithms course is the one by Steven Skiena from Stony Brook. This one is quite different from the previous two in the approach it takes (although the recommended course textbook is also CLRS). It far less mathematically rigorous and doesn't try so hard to prove everything. This might sound like a bad thing, but the emphasis of the course is on understanding how algorithms work and on general techniques for algorithm design. This is in line with Skiena's book The Algorithm Design Manual. This is not really an introductory book as it glosses over a lot of the details you might want to know, but if you're already familiar with algorithms it's a great read. It also contains a great algorithms catalog that contains enough information to recognize the problem you're facing and get an idea what to do (it used to be available online, but I can't find it right now). The course ends with a great introduction to complexity theory and identifying and tackling intractable problems, which is Skiena's primary research area.

Finally, I'll mention one non-algorithms course, namely CS 61C Machine Structures from UC Berkley. They post video lectures for this course every semester, but the one I'm linking to is held by Dan Garcia who is the best lecturer I've ever seen. Apart from that, the course is so fundamental to Computer Science that I think it's the one course everyone should take. In my University program, we had about three or four courses that cover the the individual parts of this course in greater depth, but I feel adding this kind of all-in-one course would actually be great. This is an awesome course to learn about some of the key abstractions in computers. It starts with an introduction to C and basic programming, then moves on to MIPS and some low-level programming. Then there's a basic lecture about compiling where people get a feeling of how the things they write in C get converted to MIPS. After that there's a short and elementary lecture on basic electronics (basically how you move from the abstraction level of electrons and protons to the level of transistors and electronic circuits) and several lectures on digital logic elements. Here they explain how you make things like adders and registers from gates. Then they use this elements to create a functional, pipelined CPU, explain caching and virtual memory, and connect the hardware with the MIPS code through the powerful idea of the ISA (Instruction Set Architecture). After listening to this course, it's really easy to understand how computers work "from the ground up" at an elementary level. There are a few lectures in the course that are sort of out of place, like the one on networking (and it's not very good either) and optimization, but you can skip those.

If you know a good course that I missed, let me know! :)