Bradfield founder here: thanks for the recommendation but it's really not true that "most of [the course material] comes from CS:APP". It's a great book—which is why I recommend it so strongly in teachyourselfcs.com—but we use it only as a supplementary resource, for one of the eight courses we teach.
As the author of Teach Yourself CS I would definitely suggest against trying to fit this in a year! Maybe aim for CS:APP and 1-2 others, and if you have time for more that's a bonus. Most of these are books to work through, not "read".
Thanks for writing it. Yes, definitely didn't mean to imply that it could be done in just a year, just that it's a useful resource in general that people might not know about.
This guide has been posted to HN a number of times by others, typically with a very positive response.
I recently made a major update, in particular: strongly recommending _Computer Systems: A Programmer's Perspective_ and _Designing Data-Intensive Applications_; recommending _Crafting Interpreters_ over the Dragon Book for those new to compilers; updating a number of broken links (due to shutdown of Lagunita); and, adding a few secondary recommendations
Hi there, I'm the author. Yes this list precisely constitutes the topics in computer science on which I believe a software engineer with an informal education should focus. It's based on my experience of having taught computer science to over 1,000 junior to mid-level engineers, mostly bootcamp grads, in person in small classes over the last 5 years.
I've been meaning to update it slightly, to recommend _Computer Systems: A Programmer's Perspective_ over P&H (although P&H is still excellent) as well as Martin Kleppmann's book _Designing Data-Intensive Applications_ for distributed systems.
For anyone looking to pick up Computer Systems: A Programmer's Perspective, you should probably avoid the Global Edition. From the author's website [0]:
> Note on the Global Edition: Unfortunately, the publisher arranged for the generation of a different set of practice and homework problems in the global edition. The person doing this didn't do a very good job, and so these problems and their solutions have many errors. We have not created an errata for this edition.
If you can't afford the book, it seems like the First North American Edition is available on the Internet Archive, although I'm uncertain of its legality. Remember to support the authors, if not now then hopefully in the future after you get a high paying software engineering job.
I haven't read each edition in order to make a comparison. However, it's probably worth mentioning that, unlike the 3rd edition, the solution manuals for both the 1st and 2nd editions can easily be found online with a quick search. If you intend to sit down and start solving problems then the 2nd edition might be better, since you'd be able to check your answers against the solution manual.
Edit: I actually hadn't looked, but it looks like all the solutions for the 3rd edition are also available online [0].
This book looks interesting, but it's unfortunate that there's no way to get the instructor's book for the answers to the exercises. Sort of diminishes the value of the book for self-learners.
The solution manuals for the 1st and 2nd edition are both easily found online with a quick search. As for the 3rd edition, I was able to find this [0], although I haven't verified if their answers are correct.
But it would appear that you're correct that Pearson doesn't seem interested in selling the 3rd edition solution manual to anyone that isn't an instructor [1]. IMO, fuck their antiquated gate-keeping bullshit.
+1 for Designing Data-Intensive Applications by Martin Kleppmann. A fantastic book, one of the best computer science books I have read! Summary of it and why I like it here:
Hey - just wanted to point out that the webpage currently points to low-quality and potentially unauthorized recordings of 6.824, but it looks like the iteration of 6.824 being offered this semester is offering publicly available (and authorized) recordings of lectures! https://pdos.csail.mit.edu/6.824/schedule.html
This is a great resource, even better for having been honed by actual teaching experience.
I was actually about to suggest added Kleppmann to the list! I think some of the earlier chapters of Kleppmann might actually be good for the databases section as well. Probably the best discussion of transaction isolation that I've read anywhere.
Another recent book that's good for databases (and that might replace or complement the "Architecture of a Database System" paper) is _Database Internals_ by Alex Petrov (O'Reilly, 2019). Like Kleppmann it also covers distributed systems; indeed it's getting harder and harder to separate the two areas these days.
I am thinking of creating a toy DBMS implementation for practice. Since, I would be doing if in off time. I won't be having much time for reading. So, what would you recommend as a starting point?
Congratulations, this is great! I'm glad you'll be reaching an underserved group.
I hope, though, that you'll be honest with your students about what your program will deliver.[1] While it's currently still possible for many non-programmers to achieve upward mobility just by learning to code, there's a huge skill gap between those who can cobble together a few libraries to make a website, and those who understand theory/systems well enough to build something novel.
While compensation levels for both groups are currently still comparable, the steadily increasing supply of bootcamp grads and self-taught engineers could result in a pronounced bimodal distribution in a matter of years. Some subset of folk will have the motivation and resources to make the jump;[2] others may end up in end-user programming roles that pay poorly or aren't fulfilling.
Somebody entering your program should have a realistic view of what it takes to reach the parts of our industry that they hope to find themselves in. If they know that Modern Labor is step 0, and see themselves on a long road of learning and growth, they're likely to do very well!
[1] I wouldn't have worried about this, except that I've seen some bootcamps tell their students that they should consider themselves "senior" upon graduation, and that their skills are comparable or superior to graduates of top computer science programs.
[2] I run https://bradfieldcs.com and maintain https://teachyourselfcs.com, both of which aim to help such folk make the jump. As much as I try, many people aren't interested or driven enough to start, let alone persist for the years that it takes.
Great point, right now we're trying to filter for that desire to be in the field for a while, but ultimately I think we will add a lot of material that gets people ready for the long road ahead of learning. We see ourselves right now as a way to get a foothold, and climb from there.
Berkeley's CS 162 is great, and recordings are available on internet archive. There are some decent undergraduate textbooks these days too: OSTEP is particularly accessible and free online, and the Tom Anderson _Operating Systems: Principles and Practice_ book is solid.
I teach a course on database systems, including one class on distributed databases (like Dynamo and Spanner) and another on dataflow engines (like MapReduce/Hadoop and Spark).
Students seem to find the Dynamo paper to be the single most enlightening resource. It does a great job of explaining Amazon's use case and how the solution fits the problem. I also reference the relevant Red Book chapter and some students value that context.
It's worth noting that students are very comfortable with relational DBMSs by this point, both in theory and in practice. It quickly becomes clear to them that NoSQL is better called "no transactions", as they know the costs and benefits of various isolation levels in a traditional RDBMS. If you don't yet have an undergraduate-level background in database systems I'd encourage you to seek that out either first or at least along the way to understanding NoSQL systems. My recommendations for how to do this as a self-learner are up on https://teachyourselfcs.com.
Yet many non-relational systems do support ACID transactions across multiple resources. Just from Google there is Megastore, Cloud Datastore, Spanner, Cloud Firestore
