Rust for Data Engineering

Graph Algorithms with Rust teaches you to model real datasets as graphs and run the classical algorithms — BFS, DFS, Dijkstra, PageRank, and Kosaraju strongly-connected components — in cache-friendly Rust. Across five modules you walk through the same problems data engineers actually solve: loading edge lists into a graph, finding the shortest walking route between Lisbon landmarks, ranking sports websites by PageRank, scoring UFC fighters by centrality, and detecting communities in a Twitter-style follower graph. You use both the textbook petgraph crate and the benchmarked aprender-graph crate, so you see two production-tested ways to model the same problem. Every algorithm comes with a runtime contract — provable assertions like "PageRank scores must sum to 1.0" — so the demos catch silent regressions, not just compile errors. The course closes with a working clap-based CLI tool that wires every algorithm together behind subcommands and emits machine-readable JSON, ready to ship as a single static binary. By the end you can pick the right algorithm for a real graph problem and ship it as a tested Rust binary.

This course pairs pragmatic agile method with AI-assisted engineering practice. Across five modules you trace the historical arc from waterfall to agile, internalize the playground-vs-plant mental model, learn root-cause analysis via the five-whys habit, sharpen technical communication and demos, structure project management with the lightest possible artifacts (Trello and spreadsheets over heavy tools), and apply AI workflows — diagram prompt engineering, summarization with Claude, AI pair programming, AWS CodeWhisperer for Rust, Bedrock-backed serverless architectures, RAG with Bedrock Knowledge Bases, and local speech-to-text with whisper.cpp. By the end you can adapt agile to your team rather than the other way around, recognize the anti-patterns that turn ceremonies into theater, and integrate AI tooling into a development loop that ships rather than just demos. Pragmatic, opinionated, and grounded in named patterns rather than methodology cargo-cult.

Build production-grade ETL pipelines in Rust that never drop rows silently and never panic on malformed input. In five weeks you will design the Extract boundary with serde-typed readers, enforce a Transform totality contract where every row either yields a validated record or flows through a structured error channel, and emit NDJSON and CSV from the same typed pipeline using the Write trait. You will master thiserror enums, ? propagation, proptest-based property testing, round-trip invariants, and the stderr-vs-stdout separation that makes every pipeline run auditable. The course closes with a preview of how the same contracts migrate to async with tokio — same invariants, different runtime. Every concept is demonstrated with real Rust code the instructor authored in the public repository, not pseudocode. This is the course for engineers who have shipped a Python ETL script that lost data at 2 a.m. and want the Rust type system to make that incident impossible.

This course takes you from a brand-new Framework Laptop and a blank USB stick to a fluent Kubuntu power user. Across four modules you assemble the hardware, flash and install Kubuntu, configure System Settings (display, users, file managers), customize the KDE Plasma desktop (themes, widgets, virtual desktops, KRunner, keyboard shortcuts, workspace effects), and gain the daily-driver skills that matter — terminal navigation, file operations, user and group management, system monitoring, and the LibreOffice trio (Writer, Impress, Calc). Every lesson is a screen-recorded walkthrough — you watch the actual click path and command sequence, not abstract diagrams. By the end you can install Kubuntu on a Framework, customize it without breaking anything, and use the terminal and LibreOffice with confidence. Aimed at first-time Linux desktop users who want a hands-on, modular, repairable laptop and a desktop environment they can shape to their own work.

Learn Rust from the ground up — the systems language that gives you C-level speed without the footguns and Python-level safety without a garbage collector. This course starts with `rustup`, `cargo`, and your first `Hello, world!`, then builds through the ideas that make Rust distinctive: ownership, borrowing, and the borrow checker. You will master move semantics, the `Copy` and `Clone` traits, and how Rust prevents dangling references at compile time. You will handle errors with `Option`, `Result`, and the `?` operator, and match them exhaustively with patterns and guards. Finally, you will write generic code with traits and lifetimes, organize programs with modules, and use closures and iterators to process data lazily and efficiently. Each lesson pairs transcripts with runnable Cargo examples grounded in the Rust compiler's own error messages. By the end, you will ship a capstone project that combines the course concepts into an end-to-end Rust program you can extend.

