Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/fuad1502/self-study-cs
Self Study CS: A self study guide to CS mastery 🧙♂️
https://github.com/fuad1502/self-study-cs
computer-science study
Last synced: 11 days ago
JSON representation
Self Study CS: A self study guide to CS mastery 🧙♂️
- Host: GitHub
- URL: https://github.com/fuad1502/self-study-cs
- Owner: fuad1502
- Created: 2024-03-08T08:53:01.000Z (11 months ago)
- Default Branch: master
- Last Pushed: 2024-04-18T00:49:35.000Z (10 months ago)
- Last Synced: 2024-11-16T14:12:07.899Z (2 months ago)
- Topics: computer-science, study
- Homepage:
- Size: 28.3 KB
- Stars: 0
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
README
# Self Study CS: A self study guide to CS mastery 🧙♂️
* [What's this repository for?](#whats-this-repository-for)
* [Background](#background)
* [Specialization Plan](#specialization-plan)
* [Self Study Curriculum Overview and My Progress](#self-study-curriculum-overview-and-my-progress)
* [Projects & Exercises](#projects-exercises)
+ [Projects](#projects)
+ [Exercises](#exercises)
* [Topics Breakdown](#topics-breakdown)
* [Reference](#reference)
## What's this repository for?
Originally, I created this repository to show potential recruiters what I've
been doing in my ~7 months career gap. However, I quickly realized that this
would also be useful to anyone out there who also found themselves wanting to
study everything there is in the computer science field of study by themselves.
> ⚠️ **Disclaimer**: I am by no means an expert in Computer Science, in fact, as you
will soon read, I am meerly a novice. Any advice should be taken with a grain
of salt.
## Background
I am an Electrical Engineering graduate and have been working in the hardware
(*RF / electronics / embedded*) industry for over 4 years. However, after
finally getting my dream job abroad at *Keysight Technologies* Malaysia, I
resigned after only working for a shy of 2 years due to some personal reasons.
At that point, I also realized that I am more suited to pursue a career that
allows me to work remotely. Along with [other reasons]() that I wont be
discussing here, **I realized that I want to be in the computing industry.**
However, scrapping away (almost) all of my previous knowledge and 4 years of
experience to start from basically "zero" is not easy. Moreover, I don't want
to only have practical skills that would get me an interview quickly without
having a solid understanding of the fundamentals. From my experience, having a
holistic view of your field of study is the upmost important thing in mastering
your field of study. That's why I searched for a "self study CS curriculum".
And if you're like me, you'll stumble upon [**Teach Yourself Computer
Science**](https://teachyourselfcs.com/). **That is the main source for my self
study journey.**
[**Teach Yourself Computer Science**](https://teachyourselfcs.com/) seems
perfect for me at first. However, I quickly realized that I lack some knowledge
that are not listed there. Moreover, I also still need some practical knowledge
on current technologies to understand how the industry is running today. **With
that additions, I came up with this self study checklist.**
## Specialization Plan
Since the beginning of my journey, I have determined to at least scratch the
surface of every sub domain there is in Computer Science. And I encourage you
to do so to. The reasons are:
- To remove bias when you have to make a decision on which specialization path to
choose.
- You might found yourself needing to draw knowledge from multiple domains to
craft a solution / product.
- It simply is intelectually interesting to see how each of the specialization
are related and interacts with one another from a holistic view.
However, of course once you feel *confident* that you know the *crux* of each
subdomain, you have to make a decision on what to focus on if you want to be
technically successful. ***For me, I would like to focus on Systems***.
The reason why I love *Systems* the most throughout my study, is because of my
deep curiosity on seeing what's behind the abstraction, to see the complex
machinery that make the systems that we all have taken for granted *just work*.
That's actually the reason why 10 years ago I chose EE, but let's not [get into
that]() here. There are of course further specialization down this road, but
for now, one level of specialization below *Computer Science* is good enough
for me.
## Self Study Curriculum Overview and My Progress
Here is an overview of what I have and will learn throughout my self study
jouney up till now (March 2024). Started studies with progress above 75% are
marked with 🟢, started studies with progress above 25% and below 75% are
marked with 🟡, while studies with progress below 25% or not yet started are
marked with ⚫.
**Note that some topics might get more sub topics with more knowledge acquired.**
| ID | Topic | [Reference](#reference)\* | Dependencies | Progress |
|-------|-----------------------------------|-----------------------------------------------|--------------|------------|
| 0 | **Computer Science Fundamentals** | | | |
| 0.0 | Algorithms* | Algorithm Design Manual | | 🟡 |
| 0.1 | Computer Systems | Computer Systems: A Programmer's Perspective | | 🟢 |
| 0.2 | Computer Networks | Computer Networking: A Top-Down Approach | | 🟡 |
| 0.3 | Computer Architecture | Computer Architecture: A Quantitative Approach| | ⚫ |
| 0.4 | Discrete Mathematics | Mathematics for Computer Science | | 🟡 |
| 0.5 | Programming | SICP | | ⚫ |
| 0.6 | Automata Theory | Introduction to Automata Theory | | ⚫ |
| 1 | **Software Engineering** | | | |
| 1.0 | Object Oriented Programming | Head First Java | | 🟢 |
| 1.1 | Design Patterns | Head First Design Patterns | 1.0 | 🟢 |
| 1.2 | Database Application | Database Management Systems | 0.2 | 🟢 |
| 1.3 | Software Craftmanship | Clean Code | 1.1 | 🟡 |
| 3 | **Advanced Computer Systems** | | | |
| 3.0 | Operating Systems | Operating Systems: Three Easy Pieces | 0.1 | 🟡 |
| 3.1 | Systems Programming | Advanced Programming in the UNIX Environment | 0.1 | ⚫ |
| 3.2 | Linux Kernel | Understanding the Linux Kernel | 3.0 | ⚫ |
| 3.3 | Database Implementation | Database Management Systems | 1.2 | ⚫ |
| 3.4 | Distributed Systems | Designing Data-Intensive Applications | 1.2 | 🟡 |
| 4 | **Embedded Systems** | | | |
| 4.0 | Embedded Systems Fundamentals | Making Embedded Systems: Design Patterns | 1.1 | 🟡 |
| 4.1 | Real Time Operating Systems | MicroC/OS-III The Real Time Kernel | 0.1, 1.1 | ⚫ |
| 4.2 | Embedded Linux | Embedded Linux Primer | 0.1, 1.1 | ⚫ |
| 5 | **Computer Hardware** | | | |
| 5.0 | RTL Design | RTL Modeling with SystemVerilog | | 🟢 |
| 5.1 | RTL Verification | SystemVerilog for Verification | 5.0 | ⚫ |
| 5.2 | Modern Processor Design | Modern Processor Design | 0.1, 0.3 | ⚫ |
| 6 | **Computer Languages** | | | |
| 6.0 | Introduction to Interpreters | Crafting Interpreters | | 🟡 |
| 6.1 | Compiler Theory | Compilers: Principles, Techniques, and Tools | 0.6, 6.0 | ⚫ |
| 7 | **Computer Security** | | | |
| 7.0 | Computer Security | Computer Security: Principles & Practice | 0.1, 0.2 | ⚫ |
| 8 | **Computer Graphics** | | | |
| 8.0 | Computer Graphics | 3D Computer Graphics: A Mathematical Intro | | ⚫ |
| 9 | **Technologies** | | | |
| 9.0 | *Programming Languages* | | | |
| 9.0.0 | HTML / CSS / JS | MDN Learning Area | | 🟢 |
| 9.0.1 | Rust | The Rust Programming Language | | 🟢 |
| 9.0.2 | C++ | Tour of C++ | | 🟡 |
| 9.0.2 | C | The C Programming Language | | 🟢 |
| 9.0.3 | Go | A Tour of Go | | 🟢 |
| 9.0.4 | Java | Effective Java | | 🟡 |
| 9.0.6 | Any FP Language | | | ⚫ |
| 9.1 | *Library / Framework* | | | |
| 9.1.0 | React | Learn React | 9.0.0 | 🟢 |
| 9.1.1 | Zephyr | Zephyr Docs | | 🟡 |
| 9.2 | *DevOps Tools* | | | |
| 9.2.0 | Docker / Podman | Docker Guides | | 🟢 |
| 9.2.1 | Make | Makefile Tutorial By Example | | 🟢 |
| 9.2.2 | CMake | CMake Tutorial | | 🟢 |
\* *Notice that most of my references are books. If you like online courses
better, unfortunately you'll need to look it up yourself.*
\* *Algorithms is not listed in any of the dependency lists, altough it is
assumed that the Algorithms reference is already read with at least 50%
progress before moving on to other topics.*
## Projects & Exercises
**To really solidify the knowledge of what you've learned**, you'll have to use
that knowledge to solve problems by writing some code. I categorize two ways
that you can do this, by doing projects and exercises.
**Projects** are usually larger, strikes close to what you might actually do in a
specific target industry, and requires knowledge on various technologies.
**Exercises** on the other hand are small close ended problems that are
specifically designed to test and solidify your knowledge on a very specific
topic, sometimes in a *prepared* learning environment. In contrast to projects,
the resulting code itself *usually* don't have much practical use outside of
the learning environment.
**Both are essential for learning**. Most of the time, you need to do some
exercises before diving into a project. Just doing exercises will deprive you
of a holistic view and practical skills, but just doing projects will deprive
you of really understanding specific things that might otherwise be lost in
abstractions, and therefore hinder your ability to tackle the project.
### Projects
Started and finished (is it ever finished?) projects have an entry in the
repository column.
| Project Problem Statement | Repository | Related Topics | Target Industry |
|------------------------------------------------------- | ------------------------------------- | ---------------------------------------- | ------------------------- |
| Develop a typing test Web Application | | 9.0.0, 8.1.0\* | Frontend Web Development |
| Develop & deploy your own Social Media Web Application | | 0.2, 1.2, 9.0.0, 9.0.3\*, 9.1.0\*, 9.2.0 | Backend Web Development |
| Implement a pipelined RISC-V CPU | | 0.1, 5.0 | Hardware |
| Implement an out of order RISC-V CPU | | 0.3, 5.2 | Hardware |
| Implement a RISC-V Assembler | | 0.1, 6.0, 9.0.1\* | Systems, Languages |
| Implement your own RISC-V Kernel | | 3.0 | Systems |
| Implement your own Relational Database | | 3.2 | Systems |
| Design a GPS Running Watch | | 4.0, 4.1, 9.1.1 | Systems |
| Implement Lox in a language other than Java\* | | 6.0, 9.0.2\* | Languages |
\* *You can use any programming language of your choosing.*
### Exercises
| Exercise | Repository | Related Topics |
| ------------------------------------------------------------- | ------------------------------------------------------ | ----------------- |
| Wrote Design Pattern examples in a language other than Java\* | | 1.0, 1.1, 9.0.1\* |
| Solve LeetCode problems using multiple languages | | 0.0, 9.0.\* |
| Participate in *Advent of Code* using multiple languages | | 9.0.\* |
| Do the lab assignments from the Computer Systems reference | | 0.1 |
| Do the *projects* from the Operating Systems reference | | 3.0 |
| Do the *exercises* from each book references | \* | \* |
\* *A repository containing my solutions to selected exercises from several book references is given below*
| Book Reference | Repository |
|--------------------------------------------- | ------------------------------------ |
| Algorithm Design Manual | |
| Computer Systems: A Programmer's Perspective | |
| Operating Systems: Three Easy Pieces | |
## Topics Breakdown
## Reference
- [The Algorithm Design Manual](https://www.amazon.com/gp/product/3030542556/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=3030542556&linkCode=as2&tag=algorist-20&linkId=00b8675b374dcd56244e23efeecc80b0)
- [Computer Systems: A Programmer's Perspective](https://www.amazon.com/Computer-Systems-Programmers-Perspective-3rd/dp/013409266X)
- [Computer Networking: A Top-Down Approach](https://www.amazon.com/Computer-Networking-Top-Down-Approach-7th/dp/0133594149)
- [Computer Architecture: A Quantitative Approach](https://www.amazon.com/Computer-Architecture-Quantitative-John-Hennessy/dp/012383872X)
- [Mathematics for Computer Science](https://ocw.mit.edu/courses/6-042j-mathematics-for-computer-science-fall-2010/93cad640cf3ed0b23ef70688f452d4d5_MIT6_042JF10_notes.pdf)
- [SICP](https://web.mit.edu/6.001/6.037/sicp.pdf)
- [Introduction to Automata Theory, Languages, and Computation](https://www.amazon.com/Introduction-Automata-Theory-Languages-Computation/dp/0321455363)
- [Head First Java](https://www.amazon.com/_/dp/1491910771?smid=ATVPDKIKX0DER&_encoding=UTF8&tag=oreilly20-20)
- [Head First Design Patterns](https://www.amazon.com/Head-First-Design-Patterns-Object-Oriented-dp-149207800X/dp/149207800X/ref=dp_ob_title_bk)
- [Database Management Systems](https://www.amazon.com/Database-Management-Systems-Raghu-Ramakrishnan/dp/0072465638)
- [Clean Code](https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882)
- [Operating Systems: Three Easy Pieces](https://pages.cs.wisc.edu/~remzi/OSTEP/)
- [Designing Data-Intensive Applications](https://www.amazon.com/Designing-Data-Intensive-Applications-Reliable-Maintainable/dp/1449373321)
- [RTL Modeling with SystemVerilog for Simulation and Synthesis](https://www.amazon.com/RTL-Modeling-SystemVerilog-Simulation-Synthesis/dp/1546776346)
- [SystemVerilog for Verification](https://www.amazon.com/SystemVerilog-Verification-Learning-Testbench-Language/dp/1461407141)
- [Modern Processor Design: Fundamentals of Superscalar Processors](https://www.amazon.com/Modern-Processor-Design-Fundamentals-Superscalar/dp/1478607831)
- [Crafting Interpreters](https://craftinginterpreters.com/)
- [Compilers: Principles, Techniques, and Tools](https://www.amazon.com/Compilers-Principles-Techniques-Tools-2nd/dp/0321486811)
- [Computer Security: Principles and Practice](https://www.amazon.com/Computer-Security-Principles-Practice-4th/dp/0134794109)
- [3D Computer Graphics: A Mathematical Introduction with OpenGL](https://www.amazon.com/3D-Computer-Graphics-Mathematical-Introduction/dp/0521821037)
- [MDN Learning Area](https://developer.mozilla.org/en-US/docs/Learn)
- [The Rust Programming Language](https://doc.rust-lang.org/book/)
- [Tour of C++](https://www.amazon.com/Tour-C-Bjarne-Stroustrup-dp-0136816487/dp/0136816487/ref=dp_ob_title_bk)
- [The C Programming Language](https://www.amazon.com/Programming-Language-2nd-Brian-Kernighan/dp/0131103628)
- [A Tour of Go](https://go.dev/tour/welcome/1)
- [Effective Java](https://www.amazon.com/Effective-Java-Joshua-Bloch/dp/0134685997)
- [Learn React](https://react.dev/learn)
- [Docker Guides](https://docs.docker.com/get-started/)
- [Makefile Tutorial By Example](https://makefiletutorial.com/)
- [CMake Tutorial](https://cmake.org/cmake/help/latest/guide/tutorial/index.html)
- [Advanced Programming in the UNIX Environment](https://www.amazon.com/Advanced-Programming-UNIX-Environment-3rd/dp/0321637739)
- [Zephyr Docs](https://docs.zephyrproject.org/latest/)
- [Understanding the Linux Kernel](https://www.amazon.com/Understanding-Linux-Kernel-Third-Daniel/dp/0596005652)
- [Making Embedded Systems: Design Patterns for Great Software](https://www.amazon.com/Making-Embedded-Systems-Patterns-Software-dp-1098151542/dp/1098151542/ref=dp_ob_title_bk)
- [MicroC/OS-III Real Time Kernel](https://www.amazon.com/uC-OS-III-Real-Time-Jean-Labrosse/dp/0982337531)
- [Embedded Linux Primer](https://www.amazon.com/Embedded-Linux-Primer-Practical-Real-World/dp/0137017839)