Rust on Software Engineering Learning Paths

Getting Started

Mon, 01 Jan 0001 00:00:00 +0000

Getting Started#

Rust’s toolchain is self-contained and well-designed. rustup manages versions, cargo handles building, testing, and dependency management. Within minutes of installation you can compile, run, test, and lint Rust code.

Installation#

# Install rustup (manages Rust versions)
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Verify
rustc --version # compiler
cargo --version # build tool + package manager
rustup --version # toolchain manager

Toolchain Management#

rustup update # update to latest stable
rustup default stable # use stable channel
rustup default nightly # use nightly (for bleeding-edge features)
rustup component add clippy # add linter
rustup component add rustfmt # add formatter
rustup target add wasm32-unknown-unknown # add WebAssembly target

Hello World#

fn main() {
 println!("Hello, World!");
}

rustc main.rs # compile directly
./main # run

# But in practice, always use cargo:
cargo new hello # creates a project
cd hello
cargo run # compile + run

What’s `println!`?#

The ! indicates a macro, not a function. Macros are expanded at compile time — println! accepts variable argument counts and format strings that are checked at compile time.

Types & Variables

Mon, 01 Jan 0001 00:00:00 +0000

Types & Variables#

Rust is statically typed with powerful type inference. The compiler deduces most types, but you must be explicit in function signatures. Every value has exactly one owner, a fixed type, and a fixed size known at compile time (or stored behind a pointer).

Scalar Types#

Type	Size	Range	Example
`i8`	1 byte	-128 to 127	`let x: i8 = -42;`
`i16`	2 bytes	-32,768 to 32,767
`i32`	4 bytes	-2³¹ to 2³¹-1	Default integer type
`i64`	8 bytes	-2⁶³ to 2⁶³-1
`i128`	16 bytes	Very large
`isize`	Pointer-sized	Platform-dependent	Index into collections
`u8`	1 byte	0 to 255	Bytes, ASCII
`u16`	2 bytes	0 to 65,535
`u32`	4 bytes	0 to 2³²-1
`u64`	8 bytes	0 to 2⁶⁴-1
`u128`	16 bytes	Very large
`usize`	Pointer-sized	Platform-dependent	Array indices, sizes
`f32`	4 bytes	~7 digits
`f64`	8 bytes	~15 digits	Default float type
`bool`	1 byte	`true` / `false`
`char`	4 bytes	Unicode scalar value	`'a'`, `'🦀'`

Integer Literals#

let decimal = 98_222; // underscores for readability
let hex = 0xff;
let octal = 0o77;
let binary = 0b1111_0000;
let byte_literal = b'A'; // u8 only

Integer Overflow#

In debug mode, overflow panics. In release mode, it wraps (two’s complement). To be explicit:

Ownership & Borrowing

Mon, 01 Jan 0001 00:00:00 +0000

Ownership & Borrowing#

This is the concept that makes Rust unique. The ownership system is a set of compile-time rules that ensure memory safety without a garbage collector. Every value has exactly one owner, and when the owner goes out of scope, the value is dropped (freed). Borrowing lets you temporarily access values without taking ownership.

The Three Rules of Ownership#

Each value has exactly one owner.
When the owner goes out of scope, the value is dropped.
Ownership can be transferred (moved) but not duplicated (for non-Copy types).

{
 let s = String::from("hello"); // s owns the String
 // s is valid here
} // s goes out of scope — String is dropped, memory freed

No garbage collector. No manual free(). The compiler inserts drop calls at the right places.

Structs & Enums

Mon, 01 Jan 0001 00:00:00 +0000

Structs & Enums#

Structs group related data. Enums represent values that can be one of several variants. Together with pattern matching, they form Rust’s primary data modelling toolkit — replacing classes, inheritance, and null in other languages.

Structs#

struct User {
 id: u64,
 name: String,
 email: String,
 active: bool,
}

let user = User {
 id: 1,
 name: String::from("Alice"),
 email: String::from("alice@example.com"),
 active: true,
};

println!("{}", user.name);

Field Init Shorthand#

fn new_user(name: String, email: String) -> User {
 User {
 id: generate_id(),
 name, // shorthand: field name matches variable name
 email, // same
 active: true,
 }
}

Struct Update Syntax#

let user2 = User {
 email: String::from("bob@example.com"),
 ..user // take remaining fields from user (MOVES String fields)
};

Tuple Structs#

struct Color(u8, u8, u8);
struct Point(f64, f64);

let red = Color(255, 0, 0);
let origin = Point(0.0, 0.0);
println!("r={}", red.0);

Unit Structs#

struct AlwaysEqual; // no fields, used as markers or trait implementations

Methods#

Defined in impl blocks:

Error Handling

Mon, 01 Jan 0001 00:00:00 +0000

Error Handling#

Rust uses Result<T, E> for recoverable errors and panic! for unrecoverable ones. There are no exceptions, no try/catch — errors are values in the type system, and the compiler forces you to handle them.

Result<T, E>#

enum Result<T, E> {
 Ok(T), // success with value
 Err(E), // failure with error
}

use std::fs;

fn read_config(path: &str) -> Result<String, std::io::Error> {
 fs::read_to_string(path)
}

