Ask HN: How Sound Is the “Teach Yourself CS” Learning Resource?

Looks about right. FWIW, I'm a CS student at a top CS school in US and we use all the same textbooks as the website recommends.

Pretty good! My CS degree focused most on math, algorithm, data structures, programming, and computer architecture.

The other topics I don't really think of as computer science, more as electives a CS student might take.

Looks like a fantastic resource and covers all the fundamental concepts to get you started on your CS path. Highly recommended!

If the goal is resolving insecurities, I don't know if the site will help. If the goal is to learn more about computer science topics that haven't been studied previously, it will help. I can say this as someone who has used many of the resources on that site.

I've followed this curriculum for the past two years and I can report back that it will rid yourself of those insecurities. But I don't recommend following it to the letter. I used it as a starting point for each topic and then found multiple text books, university curriculums and hands on projects that fit my style of learning. For example, everyone recommends SICP, but I had a hard time staying with the original text book. Both Berkley and MIT have great video lectures based on the book and updated lectures based on Python. Watching both of these gave me a good understanding of the core of what SCIP really was trying to communicate. I later went back and went through the book, but used Racket as the scheme flavor and became familiar with that world.

Looks great. But just to clarify: in the context of a CS program, it's not about reading and retaining the entire books cover-to-cover, retaining everything, or doing 100% of the exercises. The professor will assign specific readings and exercises that track the lectures. Some will not use the textbook's exercises at all, and instead build their own homework assignments. You can typically find a PDF describing the assignment on a course's website, along with starter code. Typically there's a test suite that does automated grading. If you're lucky, you'll be able to obtain that and run it locally without a university login.

I spent the vast majority of my time and effort on the programming assignments, and while I did the readings, I didn't pore over the books that closely except when stuck. IMO, that's the way to do it. You want to think of programming projects, not books, as primary.

The part of my CS education I loved and still cherish was the evenings in the library with project partners, triumphantly flushing out one last segfault moments before the 11:59pm submission deadline.

It's fantastic. I loosely followed it for a few years to get better at interviewing (Note: For interviews, you generally need data structures and algorithms knowledge).

Now I'm following it pretty closely while selecting classes for my software engineering master's degree.

FWIW, when I was trying to rid myself of similar insecurities, I went through a bunch of courses like this one, but none of them worked out for me.

The challenge was that the textbooks and material that is popular among University CS courses leave a lot of unanswered questions that I couldn't get over. For example, when I came to hash tables while studying data structures, I couldn't figure out how the hashing functions did their magic. Every book or online lecture I came across showed how to use a generic hashing function and moved on to dealing with hash conflicts. I couldn't move on because I kept coming back to questions like "ok, but why this hashing function? If I change my data a little bit, is this still the right hashing function to use? How can I tell?"

Somehow, people who had formal education managed to sail past these questions. I suspect that having someone to answer these questions when they came up played a crucial role in them understanding the material.

My point is, some of these materials are almost deliberately designed to be consumed with an instructor who can answer questions. Especially for the difficult courses.

In the end, when I was teaching myself the basics, I had to go hardcore and pick up TAOCP to keep up. TAOCP has a reputation for being a very dense reference book and being unsuitable for self study - but I found the opposite to be true. Prof. Knuth painstakingly covers every minor detail leaving nothing unaddressed. (His treatment on hash tables has several pages on hashing functions that gave me a clear understanding of how things work). I would recommend following that path if you are trying to study the basics without formal instruction. It's a little harder, but you are more likely to end up successfully digesting the fundamentals and move on to more advanced topics.

Today, I have fully rod myself of insecurities, and I have developed a habit of going to the most comprehensive treatment of a topic if I'm trying to teach myself something difficult. For easy subjects, textbooks popular in Universities is usually good enough. For difficult stuff, I prefer going hardcore.

Be aware of textbooks designed to work with formal instruction.

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.

I must say all the book suggestions are really great. Except for P&H. As mentioned in comment he now recommends CS:APP over it and I would do too.

Also, for compilers I would suggest C compiler design [1]. It provides both implementation and theory instead of just theory which the dragon book does.

[1] https://holub.com/compiler/

> Aim for 100-200 hours of study of each topic [...]

Well, for some of those books you might definitely need more time (for example SICP) to get through and do all the exercises plus the required thinking and post processing to understand the essence of them. For SICP 100h and even 200h might be only a quick fly through the 800 something pages, without really having done the exercises (oneself, without looking at solutions, plus perhaps writing tests, spending more time at an exercise when one does not get the solution right away ...) and really having understood the material. Sometimes, when I did not understand some part of SICP of the 40% of what I did of it, I spent a lazy day or two on one exercise, just to be able to understand better and not need to look at solutions online. Sometimes I would hunt bugs for a while too. From that point of view the list seems a bit dubious.

I don't know many of the books or lectures listed, so I cannot say much about the other books or lectures. Just hope, that the other material in the list is not that voluminous.

