With insider techniques from seasoned experts, get ready to be a master in Rust. In the book "Code Like a Pro in Rust, Video Edition - Brenden Matthews," you will find tips on how to code with Rust as if you are a professional at it, and many other skills such as memory management, asynchronous coding, etc. Get the best advice on project management using tools like testing and writing low-maintenance codes that produce high-quality results. The guide covers everything needed to efficiently build and deliver professional software, including essential Rust tooling, core data structures, and optimized Rust and project management strategies.
Learn about the powerful features of Rust in “Code Like a Pro in Rust, Video Edition - Brenden Matthews”. This guide contains real-world examples and practical tips on writing code in Rust using specific patterns that are also useful shortcuts like integrating this language with others. Also, you will get to know which are the best tools for testing, static analysis, and managing the life cycle of an application. This class has been designed around increasing your productivity by teaching you how to avoid common mistakes while navigating the growing number of libraries within the expanding eco-system of Rust programming language, thus ensuring that your skills don’t become outdated.
Code Like a Pro in Rust, Video Edition - Brenden Matthews Table of Contents:
- Chapter 1. Feelin’ Rusty
- Chapter 1. What’s unique about Rust?
- Chapter 1. When should you use Rust?
- Chapter 1. Tools you’ll need
- Chapter 1. Summary
- Part 1. Pro Rust
- Chapter 2. Project management with Cargo
- Chapter 2. Dependency management
- Chapter 2. Feature flags
- Chapter 2. Patching dependencies
- Chapter 2. Publishing crates
- Chapter 2. Linking to C libraries
- Chapter 2. Binary distribution
- Chapter 2. Documenting Rust projects
- Chapter 2. Modules
- Chapter 2. Workspaces
- Chapter 2. Custom building scripts
- Chapter 2. Rust projects in embedded environments
- Chapter 2. Summary
- Chapter 3. Rust tooling
- Chapter 3. Using rust-analyzer for Rust IDE integration
- Chapter 3. Using rustfmt to keep code tidy
- Chapter 3. Using Clippy to improve code quality
- Chapter 3. Reducing compile times with sccache
- Chapter 3. Integration with IDEs, including Visual Studio Code
- Chapter 3. Using toolchains: Stable vs. nightly
- Chapter 3. Additional tools: cargo-update, cargo-expand, cargo-fuzz, cargo-watch, cargo-tree
- Chapter 3. Summary
- Part 2. Core data
- Chapter 4. Data structures
- Chapter 4. Understanding slices and arrays
- Chapter 4. Vectors
- Chapter 4. Maps
- Chapter 4. Rust types: Primitives, structs, enums, and aliases
- Chapter 4. Error handling with Result
- Chapter 4. Converting types with From/Into
- Chapter 4. Handling FFI compatibility with Rust’s types
- Chapter 4. Summary
- Chapter 5. Working with memory
- Chapter 5. Understanding ownership: Copies, borrowing, references, and moves
- Chapter 5. Deep copying
- Chapter 5. Avoiding copies
- Chapter 5. To box or not to box: Smart pointers
- Chapter 5. Reference counting
- Chapter 5. Clone on write
- Chapter 5. Custom allocators
- Chapter 5. Smart pointers summarized
- Chapter 5. Summary
- Part 3. Correctness
- Chapter 6. Unit testing
- Chapter 6. Review of built-in testing features
- Chapter 6. Testing frameworks
- Chapter 6. What not to test: Why the compiler knows better than you
- Chapter 6. Handling parallel test special cases and global state
- Chapter 6. Thinking about refactoring
- Chapter 6. Refactoring tools
- Chapter 6. Code coverage
- Chapter 6. Dealing with a changing ecosystem
- Chapter 6. Summary
- Chapter 7. Integration testing
- Chapter 7. Integration testing strategies
- Chapter 7. Built-in integration testing vs. external integration testing
- Chapter 7. Integration testing libraries and tooling
- Chapter 7. Fuzz testing
- Chapter 7. Summary
- Part 4. Asynchronous Rust
- Chapter 8. Async Rust
- Chapter 8. Thinking asynchronously
- Chapter 8. Futures: Handling async task results
- Chapter 8. The async and .await keywords: When and where to use them
- Chapter 8. Concurrency and parallelism with async
- Chapter 8. Implementing an async observer
- Chapter 8. Mixing sync and async
- Chapter 8. When to avoid using async
- Chapter 8. Tracing and debugging async code
- Chapter 8. Dealing with async when testing
- Chapter 8. Summary
- Chapter 9. Building an HTTP REST API service
- Chapter 9. Creating an architecture
- Chapter 9. API design
- Chapter 9. Libraries and tools
- Chapter 9. Application scaffolding
- Chapter 9. Data modeling
- Chapter 9. Declaring the API routes
- Chapter 9. Implementing the API routes
- Chapter 9. Error handling
- Chapter 9. Running the service
- Chapter 9. Summary
- Chapter 10. Building an HTTP REST API CLI
- Chapter 10. Designing the CLI
- Chapter 10. Declaring the commands
- Chapter 10. Implementing the commands
- Chapter 10. Implementing requests
- Chapter 10. Handling errors gracefully
- Chapter 10. Testing our CLI
- Chapter 10. Summary
- Part 5. Optimizations
- Chapter 11. Optimizations
- Chapter 11. Vectors
- Chapter 11. SIMD
- Chapter 11. Parallelization with Rayon
- Chapter 11. Using Rust to accelerate other languages
- Chapter 11. Where to go from here
- Chapter 11. Summary
Who is this course for?
- Anyone who has some experience with the RUST programming language should consider taking this course.
Click on the links below to Download Code Like a Pro in Rust, Video Edition - Brenden Matthews!
در حال پاسخ به :