-
Section 3: Variables and Data types
8 Lessons -
Section 12: Structure
8 Lessons-
PreviewCreating and Initializing a struct
-
PreviewIs struct 'move' or 'copy'?
-
StartStruct and Default trait
-
StartTuple struct and Unit struct
-
StartWriting Struct methods
-
StartAssociated function as Constructor of a Struct
-
StartPattern matching with Struct
-
Startref and @ usage with struct pattern matching
-
-
Section 14: Vectors
12 Lessons-
StartIntroduction to Vectors
-
PreviewVectors under the hood
-
StartVector indexing
-
StartSlice of a vector
-
StartVector methods: push(), pop(), shrink_to_fit()
-
StartExercise-diy-11
-
StartVector methods: drain(), extract_if()
-
StartVector methods: retain(), retain_mut()
-
StartVector methods: split() and friends
-
StartVector methods: splice(), append(), extend()
-
StartVector methods: prepend using index() and splice()
-
StartVecDeque
-
-
Section 15: Error Handling
15 Lessons-
PreviewEnum Result
-
PreviewError handling using Result enum
-
StartExercise on Result enum
-
StartError propagation operator ( ? )
-
StartConverting 'Option' to 'Result' type
-
Startunwrap() and expect() methods
-
Startunwrap_err()
-
StartStd. Library error types
-
StartHandling std::io::Error
-
StartNumeric Errors : Exercise
-
StartNumeric Errors : Exercise contd
-
StartExercise on error conversion
-
StartExercise on error conversion contd.
-
Startmap_err() usage
-
StartAuto conversion of errors
-
-
Section 20: Traits
9 Lessons-
StartIntroduction to Trait and Trait methods
-
StartAssociated types of a Trait
-
StartExercise: Implementing Display trait for user defined structure part-1
-
StartExercise: Implementing Display trait for user defined structure part-2
-
StartExercise: Implementing Display trait for user defined structure part-3
-
StartTrait bounds
-
StartTrait objects and Virtual table
-
StartBoxing the DST
-
StartMemory layout of Boxing of Trait Object
-
-
Section 21: Closures
12 Lessons-
StartIntroduction to Closures and Syntax
-
StartClosure capturing environment
-
StartTraits associated with closures
-
StartBehaviour of closure variables
-
StartPassing closure as arguments to a function part-1
-
StartPassing closure as arguments to a function part-2
-
StartClosures as Struct member fields
-
StartMemory layout of the program
-
StartTypes of Closures
-
StartExercise on Closure
-
StartClosures as Struct member fields[Using Generics]
-
StartClosures and event handling
-
-
Section 22: Iterators
21 Lessons-
StartIntroduction to Iterators
-
StartTrait 'Iterator' Vs Trait 'IntoIterator'
-
StartCreating an custom iterator
-
StartIterating over custom iterator by value, mutable and immutable borrow
-
StartCreating an custom iterator: Refactoring next method
-
StartTrait 'Iterator' Vs Trait 'IntoIterator'
-
StartExercise: Implementing a custom iterator
-
StartSolution: Implementing a custom iterator
-
StartImplementing Trait 'IntoIterator' for a custom type Part-1
-
StartImplementing Trait 'IntoIterator' for a custom type Part-2
-
StartImplementing Trait 'IntoIterator' for a custom type Part-3
-
StartImplementing Trait 'IntoIterator' for a custom type Part-4-Solution
-
PreviewIterator Methods
-
Startfor_each() as an alternate to for loop
-
Startiter(), iter_mut() and into_iter() explanation
-
StartCommonly used iterator adapters
-
Startmap()
-
Startcollect()
-
StartUsing collect() with custom collection
-
StartImplementing Trait 'FromIterator' on a type
-
Startfilter()
-
-
Section 23: Structuring Code in Rust
10 Lessons-
Startpackage, crate, cargo.toml , cargo.lock
-
Start[package] section of cargo.toml, Semantic Versioning
-
StartPackage structuring rules
-
Start[dependencies] section of cargo.toml
-
StartRust editions
-
StartModules
-
StartPrivacy rules summary
-
StartStruct encapsulation
-
StartOrganizing modules into separate files
-
StartRe-exporting
-
-
Section 24: Raw and Smart pointers
10 Lessons-
StartRaw Pointers (*mut T and *const T)
-
StartSmart Pointer Box T
-
StartBox of String
-
StartUsing Dynamically Sized Type(DST)
-
StartBox of Slice [T]
-
StartBox of Trait object (dyn Trait)
-
StartStoring heterogeneous data in a Vector using Trait object
-
StartConverting Box of T in to raw pointers and vice versa
-
StartBorrow of Box T
-
StartEnabling recursive types using Box T
-
Master The Rust Programming Language : Beginner To Advanced
Learn Rust(Latest Edition) programming step by step with hands-on exercises, from basics to advanced levels.
Descriptions
println!(r#"### Our new Rust course, designed for beginners, covers ###"#);
println!(r#"### % fundamental to advanced topics % ###"#);
println!(r#"### to build a strong foundation. ###"#);
Update #7 and #8
1. Modules, Re-export, Encapsulation
2. Raw and Smart pointers
3. Boxing DST
Update #5 and #6
1. Iterators: Trait 'Iterator', Trait 'IntoIterator',
2. Creating custom iterator
3. Implementing Trait 'IntoIterator' on a custom type
Update #4
1. Traits: trait objects, virtual table, boxing DST, memory layout
2. Closures: as struct member fields, memory layout
Update #3
1. Closures: introduction, syntax
2. Closures capturing environment, traits associated with closures(Fn, FnMut, FnOnce)
3. Passing closures as function arguments
Update #2
1. Traits: introduction, methods
2. Associated types of a trait
3. Implementing custom Display trait
4. Trait bounds
Update #1
1. Generics: syntax, functions, structs, enums
2. Lifetimes: scope, annotations, elision rules
3. Lifetime annotations: structs, methods
4. Const. and static variables
Our new Rust course is designed for beginners, covering fundamental concepts and advanced topics to provide a strong foundation
Do you want to learn a new programming language?
How about The Rust Programming Language?
Rust is becoming increasingly popular in system-level programming due to its memory safety and performance. It stands as a strong competitor to C++ and is perfect for those looking to elevate their system-level programming skills. Whether you are a beginner or an experienced programmer, Rust offers a modern and powerful toolset for your development needs.
Learning Rust opens doors to high-performance, safe, and reliable system-level programming
Do you want to learn a new programming language?
How about The Rust Programming Language?
Rust is becoming increasingly popular in system-level programming due to its memory safety and performance. It stands as a strong competitor to C++ and is perfect for those looking to elevate their system-level programming skills. Whether you are a beginner or an experienced programmer, Rust offers a modern and powerful toolset for your development needs.
Learning Rust opens doors to high-performance, safe, and reliable system-level programming
Why Rust is making waves in the tech world
Here’s the latest buzz about Rust from the industry:
1. Rust developers at Google are twice as productive as C++ teamsSource: The Register
2. Google’s shift to Rust programming cuts Android memory vulnerabilities by 68%
Source: Google Security Blog
3. Microsoft is busy rewriting core Windows code in memory-safe Rust
Source: The Register
Rust is proving to be a game changer in system level programming, with leading companies adopting it for its unmatched memory safety, performance, and productivity benefits.
2023 Stack Overflow Developer Survey findings indicate that,
"Rust is the most admired language, more than 80% of developers that use it want to use it again next year."
"More respondents want to continue using Cargo(Rust's official package manager) next year than the top competitors."
Can Rust be the future of embedded systems development?
This course provides a strong foundation in Rust programming, which can be valuable for embedded software developers transitioning from C
Why should you consider learning Rust?
There are many answers, but here are the important ones.
- Memory safety without garbage collection
- Better concurrency without data races
- Safe and unsafe code * Performance friendly abstractions
- Rust is designed to be as fast as C and C++
- Awesome Tools and Ecosystem (Cargo (the package manager and build system), rustfmt (code formatting), clippy (linting), and a comprehensive standard library.)
- Built-in testing support
- Support for key Object-oriented programming principlesList item two
Why should you consider our course?
Our course is designed with beginners in mind. We use text, images, graphics, and animations to concisely demonstrate many intriguing concepts of Rust. This will build a solid foundation for you to understand the key concepts of the language. Also, we cover numerous small to large code snippets to demonstrate the concepts, allowing you to build complex programs.
Important Topics covered so far in the course
- Variables and primitive data types
- Ownership and Borrow
- Copy and Move semantics
- Tuples and Pattern matching
- Decision-making and Loops
- Structs and Pattern matching
- Enums and Pattern matching
- Struct/Enum Methods and associated functions
- Slices
- String, String slice and UTF encoding
- Lifetimes
- Traits
- Generics
- Closures
- Iterators
- Smart pointers
- More topics to come(multi-thread ,macros, etc ). We constantly update this course to ensure you have the latest knowledge and skills
Hardware/Software Requirements
1. Windows/MAC/Ubuntu machine with Microsoft VS Code IDE installed
Who This Course is For
- Anyone interested in learning a new system-level programming language
- Students and professionals seeking to enhance their skills
Completed Topics
Completed Topics
Upcoming Topics
- Rust Ownership
- Borrow Rules
- Variables and Data Types
- Move and Copy Semantics
- Strings and String slice
- Functions
- Print-related Macros
- Testing and Assert Macros
- Struct
- Enums
- Error Handling
- Vectors and HashMap
- Generics
- Traits
- Lifetimes
- Iterators
- Closures
- Modules and Crates
- Smart Pointers
- Concurrency
- Macros
24 sections • 177 lectures • 24 hours+ total length • Instant and lifetime access
24 sections • 177 lectures • 24 hours+ total length • Instant and lifetime access
Course Curriculum
FASTBIT EMBEDDED BRAIN ACADEMY
Frequently Asked Questions
Who this course is for?
For anyone who wants to learn Rust from scratch ( Do not require any prior knowledge of Rust)
Will I get instant access to all the videos?
Yes, once enrolled you get instant access to all the videos.
Are there any prerequisites for this course?
1) Microsoft visual studio code installed
2) Foundational understanding of programming in any language
What is your refund policy?
We offer a 30-days, no-questions-asked refund policy. If you're not satisfied within the first 30 days of your purchase, you can request a full refund.
How can I address any doubts or questions I may have?
Every lecture includes a dedicated Q&A discussion section. You can post your questions there, and our team will ensure they are answered within 24 to 48 hours.
How long is the course valid after purchase?
After purchasing the course, it remains accessible for a lifetime. You can access it at any time by logging into your account. In addition, you'll receive all future updates for the course at no extra cost.
Does this course cover Rust for embedded systems?
No. This course focuses on general Rust programming and does not specifically discuss no_std scenarios commonly used for embedded systems.
When can we expect the course to be fully complete?
Rust is a vast language with a steep learning curve. Our course is regularly updated with two new videos every week. The course is projected to be fully completed in another 12 to 15 months, by July 2025.
Is a certificate available for this course?
Yes. course completion certificate is available for this course.
Who is the instructor for this course?
Instructor for this course is Kiran Nayak. Please check his profiles here
1) https://www.udemy.com/user/bharati-software/
2) https://in.linkedin.com/in/nayakkiran
Reviews
5
Top Rated
Mukesh Reddy Palla
Great
As always great explanations
Amrutha Acharya
Rust
excellent course
Rate this course