Rust Programming Master Class From Beginner to Expert

Rust Programming Master Class From Beginner to Expert

What you’ll learn

Develop beginer to advance level skills of RUST Programming
Learn the basic syntax of RUST and its feature of memory safety
Developed an understanding of advance level concepts such as generics, traits, lifetimes and closures
Gain Hands-On experience of solving some intermediate to advance level problems using RUST

Requirements

We cover everything from scratch and therefore do not require any prior knowledge of RUST

Description

Programming languages usually have some tradeoffs. There are low level languages like C anc C++ usually have speed and control at the cost of memory safety. On the other hand, we high level languages such as python or java script are more safer but are not very efficient from power and speed perspectives. With rust we have best of both the worlds. More specifically, it is a system programming language which means they have speed and control but at the same time are much much better because of the safety features just like high level languages. This makes rust so clearly standout among all the other programming languages.Its popularity is increasing day by day and is therefore being adapted by bigger companies world wide. Google is also planning to use Rust in the Linux kernel, Microsoft, meanwhile, has turned to Rust to reduce memory-related bugs in Windows and Facebook has also forged closer ties with Rust, joining the Rust Foundation. All these are clear indications that Rust is gaining significant attention of the community. At 9+ hours of video tutorials, this course will take you from beginner to expert level.  This course is designed from a perspective of a student who has no prior knowledge of RUST and who is a RUST beginner. Throughout this comprehensive course, we cover a massive amount of skills and techniques including:Basic rust programming syntaxPremitive and non-premitive typesCommon Rust CollectorsEnums, Traits and StructuresGenerics, Lifetimes and ClosuresRust Module SystemUsing External Crates and how to Publish CratesThe course ensures that you learn by doingPractice exercise questions along with solutions Quizes andAssignmentsBy taking this course, you will become a fluent in RUST programming and you’ll be so good so that you can confidently and professionlay code in the language.Don’t just rely on my word, check what some of our existing students have to say about the my course. “I had viewed the video in the propose sequence, as well, as I had looked at some videos outside of the instructor propose sequence, and only had one thing to say: – This course is excellent!!!!!!!!!!!!!”  Gabriel Federo Hungria”I have gone through the course on MATLAB Gui by the instructor. It was an A++ experience. He is the best instructor, really professional and knows exactly what to teach. Thanks for your wonderful contribution to help us understand MATLAB.” Kunal Singh”Very interesting course, complete functionality of Matlab was explained and the quizzes further helped with the learning process.” Hassan AyubPleaset note… I am very confident that you will like the course and therefore provides you with a FULL money back guarantee for 30 days! So there is a ZERO risk and nothing to loose. Finally, i am super excited to teach you RUST programming, so hit enroll and enjoy learning RUST

Overview

Section 1: Introduction

Lecture 1 Course introduction

Lecture 2 Installing Rust and Web-based Enviroment for Executing Programs

Lecture 3 Running and Compiling Programs your First Program

Lecture 4 Tell us About the Course

Lecture 5 Download all the Codes for the Course

Section 2: Basic Programming

Lecture 6 Program Outputs and Comments

Lecture 7 Variables and Scalar Data Types

Lecture 8 More on Variables- Shadowing,, Constants

Lecture 9 Compound Data Types-Strings

Lecture 10 Compound Data Types-Tuples, Arrays

Lecture 11 Compound Data Types – Vectors

Lecture 12 Functions and Inputs

Section 3: Ownership: The Heart of Rust programming

Lecture 13 Ownership, Premitive and Non-Premitive Types

Lecture 14 Application Memory (Heap and Stack)

Lecture 15 Onwership and References in Functions

Lecture 16 Mutable and Immutable References

Section 4: Control Structures

Lecture 17 Conditional If and its Varaints

Lecture 18 If let and Nested if

Lecture 19 Match Statement

Lecture 20 While and Simple loops

Lecture 21 For Loops and its Variants

Lecture 22 Break and Continue

Section 5: Project: Stack Implementation

Lecture 23 Implementing Stack

Lecture 24 String Reversal Using Stacks

Lecture 25 Expression Evaluation (Infix to PostFix Illustration)

Lecture 26 Expression Evaluation (Postfix Evaluation)

Lecture 27 Expression Evaluation – Part 1

Lecture 28 Expression Evaluation – Part 2

Lecture 29 Implementing Postfix Evaluation

Section 6: Structures ,Traits, Generics, Enums

Lecture 30 Structures Basics

Lecture 31 Traits and Default Implementations

Lecture 32 Functions within a Trait

Lecture 33 Enums

