Udemy, Coursera, 2U/edX Face Lawsuits Over Meta Pixel Use

Easy Rust - Bite-Sized Rust Tutorials

Easy Rust - Bite-Sized Rust Tutorials

mithradates via YouTube Direct link

Easy Rust 001: Introduction and how to use the Rust Playground

1 of 186
Next

1 of 186

Easy Rust 001: Introduction and how to use the Rust Playground

Class Central Classrooms beta

YouTube playlists curated by Class Central.

Classroom Contents

Easy Rust - Bite-Sized Rust Tutorials

Automatically move to the next video in the Classroom when playback concludes
  1. 1 Easy Rust 001: Introduction and how to use the Rust Playground
  2. 2 Easy Rust 002: Writing comments in your code
  3. 3 Easy Rust 003: Some primitive types
  4. 4 Easy Rust 004: Type inference and floats
  5. 5 Easy Rust 005: Hello World!
  6. 6 Easy Rust 006: Declaring variables and code blocks
  7. 7 Easy Rust 007: Debug printing
  8. 8 Easy Rust 008: Mutability
  9. 9 Easy Rust 009: Shadowing
  10. 10 Easy Rust 010: The stack and the heap
  11. 11 Easy Rust 011: More advanced printing
  12. 12 Easy Rust 012: Even more advanced printing
  13. 13 Easy Rust 013: String and &str
  14. 14 Easy Rust 014: const and static
  15. 15 Easy Rust 015: More on references
  16. 16 Easy Rust 016: Mutable references
  17. 17 Easy Rust 017: Giving references to functions
  18. 18 Easy Rust 018: Giving mutable references to functions
  19. 19 Easy Rust 019: Copy types
  20. 20 Easy Rust 020: Uninitialized variables
  21. 21 Easy Rust 021: Arrays
  22. 22 Easy Rust 022: Vecs
  23. 23 Easy Rust 023: Tuples
  24. 24 Easy Rust 024: Control flow 1
  25. 25 Easy Rust 025: Control flow part 2
  26. 26 Easy Rust 026: Structs
  27. 27 Easy Rust 027: Structs part 2
  28. 28 Easy Rust 028: Enums part 1
  29. 29 Easy Rust 029: Enums part 2
  30. 30 Easy Rust 030: Enums part 3
  31. 31 Easy Rust 031: Enums part 4
  32. 32 Easy Rust 032: Loops part 1
  33. 33 Easy Rust 033: Loops part 2
  34. 34 Easy Rust 034: Loops part 3
  35. 35 Easy Rust 035: Implementing structs and enums 1
  36. 36 Easy Rust 036: Implementing structs and enums 2
  37. 37 Easy Rust 037: More about destructuring
  38. 38 Easy Rust 038: Generics part 1
  39. 39 Easy Rust 039: Generics part 2
  40. 40 Easy Rust 040: Generics part 3
  41. 41 Easy Rust 041: Generics part 4
  42. 42 Easy Rust 042: Option part 1
  43. 43 Easy Rust 043: Option part 2
  44. 44 Easy Rust 044: Option part 3
  45. 45 Easy Rust 045: Result part 1
  46. 46 Easy Rust 046: Result part 2
  47. 47 Easy Rust 047: Result part 3 (plus TURBOFISH)
  48. 48 Easy Rust 048: if let part 1
  49. 49 Easy Rust 049: if let part 2
  50. 50 Easy Rust 050: Using if let and while let together
  51. 51 Easy Rust 051: Collection types (HashMap)
  52. 52 Easy Rust 052: Collection types (BTreeMap)
  53. 53 Easy Rust 053: Collection types - some more HashMap and the entry method
  54. 54 Easy Rust 054: HashMaps and the .entry().or_insert_with() method
  55. 55 Easy Rust 055: Collection types - last video on entry method for HashMap
  56. 56 Easy Rust 056: Collection types (HashSet and BTreeSet)
  57. 57 Easy Rust 057: Collection types (BinaryHeap)
  58. 58 Easy Rust 058: Collection types (VecDeque)
  59. 59 Easy Rust 059: Collection types - VecDeque example
  60. 60 Easy Rust 060: The question mark operator (AKA try)
  61. 61 Easy Rust 061: Using the panic! macro
  62. 62 Easy Rust 062: assert!, assert_eq!, and assert_ne! macros
  63. 63 Easy Rust 063: Introduction to traits
  64. 64 Easy Rust 064: Traits part 2 - reading and understanding trait implementation
  65. 65 Easy Rust 065: Traits part 3 - implementing Display for the first time
  66. 66 Easy Rust 066: Traits part 4 - writing a bit longer trait
  67. 67 Easy Rust 067: Traits part 5 - making traits useful with other traits
  68. 68 Easy Rust 068: Traits part 6 - using trait bounds
  69. 69 Easy Rust 069: Traits part 7 - understanding the From trait
  70. 70 Easy Rust 070: Traits part 8 - implementing the From trait
  71. 71 Easy Rust 071: Type aliases and new types
  72. 72 Easy Rust 072: Traits part 9 - Implementing the From trait again
  73. 73 Easy Rust 073: Traits part 10 - AsRef
  74. 74 Easy Rust 074: Chaining methods together
  75. 75 Easy Rust 075: Quick intro to closures
  76. 76 Easy Rust 076: Iterators part 1
  77. 77 Easy Rust 077: Iterators part 2 - associated types
  78. 78 Easy Rust 078: Iterators part 3 - implementing an iterator
  79. 79 Easy Rust 079: Closures and methods with or_else
  80. 80 Easy Rust 080: Enumerate and how iterators are made
  81. 81 Easy Rust 081: collect and zip methods
  82. 82 Easy Rust 082: char_indices and closures without arguments
  83. 83 Easy Rust 083: filter, retain, and Fn, FnMut and FnOnce in closures
  84. 84 Easy Rust 084: filter_map
  85. 85 Easy Rust 085: filter map plus ok, ok_or and ok_or_else
  86. 86 Easy Rust 086: The and_then method
  87. 87 Easy Rust 087: the and method
  88. 88 Easy Rust 088: The any method
  89. 89 Easy Rust 089: The all method
  90. 90 Easy Rust 090: find, position, MAX and MIN
  91. 91 Easy Rust 091: cycle and open ended iterators
  92. 92 Easy Rust 092: The fold method
  93. 93 Easy Rust 093: take while, skip while, cloned, by ref, and sum
  94. 94 Easy Rust 094: chunks, windows, match_indices
  95. 95 Easy Rust 095: peekable iterators and the peek method
  96. 96 Easy Rust 096: Final example of iterators and quick look at clippy
  97. 97 Easy Rust 097: The dbg! macro
  98. 98 Easy Rust 098: The inspect method
  99. 99 Easy Rust 099: String, &str and a brief introduction to lifetimes
  100. 100 Easy Rust 100: Introduction to lifetimes and the 'static lifetime
  101. 101 Easy Rust 101: Named lifetimes
  102. 102 Easy Rust 102: Rust's three rules about lifetimes
  103. 103 Easy Rust 103: Anonymous lifetimes
  104. 104 Easy Rust 104: Interior mutability and why you would want it
  105. 105 Easy Rust 105: Interior mutability with Cell
  106. 106 Easy Rust 106: Dynamic interior mutability with RefCell
  107. 107 Easy Rust 107: Cell and RefCell again
  108. 108 Easy Rust 108: Mutex
  109. 109 Easy Rust 109: Mutex part 2
  110. 110 Easy Rust 110: RwLock
  111. 111 Easy Rust 111: Cow part 1
  112. 112 Easy Rust 112: Cow part 2
  113. 113 Easy Rust 113: Type aliases and the as keyword
  114. 114 Easy Rust 114: The todo! macro
  115. 115 Easy Rust 115: Introduction to Rc (reference counter)
  116. 116 Easy Rust 116: Using a reference counter
  117. 117 Easy Rust 117: Some functions for reference counters
  118. 118 Easy Rust 118: RefCell inside of an Rc
  119. 119 Easy Rust 119: Multiple threads (concurrency) - part 1
  120. 120 Easy Rust 120: Multiple threads (concurrency) - part 2
  121. 121 Easy Rust 121: Multiple threads (concurrency) - part 3
  122. 122 Easy Rust 122: Introduction to Arc, Send and Sync
  123. 123 Easy Rust 123: Using Arc and Mutex to modify concurrent threads safely
  124. 124 Easy Rust 124: Fn, FnMut, FnOnce traits for closures
  125. 125 Easy Rust 125: Putting closures into functions
  126. 126 Easy Rust 126: Longer example of closures in functions
  127. 127 Easy Rust 127: impl trait to return closures from functions
  128. 128 Easy Rust 128: One more example of impl trait to return closures
  129. 129 Easy Rust 129: Introduction to Box
  130. 130 Easy Rust 130: Boxes used for indirection
  131. 131 Easy Rust 131: Boxes used as trait objects
  132. 132 Easy Rust 132: Boxes in dynamic dispatch vs impl trait
  133. 133 Easy Rust 133: Channels part 1
  134. 134 Easy Rust 134: Channels part 2
  135. 135 Easy Rust 135: Channels part 3
  136. 136 Easy Rust 136: Attributes part 1
  137. 137 Easy Rust 137: Attributes part 2
  138. 138 Easy Rust 138: Implementing Default
  139. 139 Easy Rust 139: The builder pattern
  140. 140 Easy Rust 140: The builder pattern part 2
  141. 141 Easy Rust 141: Dereferencing and the dot operator
  142. 142 Easy Rust 142: Intro to the Deref trait
  143. 143 Easy Rust 143: Implementing Deref and DerefMut
  144. 144 Easy Rust 144: Implementing Deref weirdly
  145. 145 Easy Rust 145: modules part 1
  146. 146 Easy Rust 146: modules part 2
  147. 147 Easy Rust 147: modules part 3
  148. 148 Easy Rust 148: Introduction to testing
  149. 149 Easy Rust 149: Testing and mini calculator project part 1
  150. 150 Easy Rust 150: Testing and mini calculator project part 2
  151. 151 Easy Rust 151: Testing and mini calculator project part 3
  152. 152 Easy Rust 152: Testing and mini calculator project part 4
  153. 153 Easy Rust 153: Testing and mini calculator project part 5
  154. 154 Easy Rust 154: Testing and mini calculator project part 6
  155. 155 Easy Rust 155: Using external crates
  156. 156 Easy Rust 156: Using the rand crate
  157. 157 Easy Rust 157: Looking at some external crates
  158. 158 Easy Rust 158: Tour of the standard library: array and char
  159. 159 Easy Rust 159: Tour of the standard library: char and integers
  160. 160 Easy Rust 160: Tour of the standard library: implementing Add
  161. 161 Easy Rust 161: Tour of the standard library: methods for floats
  162. 162 Easy Rust 162: Tour of the standard library: bool
  163. 163 Easy Rust 163: Tour of the standard library: Vec
  164. 164 Easy Rust 164: Tour of the standard library: String
  165. 165 Easy Rust 165: Tour of the standard library: OsString, CString, OsStr, CStr, and unsafe
  166. 166 Easy Rust 166: Tour of the standard library: std::mem
  167. 167 Easy Rust 167: Tour of the standard library: the unsafe function transmute
  168. 168 Easy Rust 168: Tour of the standard library: no implicit prelude and no std
  169. 169 Easy Rust 169: Function pointers
  170. 170 Easy Rust 170: Function pointers part 2
  171. 171 Easy Rust 171: Tour of the standard library: std::time
  172. 172 Easy Rust 172: Tour of the standard library: one neat trick plus putting threads to sleep
  173. 173 Easy Rust 173: Tour of the standard library: some helpful macros
  174. 174 Easy Rust 174: Intro to macros
  175. 175 Easy Rust 175: More on macros
  176. 176 Easy Rust 176: Macros part 3
  177. 177 Easy Rust 177: Macros part 4
  178. 178 Easy Rust 178: Macros part 5
  179. 179 Easy Rust 179: Cargo
  180. 180 Easy Rust 180: Taking input from the user
  181. 181 Easy Rust 181: Working with user args
  182. 182 Easy Rust 182: Working with environmental variables
  183. 183 Easy Rust 183: Brushing up on Result and the ? operator
  184. 184 Easy Rust 184: Opening and writing to a file
  185. 185 Easy Rust 185: Reading the file we just opened
  186. 186 Easy Rust 186: Appending a file with OpenOptions, and goodbye for now

Never Stop Learning.

Get personalized course recommendations, track subjects and courses with reminders, and more.

Sign up for free
Someone learning on their laptop while sitting on the floor.