Packt Admin

Rust is a new systems programming language from Mozilla, created to facilitate the development of large, complex software projects. Its powerful type system and memory safety rules prevent all memory corruption bugs without compromising developer productivity.In this course, you’ll begin by getting familiar with the basic syntax and concepts of Rust, from writing a Hello World program to defining functions and creating variables. Then you’ll see how to manage toolchains with Rust up and build your first command-line program.Moving on, you’ll explore Rust’s type system to write better code and put it into practice in a simple markup language. You’ll learn to use Rust’s functional programming features to perform a physics simulation and use the Rayon crate to parallelize your computations. Finally, you’ll discover the best practices and test your code by building a simple crate with a tested, usable, well-documented API using Cargo and RustDoc.By the end of the video, you’ll be comfortable building various solutions in Rust. You’ll be able to take advantage of Rust’s powerful type system and a rich ecosystem of libraries, or “crates”, available through the Cargo package manager.  Target Audience

The video is for developers who have basic knowledge of programming. The video will also appeal to developers who are using C/C++ language to write their applications. There is no knowledge of Rust language expected.

 

 Business Outcomes

<ul>
	<li>Discover Rust’s powerful type system, which prevents data races and memory corruption</li>
	<li>Build concurrent applications without fear</li>
	<li>Take advantage of the large ecosystem of libraries available through Cargo</li>
</ul>

In this section, you’ll learn the basic syntax and concepts of Rust, from writing a “Hello, World!” program to defining functions and creating variables. This section uses the online Rust playground, so there’s nothing to install on your computer just yet.

<ul>
	<li>The Course Overview</li>
	<li>Bindings and Mutability</li>
	<li>Built-In Types</li>
	<li>Imports and Namespaces</li>
	<li>The Standard Library</li>
	<li>Recursive Fibonacci</li>
	<li>Dynamic  Fibonacci</li>
</ul>

This video gives an overview of the entire course.

The Course Overview

Course OverviewRust is a new systems programming language from Mozilla, created to facilitate the development of large, complex software projects. Its powerful type system and memory safety rules prevent all memory corruption bugs without compromising developer productivity. In this course, you’ll begin by getting familiar with the basic syntax and concepts of Rust, from writing a Hello World program to defining functions and creating variables. Then you’ll see how to manage toolchains with Rust up and build your first command-line program. Moving on, you’ll explore Rust’s type system to write better code and put it into practice in a simple markup language. You’ll learn to use Rust’s functional programming features to perform a physics simulation and use the Rayon crate to parallelize your computations. Finally, you’ll discover the best practices and test your code by building a simple crate with a tested, usable, well-documented API using Cargo and RustDoc.
By the end of the video, you’ll be comfortable building various solutions in Rust. You’ll be able to take advantage of Rust’s powerful type system and a rich ecosystem of libraries, or “crates”, available through the Cargo package manager. Target AudienceThe video is for developers who have basic knowledge of programming. The video will also appeal to developers who are using C/C++ language to write their applications. There is no knowledge of Rust language expected. This video is part of the course Learning Rust.In this video, we will examine the basic syntax of Rust and see its variables called “bindings” at work.
<ul><li>Learn that bindings are immutable by default</li><li>Learn that Rust supports mutable bindings</li><li>Know that the compiler will prevent us from using a variable that was not initialized</li></ul>

Bindings and Mutability

Course OverviewRust is a new systems programming language from Mozilla, created to facilitate the development of large, complex software projects. Its powerful type system and memory safety rules prevent all memory corruption bugs without compromising developer productivity. In this course, you’ll begin by getting familiar with the basic syntax and concepts of Rust, from writing a Hello World program to defining functions and creating variables. Then you’ll see how to manage toolchains with Rust up and build your first command-line program. Moving on, you’ll explore Rust’s type system to write better code and put it into practice in a simple markup language. You’ll learn to use Rust’s functional programming features to perform a physics simulation and use the Rayon crate to parallelize your computations. Finally, you’ll discover the best practices and test your code by building a simple crate with a tested, usable, well-documented API using Cargo and RustDoc.
By the end of the video, you’ll be comfortable building various solutions in Rust. You’ll be able to take advantage of Rust’s powerful type system and a rich ecosystem of libraries, or “crates”, available through the Cargo package manager. Target AudienceThe video is for developers who have basic knowledge of programming. The video will also appeal to developers who are using C/C++ language to write their applications. There is no knowledge of Rust language expected. This video is part of the course Learning Rust.In this video, we will examine the built-in types provided by Rust.
<ul><li>Load up the Rust playground</li><li>Learn about the two types of Rust – strong and dynamic</li><li>Get acquainted with the built-in types and check on some programming as well</li></ul>

Built-In Types

Course OverviewRust is a new systems programming language from Mozilla, created to facilitate the development of large, complex software projects. Its powerful type system and memory safety rules prevent all memory corruption bugs without compromising developer productivity. In this course, you’ll begin by getting familiar with the basic syntax and concepts of Rust, from writing a Hello World program to defining functions and creating variables. Then you’ll see how to manage toolchains with Rust up and build your first command-line program. Moving on, you’ll explore Rust’s type system to write better code and put it into practice in a simple markup language. You’ll learn to use Rust’s functional programming features to perform a physics simulation and use the Rayon crate to parallelize your computations. Finally, you’ll discover the best practices and test your code by building a simple crate with a tested, usable, well-documented API using Cargo and RustDoc.
By the end of the video, you’ll be comfortable building various solutions in Rust. You’ll be able to take advantage of Rust’s powerful type system and a rich ecosystem of libraries, or “crates”, available through the Cargo package manager. Target AudienceThe video is for developers who have basic knowledge of programming. The video will also appeal to developers who are using C/C++ language to write their applications. There is no knowledge of Rust language expected. This video is part of the course Learning Rust.In this video, we will see how rust code is organized, see some more types, and build some more programs.
<ul><li>Learn some basics about crates and modules</li><li>Learn that there are a number of imports that come into a program, known as “preludes”</li></ul>

Imports and Namespaces

Course OverviewRust is a new systems programming language from Mozilla, created to facilitate the development of large, complex software projects. Its powerful type system and memory safety rules prevent all memory corruption bugs without compromising developer productivity. In this course, you’ll begin by getting familiar with the basic syntax and concepts of Rust, from writing a Hello World program to defining functions and creating variables. Then you’ll see how to manage toolchains with Rust up and build your first command-line program. Moving on, you’ll explore Rust’s type system to write better code and put it into practice in a simple markup language. You’ll learn to use Rust’s functional programming features to perform a physics simulation and use the Rayon crate to parallelize your computations. Finally, you’ll discover the best practices and test your code by building a simple crate with a tested, usable, well-documented API using Cargo and RustDoc.
By the end of the video, you’ll be comfortable building various solutions in Rust. You’ll be able to take advantage of Rust’s powerful type system and a rich ecosystem of libraries, or “crates”, available through the Cargo package manager. Target AudienceThe video is for developers who have basic knowledge of programming. The video will also appeal to developers who are using C/C++ language to write their applications. There is no knowledge of Rust language expected. This video is part of the course Learning Rust.In this video, we will talk about the functionality that is available by default on every Rust program: Rust standard library.
<ul><li>Get to know about the contents of the rust standard library</li><li>Learn a bit about the Rust standard library’s philosophy</li></ul>