Build production-grade AWS Lambda functions in Rust using Cargo Lambda. This hands-on course covers serverless fundamentals — stateless event handlers, millisecond billing, and managed runtimes that scale on demand — then implements the same S3-triggered handler in Python, Ruby, Node.js, and Rust so you can compare runtimes head-to-head. You will install Cargo Lambda, scaffold a new Lambda crate with cargo lambda new, iterate locally with cargo lambda watch, invoke against test payloads with cargo lambda invoke, produce a release binary with cargo lambda build --release, and ship to AWS with cargo lambda deploy. Along the way you will see why Rust's compile-time guarantees, ownership model, and small memory footprint make it a strong fit for AWS Lambda's pay-per-millisecond pricing. The closing module benchmarks all four runtimes on the same workload across memory configurations from 128 MB to 10,240 MB, so you can reason about price and performance trade-offs from real measurements rather than vendor claims. By the end, you will have shipped a working Rust Lambda from cargo lambda new to a deployed AWS endpoint and know when Rust is the right tool for serverless data engineering.

By the end of this course you will read Zig source confidently, build static binaries small enough to ship inside a 50-kilobyte microcontainer, pick the right allocator (GeneralPurposeAllocator, ArenaAllocator, FixedBufferAllocator, or page_allocator) for each workload, and tell a data engineering team where Zig wins versus where Rust still owns the problem. The course is pitched at Rust developers. Every Zig idiom is paired with the Rust pattern it replaces — allocator parameters versus `'a` lifetimes, the `!T` error type versus `Result`, `comptime T: type` versus trait bounds plus `derive` plus `macro_rules!`, and `defer` plus `errdefer` versus `impl Drop`. You finish with a clear mental model of when to reach for Zig (Lambda, edge, embedded, C interop) and when to stay with Rust (long-running services with shared state). Six modules cover the language tour, performance optimization, a Marco Polo CLI, four allocator strategies side by side, a Docker multi-stage build for a Zig HTTP server, and the Rust-or-Zig decision rule on a real data team.

This course reframes AI ethics from a human-first, externality-first perspective rather than the GDP-and-shareholder framing that dominates industry discourse. Across four modules you trace how natural rights emerged from the French Revolution and post-WW2 charters, why those rights need a digital rewrite in the age of AI, how tech propaganda displaces critical thinking, and why the dominant economic models — including Shoshana Zuboff's surveillance capitalism — are broken. You leave with a working vocabulary for digital rights (privacy, consent, biometric data, freedom from algorithmic harm), a critical-thinking toolkit for resisting hype patterns like FOMO and naive utopianism, and concrete externality-first solutions such as taxing addictiveness ratios and crediting employee ownership. The course is opinionated — it does not pretend AI ethics is settled — and grounds every claim in named historical events, named books, and named patterns rather than abstract principle.

Build native desktop applications in Rust on Linux. This hands-on course walks you through five GUI frameworks — iced, FLTK, GTK4, relm4, and egui — on Kubuntu, building a portfolio of working applications: a counter, a calculator with unit tests, a to-do list, a Pong game, a password generator, Simon Says, and a quiz app. You will install Rust with rustup, configure Kate as a Rust editor with embedded terminal, and use cargo and clippy to build and lint each project. The course closes with patterns for production: choosing the right framework, persisting state to disk, keeping the UI responsive while data loads, and shipping a binary that runs on every Linux desktop. Every demo is recorded in real time on a Kubuntu 24.04 workstation, so you see the full edit-compile-run loop, including dependency wiring and clippy warnings. By the end, you will have built eight working GUIs in Rust and know which framework to reach for when the browser is the wrong surface.

