architectural_review

Architectural Review (Rust)

This skill helps you perform an architectural review of Rust code based on advanced patterns found in the "Rust Patterns & Engineering How-Tos" guide. When asked to review system architecture or suggest broad improvements in a Rust project, apply these architectural patterns: https://microsoft.github.io/RustTraining/rust-patterns-book/

Capability Mixins (Composition over Inheritance)

• Rust doesn't have class inheritance. Instead, use traits with associated types and default method implementations to compose behaviors.
• Define "Ingredient" traits containing primitive operations (e.g. HasBus { type Bus; fn bus(&self) -> &Self::Bus; }).
• Define "Mixin" traits that require ingredient traits as supertraits, and provide default implementations for domain logic (e.g. trait FeatureMixin: HasBus).
• Use blanket implementations (impl<T: HasBus> FeatureMixin for T {}) so any type with the ingredient automatically gets the mixin behavior at compile time with zero overhead.

Typed Commands (GADT-style Return Types)

• Avoid "Untyped Swamp" signatures where generic byte buffers (Vec<u8>) are passed around indiscriminately.
• Create Domain Newtypes to represent physical/logical constraints strongly (e.g., Celsius(f64), Rpm(u32)).
• Use a Command Trait where the associated type dictates the specific return type of that command (e.g., trait Command { type Response; }).
• When a command is executed, its concrete type ensures the correct return format is parsed and returned natively, turning unit-confusion runtime errors into compile-time errors.

Concurrency and Parallelism

• Understand the distinction between concurrency (tasks making progress) and parallelism (simultaneous execution).
• Threads vs. Rayon: Use OS threads (std::thread::spawn) for long-running background tasks. Use rayon::par_iter() for data parallelism when processing collections. Use scoped threads (std::thread::scope) to safely borrow stack variables across short-lived parallel tasks.
• Shared State: Use Mutex<T> for exclusive access in short critical sections. Use RwLock<T> for read-heavy workloads with rare writes. Use AtomicU64 and similar atomic types for simple flags/counters to avoid lock overhead.
• Message Passing: Prefer crossbeam-channel over std::sync::mpsc in production for multi-consumer support and select macros. Use bounded channels to implement backpressure and avoid OOM issues. Employ the Actor pattern with channels to encapsulate complex shared mutable state instead of wrapping everything in a Mutex.