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

A Computer Science Curriculum with Rust flavor!

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

• Contents
• Why learn Computer Science
• Why learn Rust
• Why this curriculum
• How to use
• Contribution
• Acknowledgment
• Curriculum
  • Prerequisites
  • Introduction
  • Programming Languages 1
  • Programming
  • Systems Fundamentals
  • Discrete Structures
  • Algorithms 1
  • Architecture and Organization
  • Networking and Communications
  • Information Management
  • Algorithms 2
  • Operating Systems
  • Distributed Computing
  • Compilers and Interpreters
  • Information Assurance and Security
  • Software Engineering
  • Mathematics
  • Intelligent Systems
  • Programming Languages 2
  • Extra
• What else I can do with Rust?
  • CLI
  • Web
  • Games
  • Web Assembly
  • Gui
  • Mobile Apps
  • Blockchain
• Rust Handy references
  • Rust language features
  • Use While Developing your Project
  • Use to finalize your Project
• Extra Projects, Workshops,Guides, & Live Streams
• Blogs and Channels
• Rust Community
• Jobs

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.

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.

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.

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.

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.

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.

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.

CS Part:
Start here. These two courses will teach you general ways of thinking about programming and how to write programs even if you have experience. the knowledge that you will learn here will serve you forever and you will use them in literally everything. Check these summeries to get a sneak peak of what is coming ahead in your CS journey here and here.

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

• Book-The Rust Programming Language Book The offcial book of the language will give you an overview of the language from first principles.
• Book-Easy Rust A breakdown of the rust language in the most plain english possible
• Track-Rustlings
• Track-Rust By Practice
• Project-PNGme - An Intermediate Rust Project.
• Project-Triangle From Scratch - draw a triangle using Win32, but no external crates

In addition to learning programming languages, learning about programming languages will benefit you tremendously.

CS part:
The first course is based on the classic book SICP, from teachyourselfcs.com: 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. The second course will teach you the general tools that you may need or make it easier for you to create programs like the shell and Git.

Rust part:
A bunch of small projects in Rust.

• Track-Rust Exercism
• Track-Rust Practise Questions
• Project-Build your own JIRA with Rust - A test-driven workshop to learn Rust building your own JIRA clone!
• Book-Rust Programming by Example
• Book-Creative Projects for Rust Programmers

CS Part:

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.

Rust Part:
These resources are not related to this section, but they are included here to keep your memory sharp and to be able to switch between doing the course and practicing Rust so you don't get bored.

• Rust Quiz

CS Part:

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. Make sure to check How to Solve it book, a unique guide to general problem solving.

Rust Part:

These resources are not related to this section, but they are included here to keep your memory sharp and to be able to switch between doing the course and practicing Rust so you don't get bored.

• Project-Hecto - Build your own text editor in Rust.

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. How to Solve it book will also be usefull here.

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

• Book-Hands-On Data Structures and Algorithms with Rust
• Repo-Rust Gym: Leetcode, AoC, Googe..
• Playlist-Rust Advent of Code 2019 - Brian Myers
• Repo-ProjectEulerRust
• Repo-Algorithm Cookbook in Rust
• Book-Learning Rust With Entirely Too Many Linked Lists

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 similar topics. I couldn't choose which one to put in the curriculum so I did put them both, you only need to take one.

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.

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

• Course-TIKV Practical Networked Applications in Rust
• Book-Network Programming with Rust
• Project-Building a DNS server in Rust
• Course-Low-Level Academy

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

CS part:
A more advanced treatment of algorithms.

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

CS part:
So what happens when a program runs?

Rust part:

• Book-Rust in Action
• Blog-Writing a file system from scratch in Rust
• Blog Series-Writing an OS in Rust
• Book-The Theseus OS Book
• News Letter-OSDev,Operating System Development in Rust
• Book-intermezzOS OS

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

Rust part:

• Book-Async Raft - the Raft distributed consensus protocol in async Rust
• TIKV Training program in Distributed Systems this course focuses on implementing important distributed algorithms, including the Raft consensus algorithm, and the Percolator distributed transaction protocol.

“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:

Rust part:

• Blog-Simple but Powerful Pratt Parsing
• Playlist-Rust Ports of Carfting interpreters
• Project-Writing Interpreters in Rust: a Guide
• Project-Make a Lisp - Joel Martin
• Project-Cross-platform Brainfuck Interpreter implementation in Rust
• Blog Series-Why and how we wrote a compiler in Rust
• Project-Build a language VM
• Intro to the Architecture of LLVM

todo()! //Inshallah

todo()! //Inshallah

Some recommended math courses, usefull specially for people want to specialize in machine learning.

CS part:

Rust part:

• Interactive tutorials on machine learning with Rust
• Repo-End-to-end Rust ML tutorial aimed at Rust beginners
• Blog Series-multiple blog posts about Rust ML
• Track the state of Rust on the Machine learning field

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:

• Blog Series-A series about making a programming language called Eldiro using the Rust programming language. (read pratt pasing first)
• Playlist-Writing a Programming Language
• Book-Create Your Own Programming Language with Rust

Courses that are not necessary but I think they are cool

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

