Oreilly – Code Like a Pro in Rust, Video Edition 2024-3
Oreilly – Code Like a Pro in Rust, Video Edition 2024-3

Code Like a Pro in Rust, Video Edition. This course teaches you advanced techniques used by Rust experts to write professional code. You’ll learn key Rust concepts like memory management, asynchronous programming, and essential tools for testing, tooling, and project management. This course will help you produce high-quality code at a low cost. Key points:
- Rust is renowned for its security, performance, and safety, but professional skills are required to make the most of this language.
- This course will help you become familiar with Rust-specific design patterns, coding shortcuts, and advanced skills like asynchronous programming.
- You will learn about Rust’s amazing tools for testing, code analysis, and application lifecycle management.
- This course will help you avoid common mistakes in this programming language.
What you will learn:
- Essential Rust tools
- Basic Rust data structures
- Memory management
- Testing in Rust
- Asynchronous programming for Rust
- Rust optimization
- Rust project management
Who is this course suitable for?
- This course is suitable for those who are familiar with the basics of Rust and want to improve their skills in this language and become a professional Rust programmer.
Code Like a Pro in Rust, Video Edition Course Details
- Publisher: Orielly
- Instructor: Brenden Matthews
- Training level: Beginner to advanced
- Training duration: 6 hours and 24 minutes
Course headings
- 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
Course images
Sample course video
Installation Guide
After Extract, view with your favorite player.
Subtitles: None
Quality: 720p
Download link
File(s) password: www.downloadly.ir
File size
890 MB