Building Reusable Code with Rust

Building Reusable Code with Rust, available at $39.99, has an average rating of 4.65, with 27 lectures, based on 64 reviews, and has 608 subscribers.

You will learn about Write clean and reusable Rust code for your applications Use loop, map, filter and fold to avoid duplicated code Understand generics and learn to use it to abstract algorithms for multiple data types Define and enforce clear interface using traits Work with macros and compiler plugins for metaprogramming Explore how the standard library uses features such as generics, traits and macros Structure your code with modules and crates and publish them online This course is ideal for individuals who are This course will appeal to Rust developers who are already familiar with the language and want to learn how to build Rust libraries that are maintainable and reusable, and have an API that honors Rust conventions. It is particularly useful for This course will appeal to Rust developers who are already familiar with the language and want to learn how to build Rust libraries that are maintainable and reusable, and have an API that honors Rust conventions.

Enroll now: Building Reusable Code with Rust

Summary

Title: Building Reusable Code with Rust

Price: $39.99

Average Rating: 4.65

Number of Lectures: 27

Number of Published Lectures: 27

Number of Curriculum Items: 27

Number of Published Curriculum Objects: 27

Original Price: $109.99

Quality Status: approved

Status: Live

What You Will Learn

Write clean and reusable Rust code for your applications
Use loop, map, filter and fold to avoid duplicated code
Understand generics and learn to use it to abstract algorithms for multiple data types
Define and enforce clear interface using traits
Work with macros and compiler plugins for metaprogramming
Explore how the standard library uses features such as generics, traits and macros
Structure your code with modules and crates and publish them online

Who Should Attend

This course will appeal to Rust developers who are already familiar with the language and want to learn how to build Rust libraries that are maintainable and reusable, and have an API that honors Rust conventions.

Target Audiences

This course will appeal to Rust developers who are already familiar with the language and want to learn how to build Rust libraries that are maintainable and reusable, and have an API that honors Rust conventions.

Rust is the ideal language for writing safe, correct code in a way that won’t make you pull your hair out. This course will teach you how to build reusable Rust code so that you can stop copying and pasting code. Write code that can adapt to many different usages.

You will reuse code by using advanced features such as traits, generics and macros. You will work with different forms of code reuse, loops, map, filter and fold to save time and resources. Achieve higher-level reuse without sacrificing runtime performance. Organize your code into modules and crates to publish them to crates. io.

By the end of the course you will be able to avoid code duplication and write clean reusable code.

About the Author

Shing Lyu is a software engineer and open-source promoter. Shing contributed to Mozilla’s Servo and Gecko (Firefox) browser engines using Rust, and is active in Rust study groups, training, and conference talks. Shing is passionate about coding, automated testing, and promoting free and open-source software craftsmanship.

Course Curriculum

Chapter 1: Basics of Code Reuse

Lecture 1: The Course Overview

Lecture 2: Setting Up the Rust Development Environment

Lecture 3: Exploring Code Reuse in Rust

Lecture 4: Loops and Iterators

Lecture 5: Using Functional Programming Loops

Lecture 6: Functions in Rust

Chapter 2: Using Generics in Rust

Lecture 1: Exploring Generics

Lecture 2: Use Generic Functions to Reuse Algorithms

Lecture 3: Reuse Structures in Enums and Structs

Lecture 4: Working with Generic in Struct Methods

Lecture 5: Generics in the Rust Standard Library – Part I

Lecture 6: Generics in the Rust Standard Library – Part II

Chapter 3: Defining Interfaces with Traits

Lecture 1: Exploring Traits

Lecture 2: Using Trait Bounds and Trait Objects to Communicate Interfaces

Lecture 3: Associated Types versus Generics and Trait Inheritance

Lecture 4: Exploring Traits, Generics, and Performance

Lecture 5: Traits in the Rust Standard Library – Part I

Lecture 6: Traits in the Rust Standard Library – Part II

Chapter 4: Hacking the Language with Macros and Compiler Plugins

Lecture 1: Write Code with Code – Metaprogramming in Rust

Lecture 2: Use Declarative Macros to Write Less Code

Lecture 3: Using Procedural Macros for Custom Derive

Lecture 4: Macros in the Rust Standard Library – Part I

Lecture 5: Macros in the Rust Standard Library – Part II

Chapter 5: Reusing the Code with Other People Using Modules and Crates

Lecture 1: Introducing Crates

Lecture 2: Using Modules to Define the Structure of Crates

Lecture 3: Using a Crate with Cargo.toml

Lecture 4: Publishing to crates.io

Instructors

Packt Publishing
Tech Knowledge in Motion

Rating Distribution

1 stars: 0 votes
2 stars: 1 votes
3 stars: 5 votes
4 stars: 28 votes
5 stars: 30 votes

Frequently Asked Questions

How long do I have access to the course materials?

You can view and review the lecture materials indefinitely, like an on-demand channel.

Can I take my courses with me wherever I go?

Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don’t have an internet connection, some instructors also let their students download course lectures. That’s up to the instructor though, so make sure you get on their good side!

Menu