The Standard Library

Course OverviewRust is a new systems programming language from Mozilla, created to facilitate the development of large, complex software projects. Its powerful type system and memory safety rules prevent all memory corruption bugs without compromising developer productivity. In this course, you’ll begin by getting familiar with the basic syntax and concepts of Rust, from writing a Hello World program to defining functions and creating variables. Then you’ll see how to manage toolchains with Rust up and build your first command-line program. Moving on, you’ll explore Rust’s type system to write better code and put it into practice in a simple markup language. You’ll learn to use Rust’s functional programming features to perform a physics simulation and use the Rayon crate to parallelize your computations. Finally, you’ll discover the best practices and test your code by building a simple crate with a tested, usable, well-documented API using Cargo and RustDoc.
By the end of the video, you’ll be comfortable building various solutions in Rust. You’ll be able to take advantage of Rust’s powerful type system and a rich ecosystem of libraries, or “crates”, available through the Cargo package manager. Target AudienceThe video is for developers who have basic knowledge of programming. The video will also appeal to developers who are using C/C++ language to write their applications. There is no knowledge of Rust language expected. This video is part of the course Learning Rust.In this video, we will build a simple Fibonacci calculator.
<ul><li>Define the program to be written</li><li>Sketch out the implementation types</li><li>Build a working implementation</li></ul>

Recursive Fibonacci

Course OverviewRust is a new systems programming language from Mozilla, created to facilitate the development of large, complex software projects. Its powerful type system and memory safety rules prevent all memory corruption bugs without compromising developer productivity. In this course, you’ll begin by getting familiar with the basic syntax and concepts of Rust, from writing a Hello World program to defining functions and creating variables. Then you’ll see how to manage toolchains with Rust up and build your first command-line program. Moving on, you’ll explore Rust’s type system to write better code and put it into practice in a simple markup language. You’ll learn to use Rust’s functional programming features to perform a physics simulation and use the Rayon crate to parallelize your computations. Finally, you’ll discover the best practices and test your code by building a simple crate with a tested, usable, well-documented API using Cargo and RustDoc.
By the end of the video, you’ll be comfortable building various solutions in Rust. You’ll be able to take advantage of Rust’s powerful type system and a rich ecosystem of libraries, or “crates”, available through the Cargo package manager. Target AudienceThe video is for developers who have basic knowledge of programming. The video will also appeal to developers who are using C/C++ language to write their applications. There is no knowledge of Rust language expected. This video is part of the course Learning Rust.In this video, we will build a more efficient Fibonacci program.
<ul><li>Define the performance bottleneck of the previous program</li><li>Understand how dynamic programming will help</li><li>Implement a dynamic solution</li></ul>

Dynamic Fibonacci

Section 1: The Power of Rust

Rust has excellent development tooling, including a toolchain manager (Rustup) and a project and package manager (Cargo). In this section, you’ll explore installing and using these tools. You’ll build your first real application, a command-line program that parses its arguments with the clap crate and generates random numbers based on user input with the random crate.

<ul>
	<li>Installing Rust with Rustup</li>
	<li>Managing Toolchains with Rustup</li>
	<li>Creating Projects with Cargo</li>
	<li>Exploring the Crate Ecosystem</li>
	<li>Rustdoc and the Documentation Ecosystem</li>
	<li>Adding Dependencies with Cargo</li>
</ul>

Course OverviewRust is a new systems programming language from Mozilla, created to facilitate the development of large, complex software projects. Its powerful type system and memory safety rules prevent all memory corruption bugs without compromising developer productivity. In this course, you’ll begin by getting familiar with the basic syntax and concepts of Rust, from writing a Hello World program to defining functions and creating variables. Then you’ll see how to manage toolchains with Rust up and build your first command-line program. Moving on, you’ll explore Rust’s type system to write better code and put it into practice in a simple markup language. You’ll learn to use Rust’s functional programming features to perform a physics simulation and use the Rayon crate to parallelize your computations. Finally, you’ll discover the best practices and test your code by building a simple crate with a tested, usable, well-documented API using Cargo and RustDoc.
By the end of the video, you’ll be comfortable building various solutions in Rust. You’ll be able to take advantage of Rust’s powerful type system and a rich ecosystem of libraries, or “crates”, available through the Cargo package manager. Target AudienceThe video is for developers who have basic knowledge of programming. The video will also appeal to developers who are using C/C++ language to write their applications. There is no knowledge of Rust language expected. This video is part of the course Learning Rust.In this video, we will cover installing and managing Rust with Rustup.
<ul><li>Learn about multiple release channels in Rust</li><li>Learn to install Rust on your system</li><li>Learn that Rustup makes it easier to manage the versions of other software</li></ul>

Installing Rust with Rustup

Course OverviewRust is a new systems programming language from Mozilla, created to facilitate the development of large, complex software projects. Its powerful type system and memory safety rules prevent all memory corruption bugs without compromising developer productivity. In this course, you’ll begin by getting familiar with the basic syntax and concepts of Rust, from writing a Hello World program to defining functions and creating variables. Then you’ll see how to manage toolchains with Rust up and build your first command-line program. Moving on, you’ll explore Rust’s type system to write better code and put it into practice in a simple markup language. You’ll learn to use Rust’s functional programming features to perform a physics simulation and use the Rayon crate to parallelize your computations. Finally, you’ll discover the best practices and test your code by building a simple crate with a tested, usable, well-documented API using Cargo and RustDoc.
By the end of the video, you’ll be comfortable building various solutions in Rust. You’ll be able to take advantage of Rust’s powerful type system and a rich ecosystem of libraries, or “crates”, available through the Cargo package manager. Target AudienceThe video is for developers who have basic knowledge of programming. The video will also appeal to developers who are using C/C++ language to write their applications. There is no knowledge of Rust language expected. This video is part of the course Learning Rust.In this video, we will learn how to manage our tools with Rustup.
<ul><li>Learn the basic commands used in Rustup</li><li>Learn to set an override for a project</li><li>Discuss tradeoffs between stable, beta and nightly</li></ul>

Managing Toolchains with Rustup

Course OverviewRust is a new systems programming language from Mozilla, created to facilitate the development of large, complex software projects. Its powerful type system and memory safety rules prevent all memory corruption bugs without compromising developer productivity. In this course, you’ll begin by getting familiar with the basic syntax and concepts of Rust, from writing a Hello World program to defining functions and creating variables. Then you’ll see how to manage toolchains with Rust up and build your first command-line program. Moving on, you’ll explore Rust’s type system to write better code and put it into practice in a simple markup language. You’ll learn to use Rust’s functional programming features to perform a physics simulation and use the Rayon crate to parallelize your computations. Finally, you’ll discover the best practices and test your code by building a simple crate with a tested, usable, well-documented API using Cargo and RustDoc.
By the end of the video, you’ll be comfortable building various solutions in Rust. You’ll be able to take advantage of Rust’s powerful type system and a rich ecosystem of libraries, or “crates”, available through the Cargo package manager. Target AudienceThe video is for developers who have basic knowledge of programming. The video will also appeal to developers who are using C/C++ language to write their applications. There is no knowledge of Rust language expected. This video is part of the course Learning Rust.In this video, we will talk about creating projects with Cargo.
<ul><li>Create a new project on our respective terminal</li><li>Create a main application file that runs all our codes and brings them all together</li></ul>

