Rust Programming Foundations 2023-9 – Download

Description

Rust programming course. Part 1: Rust Programming Basics. This course will teach you the basics of Rust programming through easy-to-follow tutorials and detailed examples. Rust is the language of choice for many passionate programmers because of its expressiveness, computational complexity, and reliability. Rust combines the efficiency, speed, and low-level capabilities of C/C++ with the benefits of higher-level languages ​​such as Java, Python, and C#, and you can use it to implement a variety of solutions, including built-in ones. systems, DevOps tools, operating systems and platforms and much more. use.

This course is the first part of your learning journey. You’ll learn about Rust tools, the type system, and how to implement data flow control. You’ll also learn how to use composite 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 mistakes in C and C++.

What you’ll learn in Rust Programming Part 1: Rust Programming Basics:

• Getting Started with Rust: Begins with an overview of Rust as a programming language and shows how to download 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.
• Implementing Control Flow: Shows how to implement conditional logic and iteration in Rust.
• Understanding Enum Types: Explains how to define and use enum types, and reviews some important standard enum types in the Rust library.
• Using Mixed Types and Sets: Shows how to create and use arrays and tuples, and how to use vectors and maps in the Rust collections library.
• Understanding Ownership in Rust: Describes in detail how Rust manages the lifetime of objects. You’ll learn the difference between copying and passing values ​​in Rust.
• Understanding Borrowing in Rust: This covers a concept called “borrowing”, where you refer to a variable without claiming ownership.

This course is suitable for people who:

• Developers who want to start writing efficient and well-structured applications in Rust.

Course details

• Publisher: Oreily
• Instructor: Andy Olsen
• Level of training: from beginner to advanced
• Training duration: 7 hours 4 minutes

Course headings

• Introduction
  1. Programming in Rust. Part 1: Introduction
• Module 1: Rust Programming Basics
  1. module introduction
• Lesson 1: Getting Started with Rust
  1. Learning Objectives
  2. 1.1 Rust Overview
  3. 1.2 Writing your first Rust application
  4. 1.3 Build and Run Your First Rust Application
  5. 1.4 Creating an application using Cargo
  6. 1.5 Creating and running an application 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 methods
• Lesson 3: Implementing Flow Control
  1. Learning Objectives
  2. 3.1 If tests
  3. 3.2 Comparison
  4. 3.3 Cycles
  5. 3.4 Using break and continue
• Lesson 4: Understanding Enumerations
  1. Learning Objectives
  2. 4.1 Definition and use of simple enumerations – Part 1
  3. 4.2 Definition and use of simple enumerations – Part 2
  4. 4.3 How to avoid warnings about unused options
  5. 4.4 Defining and using data enumerations
  6. 4.5 Using the Option enumeration
  7. 4.6 Using the “Result” enumeration
• Lesson 5: Using Composite Types and Collections
  1. Learning Objectives
  2. 5.1 Creating and using arrays
  3. 5.2 Methods for working with arrays
  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 a static local scope. Part 1.
  4. 6.3 Defining a static local scope. Part 2.
  5. 6.4 Defining a 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 Copy or 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 Introducing string slices
  5. 7.4 Line cutting technique
  6. 7.5 Introduction to array slices
  7. 7.6 Array slicing methods
• Summary
  1. Programming in Rust. Part 1: Summary

course images

Example video course

Download link

Download part 1 – 1 GB

Download part 2 – 322 MB

Password for file(s): www.downloadly.ir

size

1.3 GB