• Diving into Rust with a CLI
• Book-Command Line Book
• Book-Command-Line Rust Repo Learn the language by writing Rust versions of common Unix coreutils like head, tail, cal, cut, comm, etc.
• Rain's Rust CLI recommendations
• Crates
  • StructOpt, parses command line arguments by defining a struct
  • Clap, Command Line Argument Parser for Rust
  • tui-rs, library to build rich terminal user interfaces and dashboards.
  • Cursive, a TUI (Text User Interface) library for rust.
  • Termion,manipulation terminals.
  • Crossterm, pure-rust, terminal manipulation
  • pancurses, a curses library for Rust

• Rust web framework list and comparison
• Book-Zero to Production in Rust Repo
• Book-Black Hat Rust
• Book-Rust Servers, Services, and Apps
• Book-Rust Web Development
• Build a Smart Bookmarking Tool with Rust and Rocket and Heruko
• Roadmap to becoming a Rust Web Developer

• Learning Rust by Coding a Game of Snake
• Tic Tac Toe
• Sokoban Game
• Book-Hands-on Rust: A hands-on guide to learning Rust by making games
• Book-The ray tracer challenge
• Writing a Rust Roguelike for the Desktop and the Web
• Roguelike Tutorial in Rust + tcod

• webassembly.org
• Official WebAssembly Rust page
• Book-WebAssembly Book
• WebAssembly Mozilla Dev network
• A curated list of awesome things related to Yew / WebAssembly
• wasm.builders
• Rust-and-webassembly-from-scratch
• Using Rust and WebAssembly to Process Pixels from a Video Feed
• Bringing WebAssembly outside the web with WASI
• Getting started with Rust functions in Node.js
• Book-Programming WebAssembly with Rust
• Hello wasm-pack! - documentation and tutorials on how to use wasm-pack
• The wasm-pack Guide
• WASM it
• The wasm-bindgen Guide
• Writing a Rust Roguelike for the Desktop and the Web
• Create a simulation of evolution using neural network and genetic algorithm, and compile the application to WebAssembly
• Rust Raytracer compiled to Webassembly to run live in browser

• FLTK Rust gui tutorial: Basics
• How I Built a Cross-Platform Desktop Application with Svelte, Redis, and Rust
• Druid
• Druid todo Tutorial
• Book-gtk4-rs book
• Book-GUI development with Relm4
• 7 GUI Tasks

• Flutter+Rust
• Using WebAssembly in Flutter Web
• Write UI using Flutter, a cross-platform hot-reload high-performance toolkit, seamlessly with Rust
• rust-on-mobile
• Rust on iOS
• Building and Deploying a Rust library on Android
• Building and Deploying a Rust library on iOS

• Book-Blockchain For Rust Developers
• Awesome Blockchain Rust
• Rust in Blockchain
• Where is the best place to learn Rust in context of Crypto/Blockchain

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.

A better or detailed explanations of some Rust language features.

• There are no mutable parameters in Rust
• Rust Module System
• Mixing matching, mutation, and moves in Rust
• Rust Ownership, the Hard Way
• I do understand the * operator in Rust now (updated)
• String concatenations benchmarks (updated)
• Lifetimes:
  • Understanding Rust Lifetimes
  • Common Rust Lifetime Misconceptions
• Closures:
  • Understanding Closures in Rust
  • Why Rust Closures are (Somewhat) Hard
• Traits
  • Tour of Rust's Standard Library Traits
  • Rust Ergonomics: Default and From
  • A new impl Trait 1/4 (davidkoloski.me)
• Iterators:
  • Little tour of multiple iterators implementation in Rust
  • for loops in Rust - Karol Kuczmarski
  • Iteration patterns for Result & Option - Karol Kuczmarski
  • rust-iterators - Max Skybin
  • Creating an Iterator in Rust
• Errors:
  • Wrapping errors in Rust - Wrapping reqwest::Error and a custom error type as an enum to make library usage easier. Also mentions thiserror to automate that process.
  • Context-preserving error handling - Explains how to use crates like thiserror in combination with map_err to add context to errors to prevent information loss.
• Macros:
  • The Little Book of Rust Macros This book is an attempt to distill the Rust community's collective knowledge of Rust macros.
  • Rust macro development case studies
  • Rust Latam: procedural macros workshop _This repo contains a selection of projects designed to learn to write Rust procedural macros — Rust code that generates Rust code.
• Async, Concurrency & Parallelism:
  • Rust &TheMachine
  • Asynchronous Programming in Rust
  • Async-std
  • A practical guide to async in Rust
  • The Node Experiment - Exploring Async Basics with Rust
  • Async Rust in Practice: Performance, Pitfalls, Profiling
  • areweasyncyet.rs/
  • Stakker actor runtime guide: a low-level single-thread actor runtime for Rust
  • Systems with JT: Async/await in Rust
  • Real-Time Interrupt-driven Concurrency
  • Hands-On Concurrency with Rust
  • Futures Explained in 200 Lines of Rust
  • Tokio Tutorial - event-driven, non-blocking I/O
  • Why Rust mutexes look like they do
