Code Like a Pro in Rust, Video Edition - Brenden Matthews

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:

1. Chapter 1. Feelin’ Rusty
2. Chapter 1. What’s unique about Rust?
3. Chapter 1. When should you use Rust?
4. Chapter 1. Tools you’ll need
5. Chapter 1. Summary
6. Part 1. Pro Rust
7. Chapter 2. Project management with Cargo
8. Chapter 2. Dependency management
9. Chapter 2. Feature flags
10. Chapter 2. Patching dependencies
11. Chapter 2. Publishing crates
12. Chapter 2. Linking to C libraries
13. Chapter 2. Binary distribution
14. Chapter 2. Documenting Rust projects
15. Chapter 2. Modules
16. Chapter 2. Workspaces
17. Chapter 2. Custom building scripts
18. Chapter 2. Rust projects in embedded environments
19. Chapter 2. Summary
20. Chapter 3. Rust tooling
21. Chapter 3. Using rust-analyzer for Rust IDE integration
22. Chapter 3. Using rustfmt to keep code tidy
23. Chapter 3. Using Clippy to improve code quality
24. Chapter 3. Reducing compile times with sccache
25. Chapter 3. Integration with IDEs, including Visual Studio Code
26. Chapter 3. Using toolchains: Stable vs. nightly
27. Chapter 3. Additional tools: cargo-update, cargo-expand, cargo-fuzz, cargo-watch, cargo-tree
28. Chapter 3. Summary
29. Part 2. Core data
30. Chapter 4. Data structures
31. Chapter 4. Understanding slices and arrays
32. Chapter 4. Vectors
33. Chapter 4. Maps
34. Chapter 4. Rust types: Primitives, structs, enums, and aliases
35. Chapter 4. Error handling with Result
36. Chapter 4. Converting types with From/Into
37. Chapter 4. Handling FFI compatibility with Rust’s types
38. Chapter 4. Summary
39. Chapter 5. Working with memory
40. Chapter 5. Understanding ownership: Copies, borrowing, references, and moves
41. Chapter 5. Deep copying
42. Chapter 5. Avoiding copies
43. Chapter 5. To box or not to box: Smart pointers
44. Chapter 5. Reference counting
45. Chapter 5. Clone on write
46. Chapter 5. Custom allocators
47. Chapter 5. Smart pointers summarized
48. Chapter 5. Summary
49. Part 3. Correctness
50. Chapter 6. Unit testing
51. Chapter 6. Review of built-in testing features
52. Chapter 6. Testing frameworks
53. Chapter 6. What not to test: Why the compiler knows better than you
54. Chapter 6. Handling parallel test special cases and global state
55. Chapter 6. Thinking about refactoring
56. Chapter 6. Refactoring tools
57. Chapter 6. Code coverage
58. Chapter 6. Dealing with a changing ecosystem
59. Chapter 6. Summary
60. Chapter 7. Integration testing
61. Chapter 7. Integration testing strategies
62. Chapter 7. Built-in integration testing vs. external integration testing
63. Chapter 7. Integration testing libraries and tooling
64. Chapter 7. Fuzz testing
65. Chapter 7. Summary
66. Part 4. Asynchronous Rust
67. Chapter 8. Async Rust
68. Chapter 8. Thinking asynchronously
69. Chapter 8. Futures: Handling async task results
70. Chapter 8. The async and .await keywords: When and where to use them
71. Chapter 8. Concurrency and parallelism with async
72. Chapter 8. Implementing an async observer
73. Chapter 8. Mixing sync and async
74. Chapter 8. When to avoid using async
75. Chapter 8. Tracing and debugging async code
76. Chapter 8. Dealing with async when testing
77. Chapter 8. Summary
78. Chapter 9. Building an HTTP REST API service
79. Chapter 9. Creating an architecture
80. Chapter 9. API design
81. Chapter 9. Libraries and tools
82. Chapter 9. Application scaffolding
83. Chapter 9. Data modeling
84. Chapter 9. Declaring the API routes
85. Chapter 9. Implementing the API routes
86. Chapter 9. Error handling
87. Chapter 9. Running the service
88. Chapter 9. Summary
89. Chapter 10. Building an HTTP REST API CLI
90. Chapter 10. Designing the CLI
91. Chapter 10. Declaring the commands
92. Chapter 10. Implementing the commands
93. Chapter 10. Implementing requests
94. Chapter 10. Handling errors gracefully
95. Chapter 10. Testing our CLI
96. Chapter 10. Summary
97. Part 5. Optimizations
98. Chapter 11. Optimizations
99. Chapter 11. Vectors
100. Chapter 11. SIMD
101. Chapter 11. Parallelization with Rayon
102. Chapter 11. Using Rust to accelerate other languages
103. Chapter 11. Where to go from here
104. Chapter 11. Summary

Who is this course for?

1. 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!