Ask HN: How Sound Is the “Teach Yourself CS” Learning Resource?
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/
This is the resource in question: https://teachyourselfcs.com/
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 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.
>Architecture of a Database System
or
>Database Internals
> 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.
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...
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/
Lame. Their names are still on the front cover.
The Binary Bomb lab from CS:APP was the most fun and memorable homework assignment from all of undergrad.
https://henrikwarne.com/2019/07/27/book-review-designing-dat...
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.
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.
With mathematical subjects, the best way to revise is to go back and do more exercises. So leave some there to go back to!
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.
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.
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
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.
[0] https://craftinginterpreters.com/hash-tables.html
[1] https://softwareengineering.stackexchange.com/questions/4955...
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.
https://www.jameskerti.com/omscs-georgia-tech/
Any comment on this from your perspective?
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.
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.
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.
The word in this context roughly means "good" or "correct".
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.
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.
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 is important to know because I often felt like maybe I was wasting my time. This stupid thing took 3 hours.
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.
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.
Is a certain solution to a problem correct?
Can we make it faster or more efficient?
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.
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...
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.
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.
[1] https://www.edx.org/course/cs50s-introduction-to-computer-sc...
Now I'm following it pretty closely while selecting classes for my software engineering master's degree.
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 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.
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.
You should make sure you keep that in mind and make a plan so you will finish.
Good luck.
The other topics I don't really think of as computer science, more as electives a CS student might take.
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!
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.
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'll like to say that I had the same observation as you when went through both. I almost felt like I wrote the comment.
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.
https://www.afternerd.com/blog/learn-computer-science/
PS: not my own website
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.