Introduction to Rust Programming

Name: Introduction to Rust Programming
Rating: 4.4 (12 reviews)

A complete Rust programming course for Beginners

Created byEduonix Learning Solutions

Last updated 9/2020

English

English [Auto],

What you'll learn

Learn Rust programming language from ground up
Learn memory management in Rust
Learn to programming tips and tricks

Course content

3 sections • 20 lectures • 2h 53m total length

Install Rust and write your first Rust Program7:13
Install Rest Up to set up Rust, choose the stable version, and use Cargo to create your first Rust program and print hello world.
Structs and Enums10:30
Master structs and enums to model data like points and ship status in Rust. Use print line macro, format strings, and derive debug to inspect ship data.
Functions8:26
Learn how to add functionality to Rust data types by implementing new constructors, a transpose method, and manipulating mutable pointers for point arithmetic and reliable assertions.
Expressions and Patterns11:01
Explore patterns and matching in Rust, using enums with named fields accessed via squiggly braces, and implement a ship timestep that updates position and actions through match statements.
Loops and Iterators11:00
Master loops and iterators in Rust by reading command line args, iterating ranges, enumerating key value pairs, and implementing a Fibonacci iterator with a filter for even numbers.
Build Reusable structures with Generics9:28
Learn to build reusable code with generics by creating a library and a point type over N, implementing add, add_assign, and clone, deriving debug and PartialEq, and enabling transpose operations.
Test your Rust code6:11
Learn to write and run tests in Rust with cfg(test) and a test module, verify results with assert equals, and decide when to clone, copy, or own values.
Handle errors with Result12:05
Learn how to use the standard library’s Result for ok or error values, build a library error enum, and apply from and ? to propagate io errors.

Why do lifetimes matter8:13
Explore lifetimes and the borrow checker in Rust. Learn how references and pointers interact with ownership, and how moving and dropping values affect ownership, including undefined behavior.
Passing Lifetimes around9:26
Explore passing lifetimes around in Rust by returning a pointer from two parameters. Understand how immutable and mutable borrows interact under the borrow checker.
Owning a pointer with Box6:20
Learn how Box creates owning pointers on the heap to manage large or recursive data, understand ownership and drop, and see a binary tree example that frees memory automatically.
String vs str How to use them6:39
Compare string slices and owned strings in Rust, showing how static string literals live for the program and how String is heap allocated, and how trim and push operate.
Vec vs Slice vs Array8:31
Explore Rust's arrays, vectors, and slices, learning fixed-size arrays, dynamic vectors, and mutable slices, plus how length and capacity govern storage and access.
Shared pointers with RC and Arc11:26
Demonstrate rc and refcell for shared ownership and interior mutability, and arc with mutex for thread-safe sharing, including runtime borrow checks, mutex guards, and thread interleaving.

Auto implement new traits for any type that fits a criteria6:55
Learn to auto-implement a trait for any iterator in Rust that can be added to itself, creating a doubler that maps each item to its double using clone and add.
Use a newType to git traits to other objects4:34
Learn the new type pattern to implement traits for external types by wrapping them in a custom struct, enabling add operations and trait-based polymorphism with trait objects.
Use Dynamic types for polymorphism5:02
Learn how dynamic types enable polymorphism by boxing a trait object with debug and display, guided by the vtable and auto trait, to store mixed types in a single collection.
Manage your code in modules so you and library users can find the code they need10:42
Organize code into modules and files in Rust, making public members accessible from outside the crate. Declare modules, use paths, and build a modular library with root and submodules.
Impl std::error::Error to allow error chaining11:57
Explore error handling in Rust by implementing std::error::Error and using anyhow for error chaining. Derive partial equality and debug, and implement display for error flows in file I/O and parsing.
Use Serde to convert any data to any format8:19
learn to serialize and deserialize data with serde, converting Rust structs to JSON, TOML, or other formats using serializer and deserializer traits, and optional derive macros for automation.

Requirements

Basic knowledge of any programming language is required to start the course

Description

Master the most loved programming language in the world with this beginner’s guide!

Rust has been voted as the most loved programming language by Stack Overflow for 4 years in a row! And for a reason. Actually, many reasons!

It was created by Mozilla as a highly capable systems-level programming language. Unlike JavaScript or Python or any other language, it is very different. Rust has managed to solve all the pain points presented by a majority of other programming languages.

Rust is fast, powerful, offers strict and pedantic compiler checks, lets you write complex software without any fear, provides zero-cost abstractions, functional features & a lot of other perks. Some programmers are even using it as an alternative to C/C++ programming languages for VR simulation engines, operating systems, browser components, game engines & file systems. Moreover, from industry giants like Mozilla, Dropbox, Coursera to the emerging names like Craft ai, One Signal & others are already using Rust.

Considering its importance, many developers embark on an effort to learn & understand Rust programming language. To make things simple, we have curated this online course that will help you to have a strong command over Rust Programming from scratch.

What Makes This Course So Special?

This online tutorial is a beginners’ guide to Rust programming language. From writing “Hello World” in Rust language to effectively using all its features, everything is included in this online tutorial. It is suitable for anyone who is looking to catch up with Rust programming from the ground level.

It will give you insights into basic syntax, iterators, generics, borrow checker, code documentation, testing & so much more. Upon completion of this course, you will be able to write clear & effective code in Rust language.

This Course Includes:

Introduction to Rust programming
Rust installation & writing a program in Rust
Structs, Enums, functions, expressions, patterns, loops,
Iterators, generics, code testing, error handling
Lifetime & memory management- its importance, passing lifetimes
String vs str, and Vec vs Slice vs Array
Tips & tricks for code reuse & management
Using a New Type to git traits & Dynamic types for polymorphism
Code management in modules
Converting data by using Serde & so much more

Who this course is for:

Anyone who wants to start Rust programming language will find this course very useful

Introduction to Rust Programming

What you'll learn

Explore related topics

Course content

Introduction to Rust8 lectures • 1hr 16min

Lifetimes and Memory Management6 lectures • 51min

Traits and Tricks6 lectures • 47min

Requirements

Description

Who this course is for: