Video description
In Video Editions the narrator reads the book while the content, figures, code listings, diagrams, and text appear on the screen. Like an audiobook that you can also watch as a video.
One month. One hour a day. That’s all it takes to start writing Rust code!
Learn Rust in a Month of Lunches teaches you to write super fast and super safe Rust code through lessons you can fit in your lunch break. Crystal-clear explanations and focused, relevant examples make it accessible to anyone—even if you’re learning Rust as your first programming language.
By the time you’re done reading Learn Rust in a Month of Lunches you’ll be able to:
- Build real software in Rust
- Understand messages from the compiler and Clippy, Rust’s coding coach
- Make informed decisions on the right types to use in any context
- Make sense of the Rust standard library and its commonly used items
- Use external Rust “crates” (libraries) for common tasks
- Comment and build documentation for your Rust code
- Work with crates that use async Rust
- Write simple declarative macros
- Explore test driven development in Rust
About the Technology
Learn how to create fast powerful programs in Rust in just 24 short lessons! Rust gives you modern features like a top-notch compiler, a rich ecosystem of pre-built libraries, and the same low-level performance you get with a language like C, but without the awkward syntax, complex memory management, and code safety concerns. This book guides you step by step from your first line of code.
About the Book
Learn Rust in a Month of Lunches breaks down the Rust language into concise hands-on lessons designed to be completed in an hour or less. The examples are fun and easy to follow, so you’ll quickly progress from zero Rust knowledge to handling async and writing your own macros. You won’t even need to install Rust—the book’s code samples run in the browser-based Rust Playground. There’s no easier way to get started!
What's Inside
- Build working Rust software
- Understand messages from the compiler and Clippy
- Use external Rust “crates” (libraries) for common tasks
- Explore test driven development in Rust
About the Reader
No previous experience with Rust required.
About the Author
Dave MacLeod was an educator, Korean-English translator, project controller, and copywriter before becoming a full-time Rust developer. The technical editor on this book was Jerry Kuch.
Quotes
Breaks the journey down into manageable parts, teaching in small increments and making consistent progress. If you’ve put off learning Rust, this is the book for you!
- Luca Palmieri, Mainmatter
Covers all you need to start programming in Rust.
- Jonathan Reeves, Wolfjaw Studios
Simple language and a great pace. Easy-to-understand examples cover key language concepts. It’s everything you need to know to get going.
- Steve Fenton, Octopus Deploy
Unlock your potential as a Rust programmer with this exceptional guide.
- Srikar Vedantam, Volvo Group
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
Product information
- Title: Learn Rust in a Month of Lunches, Video Edition
- Author(s):
- Release date: April 2024
- Publisher(s): Manning Publications
- ISBN: None
You might also like
book
Learn Rust in a Month of Lunches
One month. One hour a day. That’s all it takes to start writing Rust code! Learn …
video
Rust in Action, video edition
This well-written book will help you make the most of what Rust has to offer. Ramnivas …
video
Ultimate Rust Crash Course
Are you in awe of how Rust systematically eliminates entire classes of bugs and security vulnerabilities …
video
52 Weeks of Rust
52 Weeks of Rust Learning Rust by Live Coding This video series live codes Rust and …