Skip to content
/ Rusty-CS Public
forked from AbdesamedBendjeddou/Rusty-CS

A Computer Science Curriculum with Rust flavor!

License

MIT license
1 star 55 forks Branches Tags Activity
Star
Notifications You must be signed in to change notification settings

seanmrnda/Rusty-CS

1 Branch0 Tags
This branch is 44 commits behind AbdesamedBendjeddou/Rusty-CS:main.

Folders and files

NameName
Last commit message
Last commit date

Latest commit

AbdesamedBendjeddouAbdesamedBendjeddou
Create LICENSE
Mar 28, 2022
7a74b79 · Mar 28, 2022

History

4 Commits
LICENSE
LICENSE
Mar 28, 2022
README.md
README.md
Mar 28, 2022

Repository files navigation

بسم الله الرحمان الرحيم

A Computer Science Curriculum with Rust flavor! 

// tl:dr
let RustyCS = CS.iter().zip(Rust.iter())

Contents

Why learn Computer Science

from Teachyourselfcs.com:

There are 2 types of software engineer: those who understand computer science well enough to do challenging, innovative work, and those who just get by because they’re familiar with a few high level tools. Both call themselves software engineers, and both tend to earn similar salaries in their early careers. But Type 1 engineers progress toward more fulfilling and well-remunerated work over time, whether that’s valuable commercial work or breakthrough open-source projects, technical leadership or high-quality individual contributions. Type 1 engineers find ways to learn computer science in depth, whether through conventional means or by relentlessly learning throughout their careers. Type 2 engineers typically stay at the surface, learning specific tools and technologies rather than their underlying foundations, only picking up new skills when the winds of technical fashion change. Currently, the number of people entering the industry is rapidly increasing, while the number of CS grads is relatively static. This oversupply of Type 2 engineers is starting to reduce their employment opportunities and keep them out of the industry’s more fulfilling work. Whether you’re striving to become a Type 1 engineer or simply looking for more job security, learning computer science is the only reliable path.

Why learn Rust

There are a lot of reasons why one would want to learn Rust, but I'm going to mention just what I think are the killer features: Rust is a low-level programming language with direct access to hardware and memory, giving you the same power that C and C++ do with a greater focus on memory safety. Rust also makes it easier to write concurrent programs by preventing data races at compile time. Another great thing about Rust is that Rust is a low-level language with abstractions from higher-level languages without any performance sacrifices (zero-cost abstraction). Rust is general-purpose and can be used for almost anything from embedded systems, building operating systems to running on the browser via webassembly. The possibilities are endless.

Why this curriculum

At first, I made a CS curriculum based on the ACM & IEEE Computer Science Curricula 2013 guidelines to make up for the low learning quality in the university where I study. Then I found out about Rust and fell in love with it. I wanted to jump in right away, but I had my CS courses to finish first, later I had this idea about spreading some Rust over my CS curriculum, this way I can learn them both at the same time, plus Rust being a system programming language it's almost imperative to have a strong CS background first before you can use it effectively.

How to use

This is a Computer Science curriculum first and foremost, designed to mimic an undergraduate Computer Science degree by providing high-quality learning content from top-notch universities adhering to the ACM & IEEE Computer Science Curricula 2013 guidelines. You may follow this curriculum even if you are not interested in learning Rust by skipping Rust sections. for those who are here to learn both CS and Rust, the way to go is to study the material in the given order. Each section contains the academic course(s) and the relevant Rust implementation(s). you start with the academic part and then move to the applicative Rust part if found. you don't have to study all the material, just what you are interested in and you think it may be useful for you of course in respect of the mentioned prerequisites.

Contribution

Everyone is welcome to contribute to this curriculum. For broken/missing links, spelling errors, and language refactoring, please create a pull request with the fixes. If you think that there is an issue with the curriculum, like missing or wrong prerequisites, wrong order of courses, inaccurate or a better description of courses and sections, better alternatives to the suggested courses, please open an issue stating what's wrong and your suggestion to fix it.

Acknowledgment

Although this was an original idea, I consider The OSSU and Teachyourselfcs curriculums prior arts. This project borrowed a lot from them in terms of courses recommendations and organizations, even quotes. Many thanks to them.

Curriculum

Prerequisites

The below material assumes that you have already finished high school. If not, you can study the needed math and physics course at Khan Academy. Additionally, some courses require Calculus as a prerequisite. You can either go through the courses and learn the required calculus part when needed or take a complete calculus course such as the one on Khan Academy or MIT-Open Learning Library.

