[https://doc.rust-lang.org/cargo/guide/project-layout.html](https://doc.rust-lang.org/cargo/guide/project-layout.html "https://doc.rust-lang.org/cargo/guide/project-layout.html") ![[Pasted image 20240701165142.png]] Here's a markdown table summarizing best practices for implementing Rust code: | Category | Best Practice | |----------|---------------| | Code Organization | - Organize code by functionality/features rather than low-level implementation details[1][5] | | | - Use modules to group related functionality[5] | | | - Consider using separate crates for large, self-contained parts of your project[5] | | Structure and Impl | - Keep struct definitions and their impl blocks in the same file[1] | | | - Use traits and objects with attached behavior instead of free functions when appropriate[3] | | Memory Management | - Familiarize yourself with Rust's memory management system (Rc, RefCell, Cell, Arc, Mutex)[2] | | | - Learn to avoid "fighting the borrow checker"[2] | | Code Style | - Use `cargo fmt` for consistent formatting[1] | | | - Use `cargo clippy` for additional linting[1] | | Documentation | - Write clear and comprehensive documentation for your code[4] | | | - Use `cargo doc --open` to generate and view documentation[5] | | Testing | - Write tests for your code[3] | | Security | - Use Rust's type system to your advantage[4] | | | - Sanitize input data[4] | | | - Keep dependencies up to date[4] | | | - Minimize the use of unsafe blocks[4] | | Performance | - Consider Data Oriented Design (DOD) for performance-critical code[3] | | | - Be mindful of allocations and object reuse[2] | | API Design | - Follow the Rust API Guidelines for idiomatic interfaces[3] | | | - Consider flattening public APIs for user convenience[5] | Remember that these are general guidelines and may vary depending on your specific project requirements and team preferences. Citations: [1] https://users.rust-lang.org/t/best-practices-to-write-rust-code/110040 [2] https://www.reddit.com/r/rust/comments/qy2i9o/resources_for_rust_best_practices/ [3] https://users.rust-lang.org/t/rust-best-practices/40436 [4] https://www.mayhem.security/blog/best-practices-for-secure-programming-in-rust [5] https://users.rust-lang.org/t/best-practices-around-organising-code-bases/88694 https://rust-unofficial.github.io/patterns/anti_patterns/borrow_clone.html #code #rust #programming ### cool rust stuff 070424 The `{ ... }` block syntax in Rust is useful in several scenarios. Here are some key use cases: ### 1. Creating a new scope ```rust { let x = 5; // x only exists in this scope } // x is not accessible here ``` #rust #scoping ### 2. Shadowing variables ```rust let x = 5; { let x = x * 2; // shadows outer x, only in this scope println!("Inner x: {}", x); } println!("Outer x: {}", x); ``` #variable_shadowing ### 3. Limiting the lifetime of a borrow ```rust let mut v = vec![1, 2, 3]; { let first = &v[0]; // borrow ends at end of this block println!("{}", first); } // borrow ends here v.push(4); // OK, no active borrows ``` #borrowing #lifetimes ### 4. Grouping expressions ```rust let y = { let x = 3; x * x // last expression is returned }; ``` #expressions ### 5. Temporary value dropping ```rust { let large_object = create_large_object(); // use large_object } // large_object is dropped here, freeing memory earlier ``` #memory_management ### 6. Explicit drop ```rust { let file = File::open("file.txt").unwrap(); // do something with file } // file is closed here ``` #resource_management ### 7. Organizing code in impl blocks ```rust impl MyStruct { pub fn new() -> Self { // ... } { // private helper methods fn helper1() { /* ... */ } fn helper2() { /* ... */ } } } ``` #code_organization these blocks are like zen gardens in code - they create clear boundaries and help manage the flow of data and lifetimes. use them wisely to cultivate clean, efficient rust code. ### 070624 pointers vs no pointers Here's a concise guide on when to use `&` (references) vs. raw pointers in Rust: ### When to use `&` (references): 1. **Default choice**: Use references for most cases when you need to borrow data. 2. **Function parameters**: For passing data without transferring ownership. 3. **Read-only access**: When you only need to read data. 4. **Mutable borrowing**: Use `&mut` for temporary mutable access. ### When to use raw pointers: 1. **FFI**: When interfacing with C code. 2. **Unsafe operations**: For low-level memory manipulation. 3. **Performance-critical code**: In rare cases where reference checks are too costly. 4. **Implementing data structures**: For complex structures like linked lists. ### Best practices: 1. **Prefer references**: They're safer and more idiomatic. 2. **Use `&str` over `&String`**: For string slices. 3. **Lifetime annotations**: Add when necessary for clarity. 4. **Avoid premature optimization**: Don't use raw pointers just for perceived performance gains. 5. **Document unsafe code**: Always explain why raw pointers are necessary. Remember, Rust's borrow checker ensures safety with references. Only use raw pointers when absolutely necessary and within [unsafe](file:///Users/louisbeaumont/Documents/screen-pipe/screenpipe-server/src/video.rs#100%2C5-100%2C5) blocks.