Hacker News new | past | comments | ask | show | jobs | submit login
Ask HN: How Sound Is the “Teach Yourself CS” Learning Resource?
360 points by rxsel on Feb 10, 2020 | hide | past | favorite | 76 comments
I’m a SR. Dev at a big company we all know trying to rid myself of the insecurities that come from an informal education.

This is the resource in question: https://teachyourselfcs.com/

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.

[0] http://csapp.cs.cmu.edu/3e/errata.html

> We have not created an errata for this edition.

Lame. Their names are still on the front cover.

I got offered the 2nd Edition few month ago, still worth the read or should I buy the 3rd to get the most out of it?

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].

[0] https://dreamanddead.gitbooks.io/csapp-3e-solutions/content/

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.

[0] https://dreamanddead.gitbooks.io/csapp-3e-solutions/content/

[1] https://www.pearson.com/us/higher-education/product/Bryant-I...

+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?

>Architecture of a Database System


>Database Internals

We used CS:APP for a relatively broad first-year Intro to Systems class; I'm not sure it replaces a dedicated computer architecture textbook.

The Binary Bomb lab from CS:APP was the most fun and memorable homework assignment from all of undergrad.

You should add a resource on computational theory. Discussions of P-NP, finite automata, decision problems, etc.

Check out Introduction to the Theory of Computation by Michael Sipser: https://smile.amazon.com/Introduction-Theory-Computation-Sip...

Lagunita appears to be retiring on March 26 2020. Are there any alternatives you'd suggest for the courses on Lagunita?

Thanks for creating such a fantastic resource!

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.

For math and computer science, a good rule of thumb is to treat the exercises as the primary way to learn, and to refer to the rest of the text as support to help you with the exercises.

That extends to reading academic papers; but there you have to come up with your own exercises.

(I say rule-of-thumb, because it's a good approach, but please don't take it as gospel.)

You don't need to do 100% of the exercises. A random selection is usually sufficient: the goal is to get good enough that you _could_ do any of the exercises.

The nice thing about this approach is admitting that it's _okay_ if you skip an exercise you're struggling with. It can be a little frustrating at times, and feed a little bit into that insecurity, but a key realization is that one programmer can't possibly know everything. Not in this field, it's way too big. So, skip it! If it bugs you, come back to it in a month or so and you'll be surprised at how much easier it is on a second pass. Or, you'll have such a strong grasp of the language that you'll see, "Ah, there's the fundamental element I don't understand, here's what I can search for, or who I can ask to point me in the right direction."

I agree, but only if you tried really hard. I believe that the main benefit of exercises is not so much getting the right answer (who cares anyway?), but the fact that they made you go over and over again over the concepts, forcing you to really understand, to reread your notes, and to apply them, even if you fail at first. If you do this, it will stick, and, as you said, the next time you come across said concept you will be much more likely to get the subtleties and, suddenly, that mother of a problem becomes trivial.

I'd argue that you shouldn't do 100% of the exercises, or even nearly all of them.

With mathematical subjects, the best way to revise is to go back and do more exercises. So leave some there to go back to!

Isn't this true for just about any skill, not just math and computer science? You're only going to get better at tennis by playing tennis. Or piano. Or woodworking. Or communication skills. Best way of learning is actually doing the thing, not reading about doing the thing.

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.

Sounds like you would make a good mathematician.

I had a very similar reaction to the much vaunted 'Algorithm Design Manual'. It was all fluff with not much substance.

I found http://jeffe.cs.illinois.edu/teaching/algorithms/ pretty good for an overview over Algorithms.

If you like something in a similar vein to TAOCP, the book 'Combinatorial Optimization' by Alexander Schrijver fits the bill. It teaches you everything you ever wanted to know and then some on the mathematics behind problems in P. Just like TAOCP it is also a detailed overview over known results. See https://homepages.cwi.nl/~lex/files/book.pdf for the list of contents.

I'm taking Jeff's 473 class right now and if you like his writing style, all of his lectures for both algorithms classes he teaches are online as videos - it can be a good companion to the textbook if you want worked examples. [my video] links should be raw MP4's that are not password protected.

374 (Introduction to Algorithms Videos): https://courses.engr.illinois.edu/cs374/fa2019/A/schedule.ht...

473 (Algorithms Videos): https://courses.engr.illinois.edu/cs473/sp2020/lectures.html

