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/

   .

• 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).