Learn Rust in a Month of Lunches, Video Edition - David MacLeod offers a swift and accessible journey into Rust programming, ideal for both beginners and seasoned developers looking to add a powerful language to their repertoire. With just an hour a day, you'll learn Rust's unique features, mastering its fast and safe coding practices. The book's 24 lessons are designed to fit into your lunch break, offering crystal-clear explanations and practical examples that demystify Rust's syntax and concepts.
Through Learn Rust in a Month of Lunches, Video Edition - David MacLeod, you'll learn to build real software in Rust, harness the power of its compiler and Clippy for error detection and optimization, and leverage the extensive Rust standard library and external crates for various tasks. From understanding data types to exploring async programming and crafting your own macros, each lesson propels you closer to Rust proficiency. What sets this book apart is its emphasis on practicality, you'll not only learn Rust's fundamentals but also feel confident applying them in real-world projects.
Whether you're interested in system programming, web development, or game design, Learn Rust in a Month of Lunches, Video Edition - David MacLeod equips you with the skills to thrive in Rust's ecosystem. With code samples runnable in the browser-based Rust Playground, there's no need for complex setups.
Learn Rust in a Month of Lunches, Video Edition - David MacLeod Table of Contents:
- Chapter 1. Some basics
- Chapter 1. Comments
- Chapter 1. Primitive types: Integers, characters, and strings
- Chapter 1. Type inference
- Chapter 1. Floats
- Chapter 1. “Hello, World!” and printing
- Chapter 1. Declaring variables and code blocks
- Chapter 1. Display and Debug
- Chapter 1. Smallest and largest numbers
- Chapter 1. Mutability (changing)
- Chapter 1. Shadowing
- Chapter 1. Summary
- Chapter 2. Memory, variables, and ownership
- Chapter 2. Strings
- Chapter 2. const and static
- Chapter 2. More on references
- Chapter 2. Mutable references
- Chapter 2. Shadowing again
- Chapter 2. Giving references to functions
- Chapter 2. Copy types
- Chapter 2. Variables without values
- Chapter 2. More about printing
- Chapter 2. Summary
- Chapter 3. More complex types
- Chapter 3. Control flow
- Chapter 3. Summary
- Chapter 4. Building your own types
- Chapter 4. Destructuring
- Chapter 4. References and the dot operator
- Chapter 4. Summary
- Chapter 5. Generics, option, and result
- Chapter 5. Option and Result
- Chapter 5. ummary
- Chapter 6. More collections, more error handling
- Chapter 6. The? operator
- Chapter 6. When panic and unwrap are good
- Chapter 6. Summary
- Chapter 7. Traits: Making different types do the same thing
- Chapter 7. The From trait
- Chapter 7. The orphan rule
- Chapter 7. Getting around the orphan rule with newtypes
- Chapter 7. Taking a String and a in a function
- Chapter 7. Summary
- Chapter 8. Iterators and closures
- Chapter 8. Iterators
- Chapter 8. Closures and closures inside iterators
- Chapter 8. Summary
- Chapter 9. Iterators and closures again!
- Chapter 9. The dbg! macro and .inspect
- Chapter 9. Summary
- Chapter 10. Lifetimes and interior mutability
- Chapter 10. Lifetime annotations
- Chapter 10. Interior mutability
- Chapter 10. Summary
- Chapter 11. Multiple threads and a lot more
- Chapter 11. The todo! macro
- Chapter 11. Type aliases
- Chapter 11. Cow
- Chapter 11. Rc
- Chapter 11. Multiple threads
- Chapter 11. Summary
- Chapter 12. More on closures, generics, and threads
- Chapter 12. impl Trait
- Chapter 12. Arc
- Chapter 12. Scoped threads
- Chapter 12. Channels
- Chapter 12. Summary
- Chapter 13. Box and Rust documentation
- Chapter 13. Box
- Chapter 13. Summary
- Chapter 14. Testing and building your code from tests
- Chapter 14. Testing
- Chapter 14. Test-driven development
- Chapter 14. Summary
- Chapter 15. Default, the builder pattern, and Deref
- Chapter 15. The builder pattern
- Chapter 15. Deref and DerefMut
- Chapter 15. Summary
- Chapter 16. Const, “unsafe” Rust, and external crates
- Chapter 16. Const functions
- Chapter 16. Mutable statics
- Chapter 16. Unsafe Rust
- Chapter 16. Introducing external crate
- Chapter 16. Summary
- Chapter 17. Rust’s most popular crates
- Chapter 17. Time in the standard library
- Chapter 17. chrono
- Chapter 17. Rayon
- Chapter 17. Anyhow and thiserror
- Chapter 17. Blanket trait implementations
- Chapter 17. lazy_static and once_cell
- Chapter 17. Summary
- Chapter 18. Rust on your computer
- Chapter 18. Working with user input
- Chapter 18. Using files
- Chapter 18. cargo doc
- Chapter 18. Summary
- Chapter 19. More crates and async Rust
- Chapter 19. Feature flags
- Chapter 19. Async Rust
- Chapter 19. Summary
- Chapter 20. A tour of the standard library
- Chapter 20. char
- Chapter 20. Integers
- Chapter 20. Floats
- Chapter 20. Associated items and associated constants
- Chapter 20. bool
- Chapter 20. Vec
- Chapter 20. String
- Chapter 20. OsString and CString
- Chapter 20. Summary
- Chapter 21. Continuing the tour
- Chapter 21. Setting panic hooks
- Chapter 21. Viewing backtraces
- Chapter 21. The standard library prelude
- Chapter 21. Other macros
- Chapter 21. Summary
- Chapter 22. Writing your own macros
- Chapter 22. Writing basic macros
- Chapter 22. Reading macros from the standard library
- Chapter 22. Using macros to keep your code clean
- Chapter 22. Summary
- Chapter 23. Unfinished projects: Projects for you to finish
- Chapter 23. Typing tutor
- Chapter 23. Wikipedia article summary searcher
- Chapter 23. Terminal stopwatch and clock
- Chapter 23. Summary
- Chapter 24. Unfinished projects continued
- Chapter 24. Laser pointer
- Chapter 24. Directory and file navigator
- Chapter 24. Summary
Who is this course for?
- Beginners
Click on the links below to Download Learn Rust in a Month of Lunches, Video Edition - David MacLeod!
در حال پاسخ به :