microsoft/RustTraining

Features

• Programming Language Curricula - Offers a structured curriculum for mastering the Rust language, from beginner fundamentals to expert engineering practices.
• Rust Tutorials - Offers structured curricula and practical exercises for mastering core Rust syntax and idioms.
• Language Transition Modules - Implements a transition framework mapping C++, managed, and dynamic languages to Rust idioms.
• Asynchronous Programming Guides - Provides a comprehensive guide to mastering non-blocking execution via polling state machines and futures.
• Language Fundamentals - Covers essential language fundamentals including variables, primitive types, control flow, and function signatures.
• Error Handling Patterns - Teaches robust error management strategies using specialized types to prevent runtime crashes.
• Language Transition Guides - Provides a specialized framework for mapping concepts from C++, managed languages, and dynamic typing to idiomatic Rust.
• Managed Language Transitioning - Bridges the gap between garbage-collected languages and Rust's ownership model for developers from managed ecosystems.
• Programming Courses - Delivers a structured course on systems programming, focusing on memory safety and low-level hardware interaction.
• System Programming Concepts - Provides educational explanations of low-level system concepts like memory ownership and borrowing.
• Systems Programming Training - Delivers professional training on low-level systems programming, including unsafe code and zero-copy serialization.
• Concurrency Primitives - Teaches how to use synchronization traits to build multi-threaded applications that prevent data races.
• Ownership-Based Memory Management - Covers the fundamental Rust memory model based on ownership and borrowing.
• C++ to Rust Transitioning - Helps C++ developers translate memory management and foreign function interface concepts into idiomatic Rust.
• Generic Types - Instructs on using traits and generics to implement reusable, type-safe code and design patterns.
• Generics - Teaches the application of parametric polymorphism using generics and trait bounds.
• Language Transition Mapping - Features a framework that maps concepts from C++, managed languages, and dynamic typing to idiomatic Rust.
• Metaprogramming Frameworks - Provides instruction on creating declarative and procedural macros to reduce boilerplate and extend language functionality.
• Rust - Provides a comprehensive structured training curriculum for the Rust programming language from beginner to expert levels.
• Trait-Based Polymorphism - Instructs on using traits to implement polymorphism and generic constraints.
• Asynchronous Programming - Provides comprehensive training on non-blocking execution using futures, async/await, and runtime executors.
• Rust Metaprogramming - Covers advanced use of declarative and procedural macros to automate code generation and reduce boilerplate.
• Domain-Driven Type Constraints - Instructs on using type system constraints to make invalid program states unrepresentable at compile time.
• Type-State Patterns - Teaches the use of generics, traits, and the type-state pattern to enforce program correctness at compile time.
• CLI Applications - Guides the development of functional command-line applications as a practical learning project.
• Concurrency and Parallelism - Instructs on achieving parallelism and thread safety using Rust's concurrency primitives.
• Build Scripts - Provides guidance on writing custom build scripts to manage dependencies and code generation.
• Python Extension Development - Teaches how to write high-performance native extensions for Python using Rust.
• Conditional Compilation - Teaches how to use conditional compilation to support multiple target platforms.
• High-Performance Systems Patterns - Teaches the implementation of high-performance patterns using pins, custom allocators, and lock-free structures.
• Architectural Pattern Translation - Instructs on converting common architectural patterns, such as interfaces and classes, into Rust traits and structs.
• Asynchronous Project Tutorials - Provides practical projects for applying asynchronous concurrency concepts to real-world applications.
• Language Idiom Comparisons - Teaches core fundamentals by comparing Rust idioms to equivalent concepts in other language ecosystems.
• Type-Safe Data Modeling - Teaches the use of structs and enums to create robust, type-safe data models with exhaustive pattern matching.
• Dynamic to Static Typing Transitions - Guides Python developers in transitioning from dynamic typing to static typing and implementing GIL-free concurrency.
• Interactive Programming Playgrounds - Utilizes editable code playgrounds, conceptual diagrams, and practical exercises to reinforce technical learning.
• Practical Application Exercises - Provides guided projects to practice data modeling and business logic through functional application development.
• Software Architecture Curricula - Provides a structured curriculum for designing ergonomic APIs and organizing professional software packages.
• Bare Metal Development - Provides training on writing code for embedded systems and kernels in restricted environments without a standard library.
• Production Async Implementation - Teaches the implementation of futures, streams, and cancellation safety for production-ready asynchronous applications.
• Binary Size Optimizations - Provides guidance on reducing executable footprints via release profiles and dependency pruning.
• Concurrency Patterns - Teaches thread-safe application development using message passing, shared state, and async runtimes.
• Metaprogramming & Macros - Teaches the use of declarative and procedural macros for compile-time code generation.
• Foreign Function Interfaces - Provides instruction on integrating external libraries and other languages using foreign function interfaces.
• External Library Integrations - Covers the use of foreign function interfaces and unsafe blocks to integrate and wrap external C and C++ libraries.
• Module and Package Management - Teaches how to use package managers and registries to organize code into modules and workspaces.
• Engineering Tutorials - Provides practical guides for build scripts, cross-compilation, and professional delivery pipelines.
• Type-State Patterns - Provides guidance on enforcing program state correctness at compile time using the type-state pattern.
• Cross-Platform Binary Generation - Teaches how to generate executable binaries for diverse hardware architectures and operating systems.
• Memory and Concurrency Error Detection - Teaches the use of sanitizers and fuzzing tools to detect undefined behavior, memory leaks, and race conditions.
• Async Event Loop Runtimes - Provides a framework for evaluating and selecting asynchronous event loop runtimes.
• Async Flow Patterns - Instructs on building production-ready systems using asynchronous streams, backpressure, and graceful shutdowns.
• Rust Delivery Pipelines - Provides guidance on setting up build scripts, cross-compilation pipelines, and automated delivery workflows.
• Exception-Equivalent Result Types - Provides training on using Result and Option types as idiomatic alternatives to exception-based error handling.
• Language Adoption Strategies - Provides strategies and translation patterns for incrementally migrating codebases from Python to Rust.
• Rust Engineering Workflows - Teaches professional engineering practices including build script configuration and automated delivery pipelines.
• Asynchronous Execution State Machines - Explains how asynchronous futures are implemented as polling state machines.
• Zero-Overhead Abstractions - Explains the design of high-level abstractions that incur no runtime performance penalty.
• Performance Measurement - Instructs on measuring execution speed and generating flamegraphs to identify and resolve processing bottlenecks.

Star history