
Ask HN: How Sound Is the “Teach Yourself CS” Learning Resource? - rxsel
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.<p>This is the resource in question:  <a href="https:&#x2F;&#x2F;teachyourselfcs.com&#x2F;" rel="nofollow">https:&#x2F;&#x2F;teachyourselfcs.com&#x2F;</a>
======
ozanonay
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.

~~~
TheAceOfHearts
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](http://csapp.cs.cmu.edu/3e/errata.html)

~~~
Lesabotsy
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?

~~~
TheAceOfHearts
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/](https://dreamanddead.gitbooks.io/csapp-3e-solutions/content/)

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

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

~~~
zeta0134
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."

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

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

~~~
eru
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/](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](https://homepages.cwi.nl/~lex/files/book.pdf)
for the list of contents.

~~~
epelesis
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...](https://courses.engr.illinois.edu/cs374/fa2019/A/schedule.html)

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

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

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

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

[https://www.jameskerti.com/omscs-georgia-
tech/](https://www.jameskerti.com/omscs-georgia-tech/)

Any comment on this from your perspective?

~~~
bryanwb
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](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.

------
jshowa3
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...](https://ocw.mit.edu/courses/mathematics/18-404j-theory-of-
computation-fall-2006/)

Or reading this book:
[https://tinyurl.com/rm6bgws](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](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.

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

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

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

[https://www.dictionary.com/browse/soundness](https://www.dictionary.com/browse/soundness)

------
8589934591
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/](https://bradfieldcs.com/courses/) These are
the makers of [https://teachyourselfcs.com/](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.

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

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

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

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

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

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

------
gabrielrdz
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/)
[https://bigmachine.io/products/the-imposters-handbook-
season...](https://bigmachine.io/products/the-imposters-handbook-season-2/)

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

~~~
52-6F-62
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.

------
bambataa
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](https://thecomputersciencebook.com). I'd
be grateful for any feedback.

------
klundqist
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...](https://www.edx.org/course/cs50s-introduction-to-computer-science)

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

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

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

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

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

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

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

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

------
danesparza
Hint: Impostor syndrome is a thing (see
[https://www.hanselman.com/blog/ImAPhonyAreYou.aspx](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!

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

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

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

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

------
mesaframe
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/](https://holub.com/compiler/)

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

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

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

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

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

------
drfuchs
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!

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

[https://www.afternerd.com/blog/learn-computer-
science/](https://www.afternerd.com/blog/learn-computer-science/)

PS: not my own website

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

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

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