Become fluent at the Linux terminal — the working environment every Linux user lives in. This hands-on, practical course takes you from zero to a real command-line workflow without installing anything locally. Over five weeks you set up a free Linux environment in GitHub Codespaces or a cloud shell, learn the bash, zsh, and sh shells, and master the file-and-directory commands every Linux user types daily. Instructor Alfredo Deza brings over a decade of working with Linux day in and day out — installing servers, building infrastructure, and shipping software on Linux every step of the way. The course focuses on the doing rather than the configuration: every lesson is a recorded screen session you can follow along with, using Linux that is readily available rather than fighting an install. By the end you navigate the filesystem with cd, pwd, ls, and globs; resolve binaries with which and PATH; recall commands with history and tab completion; and copy files and directories with cp. The same skills the rest of the rust-de specialization assumes you already have.

Polars is a fast columnar DataFrame engine built on Apache Arrow, and this course teaches you to use it from Rust to do real data-engineering work. You will configure a Cargo project with the lazy and csv feature flags, load wine-ratings.csv into a typed DataFrame, and learn the difference between eager DataFrames for exploration and lazy LazyFrames for production. You will compose select, filter, slice, sort, group_by, agg, and join expressions, then read explain output to see predicate pushdown and projection pushdown rewrite your query before it runs. Module 2 puts the API to work cleaning a real wine-ratings dataset with documented drop, fill, and normalize rules. Module 3 wires everything into wine-pipeline, three Rust CLI binaries that implement a bronze, silver, gold medallion architecture over a shared SQLite database and export a top-10 grape leaderboard as CSV and JSON. By the end you will have a complete, runnable Rust pipeline you can adapt to any tabular dataset.

Build production data pipelines on Google Cloud using Rust — predictable latency, single-digit-megabyte containers, and errors that fail at compile time instead of 3 a.m. This course shows engineers how to read from Cloud Storage, query BigQuery (REST jobs.query for small results, Storage Read API for million-row Arrow scans), and deploy distroless handlers to Cloud Run with sub-100 millisecond cold starts. You'll learn the gcloud CLI and Cloud Shell workflow, choose the right GCS client crate stack (google-cloud-storage, tonic, tokio), and configure Pub/Sub push subscriptions with idempotent content-hash handlers and backpressure controls. Production discipline comes through cargo-audit, cargo-deny, secure-by-design defaults, and CI gates on GitHub Actions. By the end, you'll have a working pattern for shipping a Rust ETL handler that survives at-least-once delivery, distroless image scans, and concurrent load — all on the GCP services you already pay for.

Use SQLite from Rust to build production-grade data tooling — the embedded, single-file SQL engine that ships in every Android phone, every iOS device, and most web browsers. You'll start with the basics of SQLite as a serverless library, then drive it from Rust with the rusqlite crate: opening file-backed and in-memory databases, running INSERT, SELECT, UPDATE, DELETE through prepared statements, and surfacing errors as `Result` rather than swallowing them. Module 2 turns the database into a real ETL stage: stream CSV with the csv crate and serde, ingest JSON with serde_json into typed columns or JSON1 blobs, and round-trip data back out as exports or full SQL dumps. The capstone builds **fscrawl** — a clap v4-driven CLI that walks a directory, upserts file metadata into SQLite, and exposes crawl, query, export, and db-dump subcommands. By the end you can ship a typed, transactional, embedded-SQL CLI tool from a single Rust binary.e.g. This is primarily aimed at first- and second-year undergraduates interested in engineering or science, along with high school students and professionals with an interest in programming.

RAG from Zero is a hands-on two-module course that teaches you to build production Retrieval-Augmented Generation pipelines in Rust by walking two real tools you can use the same day. Module 1 walks the encode-chunk-index-fuse-retrieve pipeline one stage at a time using the published aprender-rag crate — RecursiveChunker(512, 50) with overlap, MockEmbedder(384) for deterministic teaching with candle for production, reciprocal-rank fusion at k=60, and a closing aprender_film_search demo against a 50-row Sakila fixture that asserts four runtime contracts. Module 2 walks pmat query, a production code-search RAG that ranks by semantic intent plus pagerank plus structural signals — --churn (90-day git volatility), --duplicates (MinHash + Locality-Sensitive Hashing clones), --entropy (pattern diversity), --faults, and -G git-history fusion. The course closes with cross-project search across a sibling-repo workspace via --include-project and --include-source so you can navigate a multi-crate codebase as one indexed corpus. No toy fixtures, no aspirational APIs — aprender-rag is on crates.io today, pmat ships from paiml/pmat, and the companion paiml/rag-from-zero repo runs end-to-end with cargo run and zero infrastructure.