Creating Projects with Cargo

Course OverviewRust is a new systems programming language from Mozilla, created to facilitate the development of large, complex software projects. Its powerful type system and memory safety rules prevent all memory corruption bugs without compromising developer productivity. In this course, you’ll begin by getting familiar with the basic syntax and concepts of Rust, from writing a Hello World program to defining functions and creating variables. Then you’ll see how to manage toolchains with Rust up and build your first command-line program. Moving on, you’ll explore Rust’s type system to write better code and put it into practice in a simple markup language. You’ll learn to use Rust’s functional programming features to perform a physics simulation and use the Rayon crate to parallelize your computations. Finally, you’ll discover the best practices and test your code by building a simple crate with a tested, usable, well-documented API using Cargo and RustDoc.
By the end of the video, you’ll be comfortable building various solutions in Rust. You’ll be able to take advantage of Rust’s powerful type system and a rich ecosystem of libraries, or “crates”, available through the Cargo package manager. Target AudienceThe video is for developers who have basic knowledge of programming. The video will also appeal to developers who are using C/C++ language to write their applications. There is no knowledge of Rust language expected. This video is part of the course Learning Rust.In this video, we talk about the crate ecosystem around rust.
<ul><li>Get to know about crates.io, a public crates repository</li><li>Learn about semantic versioning</li></ul>

Exploring the Crate Ecosystem

Course OverviewRust is a new systems programming language from Mozilla, created to facilitate the development of large, complex software projects. Its powerful type system and memory safety rules prevent all memory corruption bugs without compromising developer productivity. In this course, you’ll begin by getting familiar with the basic syntax and concepts of Rust, from writing a Hello World program to defining functions and creating variables. Then you’ll see how to manage toolchains with Rust up and build your first command-line program. Moving on, you’ll explore Rust’s type system to write better code and put it into practice in a simple markup language. You’ll learn to use Rust’s functional programming features to perform a physics simulation and use the Rayon crate to parallelize your computations. Finally, you’ll discover the best practices and test your code by building a simple crate with a tested, usable, well-documented API using Cargo and RustDoc.
By the end of the video, you’ll be comfortable building various solutions in Rust. You’ll be able to take advantage of Rust’s powerful type system and a rich ecosystem of libraries, or “crates”, available through the Cargo package manager. Target AudienceThe video is for developers who have basic knowledge of programming. The video will also appeal to developers who are using C/C++ language to write their applications. There is no knowledge of Rust language expected. This video is part of the course Learning Rust.We talk about the Rust documentation ecosystem.
<ul><li>Learn the URL for projecting information on any particular crate</li><li>Explore and learn more about the doc</li></ul>

Rustdoc and the Documentation Ecosystem

Course OverviewRust is a new systems programming language from Mozilla, created to facilitate the development of large, complex software projects. Its powerful type system and memory safety rules prevent all memory corruption bugs without compromising developer productivity. In this course, you’ll begin by getting familiar with the basic syntax and concepts of Rust, from writing a Hello World program to defining functions and creating variables. Then you’ll see how to manage toolchains with Rust up and build your first command-line program. Moving on, you’ll explore Rust’s type system to write better code and put it into practice in a simple markup language. You’ll learn to use Rust’s functional programming features to perform a physics simulation and use the Rayon crate to parallelize your computations. Finally, you’ll discover the best practices and test your code by building a simple crate with a tested, usable, well-documented API using Cargo and RustDoc.
By the end of the video, you’ll be comfortable building various solutions in Rust. You’ll be able to take advantage of Rust’s powerful type system and a rich ecosystem of libraries, or “crates”, available through the Cargo package manager. Target AudienceThe video is for developers who have basic knowledge of programming. The video will also appeal to developers who are using C/C++ language to write their applications. There is no knowledge of Rust language expected. This video is part of the course Learning Rust.In this video, we will be adding dependencies with Cargo.
<ul><li>Use Cargo to build the project</li></ul>

Adding Dependencies with Cargo

Section 2: Rustup and Cargo

Rust’s greatest strength is its static analysis. In this section, you’ll learn about Rust’s advanced type system. It protects you from null pointer dereferences, dangling pointers, use-after-free, double-free, and (in many cases) memory leaks.

<ul>
	<li>Motivation for the Borrow Checker</li>
	<li>Ownership, Borrowing, and RAII</li>
	<li>Shared and Exclusive Access</li>
	<li>Fighting with the Borrow Checker</li>
	<li>Strings, Strs, Vecs, and Slices</li>
	<li>Understanding Borrow Checker Errors</li>
</ul>

Course OverviewRust is a new systems programming language from Mozilla, created to facilitate the development of large, complex software projects. Its powerful type system and memory safety rules prevent all memory corruption bugs without compromising developer productivity. In this course, you’ll begin by getting familiar with the basic syntax and concepts of Rust, from writing a Hello World program to defining functions and creating variables. Then you’ll see how to manage toolchains with Rust up and build your first command-line program. Moving on, you’ll explore Rust’s type system to write better code and put it into practice in a simple markup language. You’ll learn to use Rust’s functional programming features to perform a physics simulation and use the Rayon crate to parallelize your computations. Finally, you’ll discover the best practices and test your code by building a simple crate with a tested, usable, well-documented API using Cargo and RustDoc.
By the end of the video, you’ll be comfortable building various solutions in Rust. You’ll be able to take advantage of Rust’s powerful type system and a rich ecosystem of libraries, or “crates”, available through the Cargo package manager. Target AudienceThe video is for developers who have basic knowledge of programming. The video will also appeal to developers who are using C/C++ language to write their applications. There is no knowledge of Rust language expected. This video is part of the course Learning Rust.In this video, we will check out the importance of the borrow checker.
<ul><li>Discuss memory corruption problems</li><li>Explain how memory corruption problems are bad</li><li>Explain how the borrow checker prevents memory unsafety</li></ul>

Motivation for the Borrow Checker

Course OverviewRust is a new systems programming language from Mozilla, created to facilitate the development of large, complex software projects. Its powerful type system and memory safety rules prevent all memory corruption bugs without compromising developer productivity. In this course, you’ll begin by getting familiar with the basic syntax and concepts of Rust, from writing a Hello World program to defining functions and creating variables. Then you’ll see how to manage toolchains with Rust up and build your first command-line program. Moving on, you’ll explore Rust’s type system to write better code and put it into practice in a simple markup language. You’ll learn to use Rust’s functional programming features to perform a physics simulation and use the Rayon crate to parallelize your computations. Finally, you’ll discover the best practices and test your code by building a simple crate with a tested, usable, well-documented API using Cargo and RustDoc.
By the end of the video, you’ll be comfortable building various solutions in Rust. You’ll be able to take advantage of Rust’s powerful type system and a rich ecosystem of libraries, or “crates”, available through the Cargo package manager. Target AudienceThe video is for developers who have basic knowledge of programming. The video will also appeal to developers who are using C/C++ language to write their applications. There is no knowledge of Rust language expected. This video is part of the course Learning Rust.In this video, we will talk about ownership, borrowing, and RAII.
<ul><li>Find out what ownership, borrowing and RAII is all about</li></ul>