Something that is missing in the list: Modelling languages and their semantics and all that goes with that. At least where I learned that was a major part of CS, because it is critical in analyzing software and modelling software for development. It is also something, which is often very much lacking in software projects found in the wild, making understanding of the software way harder than it needs to be on the conceptual level. We really ought to draw more diagrams! Also I am guilty of not often putting a diagram in my repositories as well, even if I drew some for myself. Sometimes a diagram pieced together from all the parts I do understand about some program is the only way for me to finally understand the whole program. Good to take this as a personal reminder for myself.

It is a great reference, but, IMHO, there are some alternatives that I prefer:

Programming: I would instead prefer the combo "How To Program", don't be fooled by the name, this course is the business (which will give you a rock solid foundation in systematic program design, TDD, clean coding and recursion, but most importantly, you will understand exactly why you should design your data abstractions first, because they will structure your functions), followed by "Software Construction in Java", which will give you a rock solid and principled software engineering foundation (writing industrial strength tests, specs, ADTs, mutability, grammars, concurrency, the works). Both are free in edx (also check out the latter's ocw version, 6.005). As a bonus, check out Daniel Jackson's approach to software design in ocw's 6.005 from 2008, and how he explains three approaches to software design (state machines, functional and relational/OO). The best and most systematic explanation that I know of how to properly use the much maligned Design Patterns, and a very useful in practice design technique called JSP (although the course is in Java, all the design techniques are universal, this JSP stands for "Jackson Structured Programming").

Computer Architecture: the MIT combo "Computation Structures" (on edx) and "Computer System Engineering" (on ocw and youtube) will teach you systems design all the way from atoms to the whole internet. Great instructors.

Algorithms and Data Structures: again from MIT, on OCW (as 6.006, with videos, recitations and assignments in Python), a good balance between theory and practice. The dark horse here is the TA Victor Costan, who won several European level coding competitions as a kid, and will teach you algorithm design in practice. Eric Demain's lectures on Dynamic Programming should become the reference, his "5 steps" approach is amazing.

Operating Systems: mit's 6.828, from 2011 (has videos for all lectures). You will have to read and understand all 10.000 lines of code of an old Unix (with support from the lectures), and write a large portion of you own OS.

