Rust Developer Bootcamp by LetsGetRusty (EARLY BIRD SPECIAL)

Rust Developer Bootcamp by LetsGetRusty (EARLY BIRD SPECIAL)
English | Tutorial | Size: 2.78 GB

Who is this Bootcamp for? Experienced Developers trying to switch to Rust. Learn the language of the future.

Your time is valuable (literally, $148,688/yr). Learn Rust FAST with the Bootcamp, instead of digging through low-quality resources. Students/Graduates looking for a job. Learning Rust is a great resume builder. Stand out from other candidates. Become a competent programmer. Get access to a community that can help you land your first job. And… You! Rust enthusiast. Rust is an innovative language that will expand your way of thinking Cutting-edge technologies are built in Rust.

You’ll learn how to setup your development environment, configure your IDE and install the right plugins. Then you’ll create your first Rust project!

How to Setup Your Environment
Setting Up Your IDE & Plugins
Creating Rust Packages With Cargo
Variables & Data Types in Rust
Constant & Static Variables
Functions and Control Flow

Understanding memory management is critical when learning Rust! In this section you’ll learn about memory management from the ground up!

Rust-Based CS Masterclass
How Ownership Works
How Borrowing Works
What Slices Are
String Types (str, &str, and String)

Rust doesn’t have classes or objects! Instead, Rust uses Structs and Enums for custom data types. In this section you will learn about creating your own types!

How To Create Structs & Enums
How To Use Implementation Blocks
Pattern Matching
The Option and Result Enum
Vectors

How To Structure Your Rust Projects

In this section I will explain how modules work in an easy to understand way. I’ll also go over structuring larger projects and publishing your work to Crates.io.

Project Structure Overview
The Module System
External Dependencies
Conditional Compilation
How to Structure Larger Projects
Publishing Your Rust Projects

How Test & Document Your Code

Tests are a critical part of writing robust code. In this section you’ll learn how to write and structure unit & integration tests in Rust. We’ll also cover documentation.

How To Write Unit Tests
How to Write Integration Tests
How To Structure Your Tests
Documentation Comments

Polymorphism With Generics & Traits

Rust does not support classical inheritance! Instead, polymorphism is achieved through generics and traits. In this section you’ll learn how both work!

How To Define Generics
The Trait System
Traits Bounds & Trait Objects
Supertraits
Static Dispatch vs Dynamic Dispatch
How To Derive Traits
Traits in the Standard Library

Advanced Memory Management

Memory management doesn’t end with ownership and borrowing! In this section you’ll learn about lifetimes! We’ll also cover various smart pointers in Rust.

Concrete Lifetimes
Generic Lifetimes Anotations
Liftimes in Functions And Structs
Smart Pointers & Why They Are Useful
Implicit Deref Coericon

Understanding Error Handling In Rust

Understanding error handling is critical when designing your Rust applications. In this section we will cover how error handling works in Rust.

How To Throw Unrecoverable Errors
How To Return Recoverable Errors
How To Propagate Errors
The Result And Option Enums
How To Handle Multiple Error Types
How To Use anyhow & thiserror

Functional Features In Rust

One of the most powerful things about Rust is its functional features. In this section we will cover closures, function pointers, iterators, and more!

Closures & Function Pointers
The Iterator Pattern In Rust
Implementing The Iterator Pattern
How To Iterate Over Collections
Combinators And How To Use Them

Concurrency & async/.await

This is probably the MOST IMPOTANT section. Understanding concurrency is critical, especially when using rust for web related projects.

Basic Concurrency Concepts
Creating Threads
Message Passing With Channels
Sharing State With Mutex
The async/.await Model
How Futures Work
What Is An Async Runtime
What Is Tokio And How Is It Used
What Are Tokio Tasks
Running CPU Blocking Code
Streams

Rust’s Powerful Macro System

Macros are an extremely powerful way to extend the syntax of a language. In this section you’ll learn about the Macro system in Rust from the ground up!

The Compilation Process
What Macros Are
How To Create Declarative Macros
How To Create Precedural Macros
Function-Like Procedural Macros
Attribute-Like Procedural Macros
Custom Derive Procedural Macros

Unsafe Rust & FFI

One huge benefit of Rust is its ability to interface with other languages through a foreign function interface. In this section you’ll learn about unsafe Rust and the FFI!

Unsafe Rust And When To Use It
How To Dereference Raw Pointers
What Are Unsafe Functions
What Are Unsafe Traits
How To Mutate Static Variables
How To Write Inline Assembly In Rust
How To Call C Code From Rust
How To Call Rust Code From C

NITROFLARE
nitroflare.com/view/10408BB913D7120/Rust_Developer_Bootcamp.part1.rar
nitroflare.com/view/E33411A64FE939C/Rust_Developer_Bootcamp.part2.rar
nitroflare.com/view/E35636DCBCB492B/Rust_Developer_Bootcamp.part3.rar
nitroflare.com/view/560D9F986976182/Rust_Developer_Bootcamp.part4.rar
nitroflare.com/view/53069B3CA7788B7/Rust_Developer_Bootcamp.part5.rar