Build production-quality command-line tools in Rust for data engineering. You move from a first hello-world CLI through real argument parsing with `clap`, ergonomic error handling with `anyhow`, and structured logging with `env_logger`. From there you learn subcommand design patterns suited to data pipelines (`ingest`, `transform`, `filter`, `export`), input validation that fails fast with a helpful message, and the data-specific flags (`--format`, `--output`, `--delimiter`, `--column`, `--limit`) every CSV and JSON tool needs. The course closes with packaging: Cargo metadata, publishing to crates.io, and a multi-stage Docker container. Along the way you learn the Rust toolchain — rustup, cargo, rust-analyzer — modules and the crates.io ecosystem, the difference between `Result` and `panic!`, and the discipline of `stderr` versus `stdout`. The capstone is `datactl`, a Rust CLI you build from scratch that reads, summarizes, filters, and exports CSV and JSON files. By the end you will have shipped a small, fast, statically-linked binary you can run anywhere.

MySQL from Zero is a hands-on three-module course that teaches you to install MySQL, import the Sakila sample database, query it from the terminal, and build a Bash to Python to Rust pipeline that surfaces the same answer through three increasingly type-safe layers. Module 1 starts you in `mysql -u user -p` with `SHOW DATABASES`, `USE sakila`, and `SELECT ... LIMIT`, then walks through `mysqldump` for safe backups, INSERT/UPDATE/DELETE on a real schema, and the `INTO OUTFILE` to `http.server` to `curl` pipeline that turns a SQL query into an HTTP endpoint with zero new packages. Module 2 dives into the Sakila schema itself: the customer to rental to inventory to film traversal that drives most queries, INNER vs LEFT JOIN with row-by-row materialization, and B-tree indexes paired with `EXPLAIN ANALYZE` so you can predict query cost before you ship. Module 3 closes with a typed Rust client: `sqlx::MySqlPool` against the same Sakila, the `FromRow` derive mapping rows to a struct, and four runtime `assert!` contracts that fail loudly when data drifts. By the end you can pick the right query for a real database problem and ship it as a single static Rust binary.

Take a Rust crate from a "works on my machine" laptop build to a production-grade artifact that ships through a gate no one can bypass. The course walks through a real 3-crate ETL workspace — etl-core, etl-cli, and etl-bench — built around clap derive macros, a tuned `[profile.release]`, and a multi-stage Dockerfile that drops a 1.8 GB rust:latest image to a 6 MB scratch+musl container with no shell to attack. You then wire pmat, bashrs, forjar, and pv onto the standard fmt + clippy + test + 100% coverage + audit + deny stack — because a green build badge is misleading when an agent wrote half the code. A five-job GitHub Actions matrix runs stable, beta, and Minimum Supported Rust Version on Linux, macOS, and Windows in parallel, with cached cold builds reduced to two-minute incremental ones. You close with criterion — warmup, statistical sampling, the HTML report — and a regression gate that fails the build on a measurable throughput drop. Every concept is tied to runnable code and Provable contracts in the case-study repo.

e.g. This is primarily aimed at first- and second-year undergraduates interested in engineering or science, along with high school students and professionals with an interest in programming.DuckDB From Zero teaches you how to embed DuckDB directly into your Rust applications, treating an analytical SQL engine as a library rather than a server. Across four hands-on modules, you'll move from compiling DuckDB into a single binary to writing SQL queries over local CSV, Parquet, and JSON files, streaming Arrow record batches into Polars, and shipping a polished command-line tool with cargo dist. By the end you will understand when in-memory connections beat on-disk databases, how projection and predicate pushdown make Parquet queries fast on a laptop, how to hand results to Polars zero-copy through the Arrow C Data Interface, and how to package a Rust CLI that bundles DuckDB so users can install nothing and still run analytical queries against gigabytes of data. The course is built around short videos, key-term readings, scenario-driven reflections, and an end-to-end demo project. You will leave with a working understanding of DuckDB-in-Rust patterns, the skills to design an analytical CLI you would actually want to use, and a clear mental model of where DuckDB fits between SQLite, Spark, and the Polars/Arrow ecosystem.

