#45 overallEvergreen
6.004 Computation Structures
MIT OpenCourseWare
9 recommenders · 11 threads · recommended in 8 years, 2010–2025 · score 12.2
MIT's introductory computer architecture course, built around a series of labs that climb from transistors and gates up to building a working Beta processor, with later material on caches, pipelining, virtual memory, and multiprocessing. Lectures and materials are available free on MIT OpenCourseWare, and edX MITx versions also exist.
Commenters call it an excellent, clear walk through abstraction layers from 1s and 0s up to a CPU, and say it shaped their careers in systems work.
CS Fundamentals & Systemsintermediatefreemixed#computer architecture#digital logic#cpu design#pipelining#caches#beta processor
Recommendations by year
20062026
Wow, no idea highlights existed. Glad you used this opportunity to …uhh… highlight it via this great post.
I was at MIT just before this switch, and treasure having gotten to take these deep dive courses, even if .002 and .003 kicked my ass.
6.004 (followed up by 6.033) is probably the course that really drove my career into systems dev.
I was in Course 2 (Mechanical Engineering), but 6.004 and 6.033 were two of my favorite classes at MIT. As I remember, we spent 2 lectures covering many mistakes made in the Therac-25. We also covered the Ariane 5's first launch failure. We also covered a bunch of systems that made good design trade-offs and discussed their design spaces.
So that's part two of the 6.004 course. I'd highly recommend part one also, at least lectures 3 onward.
The course starts with making analog transistors and tweaking them into handling digital data. Then making gates and combining them into state machines and ALUs and slowly putting together the pieces of a full CPU.
The last third is adding caches, pipelining, virtual memory, multiprocessing, etc. It's useful too.
The class 6.004 at MIT basically steps through these abstractions one week/lab at a time. This was my favorite class in school. Each lab is a higher level of abstraction and eventually you've built a basic processor. It gives you a very clear picture of how "1s and 0s" can turn out to become what you see on your computer screen.
OCW Link: http://ocw.mit.edu/courses/electrical-engineering-and-comput...
They are excellent courses if your primary interest is elec engineering. 6.004 is prob the best course I took, all the lectures are online and course material from 2012. Of course you are missing recitation for many courses and TA access though. The assignments for 6.857 and lecture notes are really good for self learning too. As for a job you would have to prove your skills with a portfolio which is a repository of code you've done and develop for some open source project you are interested in. You might find job offers come to you by being helpful on their dev mailing list and somebody notices.
I'm currently auditing the Stanford compilers course online. I understand the inertia in introductory courses, and the simplicity of MIPS, but hopefully the course is eventually ported to Aarch64 or RISC-V. Presumably a spim-like simulator for Aarch64 or RISC-V is the biggest missing component.
6.004 was one of my favorite classes at MIT, and the DEC Alpha AXP was a fine architecture to simplify for the pedagogical Beta architecture. However, I'm glad to hear they've moved to RISC-V. I presume they'd been avoiding porting the course to Aarch64 (or a simplified version thereof) due to intellectual property issues.
You are welcome.
Please note that the MIT 6.828 is really tough but will turn you into a bad-ass C hacker.
It relies on MIT 6.004 - Computation Structures [1] (has edx mooc [2,3,4]) and MIT 6.033 - Computer Systems Engineering [5] as pre-requisites given that they teach you the fundamentals of computer architecture (digital abstraction, gates, circuits, processors, assembler, memory, cashes, pipelining, virtual memory, interrupts/io, buses, what have you) and system design (basically, managing complexity); they are not programming courses, but I recommend them if you have the time and interest, they are an awesome and principled way of learning the core concepts that you really need to have down before dabbling with OSs.
[1] https://ocw.mit.edu/courses/electrical-engineering-and-compu...
[2] https://courses.edx.org/courses/course-v1:MITx+6.004.1x_3+3T...
[3] https://courses.edx.org/courses/course-v1:MITx+6.004.2x+3T20...
[4] https://courses.edx.org/courses/course-v1:MITx+6.004.3x+2T20...
[5] https://ocw.mit.edu/courses/electrical-engineering-and-compu...
How do you feel, in retrospect, about 6.004? On the one hand, amazing class that takes you through multiple layers of abstraction. On the other hand, why oh why did they set the labs to be due at 6am?
(Of course, you could justly ask why oh why my sophomore-year-self didn't exercise discipline and cut myself off trying to improve my beta.)
I haven't taken the class, but have helped many friends through the course if they needed it.
The class is more of an introduction to programming using Python than a class about learning Python the language. They learned some things like sorting, searching, testing, basic hash tables, etc. However, the primary reasons the course exists are to see let students explore Computer Science or because their major requires that they take either 6.00 (This course) or 1.00 (Same type of course, but in Java.)
If you want to learn Python and you're an experienced programmer, this class will take you maybe a night or two to breeze through. I would recommend taking other courses on OCW instead though with a more specific focus. If you want basic-intermediate algorithms, take 6.006. If you want low-level, 6.004 is a great introduction. (If you want advanced algorithms, buy CLRS and take 6.046).
tl;dr: 6.00 is more for people that have never programmed anything before, not to learn Python.
Awesome! The intro computer architecture class at MIT (6.004) actually does this same thing over the course of the term. (http://6004.csail.mit.edu/). Of course it's not just NANDs, but the basic idea is working from the FET level in the first lab, then building up abstractions each subsequent lab until a Beta processor is built by the 6th. You might find some of the resources on that website helpful. Everything is built using a program one of the professors built where you define lists of components and subcircuits. Good luck!
For low level software architecture, at the level of the firmware that drives processors (plus the electronics that are below that), as NonEUCitizen recommended MIT's 6.004 is a good bet (http://ocw.mit.edu/courses/electrical-engineering-and-comput...).
For the medium level, assembly language and on up a fair bit (at least to C), CMU's got what looks like a great course and book: http://www.cs.cmu.edu/~213/ There's enough meat on the web page for the course that it should give you an idea if you want to get the book.
For the higher levels, in addition to the MIT Computer System Engineering courses mentioned by Mithrandir (http://news.ycombinator.com/item?id=1850311), especially 6.033, check out this classic from the '70s: Lions' Commentary on UNIX 6th Edition, with Source Code (http://en.wikipedia.org/wiki/Lions%27_Commentary_on_UNIX_6th...).
Me and a lot of other people learned the basics from it, and while it's certainly dated, it has the advantage of being lucid and complete while not being too big or overwhelming, and of course nowadays if you want to go so far as running a Version 6 UNIX there are PDP-11 simulators that you can use for the purpose. I.e. it's a good foundation, like SICP is for languages and TAOCP is for algorithms (although there are less detailed and difficult books to get you started on algorithms that you might want to try first).
Good luck and enjoy!
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.