Oreilly – Rust Programming Part 1: Rust Programming Foundations 2023-9

Rust Programming Course Part 1: Rust Programming Foundations. This course teaches you the basics of programming with Rust through clear tutorials and detailed examples. Rust is a language that many passionate programmers have adopted because of its expressiveness, calculated complexity, and robustness. The Rust language combines the efficiency, speed, and low-level power of C/C++ with the benefits of higher-level languages ​​like Java, Python, and C#, and you can use it to implement a variety of solutions, including embedded systems, DevOps tools, operating systems and platforms, and more. use.

This course is the first part of your learning path. You will learn about Rust tools, type system and how to implement flow control. You’ll also learn how to use compound types and collections, and how Rust carefully manages the lifetime of objects and their safe references in your code. Experienced instructor Andy Olsen systematically shows you how to avoid common pitfalls and errors in C and C++.

What you will learn in Rust Programming Part 1: Rust Programming Foundations:

• Getting Started with Rust: Starts with an overview of Rust as a programming language and shows you how to download the Rust tools.
• Understanding variables and data types in Rust: Shows how to declare variables in Rust and takes a closer look at some of the primitive data types available in the language.
• Flow control implementation: shows how to implement conditional logic and iteration in Rust.
• Understanding Enumeration Types: Explains how to define and use enumeration types, and also reviews some of the important standard enumeration types in the Rust library.
• Using Mixed Types and Sets: Shows how to create and use arrays and tuples, as well as how to use vectors and maps in the Rust collections library.
• Understanding Ownership in Rust: Details how Rust manages the lifetime of objects. You will learn the differences between copying values ​​and passing values ​​in Rust.
• Understanding Borrowing in Rust: It deals with a concept called “borrowing”, which is where you refer to a variable without claiming ownership.

This course is suitable for people who:

• Developers who want to get started writing efficient and well-structured Rust applications.

Course details

• Publisher: Oreilly
• Instructor: Andy Olsen
• Training level: beginner to advanced
• Training duration: 7 hours 4 minutes

Course headings

• Introduction
  1. Rust Programming Part 1: Introduction
• Module 1: Rust Programming Essentials
  1. Module introduction
• Lesson 1: Getting Started with Rust
  1. Learning objectives
  2. 1.1 Overview of Rust
  3. 1.2 Writing your first Rust application
  4. 1.3 Building and running your first Rust application
  5. 1.4 Creating an application by using Cargo
  6. 1.5 Building and running an application by using Cargo
• Lesson 2: Understanding Rust Variables and Types
  1. Learning objectives
  2. 2.1 Integer types
  3. 2.2 Floating-point types
  4. 2.3 Other simple types
  5. 2.4 Additional techniques
• Lesson 3: Implementing Flow Control
  1. Learning objectives
  2. 3.1 If-tests
  3. 3.2 Matching
  4. 3.3 Loops
  5. 3.4 Using break and continue
• Lesson 4: Understanding Enums
  1. Learning objectives
  2. 4.1 Defining and using simple enums – Part 1
  3. 4.2 Defining and using simple enums – Part 2
  4. 4.3 Avoiding warnings about unused variants
  5. 4.4 Defining and using enums with data
  6. 4.5 Using the Option enum
  7. 4.6 Using the Result enum
• Lesson 5: Using Compound Types and Collections
  1. Learning objectives
  2. 5.1 Creating and using arrays
  3. 5.2 Array techniques
  4. 5.3 Creating and using tuples
  5. 5.4 Creating and using vectors
  6. 5.5 Creating and using maps
• Module 2: Rust Ownership and Borrowing
  1. Module introduction
• Lesson 6: Understanding Ownership in Rust
  1. Learning objectives
  2. 6.1 Understanding local scope
  3. 6.2 Defining static local scope – Part 1
  4. 6.3 Defining static local scope – Part 2
  5. 6.4 Defining static global scope
  6. 6.5 Defining static mutable variables – Part 1
  7. 6.6 Defining static mutable variables – Part 2
  8. 6.7 Understanding strings in Rust – Part 1
  9. 6.8 Understanding strings in Rust – Part 2
  10. 6.9 Copying vs. moving
  11. 6.10 Cloning
• Lesson 7: Understanding Borrowing in Rust
  1. Learning objectives
  2. 7.1 Understanding simple borrowing
  3. 7.2 Understanding the Rust borrow checker
  4. 7.3 Introduction to string slices
  5. 7.4 String slice techniques
  6. 7.5 Introduction to array slices
  7. 7.6 Array slice techniques
• Summary
  1. Rust Programming Part 1: Summary

Course images

Sample video of the course

download link

Download part 1 – 1 GB

Download part 2 – 322 MB

File(s) password: www.downloadly.ir

Size

1.3 GB