I'm looking for a good book on the fundamentals of CS

I had a good relantionship with Segdewick's books, before being turned off by Cormen a few times. They are less math focused, and overall have a beginner friendliness to them. They won't take you by the hand an explain things like you are 5, but nevertheless they are more easy to digest.

Also as a non-popular opinion in this current age, I recommend you to learn how to implement your algorithms in C, rather than an easier to grasp programming language. Even if you are probably not not going to program in C in your future career, understanding how memory management works will give you an edge later.

Also given C's loose style, you will also get some skills in organizing your code in a language that doesn't impose a lot of obvious constraints to the way you write your code. You will be able to build your own conventions, and evolve them once you get more skilled. Seeing what others are doing is also important.

Good luck!

PS: Don't fall into the macro trap, you will never get out. (inside joke).

"Foundations of Computer Science" by Aho and Ullman might fit your bill. Its focus is more on the concepts and principles of computing rather than math-centric CS theory. http://infolab.stanford.edu/~ullman/focs.html

Another nontraditional intro to computing worth mentioning is "Structure and Interpretation of Computer Programs" by Abelson and Sussman(s). It teaches programming concepts using the Lisp/Scheme language (seldom used any more), but does so brilliantly.

"Think Python: How to Think Like a Computer Scientist" by Downey might provide the right mix of computing concepts and programming practice.

If you do want a traditional intro to CS theory, two books that cover that topic well are: "Introduction to the Theory of Computation" by Sipser, and "Introduction to Automata Theory, Languages, and Computation" by Hopcroft, Motwani, and Ullman.

Three very good books that introduce algorithms are: "Introduction to Algorithms: A Creative Approach" by Manber, "The Algorithm Design Manual" by Skiena, and "Algorithms" by Sedgewick and Wayne.

Remember that CS theory doesn't age, so buying a used early edition of a textbook should serve your needs just as well as an new up-to-date edition.

Based on the description you give, you probably want a Data Structures/Algorithms intro.

The canonical Algorithms textbook is Introduction to Algorithms by Cormen et al. The MIT OpenCourseware course on Algorithms -- which includes videos and assignments -- follows along with that book: https://ocw.mit.edu/courses/electrical-engineering-and-compu...

Note: In your case, I'll recommend against SICP as a first resource, which is mentioned in some other comments. It's more of an introduction to functional programming. From your description, I'm not sure you need an intro to programming. And functional programming in particular is not really on the critical path of knowledge you'll need to muck about in VR land. It's not irrelevant, but it's not the critical path. An algorithms course probably is indispensable for that endeavor, though.

By all means, read SICP if you'd like. It's a great resource. But if you're trying to get from "I can program" to "hardcore hacking on VR stuff", step 1 is probably a decent algorithms course taught in the imperative style.

I'm currently going through TAOCP[1]. So far, seems pretty good (although I found one mistake in an exercise).

Also, I can never recommend Computer Systems: A Programmer's Perspective[1] enough. (Also features a rare mistakes in an exercise or two, but that's detail.)

And for network protocols, Comer's Internetworking with TCP/IP[3] was just great (you only need volume 1). I've read Stevens' books on socket and IPC programming in Unix, but didn't like them, so I also stayed away from TCP/IP Illustrated, but others have different opinions.

[1]: <https://www-cs-faculty.stanford.edu/~knuth/taocp.html>

[2]: <https://www.csapp.cs.cmu.edu/>

[3]: <https://www.pearson.com/us/higher-education/program/Comer-In...>

I highly recommend "An Introduction to General Systems Thinking, by Gerald Weinberg. An orthogonal piece of advice that I got from a different book of Gerald Weinbergs' is to learn 3 or 4 Very Different languages simultaneously, to grasp the enormous difference between them all. In 2021 I'd recommend C (lowest level other than assembler: 1st caveat, I haven't looked at Rust) and then at least one Lisp-family language that has Lots of Insane Silly Parentheses, which Paul Graham argues is the most powerful language (by far). I'd also choose Smalltalk and Python. Caveat 2: Every programmer will have an opinion on this list, but the main point is to get exposed to the diversity of languages. Also, I'd recommend listening to a lot of talks by Alan Kay. There is lots of fun and interesting stuff to learn from lots of different people, but Alan Kay has focussed on how do we develop stuff that is radically simple, radically powerful, and completely accessible to children as a tool for learning and exploration. His notion of 'object-oriented' (a term he invented) is completely different from how the term is used today.

