Who is this for
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+ No Concept of
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The
+
+
+
+
+
+
+ The
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/courses/IntroToRust/src/main.js b/courses/IntroToRust/src/main.js
new file mode 100644
index 0000000..793f962
--- /dev/null
+++ b/courses/IntroToRust/src/main.js
@@ -0,0 +1,25 @@
+import Reveal from "reveal.js";
+import Notes from "reveal.js/plugin/notes/notes.esm.js";
+import Highlight from "reveal.js/plugin/highlight/highlight.esm.js";
+
+import "reveal.js/dist/reveal.css";
+import "reveal.js/dist/theme/black.css";
+import "reveal.js/plugin/highlight/monokai.css";
+import "../css/custom.css";
+
+import slidesHTML from "../slides/slides.html?raw"; // raw loader, make sure your bundler supports this
+
+document.addEventListener("DOMContentLoaded", () => {
+ const slidesContainer = document.querySelector(".slides");
+ slidesContainer.innerHTML = slidesHTML; // directly inject the HTML slides
+
+ const deck = new Reveal({
+ hash: true,
+ plugins: [Highlight, Notes],
+ });
+
+ deck.initialize({
+ center: false,
+ slideNumber: true,
+ });
+});
diff --git a/courses/IntroToRust/vite.config.js b/courses/IntroToRust/vite.config.js
new file mode 100644
index 0000000..559d6ac
--- /dev/null
+++ b/courses/IntroToRust/vite.config.js
@@ -0,0 +1,12 @@
+import { defineConfig } from "vite";
+import { viteSingleFile } from "vite-plugin-singlefile";
+
+export default defineConfig({
+ plugins: [viteSingleFile()],
+ build: {
+ rollupOptions: {
+ input: "index.html",
+ },
+ assetsInlineLimit: 100_000, // inline images/fonts up to ~100kb, save server space, enforce this?
+ },
+});
-
+
- Students +
- Developers +
- Engineers +
+
+
+Rust
+
+ 
+
+-
+
- Programming Language +
- Many advantages over other language +
- Makes C++ nervous +
+ Ferris!
+
+ 
+
+-
+
- Awesome Mascot +
- Ferris! +
- Favorite Crustacean +
+ White House
+
+
+ 
+
+-
+
- Over 50% of CVEs are memory-safety bugs +
- National security nightmare +
- Feb. 2024 Press Release +
+
+Errors
+
+
+ 
+
+-
+
- Programming errors +
- Developers are not infallible +
- Basic memory errors +
+ Javascript Errors
+-
+
- What does this look like? +
const arr = ["alice", "bob", "charlie"];
+console.log(arr[5])-
+
- + Result: + +
UndefinedWhat's worse?
+
+
+ 
+
+-
+
- Only thing worse than an error +
- No error at all! +
- Engineers > Web Developers! +
+ MatLab Errors
+ +-
+
- Similar syntax +
arr = ["alice", "bob", "charlie"]
+x = arr(5)-
+
- Result: +
Index exceeds the number of array elements.
+Index must not exceed 3.
+Error in file (line 2)
+x = arr(5);This is good!
+
+
+
+-
+
- An error was caught +
- Informed the developer +
- But *who* caught this error? +
- Can we do better? +
+ Small Beginnings
+
+ 
+
+-
+
- Before we tackle how Rust handles this +
- First Rust program +
cargo init
+ cargo run
+
+ Greatness
+fn main() {
+ let greeting = "Hello, world!";
+ println!("{}", greeting);
+}
+
+
+-
+
- Main function +
- Bindings via
let
+ - Print to
stdout
+
+Arrays
+fn main() {
+ let arr = ["alice", "bob", "charlie"];
+ let x = arr[5];
+}-
+
- Similar to MatLab +
- Arrays with [ ]'s +
- Inferred → Strong + Static +
- Compiler knows the size +
Compile Time Error
+
+
+ -
+
- Program never actually ran +
Anatomy of a Compiler Error
+-
+
- Compiler knows more than you do +
- Safety as a feature +
- "This will panic at runtime" +
- You live in compiler-land before runtime +
- The compiler is your pair programmer +
Rust Philosophy
+
+ 
+
+-
+
- Make the compiler do the heavy lifting +
- Catch bugs before the code runs +
- Safety without sacrificing control +
+ Data + Compiler
+fn main() {
+ let x = 5;
+ x += 1;
+}-
+
- We forgot something +
- Safety is a priority +
- Tell Rust when data is mutable +
Compiler Messages
+
+ -
+
- Legitimately useful help message +
fn main() {
+ let mut x = 5;
+ x += 1;
+}
+
+ 
+
+-
+
- Opt-in philosophy +
- Safety as a feature +
- Allows the data's binding to mutate it how it pleases +
+ Stack Overflow
+Most-Loved Language
+ +-
+
- 2016 → Rust +
- 2017 → Rust +
- 2018 → ... +
- 2023 → Rust +
- 2024 → Rust +
The Billion Dollar Mistake
+
+ 
+
+-
+
- Tony Hoare +
- ALGOL, 1965 +
- "Simply because it was so easy to implement" +
- NULL +
+ No Concept of NULL
+ -
+
- Rust does NOT have a null type +
- No NULL → Less Memory errors +
- But things don't always strictly "exist"? +
- How does Rust accomplish this? +
The Type System
+
+ 
+
+-
+
- Algebraic Types +
- Lets the compiler do the work +
- Extensive Enums +
- C-Style* structs +
+ Enums
+
+ 
+
+-
+
- NOT just named integers +
- Compiler knows every enum type +
- Provable +
- "Sum Type" +
+ Classic Example
+enum Direction {
+ North,
+ South,
+ East,
+ West,
+}-
+
- The compiler knows that if you have a Direction +
- It must be one of those 4 types +
- Sum of the number of enumerations +
Structs
+
+ 
+
+
+-
+
- Groups related data together +
- Non mutually-exclusive +
- "Product Type" +
+ Simple Color
+struct Color{
+ r: bool,
+ g: bool,
+ b: bool,
+}
+
+let black = Color { r: false, g: false, b: false };
+let blue = Color { r: false, g: false, b: true };
+let white = Color { r: true, g: true, b: true };-
+
- If you have a Color: +
- It must be one of those 8 types +
- Product of the number of enumerations +
Match
+
+
+ 
+
+
+-
+
matchkeyword
+ - An exhaustive advanced switch +
- Only possible via algebraic types +
+ let x = match get_direction() {
+ Direction::North => 1,
+ Direction::East => 2,
+ Direction::South => 3,
+};
+ 
+
+-
+
- Exhaustion is a feature +
- Prevents bugs +
- Always ensure your code functions as intended +
- Localize state management +
+ Compile Error
+
+
+Simple Fix
+let x = match get_direction() {
+ Direction::North => 1,
+ Direction::East => 2,
+ Direction::South => 3,
+ Direction::West => 4
+};-
+
- Happy Compiler +
- Proved every case +
Type Composition
+
+
+ 
+
+-
+
- Model your data +
- Without classes +
- Complex relations +
+ Cats?
+struct FakeCat {
+ alive: bool,
+ hungry: bool,
+}
+ 
+
+-
+
- Copies OOP paradigms +
- But are there really 4 types of cats? +
- Can a dead cat be hungry? +
+ Build a Better Type
+enum RealCat {
+ Alive { hungry: bool },
+ Dead,
+}-
+
- Composition → better modeling +
- Real life is not classes +
- Real life is data +
- Encode real data with your own, specific type system +
Covering Your Bases
+let status = match getCat() {
+ RealCat::Alive { hungry: true } => "Feed me!",
+ RealCat::Alive { hungry: false } => "Doing great",
+ RealCat::Dead => ":(",
+}-
+
- Algebraic types +
- Provably exhaustive +
- Encoded only the necessary state +
- Build your own type system → NULL? +
The Option Type
+ -
+
- Explicit:
Some(T)orNone
+ - Forces handling of missing values +
- Compiler ensures you check it +
pub enum Option<T> {
+ None,
+ Some(T),
+}None
+fn find_user_id(name: &str) -> Option<i32> {
+ // or return Some(user)
+ return None;
+}
+fn main() {
+ match find_user_id("Alice") {
+ Some(id) => println!("Found user with id {id}"),
+ None => println!("User not found"),
+ }
+}-
+
- None only exists where it needs to +
- Limited scope → handled immediately +
- Never NULL → but what about errors? +
The Result Type
+ -
+
- Explicit:
Ok(T)orErr(T)
+ - Errors are expected +
- They are not an "exception" +
enum Result<T, E> {
+ Ok(T),
+ Err(E),
+}Error Handling
+fn divide(a: i32, b: i32) -> Result<i32, String> {
+ if b == 0 {
+ return Err("cannot divide by zero".to_string());
+ }
+ Ok(a / b)
+}
+
+fn main() {
+ let x = match divide(10, 2) {
+ Ok(result) => result * 2,
+ Err(err) => 0,
+ };
+}Chaining
+fn divide(a: i32, b: i32) -> Result<i32, String> {
+ if b == 0 {
+ return Err("cannot divide by zero".to_string());
+ }
+ return Ok(a / b);
+}
+
+fn do_math() -> Result<i32, String> {
+ let temp = divide(15, 3)?;
+ return Ok(temp);
+}
+
+-
+
- ? → early return if Err() +
- ? → get value if Ok() +
Memory Management
+-
+
- No garbage collector +
- No manual
free()
+ - Ownership & Borrowing system +
Ownership Rules
+
+
+ 
+
+-
+
- Each value has one owner +
- Ownership is transferred on assignment +
- When the owner goes out of scope → value freed +
+ Ownership Ideas
+fn greet(name: String) {
+ println!("Hello, {}!", name);
+}
+
+fn main() {
+ let name = String::from("Bob");
+
+ greet(name);
+
+ println!("You greeted {}", name);
+}
+ -
+
- `let` is a binding +
- Variable Owns → Some Data +
fn greet(name: String) {
+ println!("Hello, {}!", name);
+}
+
+fn main() {
+ let name = String::from("Bob");
+
+ greet(name);
+
+ println!("You greeted {}", name);
+}
+ fn greet(name: &String) {
+ println!("Hello, {}!", name);
+}
+
+fn main() {
+ let name = String::from("Bob");
+
+ greet(&name);
+
+ println!("You greeted {}", name);
+}
+ -
+
- Lets pass a reference instead +
- Compiler needs to know this +
- Change the signature +
- Immutable Borrow +
fn greet(name: &String) {
+
+ name = &name.to_uppercase();
+ println!("Hello, {}!", name);
+}
+
+fn main() {
+ let name = String::from("Bob");
+
+ greet(&name);
+
+ println!("You greeted {}", name);
+}
+ -
+
- Attempting to edit name +
- But main() never promised this +
- Compiler Error +
fn greet(name: &String) {
+ name = &name.to_uppercase();
+ println!("Hello, {}!", name);
+}
+
+fn main() {
+ let name = String::from("Bob");
+ greet(&name);
+ println!("You greeted {}", name);
+}
+ fn greet(name: &mut String) {
+ *name = name.to_uppercase();
+ println!("Hello, {}!", name);
+}
+
+fn main() {
+ let mut name = String::from("Bob");
+ greet(&mut name);
+ println!("You greeted {}", name);
+}
+ -
+
- Opt in to `mut` +
- Call site changes +
- 1 Mutable reference +
- ∞ *Immutable* references +
- 1 Owner +
Why have all that?
+ +
+ 
+
+-
+
- Strict State Management +
- Prevent Bugs +
- No manual memory management +
- No garbage collector +
+ No-Cost Abstractions
+-
+
- High-level code that compiles to low-level performance +
- Zero runtime overhead for iterators, generics, traits +
- "You don’t pay for what you don’t use" +
Macros
+
+ 
+
+
+-
+
- Works with the type system +
- Operate on Rust tokens +
- Compile-time code generation +
- Enables
println!,vec!,format!
+ - Powerful but safe +
+ Macro Definition
+macro_rules! say_hello {
+ () => {
+ println!("Hello, world!");
+ };
+}
+
+fn main() {
+ say_hello!();
+}-
+
- Simple example +
- Can pass token stream +
- Turtles all the way down +
- Forward-growth mindset +
Macro Examples
+fn main() {
+ let names = vec!("Alice", "Bob", "Charlie");
+
+ let x = true;
+ assert!(x, "x wasn't true!");
+
+ println!("{:?}", names);
+}
+ -
+
- Vector of data +
- Simple Assertions +
- Powerful, relevant, forever +
Cargo
+
+ 
+
+-
+
- Rust’s package manager + build system +
- Handles dependencies, testing, documentation +
- Enables Rust's rich, stable ecosystem +
+ [package]
+name = "IntroToRust"
+version = "0.1.0"
+edition = "2021"
+authors = ["Reese Hatfield <reese@example.com>"]
+description = "Introductory Rust code snippets"
+license = "MIT"
+
+[dependencies]
+rand = "0.8"
+chrono = "0.4"-
+
- Cargo.toml +
- cargo run → Run project +
- cargo test → Test project +
- cargo publish → Publish to an extensive ecosystem +
Universal Language
+
+ 
+
+-
+
- Systems Programming +
- Web (WASM) +
- Backend Services +
- Embedded + IoT +
- Games + Engines +
+ Famous Rust Users
+
+ 
+
+-
+
- Microsoft +
- AWS +
- Cloudflare +
- Your next company +
+ Why Rust?
+ +
+
+
+-
+
- Safety without GC +
- Performance without pain +
- Compiler is your friend +
- Strong type system +
- Active community +
+