e.g. This is primarily aimed at first- and second-year undergraduates interested in engineering or science, along with high school students and professionals with an interest in programming.Postgres From Zero takes you from never having opened a PostgreSQL prompt to shipping a typed Rust binary that emits production-grade JSON reports against a real schema. You will operate Postgres through psql using backslash commands, information_schema, and safe SELECT ... LIMIT queries, then execute INSERT, UPDATE, and DELETE inside BEGIN/ROLLBACK/COMMIT transactions so a wrong move ends with a rollback rather than a restore from backup. You will read the 16-table Pagila Sakila schema as a relational map, walk the customer to rental to inventory to film spine with multi-table JOINs, distinguish INNER from LEFT JOIN row-by-row, and read EXPLAIN ANALYZE plans to compare query plans and spot Seq Scan versus Index Scan trade-offs. Finally, you will build a typed Rust client with sqlx::PgPool and the FromRow derive, map Postgres column types to Rust struct fields, and ship the postgres-reports binary with three Top-N analytical reports, each enforcing named runtime contracts. Every lesson uses the Pagila open dataset and the public paiml/postgres-from-zero GitHub repository, so you can reproduce everything on a fresh laptop with Docker Compose and a single make target.

e.g. This is primarily aimed at first- and second-year undergraduates interested in engineering or science, along with high school students and professionals with an interest in programming.Master modern DataOps practices by building robust, automated CI/CD pipelines for data applications using Rust. This course teaches you how to design, implement, and maintain end-to-end deployment pipelines that combine the safety and performance of Rust with industry-standard DevOps tooling. You will start with the fundamentals of Continuous Integration and Continuous Deployment, then progress to advanced topics including matrix builds, interdependent jobs, Dockerfile linting, and container packaging. Hands-on labs use GitHub Actions, Makefiles, and Docker to give you practical experience automating the full software delivery lifecycle for data-driven Rust applications. By the end of the course, you will be able to: write production-grade GitHub Actions workflows; lint, test, and release containerized Rust applications; manage complex job dependencies and matrix configurations; and ship a complete end-to-end deployment pipeline. Whether you are a data engineer modernizing your pipelines or a Rust developer adopting DataOps, this course gives you the patterns and tools to deliver reliable, automated, container-based data systems.

Stand up production-grade monitoring for Rust services and automate the operational tasks that keep them running. This intermediate course pairs systems engineering practice with the modern Rust toolchain to instrument, observe, and operate data infrastructure. Module 1 walks through the full monitoring stack: logging versus metrics, the four golden signals, push and pull collection strategies, the ELK stack on Linux, Prometheus and Grafana for metric collection and visualization, and the `tracing` crate for structured Rust logs. A parallel AI-augmented track introduces Amazon Q Developer for code assistance. Module 2 builds Rust CLIs for system automation: filesystem traversal with walkdir and glob, log parsing with regex and flate2, wrapping external commands with `std::process::Command`, and a graded compliance utility that crawls JSON-defined rules and exits non-zero on violations — drop-in CI/CD ready. Throughout, learners pair the standard tooling with AWS Bedrock prompt management for AI-augmented operations.

Software engineers learn to use Claude across its five working surfaces — claude.ai chat, Projects, Claude Code, Claude Chrome, and Claude Design — to write, review, and maintain production code. The course starts in the browser with chat and shows the three signals that you have outgrown it: copy-paste friction, multi-file change, and long-running tasks. You then move into Claude Code, the terminal agent, where you meet its tool surface (Read, Edit, Bash, Grep) and pin invariants in a project CLAUDE.md so every session starts with the same context. From there you build slash-command skills that wrap Rust binaries like cargo clippy, dispatch sub-agents in parallel with YAML-contract guardrails, and replace raw grep with pmat query enrichment flags (--churn, --faults, --coverage-gaps, -G). The course closes with pmat comply and pmat hooks wired into pre-commit, so failing code cannot land.