match read_config("config.toml") {
 Ok(contents) => println!("{contents}"),
 Err(e) => eprintln!("Failed to read config: {e}"),
}

The `?` Operator#

? propagates errors — if the Result is Err, return it immediately; if Ok, unwrap the value:

Collections & Iterators

Mon, 01 Jan 0001 00:00:00 +0000

Collections & Iterators#

Rust’s collections are heap-allocated, growable data structures. Its iterator system is the primary way to process collections — zero-cost abstractions that compile to code as fast as hand-written loops.

Vec — Dynamic Array#

// Create
let mut v: Vec<i32> = Vec::new();
let v = vec![1, 2, 3, 4, 5]; // macro shorthand
let v = vec![0; 10]; // 10 zeros
let v = Vec::with_capacity(100); // pre-allocate

// Access
let first = v[0]; // panics if out of bounds
let first = v.get(0); // returns Option<&T>
let last = v.last(); // Option<&T>

// Modify
v.push(6);
v.pop(); // returns Option<T>
v.insert(0, 10); // insert at index
v.remove(2); // remove at index
v.retain(|x| x % 2 == 0); // keep only evens
v.sort();
v.dedup(); // remove consecutive duplicates

// Iteration
for item in &v { ... } // borrow
for item in &mut v { ... } // mutable borrow
for item in v { ... } // consume (v is moved)

// Slicing
let slice: &[i32] = &v[1..4];

Vec Internals#

A Vec<T> is three values on the stack: pointer, length, capacity.

Traits & Generics

Mon, 01 Jan 0001 00:00:00 +0000

Traits & Generics#

Traits define shared behaviour. Generics enable type-safe code that works across multiple types. Together they form Rust’s mechanism for polymorphism — replacing inheritance and interfaces from object-oriented languages.

Traits#

A trait defines a set of methods a type can implement:

trait Summary {
 fn summarize(&self) -> String;

 // Default implementation (can be overridden)
 fn preview(&self) -> String {
 format!("{}...", &self.summarize()[..20])
 }
}

Implementing a Trait#

struct Article {
 title: String,
 author: String,
 content: String,
}

impl Summary for Article {
 fn summarize(&self) -> String {
 format!("{}, by {}", self.title, self.author)
 }
 // preview() uses the default implementation
}

let article = Article { /* ... */ };
println!("{}", article.summarize());

Orphan Rule#

You can implement a trait for a type only if either the trait or the type is defined in your crate. You cannot implement a foreign trait for a foreign type.

Lifetimes

Mon, 01 Jan 0001 00:00:00 +0000

Lifetimes#

Lifetimes are Rust’s way of ensuring that references are always valid. They are annotations that tell the compiler how long a reference must live. Most of the time, the compiler infers lifetimes automatically. You only need explicit annotations when the compiler cannot figure it out.

What Lifetimes Prevent#

// C — dangling pointer (compiles, crashes at runtime)
int* dangling() {
 int x = 42;
 return &x; // x is freed when function returns — pointer is invalid
}

// Rust — compiler rejects this
fn dangling() -> &i32 {
 let x = 42;
 &x // ERROR: `x` does not live long enough
}

The compiler tracks how long every reference is valid and rejects code where a reference outlives its referent.

Concurrency

Mon, 01 Jan 0001 00:00:00 +0000

Concurrency#

Rust makes data races impossible at compile time. The type system (via Send and Sync traits) ensures that data shared between threads is always properly protected. If it compiles, there are no data races.

Threads#

use std::thread;

let handle = thread::spawn(|| {
 println!("hello from thread");
 42 // return value
});

let result = handle.join().unwrap(); // 42

Moving Data into Threads#

let name = String::from("Alice");

// ERROR: closure might outlive name
// thread::spawn(|| println!("{name}"));

// OK: move ownership into the thread
thread::spawn(move || {
 println!("{name}");
});
// name is no longer accessible here

Scoped Threads (Rust 1.63+)#

Scoped threads can borrow from the parent stack:

Smart Pointers & Memory

Mon, 01 Jan 0001 00:00:00 +0000

Smart Pointers & Memory#

Smart pointers are types that act like pointers but have additional metadata and capabilities. They manage memory automatically through ownership and the Drop trait. Understanding them is essential for complex data structures, interior mutability, and interop with C.

Box — Heap Allocation#

Box<T> puts a value on the heap. The Box itself (a pointer) lives on the stack.

let b = Box::new(5);
println!("{b}"); // auto-derefs to i32

When to Use Box#

Use Case	Why
Recursive types	Compiler needs a known size
Large data	Avoid stack overflow or expensive copies
Trait objects	`Box<dyn Trait>` for dynamic dispatch
Transferring ownership	When you need a heap allocation

Recursive Types#

// ERROR: size of List is infinite
// enum List { Cons(i32, List), Nil }

// OK: Box gives a fixed-size pointer
enum List {
 Cons(i32, Box<List>),
 Nil,
}

let list = List::Cons(1, Box::new(List::Cons(2, Box::new(List::Nil))));

Rc — Reference Counting (Single-Threaded)#