Ownership, Borrowing, and RAII

Course OverviewRust is a new systems programming language from Mozilla, created to facilitate the development of large, complex software projects. Its powerful type system and memory safety rules prevent all memory corruption bugs without compromising developer productivity. In this course, you’ll begin by getting familiar with the basic syntax and concepts of Rust, from writing a Hello World program to defining functions and creating variables. Then you’ll see how to manage toolchains with Rust up and build your first command-line program. Moving on, you’ll explore Rust’s type system to write better code and put it into practice in a simple markup language. You’ll learn to use Rust’s functional programming features to perform a physics simulation and use the Rayon crate to parallelize your computations. Finally, you’ll discover the best practices and test your code by building a simple crate with a tested, usable, well-documented API using Cargo and RustDoc.
By the end of the video, you’ll be comfortable building various solutions in Rust. You’ll be able to take advantage of Rust’s powerful type system and a rich ecosystem of libraries, or “crates”, available through the Cargo package manager. Target AudienceThe video is for developers who have basic knowledge of programming. The video will also appeal to developers who are using C/C++ language to write their applications. There is no knowledge of Rust language expected. This video is part of the course Learning Rust.In this video, we will take a look at shared and exclusive access and see how they work with the Rust compiler.
<ul><li>Create a program</li><li>Learn how to use shared and exclusive access</li></ul>

Shared and Exclusive Access

Course OverviewRust is a new systems programming language from Mozilla, created to facilitate the development of large, complex software projects. Its powerful type system and memory safety rules prevent all memory corruption bugs without compromising developer productivity. In this course, you’ll begin by getting familiar with the basic syntax and concepts of Rust, from writing a Hello World program to defining functions and creating variables. Then you’ll see how to manage toolchains with Rust up and build your first command-line program. Moving on, you’ll explore Rust’s type system to write better code and put it into practice in a simple markup language. You’ll learn to use Rust’s functional programming features to perform a physics simulation and use the Rayon crate to parallelize your computations. Finally, you’ll discover the best practices and test your code by building a simple crate with a tested, usable, well-documented API using Cargo and RustDoc.
By the end of the video, you’ll be comfortable building various solutions in Rust. You’ll be able to take advantage of Rust’s powerful type system and a rich ecosystem of libraries, or “crates”, available through the Cargo package manager. Target AudienceThe video is for developers who have basic knowledge of programming. The video will also appeal to developers who are using C/C++ language to write their applications. There is no knowledge of Rust language expected. This video is part of the course Learning Rust.In this video, we will talk about the phenomenon of fighting with the borrow checker.
<ul><li>Learn what exactly fighting with the borrow checker means</li><li>Learn the different designs in a borrow checker</li><li>Learn why we must not fight the borrow checker</li></ul>

Fighting with the Borrow Checker

Course OverviewRust is a new systems programming language from Mozilla, created to facilitate the development of large, complex software projects. Its powerful type system and memory safety rules prevent all memory corruption bugs without compromising developer productivity. In this course, you’ll begin by getting familiar with the basic syntax and concepts of Rust, from writing a Hello World program to defining functions and creating variables. Then you’ll see how to manage toolchains with Rust up and build your first command-line program. Moving on, you’ll explore Rust’s type system to write better code and put it into practice in a simple markup language. You’ll learn to use Rust’s functional programming features to perform a physics simulation and use the Rayon crate to parallelize your computations. Finally, you’ll discover the best practices and test your code by building a simple crate with a tested, usable, well-documented API using Cargo and RustDoc.
By the end of the video, you’ll be comfortable building various solutions in Rust. You’ll be able to take advantage of Rust’s powerful type system and a rich ecosystem of libraries, or “crates”, available through the Cargo package manager. Target AudienceThe video is for developers who have basic knowledge of programming. The video will also appeal to developers who are using C/C++ language to write their applications. There is no knowledge of Rust language expected. This video is part of the course Learning Rust.In this video, we will learn about strings, strs, vecs, and slices.
<ul><li>Learn about strings and vecs</li><li>Learn about strs and slices</li></ul>

Strings, Strs, Vecs, and Slices

Course OverviewRust is a new systems programming language from Mozilla, created to facilitate the development of large, complex software projects. Its powerful type system and memory safety rules prevent all memory corruption bugs without compromising developer productivity. In this course, you’ll begin by getting familiar with the basic syntax and concepts of Rust, from writing a Hello World program to defining functions and creating variables. Then you’ll see how to manage toolchains with Rust up and build your first command-line program. Moving on, you’ll explore Rust’s type system to write better code and put it into practice in a simple markup language. You’ll learn to use Rust’s functional programming features to perform a physics simulation and use the Rayon crate to parallelize your computations. Finally, you’ll discover the best practices and test your code by building a simple crate with a tested, usable, well-documented API using Cargo and RustDoc.
By the end of the video, you’ll be comfortable building various solutions in Rust. You’ll be able to take advantage of Rust’s powerful type system and a rich ecosystem of libraries, or “crates”, available through the Cargo package manager. Target AudienceThe video is for developers who have basic knowledge of programming. The video will also appeal to developers who are using C/C++ language to write their applications. There is no knowledge of Rust language expected. This video is part of the course Learning Rust.In this video, we will understand and deal with borrow checker errors.
<ul><li>Understand what the borrow checker is</li><li>Get to know the types of borrow checker errors</li></ul>

Understanding Borrow Checker Errors

Section 3: Ownership and Borrowing

Rust’s type system is powerful and flexible, and using it appropriately will help you write better code. In this section, you’ll learn a little bit of theory regarding types and put it into practice in a simple markup language.

<ul>
	<li>Structured Data</li>
	<li>Enumerations</li>
	<li>Match Expressions</li>
	<li>Designing a Markup Language</li>
	<li>Implementing the Markup Language</li>
</ul>

Course OverviewRust is a new systems programming language from Mozilla, created to facilitate the development of large, complex software projects. Its powerful type system and memory safety rules prevent all memory corruption bugs without compromising developer productivity. In this course, you’ll begin by getting familiar with the basic syntax and concepts of Rust, from writing a Hello World program to defining functions and creating variables. Then you’ll see how to manage toolchains with Rust up and build your first command-line program. Moving on, you’ll explore Rust’s type system to write better code and put it into practice in a simple markup language. You’ll learn to use Rust’s functional programming features to perform a physics simulation and use the Rayon crate to parallelize your computations. Finally, you’ll discover the best practices and test your code by building a simple crate with a tested, usable, well-documented API using Cargo and RustDoc.
By the end of the video, you’ll be comfortable building various solutions in Rust. You’ll be able to take advantage of Rust’s powerful type system and a rich ecosystem of libraries, or “crates”, available through the Cargo package manager. Target AudienceThe video is for developers who have basic knowledge of programming. The video will also appeal to developers who are using C/C++ language to write their applications. There is no knowledge of Rust language expected. This video is part of the course Learning Rust.In this video, we will talk about structured data, also known as structs or data structures
<ul><li>Create a simple program using struct and get the output</li><li>Explore the different ways in which we can use structs in our programs</li></ul>

Structured Data

