English | MP4 | AVC 1280×720 | AAC 48KHz 2ch | 6h 41m | 1.03 GB
If you know even a little bit about programming languages, you know there are a plethora of options to choose from. If your priority is a language focused on reliability, speed, memory, safety, and parallelism, then Rust may be the one for you. In this course, instructor Barron Stone covers the key components of Rust, starting with basic programming concepts including variables, data types, functions, and control loops. He then moves on to some of the core concepts that are unique to Rust, including ownership, borrowing references, and crates. While Rust is great for low-level systems programming, it’s also being used for web apps, network services, and embedded programs. As Barron shows, the features of Rust, along with great tools, documentation, and a welcoming community, have made Rust a language that developers love.
Table of Contents
1 Learn Rust programming
2 Integer data types
3 Matching Result-T, E- to recover from errors
4 Propagating errors
5 Challenge- Handle errors
6 Solution – Handle errors
7 Vectors
8 HashMaps
9 Challenge- Count words
10 Solution- Count words
11 Where to go next
12 Floating-point data types
13 Arithmetic operations
14 Formatting print statements
15 Bitwise operations
16 Boolean data type and operations
17 Comparison operations
18 Char data types
19 Challenge- Find the average
20 Solution- Find the average
21 What you should know
22 Arrays
23 Multidimensional arrays
24 Tuples
25 Function parameters
26 Statements vs. expressions
27 Function return values
28 Challenge- Convert temperature
29 Solution- Convert temperature
30 Conditional execution
31 Multiple conditions
32 What is Rust-
33 Conditional assignment
34 Loops
35 While loops
36 For loops
37 Nested loops
38 Challenge- Max, min, mean
39 Solution- Max, min, mean
40 Variable scope
41 Shadowing variables
42 Stack and heap memory
43 Installing Rust on Windows
44 String data type
45 Ownership
46 Moving, cloning, and copying data
47 Transferring ownership
48 Borrowing references
49 Mutable references
50 Dangling references
51 Slices
52 Slices as function parameters
53 Challenge- Trim spaces
54 Installing Rust on Linux and macOS
55 Solution- Trim spaces
56 Rust Standard Library and prelude
57 Standard input
58 Parse strings
59 Crates
60 Challenge- Higher or lower
61 Solution- Higher or lower
62 Command-line arguments
63 Reading from files
64 Writing to files
65 Anatomy of a Rust program
66 Challenge- Check the roster
67 Solution- Check the roster
68 Defining structs
69 Struct update syntax
70 Struct methods
71 Associated functions
72 Tuple structs
73 Challenge- Represent shapes
74 Solution- Represent shapes
75 Generic struct definitions
76 Adding comments
77 Generic method definitions
78 Generic function definitions
79 Box data type
80 Challenge- Sum boxes
81 Solution- Sum boxes
82 Implement traits
83 Default trait implementation
84 Derive traits
85 Trait bounds
86 Multiple trait bounds
87 Building programs using Cargo
88 Return types with implemented traits
89 Challenge- Implement the display trait
90 Solution- Implement the display trait
91 The borrow checker
92 Lifetime annotation syntax
93 Multiple lifetime annotations
94 Lifetime elision rules
95 Struct lifetime annotations
96 Static lifetime
97 Define enums
98 Declaring variables
99 Match operator
100 Match with default placeholder
101 Enum methods
102 Option-T- enum
103 Matching Option-T-
104 If-let syntax
105 Challenge- Represent a location
106 Solution- Represent a location
107 Unrecoverable errors
108 Result-T, E- enum
Resolve the captcha to access the links!