e.g. This is primarily aimed at first- and second-year undergraduates interested in engineering or science, along with high school students and professionals with an interest in programming.Design by Provable Contracts teaches you how to move from "the tests pass" to "the math says it cannot break." Across five modules, you'll climb a five-rung provability ladder — from lint and types, through property-based and bounded-model checking, to dependent-typed proofs in Lean 4 — applied to a single running example: the softmax function used in modern machine learning. By the end, you will be able to: (1) read a peer-reviewed paper and translate its preconditions, postconditions, and invariants into a YAML contract; (2) choose the right verification rung for a given cost-vs-confidence trade-off, using lint, types, proptest, and Kani in Rust; and (3) build a complete pipeline from paper to YAML to Lean theorem, producing a machine-checked guarantee that holds for every input of every length. The course is hands-on and tool-first: Rust for the lower rungs, Lean 4 for the top rung, and YAML as the connective tissue between math and code. You will leave with a reusable mental model and a working capstone you can apply to any safety-critical numerical kernel.

Stop stitching three databases together. HelixDB is a Rust-native graph plus vector engine that holds your nodes, your embeddings, your typed edges, and your key-value documents in one process — no separate Postgres, no separate Qdrant, no separate Neo4j. This course walks a Rust-fluent engineer from helix init through a typed HelixQL schema, the helix check and helix compile pre-deploy gates, side-by-side graph traversal and vector search in the same query language, and a typed Rust client that calls a live HelixDB instance with four runtime contracts. Every primitive you meet is wired into a working .hx schema and a running engine you can install in one command. Module 4 puts graph traversal verbs (Out, In, WHERE, ORDER, RANGE) and vector top-k search side by side in the same query language, and adds ShortestPathDijkstras with composable weight expressions for cost-aware routing. You finish with the canonical hybrid-RAG pattern — SearchV returns top-k embeddings, then a typed edge climbs back to the source documents — shipped as a typed Rust client (helix-rs plus serde) with four runtime assertion contracts. The course closes with an honest read on where HelixDB is the wrong choice: columnar OLAP, Spark execution semantics, multi-tenant analytical warehouses.

You learn IAC fundamentals — plan, apply, saved plans, JSON plans, resource lifecycle, refactoring, drift detection, policy gates, cross-config sharing, testing, and state security — by walking ten OpenTofu features next to their forjar equivalents. Forjar is a single Rust binary with state in Git as BLAKE3-hashed YAML, 17 crate dependencies, and ten falsifiable C1-C10 contracts asserted on every apply. Each module compares one OpenTofu feature (`terraform plan -out`, `terraform show -json`, `lifecycle`, `moved`, `-target`, `refresh-only`, `check`, `terraform_remote_state`, `.tftest.hcl`, `state_encryption`) against the forjar approach so you finish knowing the industry default and a concrete second tool.

TUI from Zero teaches you to build a pure-Rust terminal-UI framework from first principles to a working ptop-mini process monitor. Across five modules, you'll learn the wire format of a terminal — cells, ANSI escape sequences, Unicode block elements, and Braille code points — and how CellBuffer and DiffRenderer turn those primitives into a zero-allocation steady state. You'll master the Elm-style init/update/view shape, composite layout with Container/Row/Column, the .prs declarative scene format, and probar snapshot testing so every render byte is deterministic in CI. The capstone is ptop-mini, a Rust process monitor whose production binary swaps a Snapshot fixture for a live /proc reader without changing one line of the view function. Every widget is gated by a YAML contract and a probar snapshot test, so the framework you build is provable, not merely working. You should be comfortable with intermediate Rust — ownership and borrowing, traits and generics, Result and the ? operator. No prior terminal-UI experience is required.