Interested in what gets suggested here...

There are a lot of "CS Course Online" type suggestions posted on HN, which are great - but for those of us with full time jobs and lives it's just a non-starter to approach that quantity of material.

I'm also more of a hands on learner which is how I got to where I am - but at the same time I can appreciate and happily absorb a well written, thoughtful book... In other words, I only have time for high quality, and high information density.

My meta suggestion in answer to the author: Not to downplay the utility in general CS knowledge and fundamentals, but you already sound like you are driven and have a direction - I recommend you ride that wave and buy books or seek out material that's more specific and relevant to what you are doing right now. You will soak it up so easily when you have something right in front of you to apply it to or think about - it's an opportunity, you will work on different things throughout your working life and this opportunity may pass. Personally, I have found CS fundamentals work their way to the surface through research into these more domain specific things - although I still recognise I could have much better awareness if I tackled it head on as you are suggesting.

Algorithmics by David Harel is not much mentioned anymore, but it's really good if you can find it. An easy and inviting read, it was written as a popular book not a textbook but nevertheless covers many topics with very thorough and clear explanations, and also touches on history and culture. I recall there were several versions with different titles - Algorithmics: The Soul of Computing was, I think, a cut-down version.

Seconding Petzold's Code for hardware and low-level programming. Also seconding Downey's Think Python (which has appeared in several versions with different titles). It is an easy read but is a bit deeper than many introduction to Python books.

Also seconding Wirth's Algorithms + Data Structures = Programs but it requires a lot more concentration and study than the previous suggestions. It is also old-fashioned, from the late 1970s I think, uses Pascal as its programming language. It teaches and celebrates a rigorous, economical programming method and coding style which is not much in vogue any more.

”Code: The Hidden Language of Computer Hardware and Software” by Charles Petzold.

It will take you on a journey from a lightbulb to assembly language. It’s extremely well written and I wish there were more books like it.