Course OverviewRust is a new systems programming language from Mozilla, created to facilitate the development of large, complex software projects. Its powerful type system and memory safety rules prevent all memory corruption bugs without compromising developer productivity. In this course, you’ll begin by getting familiar with the basic syntax and concepts of Rust, from writing a Hello World program to defining functions and creating variables. Then you’ll see how to manage toolchains with Rust up and build your first command-line program. Moving on, you’ll explore Rust’s type system to write better code and put it into practice in a simple markup language. You’ll learn to use Rust’s functional programming features to perform a physics simulation and use the Rayon crate to parallelize your computations. Finally, you’ll discover the best practices and test your code by building a simple crate with a tested, usable, well-documented API using Cargo and RustDoc.
By the end of the video, you’ll be comfortable building various solutions in Rust. You’ll be able to take advantage of Rust’s powerful type system and a rich ecosystem of libraries, or “crates”, available through the Cargo package manager. Target AudienceThe video is for developers who have basic knowledge of programming. The video will also appeal to developers who are using C/C++ language to write their applications. There is no knowledge of Rust language expected. This video is part of the course Learning Rust.In this video, we will examine another basic kind of type in rust called enumerations or enum.
<ul><li>Create a simple program using enum and get the output</li><li>Explore the different ways in which we can use enum in our programs</li></ul>

Enumerations

Course OverviewRust is a new systems programming language from Mozilla, created to facilitate the development of large, complex software projects. Its powerful type system and memory safety rules prevent all memory corruption bugs without compromising developer productivity. In this course, you’ll begin by getting familiar with the basic syntax and concepts of Rust, from writing a Hello World program to defining functions and creating variables. Then you’ll see how to manage toolchains with Rust up and build your first command-line program. Moving on, you’ll explore Rust’s type system to write better code and put it into practice in a simple markup language. You’ll learn to use Rust’s functional programming features to perform a physics simulation and use the Rayon crate to parallelize your computations. Finally, you’ll discover the best practices and test your code by building a simple crate with a tested, usable, well-documented API using Cargo and RustDoc.
By the end of the video, you’ll be comfortable building various solutions in Rust. You’ll be able to take advantage of Rust’s powerful type system and a rich ecosystem of libraries, or “crates”, available through the Cargo package manager. Target AudienceThe video is for developers who have basic knowledge of programming. The video will also appeal to developers who are using C/C++ language to write their applications. There is no knowledge of Rust language expected. This video is part of the course Learning Rust.In this video, we talk about match expressions.
<ul><li>Create a program on the simulation of guiding a robot around using enumerations</li><li>Learn to write commands for the robot using enums</li><li>Learn to use the match expression in writing a program efficiently to control the robot</li></ul>

Match Expressions

Course OverviewRust is a new systems programming language from Mozilla, created to facilitate the development of large, complex software projects. Its powerful type system and memory safety rules prevent all memory corruption bugs without compromising developer productivity. In this course, you’ll begin by getting familiar with the basic syntax and concepts of Rust, from writing a Hello World program to defining functions and creating variables. Then you’ll see how to manage toolchains with Rust up and build your first command-line program. Moving on, you’ll explore Rust’s type system to write better code and put it into practice in a simple markup language. You’ll learn to use Rust’s functional programming features to perform a physics simulation and use the Rayon crate to parallelize your computations. Finally, you’ll discover the best practices and test your code by building a simple crate with a tested, usable, well-documented API using Cargo and RustDoc.
By the end of the video, you’ll be comfortable building various solutions in Rust. You’ll be able to take advantage of Rust’s powerful type system and a rich ecosystem of libraries, or “crates”, available through the Cargo package manager. Target AudienceThe video is for developers who have basic knowledge of programming. The video will also appeal to developers who are using C/C++ language to write their applications. There is no knowledge of Rust language expected. This video is part of the course Learning Rust.In this video, we will see how to design a simple markup language.
<ul><li>Create a simple program on finite-state machines</li><li>Explore what goes into designing the markup language</li></ul>

Designing a Markup Language

Course OverviewRust is a new systems programming language from Mozilla, created to facilitate the development of large, complex software projects. Its powerful type system and memory safety rules prevent all memory corruption bugs without compromising developer productivity. In this course, you’ll begin by getting familiar with the basic syntax and concepts of Rust, from writing a Hello World program to defining functions and creating variables. Then you’ll see how to manage toolchains with Rust up and build your first command-line program. Moving on, you’ll explore Rust’s type system to write better code and put it into practice in a simple markup language. You’ll learn to use Rust’s functional programming features to perform a physics simulation and use the Rayon crate to parallelize your computations. Finally, you’ll discover the best practices and test your code by building a simple crate with a tested, usable, well-documented API using Cargo and RustDoc.
By the end of the video, you’ll be comfortable building various solutions in Rust. You’ll be able to take advantage of Rust’s powerful type system and a rich ecosystem of libraries, or “crates”, available through the Cargo package manager. Target AudienceThe video is for developers who have basic knowledge of programming. The video will also appeal to developers who are using C/C++ language to write their applications. There is no knowledge of Rust language expected. This video is part of the course Learning Rust.In this video, we implement the markup language.
<ul><li>Explore the previous program by making a few alterations</li><li>Learn to use the derivation keyword to copy and clone the values in the enum state</li><li>Explore the usage of several match expressions within the program</li></ul>

Implementing the Markup Language

Section 4: Basic Types – Enums and Structs

Rust provides excellent facilities for reducing code duplication via traits and generic code. In this section, we’ll examine the mechanisms and use cases for traits and generics.

<ul>
	<li>Introduction to Traits</li>
	<li>Built-In Traits</li>
	<li>Writing Your Own Traits</li>
	<li>Generic Functions</li>
	<li>Generic Types</li>
	<li>Trait Objects and Dynamic Dispatch</li>
</ul>

Course OverviewRust is a new systems programming language from Mozilla, created to facilitate the development of large, complex software projects. Its powerful type system and memory safety rules prevent all memory corruption bugs without compromising developer productivity. In this course, you’ll begin by getting familiar with the basic syntax and concepts of Rust, from writing a Hello World program to defining functions and creating variables. Then you’ll see how to manage toolchains with Rust up and build your first command-line program. Moving on, you’ll explore Rust’s type system to write better code and put it into practice in a simple markup language. You’ll learn to use Rust’s functional programming features to perform a physics simulation and use the Rayon crate to parallelize your computations. Finally, you’ll discover the best practices and test your code by building a simple crate with a tested, usable, well-documented API using Cargo and RustDoc.
By the end of the video, you’ll be comfortable building various solutions in Rust. You’ll be able to take advantage of Rust’s powerful type system and a rich ecosystem of libraries, or “crates”, available through the Cargo package manager. Target AudienceThe video is for developers who have basic knowledge of programming. The video will also appeal to developers who are using C/C++ language to write their applications. There is no knowledge of Rust language expected. This video is part of the course Learning Rust.In this video, we will be taking a look at traits.
<ul><li>Learn the specific behavior of traits</li><li>Understand the default methods used in traits</li><li>Explore the syntax and parameters used in traits</li></ul>

Introduction to Traits

