OWNERSHIP
& BORROWING

The Three Rules

• Every value has exactly one owner (a variable)
• When the owner goes out of scope, the value is dropped (memory freed — no GC needed)
• There can be either one mutable reference OR any number of immutable references — never both

Move Semantics

let s1 = String::from("hello");
let s2 = s1;  // s1 is MOVED into s2
println!("{}", s1);  // COMPILE ERROR: value moved

// Fix 1: Clone (deep copy)
let s3 = s2.clone();

// Fix 2: Borrow (reference)
let s4 = &s2;  // s2 still owns the data
println!("{} {}", s2, s4);  // both work

Borrowing in Practice

fn calculate_total(orders: &[Order]) -> f64 {
    // takes immutable borrow — caller still owns orders
    orders.iter().map(|o| o.price * o.qty as f64).sum()
}

fn apply_discount(orders: &mut Vec<Order>, pct: f64) {
    // mutable borrow — exclusive access
    for o in orders.iter_mut() {
        o.price *= 1.0 - pct;
    }
}

Lifetimes: References Must Not Outlive Data

// This won't compile — reference outlives the data
fn dangling() -> &str {
    let s = String::from("hello");
    &s  // ERROR: s is dropped here, reference would dangle
}

// This is fine — the reference borrows from the caller's data
fn first_word(s: &str) -> &str {
    s.split_whitespace().next().unwrap_or("")
}

RESULT,
OPTION &
ERROR

Option: No Null Pointer Exceptions — Ever

fn find_user(id: u64) -> Option<User> {
    db.get(&id).cloned()  // Some(user) or None
}

match find_user(42) {
    Some(user) => println!("Found: {}", user.name),
    None       => println!("Not found"),
}

// Or use ? in functions returning Option
let name = find_user(42)?.name;

Result: Errors Are Values

use std::fs;

fn load_config(path: &str) -> Result<Config, Box<dyn std::error::Error>> {
    let data = fs::read_to_string(path)?;  // ? propagates error
    let cfg: Config = serde_json::from_str(&data)?;
    Ok(cfg)
}

// ? is sugar for:
// let data = match fs::read_to_string(path) {
//     Ok(d)  => d,
//     Err(e) => return Err(e.into()),
// };

TRAITS
& GENERICS

Defining and Implementing Traits

trait Serialize {
    fn serialize(&self) -> Vec<u8>;
    fn size_hint(&self) -> usize { 0 }  // default impl
}

struct Order { id: u64, symbol: String, qty: i32 }

impl Serialize for Order {
    fn serialize(&self) -> Vec<u8> {
        format!("{}:{}:{}", self.id, self.symbol, self.qty)
            .into_bytes()
    }
}

Generics with Trait Bounds

// Works for any T that implements Serialize — zero runtime overhead
fn write_to_disk<T: Serialize>(item: &T, path: &str) -> Result<(), io::Error> {
    let bytes = item.serialize();
    fs::write(path, bytes)
}

// Dynamic dispatch when type isn't known at compile time
fn write_any(item: &dyn Serialize, path: &str) -> Result<(), io::Error> {
    fs::write(path, item.serialize())
}

BUILD:
HTTP SERVER
FROM SCRATCH

use std::net::{TcpListener, TcpStream};
use std::io::{BufRead, BufReader, Write};
use std::thread;

fn main() {
    let listener = TcpListener::bind("0.0.0.0:4221").unwrap();
    for stream in listener.incoming() {
        let stream = stream.unwrap();
        thread::spawn(|| handle(stream));
    }
}

fn handle(mut stream: TcpStream) {
    let reader = BufReader::new(&stream);
    let request: Vec<String> = reader.lines()
        .map(|l| l.unwrap())
        .take_while(|l| !l.is_empty())
        .collect();
    let path = parse_path(&request[0]);
    let response = route(path);
    stream.write_all(response.as_bytes()).unwrap();
}

BUILD:
DNS
RESOLVER

struct DnsHeader {
    id:      u16,
    flags:   u16,  // QR(1) OPCODE(4) AA(1) TC(1) RD(1) RA(1) Z(3) RCODE(4)
    qdcount: u16,
    ancount: u16,
    nscount: u16,
    arcount: u16,
}

impl DnsHeader {
    fn parse(buf: &[u8]) -> Self {
        Self {
            id:      u16::from_be_bytes([buf[0], buf[1]]),
            flags:   u16::from_be_bytes([buf[2], buf[3]]),
            qdcount: u16::from_be_bytes([buf[4], buf[5]]),
            ancount: u16::from_be_bytes([buf[6], buf[7]]),
            nscount: u16::from_be_bytes([buf[8], buf[9]]),
            arcount: u16::from_be_bytes([buf[10], buf[11]]),
        }
    }
    fn is_response(&self) -> bool { self.flags & 0x8000 != 0 }
}

BUILD:
UNIX
SHELL

use std::process::Command;
use std::io::{self, Write};

fn main() {
    loop {
        print!("$ ");
        io::stdout().flush().unwrap();
        let mut input = String::new();
        io::stdin().read_line(&mut input).unwrap();
        let parts: Vec<&str> = input.trim().split_whitespace().collect();
        if parts.is_empty() { continue; }
        match parts[0] {
            "exit" => break,
            "cd"   => { /* handle cd */ },
            cmd    => {
                Command::new(cmd).args(&parts[1..]).spawn()
                    .map(|mut c| c.wait()).ok();
            }
        }
    }
}

BUILD:
SQLITE
ENGINE

ASYNC
WITH TOKIO

The Basics

use tokio::net::TcpListener;
use tokio::io::{AsyncReadExt, AsyncWriteExt};

#[tokio::main]
async fn main() {
    let listener = TcpListener::bind("0.0.0.0:8080").await.unwrap();
    loop {
        let (socket, _) = listener.accept().await.unwrap();
        tokio::spawn(async move {
            handle(socket).await;
        });
    }
}

WASM:
RUST IN
THE BROWSER

Setup and Build

cargo install wasm-pack
wasm-pack build --target web

use wasm_bindgen::prelude::*;

#[wasm_bindgen]
pub fn calculate_signals(prices: &[f64]) -> f64 {
    // Runs in browser at near-native speed
    // Same code runs server-side and client-side
    let sma: f64 = prices.iter().sum:: <f64>() / prices.len() as f64;
    sma
}

GO + RUST
TOGETHER

Pattern 1: Rust as a Shared Library

// lib.rs — compile with: cargo build --release --lib
#[no_mangle]
pub extern "C" fn compute_sma(prices: *const f64, len: usize) -> f64 {
    unsafe {
        let slice = std::slice::from_raw_parts(prices, len);
        slice.iter().sum::<f64>() / len as f64
    }
}

// main.go — call the Rust library via CGo
// #cgo LDFLAGS: -L./rust/target/release -lcompute
// #include "compute.h"
import "C"

func SMA(prices []float64) float64 {
    return float64(C.compute_sma(
        (*C.double)(&prices[0]),
        C.size_t(len(prices)),
    ))
}

Architecture: Where Each Lives

• Go layer: HTTP API, gRPC service, WebSocket, business logic, database queries
• Rust layer: signal computation, data parsing, encoding/decoding, crypto, compression
• WASM layer: same Rust code, deployed to browser for client-side compute
• Result: 3× faster hot paths, 70% less cloud compute, zero memory safety bugs in the compute layer