Learn Rust in a Month of Lunches, Video Edition

Learn Rust in a Month of Lunches, Video Edition

by David MacLeod
Released April 2024
Publisher(s): Manning Publications
ISBN: None

Watch it now on the O’Reilly learning platform with a 10-day free trial.

O’Reilly members get unlimited access to books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.

Start your free trial

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
Learn Rust in a Month of Lunches is full of 24 easy-to-digest lessons that ease you into real Rust programming. You’ll learn essential Rust skills you can use for everything from system programming, to web applications, and games. By the time you’re done learning, you’ll know exactly what makes Rust unique—and be one of the thousands of developers who say it’s their best loved language!

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

  1. Chapter 1. Some basics
  2. Chapter 1. Comments
  3. Chapter 1. Primitive types: Integers, characters, and strings
  4. Chapter 1. Type inference
  5. Chapter 1. Floats
  6. Chapter 1. “Hello, World!” and printing
  7. Chapter 1. Declaring variables and code blocks
  8. Chapter 1. Display and Debug
  9. Chapter 1. Smallest and largest numbers
  10. Chapter 1. Mutability (changing)
  11. Chapter 1. Shadowing
  12. Chapter 1. Summary
  13. Chapter 2. Memory, variables, and ownership
  14. Chapter 2. Strings
  15. Chapter 2. const and static
  16. Chapter 2. More on references
  17. Chapter 2. Mutable references
  18. Chapter 2. Shadowing again
  19. Chapter 2. Giving references to functions
  20. Chapter 2. Copy types
  21. Chapter 2. Variables without values
  22. Chapter 2. More about printing
  23. Chapter 2. Summary
  24. Chapter 3. More complex types
  25. Chapter 3. Control flow
  26. Chapter 3. Summary
  27. Chapter 4. Building your own types
  28. Chapter 4. Destructuring
  29. Chapter 4. References and the dot operator
  30. Chapter 4. Summary
  31. Chapter 5. Generics, option, and result
  32. Chapter 5. Option and Result
  33. Chapter 5. ummary
  34. Chapter 6. More collections, more error handling
  35. Chapter 6. The ? operator
  36. Chapter 6. When panic and unwrap are good
  37. Chapter 6. Summary
  38. Chapter 7. Traits: Making different types do the same thing
  39. Chapter 7. The From trait
  40. Chapter 7. The orphan rule
  41. Chapter 7. Getting around the orphan rule with newtypes
  42. Chapter 7. Taking a String and a in a function
  43. Chapter 7. Summary
  44. Chapter 8. Iterators and closures
  45. Chapter 8. Iterators
  46. Chapter 8. Closures and closures inside iterators
  47. Chapter 8. Summary
  48. Chapter 9. Iterators and closures again!
  49. Chapter 9. The dbg! macro and .inspect
  50. Chapter 9. Summary
  51. Chapter 10. Lifetimes and interior mutability
  52. Chapter 10. Lifetime annotations
  53. Chapter 10. Interior mutability
  54. Chapter 10. Summary
  55. Chapter 11. Multiple threads and a lot more
  56. Chapter 11. The todo! macro
  57. Chapter 11. Type aliases
  58. Chapter 11. Cow
  59. Chapter 11. Rc
  60. Chapter 11. Multiple threads
  61. Chapter 11. Summary
  62. Chapter 12. More on closures, generics, and threads
  63. Chapter 12. impl Trait
  64. Chapter 12. Arc
  65. Chapter 12. Scoped threads
  66. Chapter 12. Channels
  67. Chapter 12. Summary
  68. Chapter 13. Box and Rust documentation
  69. Chapter 13. Box
  70. Chapter 13. Summary
  71. Chapter 14. Testing and building your code from tests
  72. Chapter 14. Testing
  73. Chapter 14. Test-driven development
  74. Chapter 14. Summary
  75. Chapter 15. Default, the builder pattern, and Deref
  76. Chapter 15. The builder pattern
  77. Chapter 15. Deref and DerefMut
  78. Chapter 15. Summary
  79. Chapter 16. Const, “unsafe” Rust, and external crates
  80. Chapter 16. Const functions
  81. Chapter 16. Mutable statics
  82. Chapter 16. Unsafe Rust
  83. Chapter 16. Introducing external crate
  84. Chapter 16. Summary
  85. Chapter 17. Rust’s most popular crates
  86. Chapter 17. Time in the standard library
  87. Chapter 17. chrono
  88. Chapter 17. Rayon
  89. Chapter 17. Anyhow and thiserror
  90. Chapter 17. Blanket trait implementations
  91. Chapter 17. lazy_static and once_cell
  92. Chapter 17. Summary
  93. Chapter 18. Rust on your computer
  94. Chapter 18. Working with user input
  95. Chapter 18. Using files
  96. Chapter 18. cargo doc
  97. Chapter 18. Summary
  98. Chapter 19. More crates and async Rust
  99. Chapter 19. Feature flags
  100. Chapter 19. Async Rust
  101. Chapter 19. Summary
  102. Chapter 20. A tour of the standard library
  103. Chapter 20. char
  104. Chapter 20. Integers
  105. Chapter 20. Floats
  106. Chapter 20. Associated items and associated constants
  107. Chapter 20. bool
  108. Chapter 20. Vec
  109. Chapter 20. String
  110. Chapter 20. OsString and CString
  111. Chapter 20. Summary
  112. Chapter 21. Continuing the tour
  113. Chapter 21. Setting panic hooks
  114. Chapter 21. Viewing backtraces
  115. Chapter 21. The standard library prelude
  116. Chapter 21. Other macros
  117. Chapter 21. Summary
  118. Chapter 22. Writing your own macros
  119. Chapter 22. Writing basic macros
  120. Chapter 22. Reading macros from the standard library
  121. Chapter 22. Using macros to keep your code clean
  122. Chapter 22. Summary
  123. Chapter 23. Unfinished projects: Projects for you to finish
  124. Chapter 23. Typing tutor
  125. Chapter 23. Wikipedia article summary searcher
  126. Chapter 23. Terminal stopwatch and clock
  127. Chapter 23. Summary
  128. Chapter 24. Unfinished projects, continued
  129. Chapter 24. Laser pointer
  130. Chapter 24. Directory and file navigator
  131. Chapter 24. Summary

Product information

  • Title: Learn Rust in a Month of Lunches, Video Edition
  • Author(s): David MacLeod
  • Release date: April 2024
  • Publisher(s): Manning Publications
  • ISBN: None