Writing
Deep, practical writing on Go, Rust, and system design — organised into courses and series. Browse all courses →
Publishing activity
Go
Idiomatic Go 25 lessons
- 1. Error Handling
- 2. defer for Cleanup
- 3. Multiple Return Values
- 4. The comma ok Idiom
- 5. Implicit Interfaces
- 6. Accept Interfaces, Return Structs
- 7. Slices Are Views, Not Arrays
- 8. Capacity Matters
- 9. range Gotchas
- 10. Zero Values Are Useful
- 11. Nil Slice vs Empty Slice
- 12. Value vs Pointer Receivers
- 13. iota for Enums
- 14. context.Context
- 15. Goroutines Are Cheap, Not Free
- 16. Channels Are for Coordination
- 17. select Is Elegant
- 18. sync.Mutex Is Often Simpler
- 19. Table-Driven Tests
- 20. internal Package Is Underrated
- 21. Composition Over Inheritance
- 22. Small Packages Win
- 23. Error Values, Not Exceptions
- 24. Prefer Plain Structs
- 25. Simplicity Is a Language Feature
Go Concurrency Masterclass 29 lessons
- 1. Goroutine Lifecycle Management
- 2. Cancellation with context.Context
- 3. Channel Ownership Rules
- 4. Buffered vs Unbuffered Channels
- 5. sync.WaitGroup
- 6. Mutexes Done Right
- 7. Race Conditions and the Go Memory Model
- 8. Fan-Out / Fan-In
- 9. Worker Pools
- 10. Pipelines and Stage Isolation
- 11. Graceful Shutdown
- 12. Leak Prevention
- 13. Timeouts Everywhere
- 14. errgroup for Structured Concurrency
- 15. Semaphores for Concurrency Limits
- 16. Atomic Operations
- 17. Go Scheduler Behavior
- 18. Backpressure Design
- 19. Ordering vs Throughput
- 20. Profiling Contention
- 21. Supervisor Patterns
- 22. Rate Limiting and Load Shedding
- 23. Distributed vs Local Concurrency
- 24. Testing Concurrent Code
- 25. Observability for Concurrency
- 26. Safe Background Jobs in Web Servers
- 27. Idempotency in Concurrent Systems
- 28. Production Concurrency Architecture
- 29. sync.Cond
Go Database Patterns 9 lessons
- 1. database/sql Done Right
- 2. Connection Pool Tuning
- 3. Transactions That Don't Bite
- 4. The Repository Pattern
- 5. sqlc vs ORM vs Raw SQL
- 6. Context with Database Queries
- 7. The N+1 Problem
- 8. Migrations Without Downtime
- 9. Testing with Real Databases
Go and AI/LLM Integration 6 lessons
- 1. Building MCP Servers in Go
- 2. LLM API Clients
- 3. Streaming Responses
- 4. Tool Calling Patterns
- 5. Embedding and Vector Search
- 6. Agent Architectures
Go Standard Library Mastery 8 lessons
- 1. net/http Deep Dive
- 2. io Patterns
- 3. encoding/json Beyond Basics
- 4. time Package Gotchas
- 5. os and filepath
- 6. sync Package Complete Guide
- 7. context Internals
- 8. strings and bytes Builders
Go Anti-Patterns & Code Smells 10 lessons
- 1. Interface Everywhere Syndrome
- 2. Giant God Structs
- 3. Global Mutable State
- 4. Channel Misuse
- 5. Ignoring Context
- 6. Swallowing Errors
- 7. Panic as Error Handling
- 8. Premature Abstraction
- 9. Fake Clean Architecture
- 10. Over-Engineering CRUD
Go API and Service Design 10 lessons
- 1. Designing HTTP APIs in Go
- 2. Middleware Patterns
- 3. Request Validation
- 4. Error Responses
- 5. Pagination Done Right
- 6. Idempotency in APIs
- 7. Timeouts and Retries
- 8. Rate Limiting
- 9. Config Management
- 10. The Complete Go Service
Go Microservices Patterns 6 lessons
- 1. Service Boundaries
- 2. Inter-Service Communication
- 3. Service Discovery
- 4. Distributed Tracing
- 5. Saga Pattern
- 6. API Gateway Patterns
Go Deployment & Operations 8 lessons
- 1. Static Binaries
- 2. Docker for Go
- 3. Health Checks
- 4. Config Injection
- 5. CI/CD for Go
- 6. Race Detector in CI
- 7. Profiling in Containers
- 8. Zero-Downtime Deploys
Go Error Design at Scale 8 lessons
- 1. Sentinel vs Typed Errors
- 2. errors.Is and errors.As
- 3. Wrapping Strategy
- 4. Operational vs Domain Errors
- 5. Logging vs Returning
- 6. Error Boundaries Across Layers
- 7. Panic, Recover, and When They're Actually Justified
- 8. Production Error Architecture
Go Reflection & Metaprogramming 7 lessons
- 1. When Reflection Is Justified
- 2. Performance Costs
- 3. Struct Tags
- 4. Building a Serializer
- 5. Validation Frameworks
- 6. Avoiding Reflection
- 7. go:generate and Code Generation
Go CLI & Tooling 8 lessons
- 1. Building CLIs with Cobra
- 2. Config and Env Handling
- 3. File I/O Patterns
- 4. Signal Handling
- 5. Cross-Compilation
- 6. Embedding Assets
- 7. Build Flags and ldflags
- 8. Packaging and Distributing
Go Code Quality & Maintainability 8 lessons
- 1. Refactoring Go Code Safely
- 2. Spotting Over-Abstraction
- 3. Idiomatic Naming
- 4. Code Review Heuristics
- 5. Small Functions Win
- 6. Package Cohesion
- 7. Kill the Utils Package
- 8. Linting with golangci-lint
Go Networking & Distributed Systems 8 lessons
- 1. HTTP Client Internals
- 2. Retries with Exponential Backoff
- 3. Circuit Breaking
- 4. Connection Pooling
- 5. Message Queues in Go
- 6. Eventual Consistency
- 7. Outbox Pattern
- 8. gRPC Basics and Streaming
Go Interfaces & Abstraction Design 8 lessons
- 1. When NOT to Use Interfaces
- 2. Consumer-Side Interfaces
- 3. Interface Pollution
- 4. Returning Concrete Types
- 5. Composition with Embedding
- 6. Testability Without Over-Mocking
- 7. The io.Reader/Writer Ecosystem
- 8. Designing Interfaces for Libraries
Go Security in Production 9 lessons
- 1. Input Validation
- 2. Secret Handling
- 3. TLS Configuration
- 4. SSRF and Injection
- 5. Auth Middleware
- 6. Password Hashing
- 7. JWT Caveats
- 8. Secure HTTP Defaults
- 9. Dependency Scanning
Go Memory Model & Internals 8 lessons
- 1. Interface Representation
- 2. Nil Interface Gotchas
- 3. Method Sets and Addressability
- 4. Escape Analysis Deep Dive
- 5. GC Behavior and Tuning
- 6. Memory Alignment and Struct Padding
- 7. Values Copy vs Share
- 8. String Internals
Go Performance Engineering 8 lessons
- 1. Escape Analysis
- 2. Stack vs Heap Intuition
- 3. Slice and Map Performance
- 4. String and Byte Conversions
- 5. Benchmarking Done Right
- 6. pprof Deep Dive
- 7. CPU vs Memory Tradeoffs
- 8. Avoiding Premature Optimization
Go Testing Masterclass 10 lessons
- 1. Subtests and t.Run
- 2. Fuzzing in Go
- 3. Integration Tests
- 4. HTTP Handler Testing
- 5. Database Testing with Testcontainers
- 6. Mocking Alternatives
- 7. Golden File Testing
- 8. Race-Aware Tests
- 9. Flaky Test Control
- 10. Test Architecture
Go Observability in Production 7 lessons
- 1. Structured Logging with slog
- 2. Metrics That Matter
- 3. Distributed Tracing with OpenTelemetry
- 4. Correlation IDs
- 5. Profiling in Production
- 6. Debugging Latency and Leaks
- 7. The Complete Observability Stack
Modern Go: 1.21 to 1.26 5 lessons
- 1. Range Over Integers and Iterators
- 2. Enhanced HTTP Routing
- 3. Loop Variable Fix
- 4. Structured Logging with slog
- 5. What's New in Go 1.25–1.26
Go Package & Module Architecture 7 lessons
- 1. Package Boundaries
- 2. Avoiding Cyclic Dependencies
- 3. internal/ Usage Patterns
- 4. Interface Placement
- 5. Monolith vs Multi-Module
- 6. Dependency Direction
- 7. go.work and Workspace Mode
Go Plugin Systems 2 lessons
Open course page →Go Generics Masterclass 8 lessons
- 1. What Generics Solve in Go
- 2. Type Parameters and Constraints
- 3. Good Patterns
- 4. Interfaces vs Generics
- 5. Anti-Patterns
- 6. Real-World Examples
- 7. Refactoring Concrete to Generic
- 8. When Duplication Is Better Than Abstraction
Go from Scratch 25 lessons
- 1. Your First Go Program
- 2. Variables and Types
- 3. Control Flow
- 4. Functions
- 5. Arrays and Slices
- 6. Maps
- 7. Strings, Runes, and Bytes
- 8. Structs
- 9. Methods
- 10. Pointers
- 11. Interfaces
- 12. Error Handling
- 13. Goroutines
- 14. Channels
- 15. Select
- 16. Packages and Imports
- 17. Go Modules
- 18. The sync Package
- 19. Context
- 20. Testing in Go
- 21. JSON and HTTP
- 22. File I/O
- 23. The Type System
- 24. The Go Toolchain
- 25. What's Next
Fundamentals
Interview Patterns: Cracking FAANG+ in the AI Era 40 lessons
- 1. Arrays and Hashing
- 2. Two Pointers
- 3. Sliding Window
- 4. Stack
- 5. Binary Search
- 6. Linked Lists
- 7. Recursion
- 8. Sorting in Interviews
- 9. Bit Manipulation
- 10. Math Patterns
- 11. Interview Patterns L11: Binary Tree Traversal
- 12. Interview Patterns L12: BST Operations
- 13. Interview Patterns L13: Tree Construction
- 14. Interview Patterns L14: Tree DFS Patterns
- 15. Interview Patterns L15: Tree BFS Patterns
- 16. Interview Patterns L16: Graph BFS
- 17. Interview Patterns L17: Graph DFS
- 18. Interview Patterns L18: Topological Sort
- 19. Interview Patterns L19: Union Find
- 20. Interview Patterns L20: Shortest Path
- 21. 1D DP Basics
- 22. 1D DP Advanced
- 23. 2D DP Basics
- 24. 2D DP Advanced
- 25. DP on Strings
- 26. DP on Trees
- 27. Knapsack Patterns
- 28. Interval DP
- 29. State Machine DP
- 30. Bitmask DP
- 31. Monotonic Stack
- 32. Heap Patterns
- 33. Trie
- 34. Backtracking
- 35. Greedy
- 36. Intervals
- 37. Concurrency Problems
- 38. Design Problems
- 39. Hard Composites
- 40. Mock Interview Strategy
Kubernetes Patterns 5 lessons
- 1. Pod Design Patterns
- 2. Deployments and Scaling
- 3. ConfigMaps and Secrets
- 4. Operators and CRDs
- 5. Debugging in Kubernetes
Compilers and Interpreters 4 lessons
- 1. Lexing
- 2. Parsing
- 3. AST and Evaluation
- 4. Code Generation
ML System Design 4 lessons
Open course page →Event Sourcing Deep Dive 3 lessons
Open course page →System Design from First Principles 15 lessons
- 1. How the Internet Works
- 2. Load Balancing
- 3. Caching
- 4. Database Scaling
- 5. Message Queues
- 6. CDNs
- 7. Rate Limiting
- 8. Design a URL Shortener
- 9. Design a Chat System
- 10. Design a News Feed
- 11. Design a Notification System
- 12. Design a Search Engine
- 13. Design a Payment System
- 14. Designing for Failure
- 15. CAP Theorem in Practice
System Design Deep Dives 5 lessons
Open course page →Behavioral Interviews for Engineers 3 lessons
Open course page →Algorithms That Matter in Production 14 lessons
- 1. Big-O Thinking
- 2. Sorting in Practice
- 3. Binary Search
- 4. Two Pointers and Sliding Window
- 5. Hashing and Consistent Hashing
- 6. BFS and DFS
- 7. Shortest Path
- 8. Dynamic Programming Intuition
- 9. Greedy Algorithms
- 10. Backtracking
- 11. String Algorithms
- 12. Compression Basics
- 13. Cryptographic Primitives
- 14. Randomized Algorithms
Distributed Consensus 3 lessons
Open course page →Data Structures for Production Engineers 12 lessons
- 1. Arrays and Memory Layout
- 2. Linked Lists
- 3. Hash Maps
- 4. Stacks and Queues
- 5. Trees and BSTs
- 6. B-Trees and B+ Trees
- 7. Heaps and Priority Queues
- 8. Graphs
- 9. Tries
- 10. Bloom Filters
- 11. Skip Lists
- 12. Ring Buffers
Database Internals for Backend Engineers 10 lessons
- 1. How a Query Executes
- 2. B-Tree Indexes
- 3. Write-Ahead Log
- 4. MVCC
- 5. Transaction Isolation
- 6. Query Planning and EXPLAIN
- 7. Connection Pooling
- 8. Replication
- 9. Partitioning
- 10. Vacuum and Bloat
Software Architecture That Survives 8 lessons
- 1. Monolith First
- 2. Clean Architecture
- 3. Event-Driven Architecture
- 4. CQRS
- 5. DDD Essentials
- 6. API Versioning
- 7. Migration Strategies
- 8. Technical Debt
Linux for Backend Engineers 8 lessons
- 1. Processes and Threads
- 2. Virtual Memory
- 3. File Descriptors
- 4. TCP/IP Stack
- 5. Epoll and IO Multiplexing
- 6. Signals
- 7. Containers from Scratch
- 8. Memory-Mapped IO
Engineering Practices That Scale 7 lessons
- 1. Git Beyond Basics
- 2. Code Review That Works
- 3. Incident Response
- 4. Monitoring and Alerting
- 5. Load Testing
- 6. Feature Flags
- 7. On-Call Engineering
Networking for Backend Engineers 7 lessons
- 1. TCP Deep Dive
- 2. HTTP/2 and HTTP/3
- 3. TLS Handshake
- 4. DNS
- 5. WebSockets
- 6. gRPC and Protobuf
- 7. Service Mesh
Rust
Rust in Production — Real-World Architecture 10 lessons
- 1. Structuring a Large Rust Application
- 2. Domain Modeling with Rust's Type System
- 3. Hexagonal Architecture in Rust
- 4. CQRS and Event Sourcing
- 5. Multi-Crate Workspace Architecture
- 6. API Versioning and Backwards Compatibility
- 7. Feature Flags at the Type Level
- 8. Migrating Services from Go/Python/Java to Rust
- 9. War Stories
- 10. When Not to Use Rust
Rust Design Patterns 10 lessons
- 1. Builder Pattern
- 2. Strategy Pattern
- 3. Observer Pattern
- 4. Command Pattern
- 5. Decorator Pattern
- 6. Factory Patterns
- 7. Repository Pattern
- 8. Middleware / Chain of Responsibility
- 9. Entity Component System
- 10. Interpreter Pattern
Rust Async Internals & Runtime Design 8 lessons
- 1. Future Internals
- 2. Building a Minimal Executor
- 3. io_uring
- 4. epoll/kqueue
- 5. The Reactor Pattern
- 6. Work-Stealing Schedulers
- 7. Designing a Custom Async Runtime
- 8. Runtime Comparison
Rust Type System Wizardry 10 lessons
- 1. Zero-Sized Types
- 2. Advanced Typestate
- 3. Session Types
- 4. Simulating Higher-Kinded Types in Rust
- 5. Existential Types
- 6. Variance
- 7. Type-Level Programming
- 8. Sealed Traits
- 9. Proof Witnesses
- 10. Dependent Type Tricks
Rust and AI/LLM Integration 8 lessons
- 1. Building LLM API Clients in Rust
- 2. Streaming LLM Responses
- 3. Tool Calling / Function Calling Patterns
- 4. Embeddings and Vector Search
- 5. Agent Architectures in Rust
- 6. Building MCP Servers in Rust
- 7. On-Device Inference
- 8. ML Data Pipelines
Rust Compiler Plugins & Build System 8 lessons
- 1. Cargo Deep Dive
- 2. build.rs
- 3. Conditional Compilation
- 4. Custom Lints with clippy and dylint
- 5. Code Generation
- 6. Monorepo Management with Workspaces
- 7. Linking Strategies
- 8. Reproducible Builds
Rust for Systems Programming 12 lessons
- 1. no_std
- 2. Embedded Rust
- 3. Memory-Mapped I/O
- 4. Writing Linux Kernel Modules in Rust
- 5. OS Concepts in Rust
- 6. Building a File System
- 7. Implementing Network Protocols
- 8. Designing Custom Allocators
- 9. Interrupt Handlers and Real-Time Constraints
- 10. Writing a Bootloader
- 11. Building a Minimal Hypervisor
- 12. Production Systems Software
Rust WebAssembly 8 lessons
- 1. Rust to WebAssembly
- 2. wasm-bindgen
- 3. Manipulating the DOM from Rust
- 4. Leptos, Yew, Dioxus
- 5. WASM Performance
- 6. Multi-Threaded WASM
- 7. WASI
- 8. The Component Model
Rust Unsafe & FFI 10 lessons
- 1. What unsafe Actually Means
- 2. Raw Pointers
- 3. Dereferencing Raw Pointers Safely
- 4. transmute
- 5. Building Safe Abstractions Over Unsafe Code
- 6. FFI
- 7. Exposing Rust to C
- 8. PyO3
- 9. napi-rs
- 10. Soundness
Rust Microservices Patterns 8 lessons
- 1. Service Boundaries and API Contracts
- 2. gRPC Microservices with tonic
- 3. Event-Driven Architecture in Rust
- 4. Saga Pattern
- 5. Service Mesh Integration
- 6. Distributed Tracing Across Services
- 7. Testing Microservices
- 8. Monolith-First
Rust Networking & Distributed Systems 10 lessons
- 1. Building a TCP Server from Scratch
- 2. HTTP Clients
- 3. gRPC with tonic
- 4. WebSocket Servers and Clients
- 5. DNS Resolution and Custom Resolvers
- 6. TLS
- 7. Retry Strategies and Exponential Backoff
- 8. Circuit Breakers in Rust
- 9. Message Queues
- 10. Distributed System Patterns
Rust Security in Production 8 lessons
- 1. Memory Safety
- 2. Input Validation and Sanitization
- 3. Cryptography
- 4. Secret Management
- 5. Dependency Auditing
- 6. Supply Chain Security
- 7. Sandboxing and Privilege Dropping
- 8. Security Fuzzing
Rust Deployment & Operations 8 lessons
- 1. Docker for Rust
- 2. Static Linking with musl
- 3. CI/CD for Rust
- 4. Observability
- 5. Health Checks and Readiness Probes
- 6. Graceful Shutdown
- 7. Configuration
- 8. Release Profiles and Build Optimization
Rust Anti-Patterns & Code Smells 10 lessons
- 1. .clone() Everywhere
- 2. unwrap() in Production
- 3. Stringly Typed APIs
- 4. God Structs
- 5. Over-Genericizing
- 6. Trait Bloat
- 7. Arc<Mutex<T>> as Default
- 8. Premature Optimization
- 9. Macro Abuse
- 10. Using unsafe to Escape the Borrow Checker
Rust Performance Engineering 12 lessons
- 1. Performance Philosophy
- 2. Benchmarking with criterion and divan
- 3. Profiling
- 4. Reducing Allocations
- 5. Iterators vs Loops
- 6. String Performance
- 7. Choosing the Right Collection
- 8. Cache-Friendly Data Structures
- 9. Inlining
- 10. Compile Time Optimization
- 11. Binary Size Reduction
- 12. Zero-Copy Parsing
Rust Memory Model & Internals 10 lessons
- 1. Memory Layout
- 2. Stack vs Heap
- 3. Box
- 4. vtables
- 5. Fat Pointers
- 6. repr(C), repr(transparent), repr(packed)
- 7. Drop Order
- 8. Custom Allocators
- 9. Miri
- 10. How rustc Works
Rust Macros & Metaprogramming 12 lessons
- 1. Why Macros
- 2. Declarative Macros
- 3. Macro Pattern Matching
- 4. Macro Hygiene
- 5. Debugging Macros
- 6. Procedural Macros
- 7. Derive Macros
- 8. Attribute Macros
- 9. Function-Like Proc Macros
- 10. syn and quote
- 11. Real-World Macro Patterns
- 12. Macro Anti-Patterns
Async Rust Masterclass 20 lessons
- 1. Async Mental Model
- 2. The Future Trait
- 3. Tokio
- 4. Spawning Tasks and JoinHandles
- 5. tokio::select!
- 6. Streams
- 7. Async Channels
- 8. Async Mutexes
- 9. Semaphores and Rate Limiting
- 10. Cancellation Safety
- 11. Timeouts, Deadlines, and Graceful Shutdown
- 12. Async I/O
- 13. Building HTTP Clients with reqwest
- 14. Tower
- 15. Backpressure
- 16. How Async Executors Work Under the Hood
- 17. Pin in Async Context
- 18. Tracing Async Code
- 19. Testing Async Code
- 20. Production Async Architecture
Rust Concurrency Masterclass 25 lessons
- 1. Why Rust Concurrency Is "Fearless"
- 2. std::thread
- 3. move Closures
- 4. Channels
- 5. Shared State
- 6. Arc<Mutex<T>>
- 7. Atomics
- 8. Memory Ordering
- 9. Send and Sync
- 10. Rayon
- 11. Crossbeam
- 12. Worker Pool Patterns
- 13. Fan-Out Fan-In in Rust
- 14. parking_lot
- 15. Condvar
- 16. Barriers and Once
- 17. Lock-Free Data Structures in Rust
- 18. Debugging Deadlocks and Data Races
- 19. Thread-Local Storage
- 20. The Actor Model with Rust
- 21. CSP-Style Concurrency
- 22. SIMD
- 23. GPU Computing from Rust
- 24. Testing Concurrent Code
- 25. Production Concurrency Architecture
Rust Database Patterns 10 lessons
- 1. SQLx
- 2. Diesel
- 3. Connection Pooling with deadpool and bb8
- 4. Schema Migrations in Rust Projects
- 5. Transactions and Error Rollback
- 6. The Repository Pattern in Rust
- 7. Building Type-Safe Query Builders
- 8. Testing with Real Databases
- 9. N+1 Queries, Indexes, and EXPLAIN
- 10. Redis, MongoDB, and Non-Relational Stores
Rust Web & API Development 12 lessons
- 1. The Rust Web Landscape
- 2. Axum from Zero
- 3. Middleware with Tower Layers
- 4. Request Validation and Error Responses
- 5. Authentication
- 6. Database Integration
- 7. Pagination, Filtering, and Sorting
- 8. WebSockets with Axum
- 9. Rate Limiting and Throttling
- 10. OpenAPI / Swagger Generation
- 11. Integration Testing HTTP Services
- 12. Production Deployment
Rust Standard Library Mastery 10 lessons
- 1. Collections Deep Dive
- 2. Iterator Trait and Adapters
- 3. std::io
- 4. std::fs and std::path
- 5. std::fmt
- 6. std::net
- 7. std::process
- 8. std::time
- 9. std::sync
- 10. Conversion Traits
Rust CLI & Tooling 10 lessons
- 1. clap
- 2. stdin, stdout, stderr
- 3. Configuration Files and Environment Variables
- 4. Colored Output and Progress Bars
- 5. Signal Handling and Graceful Shutdown
- 6. Subcommands and Complex CLI Structures
- 7. Cross-Compilation for Linux, Mac, Windows
- 8. Distribution
- 9. Building TUIs with ratatui
- 10. Testing CLI Applications
Rust Testing Masterclass 12 lessons
- 1. Unit Tests
- 2. Integration Tests
- 3. Doc Tests
- 4. Test Fixtures and Setup/Teardown
- 5. Mocking
- 6. Property-Based Testing with proptest
- 7. Fuzz Testing with cargo-fuzz
- 8. Snapshot Testing with insta
- 9. Code Coverage
- 10. Benchmarking with criterion
- 11. Testing in CI
- 12. Test Architecture
Rust Pattern Matching & Enums Deep Dive 8 lessons
- 1. match
- 2. Destructuring
- 3. Match Guards and Bindings
- 4. Or Patterns, @ Bindings, and Rest Patterns
- 5. Enums Carrying Data
- 6. State Machines with Enums
- 7. The Visitor Pattern via Enums
- 8. Refutable vs Irrefutable Patterns
Rust Error Handling at Scale 10 lessons
- 1. Rust's Error Philosophy
- 2. Result and Option
- 3. The ? Operator
- 4. Designing Custom Error Types
- 5. thiserror
- 6. anyhow
- 7. Library vs Application Error Strategy
- 8. Adding Context
- 9. panic!, unwrap, expect
- 10. Production Error Architecture
Rust Traits & Generics Masterclass 15 lessons
- 1. Trait Fundamentals
- 2. Default Implementations and Selective Overrides
- 3. Trait Bounds
- 4. where Clauses
- 5. Associated Types vs Generic Parameters
- 6. Supertraits
- 7. dyn Trait
- 8. Object Safety
- 9. Blanket Implementations
- 10. Orphan Rules and the Newtype Workaround
- 11. Essential Std Traits
- 12. Operator Overloading with Traits
- 13. Monomorphization
- 14. Const Generics
- 15. GATs
Rust Ownership & Lifetimes Masterclass 15 lessons
- 1. The Mental Model
- 2. Move Semantics
- 3. Copy vs Clone
- 4. The Borrow Checker
- 5. Lifetime Annotations
- 6. Lifetime Elision Rules
- 7. Lifetimes in Structs
- 8. 'static
- 9. Higher-Ranked Trait Bounds
- 10. Self-Referential Structs
- 11. Interior Mutability
- 12. Rc and Arc
- 13. Weak References
- 14. Pin and Unpin
- 15. When You're Fighting the Borrow Checker
Idiomatic Rust 25 lessons
- 1. Think in Ownership
- 2. Borrow Strategically
- 3. Option and Result Are Your Control Flow
- 4. if let and while let
- 5. Iterator Chains Over Manual Loops
- 6. The Typestate Pattern
- 7. The Newtype Pattern
- 8. The Builder Pattern in Rust
- 9. From and Into
- 10. Deref Coercion
- 11. Cow
- 12. Designing Error Types
- 13. Display and Debug
- 14. derive Is Your Best Friend
- 15. Exhaustive Matching
- 16. Enums Over Booleans
- 17. Zero-Cost Abstractions
- 18. Drop and RAII
- 19. PhantomData
- 20. API Design Guidelines
- 21. The Turbofish ::<>
- 22. Feature Flags and Conditional Compilation
- 23. Clippy Is Your Mentor
- 24. Writing Great Rust Documentation
- 25. When to Reach for unsafe
Rust from Scratch 25 lessons
- 1. Why Rust Exists
- 2. Installing Rust
- 3. Hello, World
- 4. Variables, Mutability, and Primitive Types
- 5. Functions, Expressions, and Statements
- 6. Control Flow
- 7. Ownership
- 8. Borrowing and References
- 9. Slices
- 10. Strings
- 11. Structs
- 12. Enums and Option
- 13. Pattern Matching
- 14. Methods and Associated Functions
- 15. Vec, HashMap, and HashSet
- 16. Result and the ? Operator
- 17. Modules
- 18. Crates, Cargo.toml, and Dependencies
- 19. Traits
- 20. Generics
- 21. Closures
- 22. Iterators
- 23. Writing Your First Tests
- 24. Reading and Writing Files
- 25. Where to Go from Here
Rust in Practice 5 lessons
- 1. Mastering Rust Lifetimes: The Comprehensive Guide
- 2. Mastering Rust: The Complete Guide to Pattern Matching
- 3. Rust Ultimate: The Ultimate Rust Cheatsheet You'll Ever Need
- 4. From Novice to Master: 10 Must-Try Low-Level Programming Projects in Rust
- 5. Rust in Finance: Building a Scalable High-Frequency Trading Platform from Scratch