Use Valkey — the Apache-2.0 fork of Redis maintained by the Linux Foundation — as the cache, stream, and coordination primitive at the heart of a Rust service. This course is the most direct path from `cargo add redis` to a real-time data pipeline that survives partitions and operator changes. You begin with the license rift and what wire compatibility means in practice, then dive into the four data shapes that drive every Valkey workload — strings with TTL, hashes with per-field expiry, lists as queues, and sorted sets as the leaderboard primitive. From there the course turns to streams + consumer groups (the data-engineering core), XADD and XREADGROUP for exactly-once delivery, plus XPENDING + XCLAIM for failure handling. The back half covers the patterns that make Valkey production-grade in Rust: pipelining for round-trip math, MULTI/EXEC with WATCH for multi-key atomicity, EVAL and the script cache for server-side atomicity, connection-pool sizing under load, and criterion for honest p50/p99 benchmarking. The course closes with the operational story — RDB vs AOF, replication, Sentinel failover, cluster sharding, and the split-brain accounting that "highly available" actually buys you.

Big O notation: Python to Rust is a hands-on algorithmic complexity course for engineers transitioning from Python to Rust who want to reason rigorously about how their code scales. You will learn Big O, Big Theta, and Big Omega notation; analyze the time and space complexity of common operations on Python and Rust data structures (list/Vec, dict/HashMap, set/HashSet, tuple, slice, BTreeMap); and compare measured performance in both languages on identical workloads. The course covers amortized analysis, recursion and master theorem, worst case versus expected case, the cost of allocation and borrowing, and how Rust's ownership model affects real-world constants even when asymptotic complexity is identical. You will profile Python code with cProfile and timeit, profile Rust code with criterion and perf, and translate Python algorithms (search, sort, hashing, graph traversal, dynamic programming) into idiomatic Rust while keeping or improving complexity guarantees. By the end of the course, you will be able to predict performance, choose appropriate data structures, justify rewrites from Python to Rust on quantitative grounds, and communicate trade-offs to a team. Part of the Rust for Data Engineering specialization.

WASM from Zero is a hands-on introduction to WebAssembly for engineers who want to ship fast, portable, sandboxed code that runs anywhere: the browser, the edge, the server, and embedded devices. You will learn what WebAssembly is, why it was designed, how it relates to Rust, and how to compile Rust libraries to .wasm modules that can be invoked from JavaScript, Python, or any host language. The course walks through the toolchain (rustc target wasm32, wasm-bindgen, wasm-pack, wasmtime, wasmer), the WASM component model, WASI, and the security and performance trade-offs that make WebAssembly a compelling deployment target for data engineering, ML inference, plugin systems, and serverless workloads. By the end of this course, you will be able to build, package, deploy, and debug a Rust-to-WASM data processing module, embed it in a web page and a server runtime, and reason about when WASM is the right tool versus a native binary or a container. This is part of the Rust for Data Engineering specialization and assumes basic Rust familiarity from Rust From Zero.

OO: Python to Rust is a hands-on course on object-oriented design for engineers moving from Python (a class-based, dynamic OO language) to Rust (a struct-and-trait-based language with no inheritance and strict ownership). You will learn how Rust models the four classical OO pillars - encapsulation, abstraction, polymorphism, and code reuse - without classes or inheritance, using structs, methods (impl blocks), traits, trait objects, generics, enums, and the type state pattern. The course translates common Python OO patterns (dataclasses, dunder methods, ABCs, mixins, descriptors, protocols, the singleton, factory, observer, strategy, and decorator patterns) into idiomatic Rust, and explains why some of them simply don't apply once you have algebraic data types and ownership. You will refactor a non-trivial Python OO codebase into Rust, learn when composition beats inheritance, when an enum beats a class hierarchy, and how to design APIs that leverage Rust's compile-time guarantees. By the end of the course, you will be able to read OO Python code and produce a correct, idiomatic Rust translation, and justify your design decisions on a code review. Part of the Rust for Data Engineering specialization.