Thanks! I don't really like videos for math-y content, but I have recommended his books to people who will definitely appreciate the videos.

Btw, I tried to reach out to Jeff for a linear time solution to an exercise in the chapter on matroids in section 8.2. It's about 'Scheduling with Deadlines', and his best solution is O(n log n).

But alas, I never got a reply.

For those interested in hash tables I found the Hash Tables section of Crafting Interpreters pretty good[0]. It has a section on hashing, which supplemented with this SE post[1], I've found to be comprehensive enough. Of course, if you aren't familar with binary/basic bit manipulation, you may still find the internals of the hashing functions mentioned slightly confusing.

[0] https://craftinginterpreters.com/hash-tables.html

[1] https://softwareengineering.stackexchange.com/questions/4955...

I haven't ever had to worry about how hashing functions work beyond knowing a few of the basic qualities of a good hashing function. I guess most students were like me in that they don't worry about those details because even though you call them fundamental, I think most programmers get by perfectly fine without knowing how a hash tables works as long as they know how and when to use one.

I did have a formal CS education, and I still got a lot out of TAOCP even years later. You’re right that it really covers details that you just can’t find anywhere else, and every single exercise has worked-out solutions in the back, unlike a lot of the pretentious textbooks out there.

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.

Searching for OMSCS on ddg, the second link, gives me a guys perspective on why he had to quit after joining OMSCS -


Any comment on this from your perspective?

The quality of courses varies wildly. Some courses were created by profs that have since moved on and are run by TAs who don't care. Those also happen to be the easier courses.

Some classes are very poorly run. However, you can avoid those courses. There are reviews of all courses on https://omscentral.com/courses

I took Machine Learning for Trading (basically intro to ML) and enjoyed it tremendously even though the prof has since moved on.

I also took High perf Computer Architecture - basically graduate computer architecture - and enjoyed it immensely even though the professor was not active. We had a great TA, exams were insanely hard but gr8 test of knowledge, and I learned a ton from classmates. One classmate was an actual hardware engineer on PowerPC. I learned so much from him.

Most classes have active Slack channels w/ active discussions at all hours. Those channels alone are worth joining the OMSCS IMO.

Is there something similar to this for someone without a bachelors degree?

I think Oregon State does but I suspect the quality of online CS programs drops radically quality from OMSCS.

CS graduate here.

Can confirm this site is legit. These are all standard recommended texts in CS curriculum.

You could probably substitute SICP with other modern language text books on programming, but you're not really starting from square one so I'd skip to data structures and algorithms.

That being said, from my limited experience with SICP, it's very good. Even the old MIT lectures are good. And it gives you exposure to a functional language.

The only thing glaringly missing is computational theory which you can acquire this by going here: https://ocw.mit.edu/courses/mathematics/18-404j-theory-of-co...

Or reading this book: https://tinyurl.com/rm6bgws. It's the one I used in my studies and it isn't that great.

This book is apparently good because it's less wordy: https://cs.uwaterloo.ca/~shallit/second.html

WARNING: This stuff is very difficult to learn on your own. It takes a considerable amount of time to master and it would be worth it to go to university for support. You will often find that many of this stuff is not directly applicable to the workforce unless you're entering research positions. That being said, if you're a genius, unlike me, and extremely dedicated and consistent (also not me) you probably won't have any difficulty.

I've not taken the MIT course or read the second book so I can't vouch for its quality.

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.

> I'm not sure what you mean by "sound"

The word in this context roughly means "good" or "correct".


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'm currently close to finishing their course on computer architecture. I'm self-taught; for me, it has been absolutely worth the money. I had learned a bit of architecture on my own, but the course has given me the kind of clarity that would have been very hard to get on my own. The syllabus is really good, it's practical, classes build up on previous classes. That gives you a solid understanding of all the components in a system. When I'd studied on my own, I spent too much time in specific areas that weren't _that_ useful for a software engineer. Oz himself is extremely approachable and the other students are really smart too.

Keep in mind though that it's ~18 hours of classes with ~3 hours of post-class and pre-class work per week. With any class like this, I've found that it's really important to actually do the pre-class and post-class work, especially the practical work -- it reinforces what you've learned in a class, helps you notice the gaps in your understanding and ask better questions.