Course OverviewRust is a new systems programming language from Mozilla, created to facilitate the development of large, complex software projects. Its powerful type system and memory safety rules prevent all memory corruption bugs without compromising developer productivity. In this course, you’ll begin by getting familiar with the basic syntax and concepts of Rust, from writing a Hello World program to defining functions and creating variables. Then you’ll see how to manage toolchains with Rust up and build your first command-line program. Moving on, you’ll explore Rust’s type system to write better code and put it into practice in a simple markup language. You’ll learn to use Rust’s functional programming features to perform a physics simulation and use the Rayon crate to parallelize your computations. Finally, you’ll discover the best practices and test your code by building a simple crate with a tested, usable, well-documented API using Cargo and RustDoc.
By the end of the video, you’ll be comfortable building various solutions in Rust. You’ll be able to take advantage of Rust’s powerful type system and a rich ecosystem of libraries, or “crates”, available through the Cargo package manager. Target AudienceThe video is for developers who have basic knowledge of programming. The video will also appeal to developers who are using C/C++ language to write their applications. There is no knowledge of Rust language expected. This video is part of the course Learning Rust.In this video, we will discuss some of the built-in traits that come with the rust compiler and standard library.
<ul><li>Learn about comparison</li><li>Learn about display and debug</li><li>Learn about clone and copy and also about the iterator</li></ul>

Built-In Traits

Course OverviewRust is a new systems programming language from Mozilla, created to facilitate the development of large, complex software projects. Its powerful type system and memory safety rules prevent all memory corruption bugs without compromising developer productivity. In this course, you’ll begin by getting familiar with the basic syntax and concepts of Rust, from writing a Hello World program to defining functions and creating variables. Then you’ll see how to manage toolchains with Rust up and build your first command-line program. Moving on, you’ll explore Rust’s type system to write better code and put it into practice in a simple markup language. You’ll learn to use Rust’s functional programming features to perform a physics simulation and use the Rayon crate to parallelize your computations. Finally, you’ll discover the best practices and test your code by building a simple crate with a tested, usable, well-documented API using Cargo and RustDoc.
By the end of the video, you’ll be comfortable building various solutions in Rust. You’ll be able to take advantage of Rust’s powerful type system and a rich ecosystem of libraries, or “crates”, available through the Cargo package manager. Target AudienceThe video is for developers who have basic knowledge of programming. The video will also appeal to developers who are using C/C++ language to write their applications. There is no knowledge of Rust language expected. This video is part of the course Learning Rust.In this video, we will learn how to write our own traits.
<ul><li>Understand the various applications of traits</li><li>Create a simple program</li><li>Learn how to use traits within the program</li></ul>

Writing Your Own Traits

Course OverviewRust is a new systems programming language from Mozilla, created to facilitate the development of large, complex software projects. Its powerful type system and memory safety rules prevent all memory corruption bugs without compromising developer productivity. In this course, you’ll begin by getting familiar with the basic syntax and concepts of Rust, from writing a Hello World program to defining functions and creating variables. Then you’ll see how to manage toolchains with Rust up and build your first command-line program. Moving on, you’ll explore Rust’s type system to write better code and put it into practice in a simple markup language. You’ll learn to use Rust’s functional programming features to perform a physics simulation and use the Rayon crate to parallelize your computations. Finally, you’ll discover the best practices and test your code by building a simple crate with a tested, usable, well-documented API using Cargo and RustDoc.
By the end of the video, you’ll be comfortable building various solutions in Rust. You’ll be able to take advantage of Rust’s powerful type system and a rich ecosystem of libraries, or “crates”, available through the Cargo package manager. Target AudienceThe video is for developers who have basic knowledge of programming. The video will also appeal to developers who are using C/C++ language to write their applications. There is no knowledge of Rust language expected. This video is part of the course Learning Rust.In this video, we will learn about generic functions.
<ul><li>Learn about arguments for generic functions</li><li>Learn the generic syntax and trait bounds</li><li>Explore the concepts through a programming example</li></ul>

Generic Functions

Course OverviewRust is a new systems programming language from Mozilla, created to facilitate the development of large, complex software projects. Its powerful type system and memory safety rules prevent all memory corruption bugs without compromising developer productivity. In this course, you’ll begin by getting familiar with the basic syntax and concepts of Rust, from writing a Hello World program to defining functions and creating variables. Then you’ll see how to manage toolchains with Rust up and build your first command-line program. Moving on, you’ll explore Rust’s type system to write better code and put it into practice in a simple markup language. You’ll learn to use Rust’s functional programming features to perform a physics simulation and use the Rayon crate to parallelize your computations. Finally, you’ll discover the best practices and test your code by building a simple crate with a tested, usable, well-documented API using Cargo and RustDoc.
By the end of the video, you’ll be comfortable building various solutions in Rust. You’ll be able to take advantage of Rust’s powerful type system and a rich ecosystem of libraries, or “crates”, available through the Cargo package manager. Target AudienceThe video is for developers who have basic knowledge of programming. The video will also appeal to developers who are using C/C++ language to write their applications. There is no knowledge of Rust language expected. This video is part of the course Learning Rust.In this video, we will learn about generic types.
<ul><li>Learn about arguments for generic types</li><li>Learn about generic type syntax</li><li>Learn about existing generic types</li></ul>

Generic Types

Course OverviewRust is a new systems programming language from Mozilla, created to facilitate the development of large, complex software projects. Its powerful type system and memory safety rules prevent all memory corruption bugs without compromising developer productivity. In this course, you’ll begin by getting familiar with the basic syntax and concepts of Rust, from writing a Hello World program to defining functions and creating variables. Then you’ll see how to manage toolchains with Rust up and build your first command-line program. Moving on, you’ll explore Rust’s type system to write better code and put it into practice in a simple markup language. You’ll learn to use Rust’s functional programming features to perform a physics simulation and use the Rayon crate to parallelize your computations. Finally, you’ll discover the best practices and test your code by building a simple crate with a tested, usable, well-documented API using Cargo and RustDoc.
By the end of the video, you’ll be comfortable building various solutions in Rust. You’ll be able to take advantage of Rust’s powerful type system and a rich ecosystem of libraries, or “crates”, available through the Cargo package manager. Target AudienceThe video is for developers who have basic knowledge of programming. The video will also appeal to developers who are using C/C++ language to write their applications. There is no knowledge of Rust language expected. This video is part of the course Learning Rust.In this video, we will learn about traits, objects, and dynamic dispatch.
<ul><li>Learn about static dispatch</li><li>Learn about dynamic dispatch</li></ul>

Trait Objects and Dynamic Dispatch

Section 5: Advanced Types – Traits and Generics

Rust’s safety features are great for preventing errors in all code, but they are most important in concurrent code. In this section, you’ll learn how to use Rust’s functional programming features to do some physics simulation, and how to use the Rayon crate to parallelize your computations.

<ul>
	<li>Closures</li>
	<li>Iterators</li>
	<li>Map, Filter, and Fold</li>
	<li>Building a Barycenter Finder</li>
	<li>Parallelizing the Barycenter Finder</li>
</ul>