Introduction

CS Part:
If you have no programming background, start here. These two courses will introduce you to the world of Computer Science and give you solid fundamentals that you need to go through the curriculum and the Rust book. I would also suggest that you do some small projects with python for maximized learning.

Course name Associated Book Other Resources Prerequisite
Python for Everybody Python for Everybody Book Coursera’s version /
Introduction to Computer Science and Programming using Python Introduction to Computation and Programming Using Python OCW’s Version /

Rust Part:
After finishing the above courses, you should be able to read the book, in addition to the official book, another small book with a gentler introduction to some concepts is provided. And while you're at it, solve the exercises and questions below to help retain the knowledge. There is no particular order to go through the materials except of course reading the relevant chapter from the book before solving its exercises. If you learn better by watching videos, you can also check the following Youtube series Crust of Rust.

Systems Fundamentals

The best course to learn how computers work and how to build one. This course will prepare you for the upcoming courses about computer architectures and operating systems.

Course name Associated Book Other Resources Prerequisite
Build a Modern Computer from First Principles Part 1 The Elements of Computing Systems Course website /
Build a Modern Computer from First Principles Part 2 The Elements of Computing Systems Course website Build a Modern Computer from First Principles Part 1

Discrete Structures

This course covers the most important parts of mathematics relevant to CS, which are needed later in areas like Algorithms and Sytems studies. The set of lecture notes by László Lovász did a good job of making the content approachable and intuitive, so this serves as a better starting point, then you can move to the more advanced Math for CS by MIT.

Course name Associated Book Other Resources Prerequisite
lecture notes by László Lovász / / /
Mathematics for Computer Science Mathematics for Computer Science - Lehman, Meyer, Leighton Alternate version with solutions to the problem sets /

Algorithms 1

CS part:
Familiarity with common algorithms and data structures is one of the most empowering aspects of a computer science education. This is also a great place to train one’s general problem-solving abilities, which will pay off in every other area of study.

Course name Associated Book Other Resources Prerequisite
Introduction to Algorithms Introduction to algorithms 2nd ed- CLRS VisuAlgo visualizing data structures and algorithms through animation - Introduction to Computer Science and Programming using Python.
- Mathematics for Computer Science.

Rust part:
Solving problems with the language that you are trying to learn is the best way to learn it. Go ahead and solve as most as you can. Check more problems at leetcode.com, Hackerrank, Codewars, etc...

Programming