• FFI:
  • I C and .so does Rust
  • The Rust FFI Guide - using unsafe for fun and profit - Michael-F-Brya
  • Writing fast and safe native Node.js modules with Rust - Peter Czibik
  • The Rust FFI Omnibus
  • The (unofficial) Rust FFI Guide - FFI in depth

• Cheat Sheets:
  • Rust Cheat Sheet
  • Another Cheat sheet
  • Rust Types Methods Cheat sheet
  • Another Rust Types Methods Cheat sheet
  • The Periodic Table of Rust Types
  • Rust Ownership Cheat sheet
  • Iterator Cheat Sheet
  • Rust Container Cheat Sheet
  • Learn Rust with a few minutes to spare
  • Do the same things in Rust!
  • Notes for small Rust snippets
• References:
  • Book-Rust for Rustaceans - Covers how to design reliable, idiomatic, and ergonomic Rust programs based on best principles.
  • Book-Programming Rust
  • Official Ressources
    • Standard Library
    • Cargo Book
    • Rust doc Book
    • Rustc Book
    • Clippy
    • Compiler Error Index
    • The Rust Reference
• Guidelines and Idioms:
  • Rust by Example A community driven collection of example code which follow Rust best practices.
  • Rust Cook Book a collection of simple examples that demonstrate good practices to accomplish common programming tasks.
  • Rust API guidelines An extensive list of recommendations for idiomatic Rust APIs.
  • Rust Design Patterns A catalogue of design patterns in Rust.
  • Elegant Library APIs in Rust
  • Effective Rust - Rust guidelines
  • Rust Programming Tipz A collection of software engineering techniques for effectively expressing intent with Rust.
  • The Rust Performance Book
  • Secure Rust Guidelines
  • stdx: Learn these crates first as an extension to std
  • Common Newbie Mistakes and Bad Practices in Rust: Bad Habits
  • Are out parameters idiomatic in Rust? - Discusses the pros and cons of functions returning a value vs. modifying a parameter in-place.
  • Aiming for idiomatic Rust Discusses different ways to solve a popular coding puzzle, "balanced brackets", in Rust.
  • Hexagonal architecture in Rust
• Debugging:
  • explaine.rs
  • Compiler Explorer
  • Pernos demo
  • Debugging a segfault in my Rust program
  • Profiling Rust applications on Linux
• Compiling
  • How to speed up the Rust compiler in April 2022
  • Tips for Faster Rust Compile Times
  • Compile Time Feature Flags in Rust
• Benchmark:
  • Benchmarking programs in Rust
  • Criterion.rs Benchmark
• Cargo:
  • Most useful Rust cargo tools
• Tools:
  • Awesome Rust: Development Tools
  • Awesome Rust: Libraries
  • Caniuse.rs - Rust feature search
  • Rust external web APIs: The definitive guide Githib api, Discord...etc

• Rust verification tools
• Rust Fuzz Book Fuzz testing
• Great Rust CI
• Keeping Rust projects' README.md code examples up-to-date
• Guide on how to write documentation for a Rust crate - Writing good documentation with rustdoc including many examples.
• rust-cross, Everything you need to know about cross compiling Rust programs! - Jorge Aparicio
• Building an open source project?
  • TP 101: Introduction to open source software
  • TP 102: How to use Git and GitHub
  • TP 103: Build a welcoming community

• Projects-from-Scratch Projects Ideas.
• Learning Parser Combinators With Rust
• Blog-Rust and CSV Parsing
• Learning Rust: Let's Build a Parser!
• Why your first FizzBuzz implementation may not work
• Web browser from scratch in Rust
• Implementing ArrayVec Using Const Generics
• Build Your Own Shell using Rust_
• Elegant Rust Codebases:
  • ripgrep (rg) a line-oriented search tool.
  • Tealdeer (tldr) a fast cli tool to learn basic uses for many commands
  • GNU coreutils in Rust
  • Awesome Rust: Applications
• Rewrite in Rust Exercises
  • A Regular Expression Matcher
  • Regular Expression Matching Can Be Simple And Fast
  • Projects Ideas

• Awesome Rust Streaming
• Hackr.io: most upvoted Rust ressources
• Morioh
• AreWeRustYet
• Lobsters.rs
• Rust official Blog
• This Week in Rust
• Dev.to Rust
• Llogiq on stuff
• Niko Matsakis
• Endler
• Lucas Palmieri
• Michael Gattozzi
• MICHAEL-F-BRYAN
• Faster Than Lime
• Antoyo's Blog
• Sylvain Kerkour
• matklad
• Manning Publications Rust channel
• Gamozolabs Security researcher who writes everything in rust, primarily focused on fuzzing
• Possible Rust A blog for intermediate Rust programmers exploring real-world code and design patterns.

• The Rust Programming Language Forum
• Stackoverflow Rust questions
• Rust Mentors
• Rustacean Station
• Rust-Saar
• Rust Programming Language Community Discord Server
• Rust Programming Language Official Discord Server
• Rustacean Station Discord Server
• Rust بالعربي Discord Server
• zulip chat

• RustJobs
• Companies that use Rust