About the course
Our AI augmented Rust training course will give you the skills to develop high-performance software systems with the popular language that is giving C++ a run for its money.
This course aims to help you conquer the Rust language, balancing theoretical knowledge and hands-on practical experience.
You'll also learn to work effectively with AI assistance from your choice of LLM including ChatGPT, DeepSeek Coder, Gemini and Copilot to complement the learning process and boost your on-going projects - showing you how and when to trust AI on-the-spot clarifications, additional explanations, and coding assistance
This foundational Rust training course is available as part of a wider training programme or as a standalone workshop - we are happy to customise the syllabus to suit you and your team's learning goals, project requirements, and accommodate your preference for on-site / remote delivery.
-
- Understand the core philosophy of Rust, its unique memory safety guarantees, and effectively set up a productive Rust development environment.
- Leverage Large Language Models (LLMs) such as ChatGPT or Copilot for coding assistance, on-the-spot clarifications, and accelerating the Rust learning process.
- Write basic Rust programs using variables, fundamental data types, and essential control flow constructs (if-else, loops).
- Grasp Rust's unique ownership system, including concepts of move semantics, copying, and borrowing rules for safe memory management.
- Define and effectively use structured data with structs and enums to model real-world concepts.
- Work with common Rust collections, specifically Vectors, and understand basic usage of Strings and HashMaps.
- Implement basic error handling in Rust using the Result and Option enums for robust program design.
- Manage project dependencies and incorporate external libraries (crates) using Cargo.
- Apply foundational Rust programming concepts by completing practical exercises and a reinforcing mini-project.
- Possess a solid foundational understanding of Rust, enabling further exploration into systems programming, web development, or high-performance applications.
-
This 3-day intensive hands-on training course is perfectly suited for absolute beginners to programming or individuals with coding experience in other languages who are looking for a structured, practical, and comprehensive introduction to the Rust language and its unique paradigms. It is ideal for:
Anyone new to programming eager to learn Rust as their first language.
Developers from other languages (e.g., Python, JavaScript, Java, C#) interested in Rust's performance and safety features.
Aspiring systems programmers, web developers, or data engineers who need to build a strong foundational understanding of Rust.
Professionals interested in leveraging AI coding assistants to enhance their learning and development workflow in Rust.
-
No prior programming experience in Rust is required. Participants should have:
Basic computer literacy and comfort with navigating a graphical user interface (GUI).
Ability to install software on their computer (guidance will be provided if needed).
A logical approach to problem-solving.
Familiarity with general programming concepts (like variables, loops) will be beneficial but not strictly necessary as the course starts from fundamentals.
-
This Rust course is available for private / custom delivery for your team - face-to-face, on-site at your location of choice, or remotely via MS Teams or your own platform - get in touch to find out how we can deliver tailored training which focuses on your project requirements and learning goals.
-
Day 1: Rust Fundamentals and Basic Syntax
Introduction to Rust
Overview of Rust and its ecosystem: What Rust is, why it's gaining popularity (performance, safety), and its common use cases.
Setting up the Rust development environment: Installing Rust (using rustup), Cargo (Rust's build system and package manager), and choosing a code editor/IDE (e.g., VS Code with Rust Analyzer).
Understanding Rust's design philosophy and safety features: A high-level look at how Rust achieves memory safety without a garbage collector.
Basics of Rust Syntax
Variables, data types, and mutability: Declaring variables, understanding Rust's static typing, common data types (integers, floats, booleans, characters), and the concept of mut for mutability.
Control flow structures (if, else, match expressions): Making decisions and handling different cases.
Loops (loop, while, for): Repeating code blocks.
Day 2: Ownership, Borrowing, and Structured Data
Ownership in Rust
Concepts of ownership: Understanding the core rules of ownership, move semantics, and the stack vs. heap.
Copying and Cloning: Differentiating between moving, copying, and cloning data.
Understanding how Rust manages memory automatically through ownership rules.
Borrowing in Rust
References: Creating non-owning references to data.
Mutable and Immutable Borrows: Rules for allowing multiple readers or a single writer.
Understanding how borrowing ensures data safety and prevents data races.
Structs and Enums
Defining and using structs: Creating custom data types with named fields.
Implementing methods and associated functions: Adding behavior to structs.
Enums: Defining custom types that can be one of several variants.
Day 3: Collections, Basic Error Handling, and Simple Project Building
Common Collections
Working with Vectors: Creating, adding, accessing, iterating over elements in dynamic arrays.
Strings: Introduction to Rust's String and &str types and basic string manipulation.
Hash Maps: Very basic introduction to key-value pair storage.
Basic Error Handling
Understanding Result and Option enums: Rust's idiomatic way to handle recoverable errors and the possible absence of a value.
Using match expressions for basic error handling and pattern matching.
Simple use of unwrap(), expect(), ? operator (with caution explained).
Dependency Management and Simple Project Building
Cargo basics revisited: Adding a simple external crate (dependency) to your project.
Building a Simple Program / Mini-Project: A guided, hands-on exercise combining learned concepts (e.g., a simple command-line tool that takes input, processes data using collections, and handles basic errors).
Review key concepts, discuss next steps for learning, and reinforce the role of AI coding assistance in continued development.
Cross-Cutting Concerns (Integrated Throughout)
Emphasis on Memory Safety: Highlighted continuously through discussions on ownership and borrowing.
Error Handling: Practical application with Result and Option in exercises.
Real-World Applications: Examples and the mini-project will illustrate practical uses.
Code Quality and Best Practices: Brief discussions on idiomatic Rust and formatting (e.g., rustfmt).
AI Coding Assistance: Integrated throughout the learning process to demonstrate on-the-spot clarifications, additional explanations, and coding assistance, fostering interactive learning and problem-solving with tools like ChatGPT, Gemini, and Copilot.
-
Here are some key online resources for continuing your Rust learning journey after this course, especially with an eye towards leveraging AI tools:
The Rust Programming Language (The Book): The official and most comprehensive guide to Rust. Highly recommended for continued learning.
Rust By Example: A collection of runnable examples that illustrate various Rust concepts.
Rust Playground: An online tool to write, compile, and run Rust code directly in your browser.
Cargo Book: The official guide to Rust's package manager and build system.
Crates.io: The official Rust package registry, where you can find and publish open-source Rust libraries (crates).
Guides for Recommended IDEs/Editors:
Visual Studio Code (VS Code) with Rust Analyzer extension: A popular and highly capable setup for Rust development.
Search in VS Code extensions marketplace for "Rust Analyzer Extension"
IntelliJ Rust Rover IDE
Rustlings: Small exercises to get you used to reading and writing Rust code.
Large Language Models for Coding: Tools to assist your learning and development:
ChatGPT: https://chatgpt.com/
GitHub Copilot: https://github.com/features/copilot/
Google Gemini: https://gemini.google.com/
DeepSeek Coder: (Often available via specific IDE integrations or APIs).
Trusted by