Lecture 34 Generics

Lecture 35 Option Enum

Lecture 36 Result Enum

Lecture 37 Hash Maps

Section 7: Iterators, Lifetimes and Closures

Lecture 38 Lifetimes (Part 1)

Lecture 39 Lifetimes (Part 2)

Lecture 40 Closures (Part 1)

Lecture 41 Closures (Part 2)

Lecture 42 Function Types

Lecture 43 Iterators (Part 1)

Lecture 44 Iteartors (Part 2)

Section 8: Rust Modules and Crates

Lecture 45 Rust Modules (Part 1)

Lecture 46 Rust Modules (Part 2)

Lecture 47 Using External Crates

Lecture 48 Publishing your Crate

Section 9: Smart Pointers

Lecture 49 Basics of Smart Pointers

Lecture 50 Box Smart Pointers and when to use it

Lecture 51 Refining Cons List and Custom Defined Smart Pointers

Lecture 52 Singly Link List (Part 1)

Lecture 53 Singly Link List (Part 2)

Lecture 54 Generics and Deref Coercion in Smart Pointers

Lecture 55 Rc Smart pointer

Lecture 56 RefCell Smart Pointer

Lecture 57 Doubly Link List (Part 1)

Lecture 58 Doubly Link List (Part 2)

Lecture 59 Reference Cycles Creating Memory Leakage

Section 10: Advance Techniques

Lecture 60 Macros Basic

Lecture 61 Capturing Types

Lecture 62 Repeating Patterns

Lecture 63 Unit Type, Expression vs statements and Partial Move

Lecture 64 As_ref and Partial move in Option

Lecture 65 Take and Swap for Avoiding Allocations

Lecture 66 Question Mark Operator

Lecture 67 Testing Your Code (Part 1)

Lecture 68 Testing your Code (Part 2)

Lecture 69 Some Useful Traits

Lecture 70 Trait Bounds

Lecture 71 Associated Types

Section 11: Real Life Applications and Problem Solving using Rust

Lecture 72 Search Results using Word Groupings using HashMaps and Nested Loops

Lecture 73 Product Popularity using HashMaps

Lecture 74 Highest Stock Price Using MaxStack and Structures

Lecture 75 Finding and employee with no meeting Using Multidimensional Arrays

Lecture 76 Longest Non-Stop Working Employee using HashSets

Lecture 77 Items Suggestions using HastSets and Vectors

Lecture 78 Items in Ranges using Binary Search Tree(Part 1)

Lecture 79 Items in Ranges using Binary Search Tree (Part 2)

Lecture 80 Fetching Top Products

Lecture 81 Effective Storage and Retrieval using Trie Data Structure

Lecture 82 Most Recently Used Product using Doubly link list and hashmaps (Part 1)

Lecture 83 Most Recently Used Product using Doubly link list and hashmaps (Part 2)

Lecture 84 Dsiplaying Participants in an online meeting (Part 1)

Lecture 85 Dsiplaying Participants in an online meeting (Part 2)

Section 12: Efficient Programming with Rust

Lecture 86 Initializing Struct Instances

Lecture 87 Function inputs and coercion

Lecture 88 Iterating through Option

Lecture 89 Disabling Mutability for Finalized Objects

Lecture 90 String Concatenation and Ownership

Lecture 91 Simplifying Structures

Lecture 92 Efficient Programming Tips

Lecture 93 String Literals

Lecture 94 Todo Macro and Some Useful Extentions

Lecture 95 Static versus Dynamic Dispatch

Lecture 96 The Builder Pattern

Section 13: Concurrency

Lecture 97 Threads Basics

Lecture 98 Multiple Threads and Ownership in Threads

Lecture 99 Communication through Channels

Lecture 100 Multiple Producers, Threads and Functions

Lecture 101 Sharing States

Lecture 102 Passes Mutexes between Threads

Lecture 103 Synchronization through Barriers

Lecture 104 Project: Web Scrapping using Threads

Lecture 105 Scoped Threads

Lecture 106 Thread Parking, Yielding

Lecture 107 Async Await (Part 1)

Section 14: Text Processing, File and Directory Handling

Lecture 108 Basic File Handling

Lecture 109 Directory and path related functions

Lecture 110 Regular Expressions Basics

Lecture 111 Repeititions Quantifiers and Capturing Groups

Anyone looking to build a strong career in programming through excellent RUST coding skills

Course Information:

Udemy | English | 19h 22m | 6.06 GB
Created by: Nouman Azam

You Can See More Courses in the Developer >> Greetings from CourseDown.com