Take your first steps with Rust

In this module, you'll:

• Get a brief introduction to Rust.
• Discover why developers choose Rust over other programming languages.
• Understand the basic components and tools for using Rust.
• Try working with code in the Rust playground.

In this module, you will learn how to:

• Set up your development environment for using Rust.
• Write a simple "Hello, world!" program.
• Use Cargo, Rust's build tool and dependency manager.

In this module, you will:

• Explore core Rust language concepts, including functions, data types, and variables
• Understand basic Rust types for text, numbers, boolean values, and compound data
• Create, compile, and run a basic Rust program
• Discover how to print output from your program

In this module, you will:

• Explore Rust compound data types: arrays and vectors
• Discover how to use if/else statements to test conditions in a Rust program
• Create, compile, and run a Rust program to process compound data and test values

In this module, you will:

• Discover the hash map data type in Rust, and how to access keys and values
• Explore how to use loop expressions to iterate through data in a Rust program
• Create, compile, and run a Rust program to iterate on hash map data by using a loop

In this module, you'll learn how to:

• Use panic! to deal with unrecoverable errors.
• Use the Option enum when a value is optional or the lack of a value is not an error condition.
• Use the Result enum when things could go wrong and a caller might have to deal with the problem.

In this module, you'll learn:

• The concept of ownership in Rust.
• Moving and borrowing values.
• Scoping rules and lifetimes.
• Rust's pointer types, commonly called references.

In this module, you'll learn:

• What generic types are and how "wrapper" types use them.
• What traits are and how they help us define shared behavior.
• How to implement an existing trait for a custom type.
• How to implement a custom trait for an existing type.
• How trait bounds help us write generic functions.
• How to implement an Iterator trait to iterate through collections.

In this module, you'll learn:

• How to organize your code in files, modules, and packages.
• How those concepts interact.
• How to use third-party packages from the Crates.io repository.

In this module, you'll learn:

• How to write unit tests.
• How to write integration tests.
• How to write documentation tests.

In this module, you'll learn:

• How to develop a real-world command-line program by using tested third-party crates for command-line parsing and error handling.

• Introduction
• What is Rust?
• Unique features of Rust
• The Rust playground
• Exercise
• Summary

• Introduction
• Install Visual Studio Code
• Install Visual C++ build tools
• Install Rust
• Exercise: Hello World
• Summary

• Introduction
• Understand the basic Rust program structure
• Create and use variables in Rust
• Explore data types for numbers, text, and true/false values
• Define data collections by using tuples and structs
• Use enum variants for compound data
• Work with functions in Rust
• Exercise: Write a function to build a car
• Summary

• Introduction
• Create and use arrays
• Explore the vector data type
• Exercise: Work with compound types
• Use if/else conditions
• Exercise: Work with if/else conditions
• Summary

• Introduction
• Work with hash maps
• Exercise: Use a hash map to track orders
• Use for, while, and loop expressions
• Exercise: Use a loop to iterate on data
• Summary

• Introduction
• Learn about fatal errors with panic!
• Use the Option type to deal with absence
• Exercise - Use the Option type to deal with absence
• Use the Result type to handle errors
• Exercise - Use the Result type to handle errors
• Knowledge check
• Summary

• Introduction
• What is ownership?
• Learn about borrowing
• Validate references by using lifetimes
• Exercise - Lifetimes
• Knowledge check
• Summary

• Introduction
• What are generic data types?
• Define shared behavior with traits
• Use the derive trait
• Use trait bounds and generic functions
• Use iterators
• Exercise - Implement a generic type
• Exercise - Implement an iterator
• Knowledge check
• Summary

• Introduction
• Understand concepts behind code organization
• Split code into modules
• Separate modules into different files
• Add third-party crates to your project
• Exercise - Visibility
• Exercise - Modules
• Knowledge check
• Summary

• Introduction
• Write unit tests
• Exercise - Write unit tests
• Write documentation tests
• Exercise - Write documentation tests
• Write integration tests
• Knowledge check
• Summary

• Introduction
• Outline the application
• Create the CLI module
• Create the tasks module
• Write a function that adds tasks
• Write a function that completes tasks
• Write a function that prints tasks
• Complete the main module
• Use a default journal file to store tasks
• Display friendly error messages
• Knowledge check
• Summary