Course OverviewRust is a new systems programming language from Mozilla, created to facilitate the development of large, complex software projects. Its powerful type system and memory safety rules prevent all memory corruption bugs without compromising developer productivity. In this course, you’ll begin by getting familiar with the basic syntax and concepts of Rust, from writing a Hello World program to defining functions and creating variables. Then you’ll see how to manage toolchains with Rust up and build your first command-line program. Moving on, you’ll explore Rust’s type system to write better code and put it into practice in a simple markup language. You’ll learn to use Rust’s functional programming features to perform a physics simulation and use the Rayon crate to parallelize your computations. Finally, you’ll discover the best practices and test your code by building a simple crate with a tested, usable, well-documented API using Cargo and RustDoc.
By the end of the video, you’ll be comfortable building various solutions in Rust. You’ll be able to take advantage of Rust’s powerful type system and a rich ecosystem of libraries, or “crates”, available through the Cargo package manager. Target AudienceThe video is for developers who have basic knowledge of programming. The video will also appeal to developers who are using C/C++ language to write their applications. There is no knowledge of Rust language expected. This video is part of the course Learning Rust.In this video, we will learn about closures in Rust.
<ul><li>Learn what are closures and their syntax</li><li>Understand closure syntax</li><li>Learn various other concepts such as closing variables, closure return strategies, and so on</li></ul>

Closures

Course OverviewRust is a new systems programming language from Mozilla, created to facilitate the development of large, complex software projects. Its powerful type system and memory safety rules prevent all memory corruption bugs without compromising developer productivity. In this course, you’ll begin by getting familiar with the basic syntax and concepts of Rust, from writing a Hello World program to defining functions and creating variables. Then you’ll see how to manage toolchains with Rust up and build your first command-line program. Moving on, you’ll explore Rust’s type system to write better code and put it into practice in a simple markup language. You’ll learn to use Rust’s functional programming features to perform a physics simulation and use the Rayon crate to parallelize your computations. Finally, you’ll discover the best practices and test your code by building a simple crate with a tested, usable, well-documented API using Cargo and RustDoc.
By the end of the video, you’ll be comfortable building various solutions in Rust. You’ll be able to take advantage of Rust’s powerful type system and a rich ecosystem of libraries, or “crates”, available through the Cargo package manager. Target AudienceThe video is for developers who have basic knowledge of programming. The video will also appeal to developers who are using C/C++ language to write their applications. There is no knowledge of Rust language expected. This video is part of the course Learning Rust.In this video, we will take a look at iterators.
<ul><li>Define iterators</li><li>Create iterators</li><li>Learn about the different methods used</li></ul>

Iterators

Course OverviewRust is a new systems programming language from Mozilla, created to facilitate the development of large, complex software projects. Its powerful type system and memory safety rules prevent all memory corruption bugs without compromising developer productivity. In this course, you’ll begin by getting familiar with the basic syntax and concepts of Rust, from writing a Hello World program to defining functions and creating variables. Then you’ll see how to manage toolchains with Rust up and build your first command-line program. Moving on, you’ll explore Rust’s type system to write better code and put it into practice in a simple markup language. You’ll learn to use Rust’s functional programming features to perform a physics simulation and use the Rayon crate to parallelize your computations. Finally, you’ll discover the best practices and test your code by building a simple crate with a tested, usable, well-documented API using Cargo and RustDoc.
By the end of the video, you’ll be comfortable building various solutions in Rust. You’ll be able to take advantage of Rust’s powerful type system and a rich ecosystem of libraries, or “crates”, available through the Cargo package manager. Target AudienceThe video is for developers who have basic knowledge of programming. The video will also appeal to developers who are using C/C++ language to write their applications. There is no knowledge of Rust language expected. This video is part of the course Learning Rust.In this video, we will learn map, filter, and fold.
<ul><li>Learn about map, filter, and fold</li><li>Learn about the combination of the three</li><li>Understand the perks of using them</li></ul>

Map, Filter, and Fold

Course OverviewRust is a new systems programming language from Mozilla, created to facilitate the development of large, complex software projects. Its powerful type system and memory safety rules prevent all memory corruption bugs without compromising developer productivity. In this course, you’ll begin by getting familiar with the basic syntax and concepts of Rust, from writing a Hello World program to defining functions and creating variables. Then you’ll see how to manage toolchains with Rust up and build your first command-line program. Moving on, you’ll explore Rust’s type system to write better code and put it into practice in a simple markup language. You’ll learn to use Rust’s functional programming features to perform a physics simulation and use the Rayon crate to parallelize your computations. Finally, you’ll discover the best practices and test your code by building a simple crate with a tested, usable, well-documented API using Cargo and RustDoc.
By the end of the video, you’ll be comfortable building various solutions in Rust. You’ll be able to take advantage of Rust’s powerful type system and a rich ecosystem of libraries, or “crates”, available through the Cargo package manager. Target AudienceThe video is for developers who have basic knowledge of programming. The video will also appeal to developers who are using C/C++ language to write their applications. There is no knowledge of Rust language expected. This video is part of the course Learning Rust.In this video, we will learn about the Barycenter finder.
<ul><li>Create a program</li><li>Compute the gravitational center of the system – Barycenter</li></ul>

Building a Barycenter Finder

Course OverviewRust is a new systems programming language from Mozilla, created to facilitate the development of large, complex software projects. Its powerful type system and memory safety rules prevent all memory corruption bugs without compromising developer productivity. In this course, you’ll begin by getting familiar with the basic syntax and concepts of Rust, from writing a Hello World program to defining functions and creating variables. Then you’ll see how to manage toolchains with Rust up and build your first command-line program. Moving on, you’ll explore Rust’s type system to write better code and put it into practice in a simple markup language. You’ll learn to use Rust’s functional programming features to perform a physics simulation and use the Rayon crate to parallelize your computations. Finally, you’ll discover the best practices and test your code by building a simple crate with a tested, usable, well-documented API using Cargo and RustDoc.
By the end of the video, you’ll be comfortable building various solutions in Rust. You’ll be able to take advantage of Rust’s powerful type system and a rich ecosystem of libraries, or “crates”, available through the Cargo package manager. Target AudienceThe video is for developers who have basic knowledge of programming. The video will also appeal to developers who are using C/C++ language to write their applications. There is no knowledge of Rust language expected. This video is part of the course Learning Rust.In this video, we will take a look at how to parallelize the Barycenter finder.
<ul><li>Parallelize the existing Barycenter program</li><li>Understand rayon and itertools</li></ul>

Parallelizing the Barycenter Finder

Section 6: Functional Features and Concurrency

Though Rust’s syntax, functional features, and type system make it easy to write comprehensible and testable code, there are some best practices that you should follow to make sure your Rust code stays maintainable and easy to read. In this section, we’ll cover these best practices, as well as how to test your code. We’ll build a simple crate with a tested, usable, and well-documented API using Cargo and RustDoc.

<ul>
	<li>Breaking Up Code with Modules</li>
	<li>Error Handling</li>
	<li>API Design</li>
	<li>Unit Testing</li>
	<li>Integration Testing</li>
	<li>Documentation</li>
</ul>

