Rust Professional Development

Goal: Write idiomatic, high-performance, and memory-safe Rust code following standard community practices (The Rust Way).

1. Core Principles

• •Ownership & Borrowing: strictly enforce ownership rules. Avoid .clone() unless necessary. Use Arc<Mutex<T>> or RwLock<T> for shared state only when message passing (mpsc) is not viable.
• •Error Handling: Use Result<T, E> with thiserror for libraries and anyhow for applications. Never use .unwrap() in production code; use .expect() with a context message or ? operator.
• •Async Runtime: Default to tokio for general purpose apps. Use join_all for parallel execution of futures.
• •Type System: Leverage traits and generics for zero-cost abstractions. Use New Type pattern to enforce validation at compile time.

2. Toolchain & Ecosystem

• •Build System: cargo
• •Linter: clippy (Treat warnings as errors in CI)
• •Formatter: rustfmt
• •Testing: Built-in #[test] and cargo test. Use mockall for mocking traits.

3. Recommended Project Structure

my_crate/
├── Cargo.toml
├── src/
│   ├── main.rs          # Binary entry point
│   ├── lib.rs           # Library entry point
│   ├── bin/             # Additional binaries
│   ├── models/          # Data structures
│   ├── error.rs         # Central error definition
│   └── utils.rs         # Helper functions
└── tests/               # Integration tests
    └── integration_test.rs

4. Common Dependencies (The Standard Stack)

• •Async: tokio, futures
• •Web: axum or actix-web
• •Serialization: serde, serde_json
• •Error Handling: anyhow, thiserror
• •Tracing/Logging: tracing, tracing-subscriber
• •config: config crate for environment management

5. Security & Performance

• •Memory: Use String only when ownership is needed; prefer &str for function arguments.
• •Unsafe: Avoid unsafe blocks unless absolutely necessary and documented with // SAFETY: comment explaining why it holds.
• •Vectors: Pre-allocate vectors with Vec::with_capacity(n) if size is known.

6. Implementation Workflow

1. •Define Types: Start with struct and enum definitions.
2. •Define Traits: Outline behavior using traits.
3. •Implement Logic: Implement traits for types.
4. •Wire up: Connect components in main.rs or lib.rs.
5. •Test: Write unit tests alongside code and integration tests in tests/.

Anti-Patterns to Avoid:

• •Excessive use of Box<dyn Trait> (prefer generics with static dispatch).
• •Ignoring Result (always handle or propagate).
• •Global mutable state (use dependency injection or actor pattern).