Multiple ownership via reference counting. The value is dropped when the last Rc is dropped.

Modules & Cargo

Mon, 01 Jan 0001 00:00:00 +0000

Modules & Cargo#

Rust’s module system organises code within a crate. Cargo manages building, testing, dependencies, workspaces, and publishing. Together they handle projects from single files to large monorepos.

Module System#

Declaring Modules#

// src/lib.rs or src/main.rs
mod handler; // looks for src/handler.rs or src/handler/mod.rs
mod service; // looks for src/service.rs or src/service/mod.rs

pub mod api { // inline module
 pub fn health() -> &'static str { "ok" }
}

File Layout#

src/
├── main.rs // crate root for binary
├── lib.rs // crate root for library
├── handler.rs // module: crate::handler
├── handler/
│ ├── mod.rs // alternative to handler.rs (older style)
│ └── middleware.rs // submodule: crate::handler::middleware
├── service.rs // module: crate::service
└── model/
 ├── mod.rs // module: crate::model
 ├── user.rs // submodule: crate::model::user
 └── order.rs // submodule: crate::model::order

Visibility#

pub struct User { // public struct
 pub name: String, // public field
 email: String, // private field (default)
}

pub fn create_user() { } // public function
fn validate() { } // private function (default)

pub(crate) fn internal() { } // visible within the crate only
pub(super) fn parent() { } // visible to parent module only

Use and Re-exports#

// Import
use crate::model::user::User;
use crate::service::{UserService, OrderService};
use std::collections::HashMap;

// Glob import (avoid in production code)
use std::io::*;

// Re-export — make internal items available at a higher level
pub use crate::model::user::User;
// Now consumers can use: your_crate::User instead of your_crate::model::user::User

Crates#

A crate is a compilation unit — the smallest amount of code the compiler considers at once.

Patterns & Ecosystem

Mon, 01 Jan 0001 00:00:00 +0000

Patterns & Ecosystem#

Rust has a rich ecosystem of crates and a strong culture of idiomatic patterns. This section covers the design patterns you will encounter in production Rust code and the key crates that form the practical foundation of the language.

The Builder Pattern#

For complex struct construction:

#[derive(Debug)]
struct Request {
 url: String,
 method: String,
 headers: Vec<(String, String)>,
 body: Option<String>,
 timeout: std::time::Duration,
}

struct RequestBuilder {
 url: String,
 method: String,
 headers: Vec<(String, String)>,
 body: Option<String>,
 timeout: std::time::Duration,
}

impl RequestBuilder {
 fn new(url: impl Into<String>) -> Self {
 Self {
 url: url.into(),
 method: "GET".to_string(),
 headers: Vec::new(),
 body: None,
 timeout: std::time::Duration::from_secs(30),
 }
 }

 fn method(mut self, method: impl Into<String>) -> Self {
 self.method = method.into();
 self
 }

 fn header(mut self, key: impl Into<String>, value: impl Into<String>) -> Self {
 self.headers.push((key.into(), value.into()));
 self
 }

 fn body(mut self, body: impl Into<String>) -> Self {
 self.body = Some(body.into());
 self
 }

 fn timeout(mut self, timeout: std::time::Duration) -> Self {
 self.timeout = timeout;
 self
 }

 fn build(self) -> Request {
 Request {
 url: self.url,
 method: self.method,
 headers: self.headers,
 body: self.body,
 timeout: self.timeout,
 }
 }
}

// Usage
let req = RequestBuilder::new("https://api.example.com")
 .method("POST")
 .header("Content-Type", "application/json")
 .body(r#"{"key": "value"}"#)
 .build();

The Newtype Pattern#

Wrap a type for type safety, trait implementations, or semantic meaning:

Rust on Software Engineering Learning Paths

Getting Started

Getting Started#

Installation#

Toolchain Management#

Hello World#

What’s println!?#

Types & Variables

Types & Variables#

Scalar Types#

Integer Literals#

Integer Overflow#

Ownership & Borrowing

Ownership & Borrowing#

The Three Rules of Ownership#

Structs & Enums

Structs & Enums#

Structs#

Field Init Shorthand#

Struct Update Syntax#

Tuple Structs#

Unit Structs#

Methods#

Error Handling

Error Handling#

Result<T, E>#

The ? Operator#

Collections & Iterators

Collections & Iterators#

Vec — Dynamic Array#

Vec Internals#

Traits & Generics

Traits & Generics#

Traits#

Implementing a Trait#

Orphan Rule#

Lifetimes

Lifetimes#

What Lifetimes Prevent#

Concurrency

Concurrency#

Threads#

Moving Data into Threads#

Scoped Threads (Rust 1.63+)#

Smart Pointers & Memory

Smart Pointers & Memory#

Box — Heap Allocation#

When to Use Box#

Recursive Types#

Rc — Reference Counting (Single-Threaded)#

Modules & Cargo

Modules & Cargo#

Module System#

Declaring Modules#

File Layout#

Visibility#

Use and Re-exports#

Crates#

Patterns & Ecosystem

Patterns & Ecosystem#

The Builder Pattern#

The Newtype Pattern#

What’s `println!`?#

The `?` Operator#