Course OverviewRust is a new systems programming language from Mozilla, created to facilitate the development of large, complex software projects. Its powerful type system and memory safety rules prevent all memory corruption bugs without compromising developer productivity. In this course, you’ll begin by getting familiar with the basic syntax and concepts of Rust, from writing a Hello World program to defining functions and creating variables. Then you’ll see how to manage toolchains with Rust up and build your first command-line program. Moving on, you’ll explore Rust’s type system to write better code and put it into practice in a simple markup language. You’ll learn to use Rust’s functional programming features to perform a physics simulation and use the Rayon crate to parallelize your computations. Finally, you’ll discover the best practices and test your code by building a simple crate with a tested, usable, well-documented API using Cargo and RustDoc.
By the end of the video, you’ll be comfortable building various solutions in Rust. You’ll be able to take advantage of Rust’s powerful type system and a rich ecosystem of libraries, or “crates”, available through the Cargo package manager. Target AudienceThe video is for developers who have basic knowledge of programming. The video will also appeal to developers who are using C/C++ language to write their applications. There is no knowledge of Rust language expected. This video is part of the course Learning Rust.In this video, we will take a look at breaking up code with modules.
<ul><li>Understand why it is important to break up code</li><li>Learn the basic organization</li><li>Understand that it is important to document the code</li></ul>

Breaking Up Code with Modules

Course OverviewRust is a new systems programming language from Mozilla, created to facilitate the development of large, complex software projects. Its powerful type system and memory safety rules prevent all memory corruption bugs without compromising developer productivity. In this course, you’ll begin by getting familiar with the basic syntax and concepts of Rust, from writing a Hello World program to defining functions and creating variables. Then you’ll see how to manage toolchains with Rust up and build your first command-line program. Moving on, you’ll explore Rust’s type system to write better code and put it into practice in a simple markup language. You’ll learn to use Rust’s functional programming features to perform a physics simulation and use the Rayon crate to parallelize your computations. Finally, you’ll discover the best practices and test your code by building a simple crate with a tested, usable, well-documented API using Cargo and RustDoc.
By the end of the video, you’ll be comfortable building various solutions in Rust. You’ll be able to take advantage of Rust’s powerful type system and a rich ecosystem of libraries, or “crates”, available through the Cargo package manager. Target AudienceThe video is for developers who have basic knowledge of programming. The video will also appeal to developers who are using C/C++ language to write their applications. There is no knowledge of Rust language expected. This video is part of the course Learning Rust.In this video, we will discuss error handling.
<ul><li>Learn about the two error handling types</li><li>Propagate the errors upwards</li></ul>

Error Handling

Course OverviewRust is a new systems programming language from Mozilla, created to facilitate the development of large, complex software projects. Its powerful type system and memory safety rules prevent all memory corruption bugs without compromising developer productivity. In this course, you’ll begin by getting familiar with the basic syntax and concepts of Rust, from writing a Hello World program to defining functions and creating variables. Then you’ll see how to manage toolchains with Rust up and build your first command-line program. Moving on, you’ll explore Rust’s type system to write better code and put it into practice in a simple markup language. You’ll learn to use Rust’s functional programming features to perform a physics simulation and use the Rayon crate to parallelize your computations. Finally, you’ll discover the best practices and test your code by building a simple crate with a tested, usable, well-documented API using Cargo and RustDoc.
By the end of the video, you’ll be comfortable building various solutions in Rust. You’ll be able to take advantage of Rust’s powerful type system and a rich ecosystem of libraries, or “crates”, available through the Cargo package manager. Target AudienceThe video is for developers who have basic knowledge of programming. The video will also appeal to developers who are using C/C++ language to write their applications. There is no knowledge of Rust language expected. This video is part of the course Learning Rust.In this video, we will take a look at API designs.
<ul><li>Use naming conventions</li><li>Learn about interoperability, document, and flexibility</li></ul>

API Design

Course OverviewRust is a new systems programming language from Mozilla, created to facilitate the development of large, complex software projects. Its powerful type system and memory safety rules prevent all memory corruption bugs without compromising developer productivity. In this course, you’ll begin by getting familiar with the basic syntax and concepts of Rust, from writing a Hello World program to defining functions and creating variables. Then you’ll see how to manage toolchains with Rust up and build your first command-line program. Moving on, you’ll explore Rust’s type system to write better code and put it into practice in a simple markup language. You’ll learn to use Rust’s functional programming features to perform a physics simulation and use the Rayon crate to parallelize your computations. Finally, you’ll discover the best practices and test your code by building a simple crate with a tested, usable, well-documented API using Cargo and RustDoc.
By the end of the video, you’ll be comfortable building various solutions in Rust. You’ll be able to take advantage of Rust’s powerful type system and a rich ecosystem of libraries, or “crates”, available through the Cargo package manager. Target AudienceThe video is for developers who have basic knowledge of programming. The video will also appeal to developers who are using C/C++ language to write their applications. There is no knowledge of Rust language expected. This video is part of the course Learning Rust.In this video, we will learn about unit testing.
<ul><li>Create a new rust library called Bucketizer</li><li>Understand that working on unit tests helps to iterate new designs without any application code</li></ul>

Unit Testing

Course OverviewRust is a new systems programming language from Mozilla, created to facilitate the development of large, complex software projects. Its powerful type system and memory safety rules prevent all memory corruption bugs without compromising developer productivity. In this course, you’ll begin by getting familiar with the basic syntax and concepts of Rust, from writing a Hello World program to defining functions and creating variables. Then you’ll see how to manage toolchains with Rust up and build your first command-line program. Moving on, you’ll explore Rust’s type system to write better code and put it into practice in a simple markup language. You’ll learn to use Rust’s functional programming features to perform a physics simulation and use the Rayon crate to parallelize your computations. Finally, you’ll discover the best practices and test your code by building a simple crate with a tested, usable, well-documented API using Cargo and RustDoc.
By the end of the video, you’ll be comfortable building various solutions in Rust. You’ll be able to take advantage of Rust’s powerful type system and a rich ecosystem of libraries, or “crates”, available through the Cargo package manager. Target AudienceThe video is for developers who have basic knowledge of programming. The video will also appeal to developers who are using C/C++ language to write their applications. There is no knowledge of Rust language expected. This video is part of the course Learning Rust.In this video, we will learn about integration testing.
<ul><li>Implement the Bucketizer</li><li>Create a well-designed crate</li></ul>

Integration Testing

Course OverviewRust is a new systems programming language from Mozilla, created to facilitate the development of large, complex software projects. Its powerful type system and memory safety rules prevent all memory corruption bugs without compromising developer productivity. In this course, you’ll begin by getting familiar with the basic syntax and concepts of Rust, from writing a Hello World program to defining functions and creating variables. Then you’ll see how to manage toolchains with Rust up and build your first command-line program. Moving on, you’ll explore Rust’s type system to write better code and put it into practice in a simple markup language. You’ll learn to use Rust’s functional programming features to perform a physics simulation and use the Rayon crate to parallelize your computations. Finally, you’ll discover the best practices and test your code by building a simple crate with a tested, usable, well-documented API using Cargo and RustDoc.
By the end of the video, you’ll be comfortable building various solutions in Rust. You’ll be able to take advantage of Rust’s powerful type system and a rich ecosystem of libraries, or “crates”, available through the Cargo package manager. Target AudienceThe video is for developers who have basic knowledge of programming. The video will also appeal to developers who are using C/C++ language to write their applications. There is no knowledge of Rust language expected. This video is part of the course Learning Rust.In this video, we will talk about documentation.
<ul><li>Discuss documentation in the Bucketizer project</li><li>Get a brief recap of the course</li></ul>

Learning Rust

What you'll learn

Explore more technology skills