I liked "Algorithms Unlocked" by Cormen (https://mitpress.mit.edu/books/algorithms-unlocked). It's the same author that co-wrote "Introduction to Algorithms" (or CLRS) that's referenced in a few other comments, but this one focuses on the what and why of algorithms and pulls samples from a few areas of interest.

It's not too long (~200 pages), so might be worth checking out before diving into one of the more comprehensive textbooks.

If you're interested in 3D programming, I found "3D Math Primer for Graphics and Game Development" to be the most accessible for the math fundamentals. I just discovered it's now available freely online as well: https://gamemath.com/.

A couple friends of mine in similar situations spoke very highly of The Imposter's Handbook (https://bigmachine.io/products/the-imposters-handbook/)

I have a CS degree and I still really enjoyed reading through the 1st ed. of the first volume. I haven't looked at what was done with the material since then.

My favorite CS book is structure and interpretation of computer programs.

I used it for one of my college CS classes. The book was written to be a semester class and MIT even has various offerings of their version of the course recorded and available on YouTube.

The book is online and available for free.

https://mitpress.mit.edu/sites/default/files/sicp/full-text/...

I can't recommend How to Design Programs (HtDP) enough.

The authors care deeply about not just the content, but the learning process itself. It may at times feel repetitious and even boring, but it's a principled introduction to CS which will set you up for success in ANY programming language. And the book is free online :)

https://htdp.org/

From here you can graduate to lower level programming concepts in C (or Rust), more practical languages like Ruby, Python or even Java for high level application design. Basically, it's time to learn about full-fledged memory management one way or another. Don't miss out on some type theory along the way, remembering that they are just codified data definitions and function signatures.

I haven't used it myself but have heard good things about the resources here - https://teachyourselfcs.com

Hope you're searching first, lots of book threads every few months here:

a month ago Ask HN: What are some of the best well-written books on computer science? https://news.ycombinator.com/item?id=29182386

3 months ago Ask HN: What are your top 5 favorite computer books? https://news.ycombinator.com/item?id=28308141

7 months ago Ask HN: Best book for software engineers (besides the well-known ones)? https://news.ycombinator.com/item?id=26833319

Structure and Interpretation of Computer Programs, by Abelson, Sussman, and Sussman.

Also known as "The Wizard Book" or "SICP".

The full text is legally available online[1], but I found it worthwhile to buy a copy.

There are at least two really good sets of video lectures to go with it if you are so inclined. Personally I enjoyed the ones from Berkeley.

[1]: https://mitpress.mit.edu/sites/default/files/sicp/index.html

Beware of the Cormen et al "Introduction to Algorithms". It's a good book. But while it says "introduction", it's typically used for like a third-year undergrad who has a fair amount of programming, data structures, and algorithm experience already. It's more about algorithm _analysis_ - that is, how to prove things about algorithms and formally establish their run-time/complexity bounds - than about how to use or write them. Probably not what you want to start with.

Knuth's Art of Computer Programming is even more hardcore than that, imho. Probably not what a beginner wants unless you want to dive right in to the deep end.

SICP is more accessible but still pretty textbook-y.

But I don't actually know what I'd recommend instead. I did a CS undergrad degree, so Cormen and other textbooks are how I learned. But I did that over 5 years with lots of professional help. Dunno what a good self-study-friendly alternative is.

Surprised no one seems to have mentioned the godfather of CS books, The C Programming Language by Brian Kernighan and Dennis Ritchie [0]. At first glance, it's a programming language book rather than a "computer science" book, but you probably won't think that by the time you're finished ...

First, every operating system you'll use - likely in your lifetime - is a giant mountain of C code. From the kernel all the way to the userspace utilities. As a programmer, your career will be forged on the shoulders of giants, and those giants wrote in C. So to understand how your machine works, you must learn C.

Second, K&R covers far more than just a language - it presents a system of thinking about computing. It covers algorithms for line counting, memory allocation, and the construction of linked lists. The techniques you learn for pointer manipulation will enable you to author implementations of data structures that are considerably more elegant and simple than the naive methods [2].

It contains fundamental, influential insights about the computer science field on nearly every page.

Still, I'd discourage you from writing C professionally if you can help it. Rust retains nearly all the advantages of C while abandoning its unsafe memory model and replacing it with compile-time determined allocations and de-allocations. As roughly 70% of CVEs in C or C++ projects are caused by memory unsafety, this is a significant feature [1]. But the insights you make in studying K&R will translate to everything you build, regardless of language.

You'll walk away with a mental model for computers so powerful that it was the genesis of our modern technology era.

[0]: https://en.wikipedia.org/wiki/The_C_Programming_Language

[1]: https://www.chromium.org/Home/chromium-security/memory-safet...

[2]: https://grisha.org/blog/2013/04/02/linus-on-understanding-po...

https://teachyourselfcs.com/

In particular they say if you can't take the time to do all of it then there are 2 books that give most bang for buck: _Computer Systems: A Programmer's Perspective

Designing Data-Intensive Applications

See hacker news thread: https://news.ycombinator.com/item?id=22286340

Bottom up cs is a great resource. https://www.bottomupcs.com/ It might feel very low level at first but once you understand these fundamental building blocks of computers you will be really well equipped to build upon this knowledge and learn higher level concepts. I also think the Rust Programming book (https://doc.rust-lang.org/book/) is a great resource for general programming knowledge. Some sections e.g. on the borrow checker and lifetimes aren’t 100% applicable to general programming knowledge but I still recommend it. It is more of a 201 level book instead of 101 though.

I don’t think you’ll find a better return on investment than working through The Elements of Computing Systems (https://www.nand2tetris.org/) which recently got a second edition. It won’t teach you how to make a rendering engine, or even necessarily any data structures or algorithms, but it will give you a big-picture understanding of the practical fundamentals (literally “what is a computer and how does it really work?”) which you can then use to direct your own learning based on what you want to know next.

There are some good mainstream recommendations in the thread already. For something less obvious: Given your background, you may find SICP (https://mitpress.mit.edu/sites/default/files/sicp/index.html) works well for you.

If you work your way through the exercises, and read the footnotes, you'll end up with a pretty solid base. You don't have to do the work in scheme, but that in itself is a good learning exercise.

This book [0] uses Java. The content of the edition using Python is the same IIRC. The first one used Swift and is a tad older.

[0] https://www.manning.com/books/classic-computer-science-probl...

Lots are recommending CLRS, but IMO it is way too dry and dense for a first course.

I taught myself algorithms with the Algorithm Design Manual by Skiena, and I strongly recommend it. The first half is an exposition on algorithms, and it is mercifully readable, fun, and short. The second half is a catalog of different algorithms. You don’t really read through it, but it is useful as a reference if you have a specific problem you’re trying to solve and you want a background on algorithms in that area.

For formal resources:

You might like the Princeton Algorithms Coursera course: https://www.coursera.org/learn/algorithms-part1

SICP is an amazing book, but I HIGHLY recommend you follow along with a lecture video as the textbook was designed to go along with lectures for electrical engineering computer science students. Brian Harvey's lectures are fantastic: https://www.youtube.com/watch?v=4leZ1Ca4f0g&list=PLhMnuBfGeC...

And maybe some math? All of this is kind of abstract to start out with. It might be useful to combine this with youtube videos on your project, because you may be discouraged with doing a lot of abstract work and not concrete work on your project.

Also, freecodecamp and youtube in general is an excellent resource if you're stuck on any particular part of CS. Freecodecamp has compiled a lot of the best videos across the internet on particular concepts and you can get a deep dive into a topic if you're ever stuck. Nowadays, if you're stuck, often viewing someone else's explanation can get you unstuck fairly quick.

Basic Microprocessors and the 6800 (1981):

https://www.amazon.com.au/Basic-Microprocessors-and-the-6800...

A lot of recommendations here, so I would like to ask for some (hope that's allowed).

- Operating Systems. I had a course on OS (I'm a student), but I felt it was kind of lacking, and would like to explore more. - Compilers? Seems very interesting

Also I've started with a bit of haskell to learn functional programming, would love some pointers from the more experienced people here :D

(Also networking?? So much to learn lol)

"Foundations of Computer Science" by Aho and Ullman is an excellent book and freely available:

http://i.stanford.edu/~ullman/focs.html

K&R. It's short, quick to get through, and the exercises are great for beginner CS. At the end you'll have a good working knowledge of C, which will act as an excellent base to move into other languages/disciplines.

I liked Algorithms by Dasgupta-Papadimitriou-Vazirani

http://algorithmics.lsi.upc.edu/docs/Dasgupta-Papadimitriou-...

It's written in an approachable, almost conversational style.

Beyond that, for a broader view of algorithms and computing that includes AI, there's Artificial Intelligence: A Modern Approach by Russell/Norvig. My favorite part of that book is actually the "Foundations of Artificial Intelligence" which goes into the deep history of computation (as far back as ancient and medieval times).

Maybe try the NAND to Tetris

https://www.nand2tetris.org/

For my CS degree, the two classes that were most useful foundations-wise were:

1. Learning how to prove things with math

2. "Baby compilers" machine code, building an assembler, building a simple MIPS compiler, regular expressions, parsing, etc

There's a lot of other topics but those two really set the foundation. All algorithms class and data structures are best understood with a mathematical intuition. Not to mention you want to go into VR, lin alg might help you.

YMMV. Lots of great programmers don't have a math background, but for me that helped.

The CLRS book is pretty standard (but mathy).

You'll learn things as you work too so don't discount patience.

"Introduction to Algorithms" by Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, Clifford Stein.

"Algorithm Design" by Jon Kleinberg, Éva Tardos.

"Introduction to the Theory of Computation" by Michael Sipser.

"Course notes for CSC B36/236/240: Introduction to the Theory of Computation" by Vassos Hadzilacos. http://www.cs.toronto.edu/~vassos/b36-notes/notes.pdf

Not a book but https://teachyourselfcs.com/ if you want typical curriculum and also not a CS book but good book "Computer Science Fundamentals" (sneaky title, free online).

Although I recommend starting from "Code: The Hidden Language of Computer Hardware and Software". Coolest book ever.

I would suggest to read beginning part of SICP, with out actually diving into reading chapters, why SICP matters ? => (https://people.eecs.berkeley.edu/~bh/sicp.html).

Take a look at Norvig's essay (https://norvig.com/21-days.html) and suggestions from teachyourselfcs.com.

https://github.com/ossu/computer-science is also a good one.

If want more, https://ocw.mit.edu/courses/electrical-engineering-and-compu...

Everything I took away from my 4 year degree in CS is in The Practice of Programming by Pike & Kernighan.

Older books on computing can really help. When computers were unfamiliar to almost everyone, the author took care to walk through the fundamentals of computer science.

Jon Bentley. "Programming Pearls" https://www.google.com/books/edition/Programming_Pearls/kse_...

-

(not about Perl the computer language, but rather pearls or unexpected jewels of wisdom)

An accessible style, a collection from the Communications of the Association for Computing Machinery (CACM). Also used in a first-year course of computer science at US Naval Academy.

Simple problems are discussed in detail, often leading to subtle insight that yields better performance.

I've always been partial to "Introduction to Computing: Explorations in Language, Logic, and Machines" [0] by David Evans of the University of Virginia.

[0] https://computingbook.org/

I found The Imposters Handbook - Rob Conery to be a fantastic overview of CS concepts. Taught me where my CS fundamentals were deficient and gave me enough of the proper language to search effectively and start filling in those deficiencies.

I'd advise SICP. Even though it is focused on functional style, it really does apply to general programming.

It made me a far far better engineer when I was first starting out.

There are lectures online for the book if you want to break up the tedium of just reading it.

Something ive needed on my learning journey is attacking "both ends" -- so something like sedgewick for reading and then something about using pre-builds and c# in unity.

Its nice to actually hang out in 3D space and start to build an intuition between fiddling with the c# and whats going on in your unity scene. Maybe your toy engine has legs and you're better off with a more foundational approach. Personally though i find dense coursework obfuscating and like having my "microwave dinners" on the way to knowing how to cook from scratch ;)

Dont listen to my advice tho listen to someone pitching a bunch of boring books. Its the right way...

Lots of good stuff in this thread already, so I'll just add a thought or two. A lot of commentators here have picked up that what you need is roughly the equivalent of a "Data Structures & Algorithms" course. I agree with that sentiment. Whether you actually take a course, or work through some books, or whatever, so long as you acquire that knowledge you'll have a great foundation.

The question then is "what next?" To which I would say that you want roughly the equivalent of a course titled something like "Introduction to Computation" or "Automata Theory & Computation" or whatever. That is, you'll want to understand things like Universal Turing Machines, Finite-State Automata, Formal Grammars, and some basics of Computational Complexity Theory (the same "Big O" stuff you'll hear mentioned in the Data Structures & Algorithms class, but going a little bit deeper). This stuff isn't necessarily required to do a lot of "grunt work" programming, but it starts coming into play if you want to do some more advanced stuff.

One of the classic texts in this area is by Hopcroft & Ullman.

https://www.amazon.com/Introduction-Automata-Theory-Language...

And on a semi-related note, there's a really good course on Youtube: MIT 6.042J Mathematics for Computer Science, taught by Tom Leighton[1], that you might find useful as well. A version of the book[2] used in that course is freely available online as well

https://www.youtube.com/playlist?list=PLB7540DEDD482705B

[1]: https://en.wikipedia.org/wiki/F._Thomson_Leighton

[2]: https://people.csail.mit.edu/meyer/mcs.pdf

This is self serving, but I wrote the Classic Computer Science Problems series for developers like you—folks who work in software but don't have a CS education. It is a broad survey, using code instead of theory. It's broad not deep. They're not textbooks:

https://classicproblems.com

I also recommend Grokking Algorithms by the same publisher as an introductory book if you don't want a textbook.

None of these go into graphics at all though, so they won't help you with rendering or VR.

Computer Science Distilled: Learn the Art of Solving Computational Problems

Highly recommended for freshers, especially who had no academic background on computer science and willing to start their career as dev.

  The best book on programming for the layman is "Alice in Wonderland"; but that's because it's the best book on anything for the layman. 

- Alan Perlis

I'll take the opportunity to hop on to this thread and admit that I have never properly learned C (I have seen some code here and there). Considering there are several comments advising on using C as the language to implement the algorithms, what is your recommendation to get started with C? I'm looking for something that is not too long (I have a problem continuing with big books) and yet is concise and teaches the language in a well rounded manner.

The Manning book is a great, very approachable and even enjoyable intro to the basics of algorithms and data structures. It’s got illustrations and everything!

It doesn’t go into loads of detail but as a first intro I think it’s great, then you can go deeper if you want.

https://www.manning.com/books/grokking-algorithms

I'm a bottom-up learner. To take bottom-up "fundamentals of CS" to an extreme (without venturing too far into electrical engineering):

First, work your way through Kernighan & Ritchie and do EVERY exercise.

Then read Hennessy & Patterson (Computer Architecture).

When you're done, you'll understand exactly how a computer executes instructions, and you'll have an abstract mental map from C code to machine code.

https://fsharpforfunandprofit.com/

Functional programming is not essential but helpful. It will help you fill your tool box. Fsharp for fun and profit teaches the concepts in an easy to learn way.

I'd recommend learning what a monad is. Then you'll see it all over. When you use tools like map or promises.

I wish I'd learnt this earlier.

Most of the answers are covering data structures and algorithms but I have a different direction. If you're doing VR/rendering, you should also look at linear algebra if you don't know it already. Specifically, make sure you're really comfortable with matrix multiplication, matrix inversion, change of basis vectors, cross products, etc.

I always recommend Robert Sedgwick's series: https://www.amazon.com/Algorithms-Parts-1-4-Fundamentals-Str...

You'll also get a chance to learn C++ as you go through it.

The Impostor's Handbook https://bigmachine.io/products/the-imposters-handbook/ has been helpful for me. Been using it to supplement learning from a coding bootcamp.

Concrete Mathematics: A Foundation for Computer Science, by Ronald Graham, Donald Knuth, and Oren Patashnik.

https://teachyourselfcs.com

I highly recommend The Computational Beauty of Nature by Gary William Flake (1998).

I stumbled on this gem a while back.

https://www.personal.kent.edu/~rmuhamma/Algorithms/algorithm...

As a self taught dev myself, check out my comment here:

https://news.ycombinator.com/item?id=29366106

it seems you want something that's less CS (math) and more algorithms. I would highly recommend the classing TAOCP (https://www-cs-faculty.stanford.edu/~knuth/taocp.html). If anything, your IQ bumps by 10 points just by putting the book in your shelf.

It's a really fun book, tons of exercises and never gets old.

Algorithms + Data Structures = Programs by Niklaus Wirth.

Take a look at the suggestions on https://teachyourselfcs.com/

You should checkout https://teachyourselfcs.com/

The Art of Computer Programming. It requires some decent math knowledge. But so does CS understanding.

Maybe this won't be a popular opinion, but there are some non-CS-specific works that really helped cement some underlying principles.

Namely, the fun stuff like "Martin Gardner's Mathematical Games" articles, "Gödel, Escher, Bach" by Hofstadter, and "The Cyberiad" by Stanislaw Lem.

These require a bit of thoughtfulness applied to relate to CS. And it was specifically worthwhile to actually work through the number theory stuff in GEB.

https://osdev.org

There are a lot of book recommendations, but I would not focus on books if I wanted to get the equivalent of a solid CS education. Instead I would work through university lecture slides, assignments, and exams -- basically fast forward through a CS undergrad leveraging what you already know.

I'm partial to CMU's CS syllabus for obvious reasons, but I find that it's also one of the most open and available resources on the web; i.e. not locked in on an intranet, etc.

With pre-existing background in software development the basic syllabus is more than doable in a 3-4 months. There are two sequences below: programming and theoretical fundamentals; you can do them in parallel.

Programming:

15-211: Introduction to Data Structures. Used to be in C++; now looks like it's in Java. https://www.cs.cmu.edu/~mjs/121/lectures.html

15-212: Principles of Programming. Still in ML. https://www.cs.cmu.edu/~me/212/schedule.html | https://www.cs.cmu.edu/~fp/courses/96-212/ (unlocked assignment pages)

15-213: Intro to Computer Systems. I hesitate to recommend this; 90% of the value in this course is in the labs and assignments, so it's difficult to do on one's own, but I would at least go through the slides and try to work through exams. https://www.cs.cmu.edu/~213/schedule.html

Theoretical:

15-251: Great Ideas in Theoretical Computer Science. Used to be Discrete Math with a heavy CS lean; it may have evolved. https://www.cs.cmu.edu/~15251/schedule.html

15-451: Algorithms. Here's a decade worth of lectures, exams and assignments - take your pick: https://www.cs.cmu.edu/~15451/ The 2013 course looks pretty complete: https://www.cs.cmu.edu/afs/cs.cmu.edu/academic/class/15451-f...

Next steps:

Since you are interested in VR, etc, you should probably look into the Computer Graphics courses. Note that the undergrad and grad courses are combined; the only difference is the expectations:

15-462: Computer Graphics http://15462.courses.cs.cmu.edu/fall2020/ Exam problems and solutions are gold: http://15462.courses.cs.cmu.edu/fall2020content/exams/finals...

15-463: Computational Photography http://graphics.cs.cmu.edu/courses/15-463/

15-464: Technical Animation http://graphics.cs.cmu.edu/nsp/course/15464-s21/www/syllabus... http://graphics.cs.cmu.edu/nsp/course/15464-s21/www/assignme...

Hope this helps. Good luck!

There are three areas to really study here:

1. Programming

2. Computer Science

3. Software engineering

Programming is, well, the act of writing code both in general and in a particular language. For this, find one or two books or courses on the languages you're using. Work through them, type up most, if not all, their sample programs yourself. Don't just copy/paste, don't download a copy of their source code. Typing it in helps a lot to internalize the information. Then create variations. I'm learning Rust, as an example, and have been writing up the programs in The Rust Programming Language, then I change their structure, make them generic, or modify other elements to see if I actually understand what's happening.

Computer science is more fundamental. For that, many of the algorithms & data structures books mentioned are great to study. It's good practice to implement both (algorithms & data structures) in whatever languages you're using, even if they already have them built in. Then switch out your implementation for the language standard version (if present) so you learn both the fundamentals (how they're built and used) and the standard (how they're used in your language). Pay attention to things like algorithm analysis, it gets cast aside here sometimes but it really is helpful especially in something like rendering. If you understand the relative costs of different choices you will get much more efficient programs, but also study how your actual system behaves. Sometimes an on-paper faster algorithm is slower in practice due to how the CPU and RAM actually work (like scanning a vector for something may be faster in practice than a faster-on-paper hash table or map data structure). You can go deeper and study theory of computation and other areas, but that's not going to be necessary yet.

Software engineering is, reductionist definition, about three things: working with others, working with your future self, organizing programs and systems. Two books I like on the non-technical side: The Mythical Man-Month by Fred Brooks and The Psychology of Computer Programming by Gerald Weinberg. Some parts of both are dated, but they're still relevant to today and thinking about how teams work and systems develop over time. On the more technical side: Learn how to test in your languages, and read Refactoring by Martin Fowler. Learn to use version control, even for toy projects. Create git repos and get in the habit of committing early and often (like with working with any file on the computer you should save early and often so you don't get burned by a crashed editor, committing early and often saves you from when you make a major change and realize you want to undo it).

---------------------

You can study programming without studying CS proper, but at some point you are likely to start running into decision points that will be hard for you without knowing the tradeoffs that CS (even just the introductory portions) teaches. Same thing with software engineering, it's not technically necessary for programming, but once you start working at scale (large projects or more than just a handful of people) it pays to understand that area.

* The elements of computer systems

* The little schemer

* The c programming language (k&r)

for what you are doing, you can probably learn more from reading id software’s open source code bases. e.g. the doom code base.

I’m addition to all of the canonical texts folks have posted here, it might be worth noting the ACM has a publication in which they define what makes a complete Computer Science curriculum:

https://dl.acm.org/doi/10.1145/240483.240502

This is behind their paywall, and I would not discourage you from paying, but someone might be able to find the same document with a simple web search.

I’m addition to all of the canonical texts folks have posted here, it might be worth noting the ACM has a publication in which they define what makes a complete Computer Science curriculum:

https://dl.acm.org/doi/10.1145/240483.240502

This is behind their paywall, and I would discourage you from paying, but someone might be able to find the same document with a simple web search.

Try harvard's free CS60

Learn Haskell. Most of Haskell concepts have root in CS and mathematics.

Hey! I have written a book on conceptual foundations of programming and CS. It is language-agnostic and focuses on principles that transcend programming languages. It talks about everything from functions and types (and where they come from, theoretically) to concurrency and parallelism. It's written with beginners in mind that want to have a grasp on concepts as well as working devs that have hands-on experience with a language, but want to learn to think in cross-language concepts. I am really short on time to put a website on the internet yet (I hope by Christmas it'd be up), but I'd love to send a draft to whoever is interested (if you like, you can pay me later, but no obligations) Email is blagovest dot gospodinov at yah00 dot c0m (just say you're from HN)

edit: pasting chapter of contents from a python script i use:

        "Foreword.md": dict(finished=False),
        "Function.md": dict(finished=False),
        "Data and Types.md": dict(finished=False),
        "Functions as Data.md": dict(finished=False),
        "Function Types.md": dict(finished=False),
        "Type Classes.md": dict(finished=False),
        "Polymorphism and Types I.md": dict(finished=False),
        "Polymorphism and Types II.md": dict(finished=False),
        "Types as Data.md": dict(finished=False),
        "Polymorphism and Types III.md": dict(finished=False),
        "Universal Types.md": dict(finished=False),
        "From Idea to Execution.md": dict(finished=False),
        "Side Effects and Purity.md": dict(finished=False),
        "Side Effects and Types.md": dict(finished=False),
        "Objects I.md": dict(finished=False),
        "Objects II.md": dict(finished=False),
        "Objects III.md": dict(finished=False),
        "Objects IV.md": dict(finished=False),
        "Objects V.md": dict(finished=False),
        "Objects VI.md": dict(finished=False),
        "Names.md": dict(finished=False),
        "Change I.md": dict(finished=False),
        "Change II.md": dict(finished=False),
        "Modes of Computation.md": dict(finished=False),
        "The Infinite.md": dict(finished=False),
        "Incomplete Functions.md": dict(finished=False),
        "Syntax and Semantics.md": dict(finished=False),
        "Memory I.md": dict(finished=False),
        "Memory II.md": dict(finished=False),
        "Parallel Computation.md": dict(finished=False),

SICP

Have you tried some of the old "Graphics Gems" series books yet? [1], [2], [3] They are not CS fundamentals but will help you out with the necessary concepts, math and algorithms for graphics programming and ray-tracing.

As others have mentioned any books on Data Structures & Algorithms are a must. [4], [5], [6]

However in my opinion, trying to understand CS fundamentals without undergoing some sort of formal education is a chore. You won't know what you are missing. Going through an established approved syllabus will give you a fuller understanding. But that is only if you are interested in the long haul.

There are a number of MOOCs that may fit the bill allowing you to slowly gather the knowledge without sacrificing too much time and focus on a day job to keep you going. I feel they are also great value for money for what you get. Some of them are from very reputable names if that is important. [7][8].

Since you have a B.Sc you can do the Masters level but there are also Bachelors level courses. [9]

1. https://www.amazon.com/Graphics-Gems-Andrew-S-Glassner/dp/01...

2. https://www.amazon.com/Graphics-Gems-II-IBM-No/dp/0120644819...

3. https://www.amazon.com/Graphics-Gems-No-3-David-Kirk/dp/0124...

4. https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press...

5. https://www.amazon.com/Algorithms-4th-Robert-Sedgewick/dp/03...

6. https://www.amazon.com/Algorithm-Design-Manual-Steven-Skiena...

7. https://www.coursera.org/degrees/master-of-computer-science-...

8. https://www.coursera.org/degrees/mcit-penn

9. https://www.coursera.org/degrees/bachelor-of-science-compute...

Textbooks are the old way to learn, but sometimes old is gold.

Use videos for faster learning though. It’s pretty much learning on cruise mode.