Databases: I would have a look at CMU's inspiring Andy Pavlo course (on youtube), just watch his intro lecture from 2018 to get a taste. Also have a look MIT's 6.813 from 2014 (some vids), created by Stonebraker, with substantial assignments based on SimpleDB (in Java, if you prefer it over CMU's C++).

Distributed Systems: MIT's 2015 6.824, by Morris (of the worm). Great text notes, and many lectures on youtube. Assignments in Go, where you will implement your own Raft and a distributed key-value store.

Some extras:

Cryptography: Paar's explanations on youtube are crystal clear.

Data Science: Berkeley's Data8 (2016, may seem basic, but the instructor is amazing and you will learn how to look at data), followed by Data100 (summer 2019, more technical, with Python tools on Jupyter galore). Will give you good intuition if you don't know much stats, and to really worry about your data samples (bias!) (garbage in, garbage out, not sure if this cliche is ever mentioned in these courses, but you will understand exactly how or why, and how to avoid it, or, at the very least, to tune your BS detector).

etc

I followed that curriculum and it sorted me out with regards to algorithms and networking. I recommend it very highly.

The idea is that once you have read these books you have the knowledge needed to identify what kind of problem you have in front of you, what tools are known to solve it, what are their disadvantages, and most importantly what should you search for to find out more about the problem.

This is very good stuff. I'd also recommend CS50x, [1] the Intro to Computer Science from Harvard for those who need an intro before diving deeper, as it gives a solid grounding in most of these topics.

[1] https://www.edx.org/course/cs50s-introduction-to-computer-sc...

I really like the resource but some of the courses I prefer some alternatives.

1. Programming - IntroCS by princeton - available on coursera with videos and graded assignments. If you require a slightly easier course, then you can check out CS61A from Berkeley or MIT's Intro course in python.

2. Algorithms and Data Structures - Princeton 2 courses in algorithms - coursera. Alongwith their book and booksite this was a very good resource for me with their graded assignments. I also would suggest CS61B from berkeley.

3. Databases - I started learning from Stanford Widom's course, but now I actually recommend CMU's course. I have heard good reviews for berkeley's course CS186 as well.

Side Note:

https://bradfieldcs.com/courses/ These are the makers of https://teachyourselfcs.com/. I notice that there are many courses, but at the same time $1800 per course is a bit too much considering USD conversion. So, I am looking for reviews if anyone has taken it, and whether the cost is justified. On the fence of joining it because of the cost.

I think the books are very sound but that doesn't mean following program will work for you. It really requires you to study well in isolation without anyone else to ask questions of or discuss ideas with. I tried to follow that same program but couldn't stick to it. After failing to stick with it, I enrolled in Georgia Tech's OMSCS. I am halfway through and I can't recommend it enough. That said it is a shit ton of work. The real value that I get from the OMSCS are my discussions with fellow students and professors, something you can't get from self-study.

I am currently taking the compiler course (CS-8803) and there is no way in the world I put this much work into a self-study project. I spend roughly 30 hours per week on it.

I am looking to read more about business; would love something similar for an MBA.

If I lacked a formal CS education and wanted to understand more, I would focus on algorithms. They are the foundation of everything at the software layer. The two basic questions you will learn to answer:

  Is a certain solution to a problem correct? 
  Can we make it faster or more efficient? 

Understanding algorithms doesn't really matter unless you need to scale or be very efficient, but when that is important, a good understanding of algorithms will be invaluable to you and your employers.

Also, this is the only major difference I've noticed between people with a good, theoretical CS degree and those without one. All the other skills are about the same.

This is a good resource BUT nothing compared with the interactivity that having someone with decades of experience in the industry gives you.

At a University you have a constant feedback loop of your knowledge being evaluated by people with experience.

A good teacher can give you this global view of a subset of what is really important very fast, so you follow Pareto's principle, you use it,you get more interested,you get deeper. This way you become continuously engaged.

Imagine you want to read "Structure an interpretation of computer programs". It is a jewel book, but if you read it you will not understand 95% of it, or what this academic stuff has anything to do with the real world.

You need someone with experience that tells you: You spent three weeks making this project, let's make it in two hours with this technology.

Of course it has taken years for this person to do in two hours what takes you weeks of work, and it will take you also years to be able to do that on the same level.

BUT if you read the most important content of this book, study and apply it over a week, you will be able to reduce the work from three weeks to a single week with one week of effort.

With a small effort you can get great rewards. That is pareto's Principle.

But you can not study only the most important principles of a book if you don't really know what is important and what is not. That is what a master knows.

Imagine that you study English as a foreign student by a book and you study words like "persistence" or "clairvoyance" at the same time you study "make","do", "he" or "she".

Worse, imagine that you study all the words but you don't study how they sound, so you make an idea in your head of the sound of the words based on your native language. Now every new word you learn, you learn it with the wrong sound.

You need someone telling you: Stop reading the book and do this and then you will understand what the book says, then follow this other part of the book.

Having a mentor or master of course is expensive, and that is the reason Universities exist, so masters could be shared and prices go down.

If you dot have direct access to a master, I recommend that you follow lectures of masters before you read X book.

It looks OK.

But:

teachyourselfcs.com has actually quite a lot of advanced reading and practical work buried in it. For the many thousands of hours that you would have to invest to do teachyourselfcs.com justice, you could quite easily complete a CS course at university.

Related question: How can I assess my level of knowledge?

I am also a Senior SWE at a large, famous company with an Electrical and Computer Engineering background, so I had a substantial amount of overlap with the typical CS curriculum with the notable exception of a compiler class.

All the books are great recommendations, except for Computer Networking (Kurose & Ross). That was the textbook we used when I was in grad school, and it was terrible. The best book on networking I’ve ever read was TCP/IP illustrated - it’s a bit out-of-date, but once you read it, you’ll understand the core networking concepts well enough to figure out the current state of modern computer networks.

I'm not sure what you mean by "sound" but it does cover a number of topics broadly which is usually what you get with a CS education.

Be aware though that you will get a vastly different CS education depending on which school you go to. It's a very broad field and different approaches pick from different branches of mathematics along the way.

If general ability is what you'd like to improve I'd add a bit of the more general mathematics to your repertoire: set theory, logic and predicate calculus, discrete mathematics, category theory, and type theory. Dip into calculus, linear and abstract algebra, information theory, semantics, and other specialized fields when you find a subject and specialization that tickles your fancy.

My reasoning there is that while the languages and technologies change, the foundations of math don't change as much, and it will help you reason about the problem you're looking at.

Information theory, for example, will help you understand the limits of compression and transmission. If you're working in networking or file storage this is useful stuff to know as there are lots of people who will make wild claims about a new compression algorithm that sounds way too good to me true. If you have a decent understanding of information theory there's a good chance you won't even need to see the code to debunk the claim. And it's also useful if you're working on some code and it's not performing up to your expectations: you know, because of the theory, that the transmission rate isn't what it could be and that gives a good start for debugging your algorithms points you to the design of your system.

Mathematics is your candle. It'll help light the way in a dark room where the dark room is your lack of knowledge and experience in a particular problem domain.

Hint: Impostor syndrome is a thing (see https://www.hanselman.com/blog/ImAPhonyAreYou.aspx for more information). Taking these courses probably won't fix that.

But there is most likely nothing wrong with these courses. Just looking at the programming section: MIT and Berkeley are no slouches when it comes to CS!

None of the content seems to cover Turing Machines and The Halting Problem, and all the rest of the Automata and Language Hierarchy stuff in, say, Ullman's "Introduction to Automata Theory, Languages, and Computation"? Computer Science, indeed!