CS part:
These courses teach general ways of thinking and form neural pathways in your brain that will serve you forever and you will use them in literally everything. (quoting from spamegg cause I couldn't find any better motivation). And from teachyourselfcs.com about SICP :SICP is unique in its ability—at least potentially—to alter your fundamental beliefs about computers and programming. Not everybody will experience this. Some will hate the book, others won't get past the first few pages. But the potential reward makes it worth trying. while the last course will help you understand the tools that you need to make it easier for you to create programs like Git.

Course name Associated Book Other Resources Prerequisite
How to Code Simple Data How to Design Programs / /
How to Code Complex Data How to Design Programs / How to Code Simple Data
Berkeley 61A Structure and Interpretation of Computer Programs Course Website /
The Missing Semester of Your CS Education / / /

Rust part:
A bunch of small projects in Rust, this is officially your first step toward the Art of Programming. there is no particular order and you don't have to do all of them.

Programming Languages 1

You can't really be a good programmer without knowing how programming languages work.

Course name Associated Book Other Resources Prerequisite
Programming Languages Part A / Course website How to Code Complex Data
Programming Languages Part B / Course website Programming Languages Part A
Programming Languages Part C / Course website Programming Languages Part B

Architecture and Organization

Learning what is going on under the hood of a computer system is what makes the difference between a programmer and a good programmer. Understand computer systems will let you write faster, more efficient and more reliable software. Both courses cover the same topics. I couldn't choose which one to put in the curriculum so I did put them both, you only need to take one.

Course name Associated Book Other Resources Prerequisite
Introduction to Computer Systems Computer Systems: A Programmer's Perspective / Build a Modern Computer from First Principles Part 2
Computation Structures / / Build a Modern Computer from First Principles Part 2

Networking and Communications

CS part:
From teachyourselfcs.com: Given that so much of software engineering is on web servers and clients, one of the most immediately valuable areas of computer science is computer networking. Our self-taught students who methodically study networking find that they finally understand terms, concepts and protocols they’d been surrounded by for years.

Course name Associated Book Other Resources Prerequisite
Introduction to Computer Networking Computer Networking: A Top-Down Approach Beej's Guide to Network Programming Some Programmming

Rust part:
A reimplementation of what you learned about networks in Rust. This will be of great value in your future projects.

Information Management

It's necessary to learn how databases work. You will find yourself dealing with them in almost all fields of programming.

Course name Associated Book Other Resources Prerequisite
Berkeley CS186 Introduction to Database Systems / - cs186berkeley.net
- Architecture of a Database System (Paper)
- redbook.io		 Some Programming
Data Modeling Data and Reality: A Timeless Perspective Databases: Modeling and Theory /

Algorithms 2

CS part:
A more advanced treatment of algorithms.

Course name Associated Book Other Resources Prerequisite
Design and Analysis of Algorithms Introduction to algorithms 2nd ed- CLRS / Introduction to Algorithms

Rust part:
solve more advanced problems from the challenges websites.

Operating Systems

CS part:
So what happens when a program runs?

Course name Associated Book Other Resources Prerequisite
Operating Systems: Three Easy Pieces / - Choose Unix kernel book
- Do the Labs xv6 labs		 Introduction to Computer Systems
or Computation Structures

Rust part:

Distributed Computing

CS part:
“It’s typical now for even very small applications to run across multiple machines. Distributed systems is the study of how to reason about the trade-offs involved in doing so.”

Course name Associated Book Other Resources Prerequisite
Distributed Systems Designing Data-Intensive Applications Author Website Operating Systems and networking

Rust part:

Compilers and Interpreters

“If you don't know how compilers work, then you don't know how computers work”. The first two courses cover the same topic, choose one. CS part:

Course name Associated Book Other Resources Prerequisite
Automata, Computability, and Complexity - Introduction to the Theory of Computation, Michael Sipser
- Computational Complexity: A Modern Approach, Sanjeev Aror		 OCW Link Mathematics for Computer Science
Theory of Computation Introduction to the Theory of Computation, Michael Sipser / Mathematics for Computer Science
Crafting interpreters / / /
Compilers Compilers: Principles, Techniques & Tools / /

Rust part:

Software Engineering

TO DO Inshallah

Mathematics

Some recommended math courses, usefull specially for people want to follow the machine learning track.

Course name Associated Book Other Resources Prerequisite
Linear Algebra Introduction to Linear Algebra - Gilbert Strang Essence of linear algebra /
Probability Introduction to Probability 2nd ed - Joe Blitzstein / /

Intelligent Systems

CS part:

Course name Associated Book Other Resources Prerequisite
Artificial intelligence Artificial Intelligence: A Modern Approach / - Berkeley 61A
- Mathematics for Computer Science
Machine Learning / / /

Rust part:

Programming Languages 2

CS part:
This part should cover the materials needed to learn about designing programming languages, it's lengthy subject, my recommendation for anyone want to study it is to follow Oregon Programming Languages Summer School Curriculum, in addition to some books like Types and Programming Languages and Category Theory for Programmers.

Rust part:

Extra

Courses that are not necessary but I think they are cool

Course name Associated Book Other Resources Prerequisite
Introduction to Computational Thinking / / /
Game Theory Part1 / / /
Game Theory Part2 / / /
Ben Eater's Build an 8-bit computer from scratch / / /
The Art of Multiprocessor Programming teaching both the theory of concurrency and practical algorithms. / / /
Great ressouces about designing systems / / /
Extra list of classic books / / /

What else I can do with Rust?

Choose topics that interest you and study them while going through the curriculum.

CLI:

Web:

Games:

Web Assembly

Gui:

Mobile Apps:

Blockchain:

Rust Handy refrences

These are useful resources but are not meant to be read cover to cover. Instead, use them every time you are developing a project. you'll find references for some features that you may have a hard time understanding or help you when you are wondering what's the best way to read a file or parse an argument.

Use While Developing your Project

Use to finalize your Project

Projects, Workshops & Live Streams:

Blogs and Channels:

Rust Community

Crates and Libs

Jobs:

Sources:

These are some of the sources I used for the Rust parts of this curriculum.

About

A Computer Science Curriculum with Rust flavor!

Resources

Readme

License

MIT license
Activity

Stars

1 star

Watchers

0 watching

Forks

0 forks
Report repository

Releases

No releases published

Packages

No packages published