Skip to main content
CF

Ultimate Rust Best Practices

1h 39m 25s
English
Paid

This course covers many best practices to help you with integrate Rust into your workflow, and let Rust’s tooling work for you. It includes formatting, linting, dependencies, vulnerabilities, code style, and general development advice.

About the Author: Ardan Labs

Ardan Labs thumbnail

Ardan Labs is a US training company founded by William Kennedy, focused almost entirely on Go (Golang) and the systems-engineering disciplines around it. Bill Kennedy is one of the most cited Go educators alive — co-author of Go in Action (Manning), maintainer of the Ardan Labs blog, and the lead instructor on a multi-track Go syllabus that runs from beginner through ultimate-Go advanced engineering.

The CourseFlix listing under this source carries nineteen Ardan Labs courses — covering Go language fundamentals, concurrency, advanced engineering patterns, Kubernetes (Bill teaches Go as the implementation language for cloud infrastructure), and the data-engineering / AI tracks Ardan added in recent years. Material is paid and aimed at engineers serious about Go as a career-defining language rather than as a syntax pickup.

Watch Online 21 lessons

This is a demo lesson (10:00 remaining)

You can watch up to 10 minutes for free. Subscribe to unlock all 21 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing
0:00
/
#1: The Best Practices Intro
All Course Lessons (21)
#Lesson TitleDurationAccess
1
The Best Practices Intro Demo
01:13
2
1.0 - Introduction - Formatting
08:29
3
1.1 - Clippy (the linter)
06:08
4
1.2 - Documentation
09:09
5
1.3 - Understanding Dependencies
04:58
6
1.4 - Managing Your Own Dependencies
05:07
7
1.5 - Checking for Vulnerabilities
01:47
8
1.6 - Check for Outdated Dependencies
01:43
9
1.7 - Denying Dependencies by Licensing
05:05
10
2.0 - Favor Iterators
08:08
11
2.1 - Minimize Cloning (we have an alternative name as well Cloning Can Be a Code Smell)
02:17
12
2.2 - Don’t Emulate OOP
05:10
13
2.3 - Favor Small Functions
03:22
14
2.4 - Clever Code
05:24
15
2.5 - Floating Point Numbers
04:16
16
2.6 - Platform & Feature Specific Code
06:21
17
3.0 - TANSTAAFL (There Ain’t No Such Thing As A Free Lunch)
03:59
18
3.1 - YAGNI : You Ain’t Gonna Need It
04:35
19
3.2 - Domain Boundaries
04:51
20
3.3 - Taming Compile Times
02:51
21
The Best Practices Outro
04:32
Unlock unlimited learning

Get instant access to all 20 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription

Related courses

Frequently asked questions

What prerequisites should I have before enrolling in this Rust course?
Before enrolling in this course, a basic understanding of Rust programming is recommended. Familiarity with concepts like functions, iterators, and dependencies will help you grasp the best practices discussed. This course is aimed at those looking to refine their Rust development process, so prior experience with the language will be beneficial.
What specific tools will I learn to use in this Rust course?
The course covers several essential tools that enhance Rust development. You'll learn to use Clippy for linting, which helps in maintaining code quality, and explore dependency management, including checking for outdated dependencies and vulnerabilities. These tools are integral to ensuring that your Rust projects are robust and secure.
Does this course cover Object-Oriented Programming (OOP) in Rust?
This course advises against emulating Object-Oriented Programming (OOP) in Rust. Instead, it emphasizes Rust's strengths, such as favoring small functions and iterators. The course discourages OOP patterns, highlighting Rust's unique features and idioms that align more naturally with its design philosophy.
How does the depth of this course compare to other Rust courses?
This course is focused on best practices rather than introductory concepts. It assumes some familiarity with Rust and dives into effective development techniques, such as minimizing cloning and managing dependencies. The course targets those who have a foundational understanding of Rust and wish to optimize their coding practices.
What is the time commitment required for this Rust course?
The course consists of 21 lessons, each designed to be concise and focused on specific best practices. While the total runtime is not specified, the course is structured to allow for incremental learning, making it suitable for fitting into various schedules. Students can expect to invest time both in viewing lessons and practicing the concepts.
What career benefits can I expect from learning Rust best practices?
Learning Rust best practices can significantly enhance your software development skills, particularly in industries that value performance and safety, such as systems programming, blockchain, and embedded systems. Mastery of Rust's tooling and idioms can make you a more efficient and effective developer, increasing your value in tech sectors adopting Rust.
What topics are explicitly not covered in this Rust course?
The course does not cover foundational Rust programming concepts or comprehensive language syntax, assuming that students already possess basic Rust knowledge. It also doesn't delve into application-specific frameworks or advanced concurrent programming topics, focusing instead on general best practices applicable across various Rust projects.