I just want to second #2. It's what took me from casual coding to serious development.

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.

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.

I appreciate this example. I have witnessed a situation where a monk from Thailand was learning english by reading words pronouncing them how he imagined them to be in his own dialect. Nobody could understand the lectures he was leading about inner peace and presence.

On the find masters before reading the book: It's a difficult chore to do if you're not in a university I guess - you would need to have a really skilled colleague helping you out otherwise.

Either way, by reading summaries of the books written by other people could give a great insights of what others found the best that you could apply to your own.

Plus, in a University setting you get classmates, this allows you to evaluate yourself against your peers. When I was in Uni for my CS, I often thought that I am dumb because I was struggling with homework assignments. Later in class I would end up doing exceptionally well on quizes/tests. This was my aha moment. Now, I know most struggle with CS concepts, algorithms, data structures at some point and we all struggle at work, have to google and so on.

It is important to know because I often felt like maybe I was wasting my time. This stupid thing took 3 hours.

> 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.

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.

Posting this since I don't see it mentioned yet.

Scott Hanselman and Rob Conery created the Imposters Handbook. I believe both of these guys are self-taught, and they are incredibly good at what they do.

They put it together precisely for self taught developers with no formal CS background.

https://bigmachine.io/products/the-imposters-handbook/ https://bigmachine.io/products/the-imposters-handbook-season...

It looks OK.


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.

I think the reason for resources like this, in spite of the time commitments, is the financial constraints of returning to school at an older age when you may have: mortgage/rent, carried CC/LOC debt, kids, car payments, etc etc.

It's definitely a very good resource and it's been a great help to guide my learning. It's definitely still a huge commitment in time (and textbooks!).

I've been working on a single volume introduction to computer science. The first chapter (on theory of computation) is available free on https://thecomputersciencebook.com. I'd be grateful for any feedback.

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...

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.

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.

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).


Many of these helped me internationalize my CS education taught in Turkish language. Highly recommend all!

Typo: should be How to Code instead of How to Program, in edx from UBCx.

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.

For what it's worth, I've had a decent career as a self-taught programmer. Over the years, I've absorbed most of a Cs education in the following way:

Whenever I approach a new problem that I don't understand, I take the time to read up on the principles and original work that led to the standard approach to that problem. If the papers reference something I don't understand, I look that up, and so on.

I was doing this before the internet became a useful resource (lots of Library time). it's become much easier now.

It also helps to have a mentor or two who understand the area you're interested in, and who don't mind you taking their time with endless questions.

Generally the hardest part of self teaching is the ability to stick to it. CS is generally complicated and long. It takes lots of self control to finish.

You should make sure you keep that in mind and make a plan so you will finish.

Good luck.

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.

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!

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.

You said it's terrible but did not state why!

I found it to be too academic, too high-level - and too top down! I had already read TCP/IP illustrated before I took the class, so I had no trouble intuiting what the authors were trying to say, but I was in class with a lot of people who had no real exposure to network concepts outside of surfing the web, and they were all horribly confused by the abstraction in the book. I wouldn’t even say it’s worth coming back to after you’ve read a better networking book: I didn’t learn anything from it that I didn’t already know.

On the other hand I would say, I learned a lot from this book. I too had no exposure to network concepts but after finishing half the book I learned a lot.

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/

> Except for P&H. As mentioned in comment he now recommends CS:APP

P&H is “Patterson & Hennesy” (Computer Organization and Design), right? I gotta say, having read both, I think they cover different ground and I wouldn’t say that once replaces the other. P&H is more hardware with a nod to software and CS:APP is more software with a nod to hardware; you won’t get a really deep understanding of instruction pipelining from CS:APP, nor will you really get great coverage of linking and loading from P&H. If you’re going to do it, read both.

I dearly agree with you. But, given an options between two I'll chose CSS:APP. Reason being it being more close to software.

I'll like to say that I had the same observation as you when went through both. I almost felt like I wrote the comment.

That's true - you're definitely correct that P&H is more of a "nice to have" for a developer.

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.

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.

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!

This article is well structured and I can say its one of the best resource guidance:


PS: not my own website

Off topic: weird HN bug?

I see this item on front page as item #12 and on the second page as item #39. The latter was posted 14hrs ago and former 7hrs ago (10:35am PST) — both have the same item id.

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

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

Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact