Exploring Rust

Slide header

Expected Q2 2024

Introduction course to the Rust programming language for experienced software engineers.


The Rust programming language offers guaranteed memory safety: a tremendous benefit in security-critical or concurrency-heavy software systems. Still, Rust is a compiled language without garbage collection, and it offers zero-overhead abstractions as well as top-tier performance optimization possibilities. And if that is not enough in and of itself, Rust features an expressive, modern syntax and an excellent tooling ecosystem.

Even though the Rust programming language is relatively young, it has been stirring up the software engineering community for some years now. But is Rust fit for production? Can it be applied in any software engineering field? Is Rust hard to learn? Can Rust interact with my existing code base or hardware? Despite its age, Rust is being widely adopted in production environments, in small and large tech companies alike. Rust is definitely fit for production, and can be applied in a plethora of use cases, from embedded environments, systems programming environments up to web applications. Furthermore, there are plenty of possibilities to have Rust interact with other programming languages or hardware devices. Even though there’s excellent documentation on Rust and many related topics, a good preparation is recommended, as the learning curve for Rust can be quite steep.

As a software engineering business, it may be challenging to adopt a new tool like Rust. Preparing for such a process is important, and will determine the success of the adoption as a whole. In this intense, two half-days introductory training course, experienced software engineers will learn about the benefits the Rust programming language can offer, and how to proceed for successful adoption of the language.


  • Showcase the strengths of the Rust programming language,
  • Build a basic understanding of the Rust programming language,
  • Build an understanding of the application domains for Rust,
  • Learn how Rust compares to some of the prevailing programming languages in systems programming,
  • Identify potential obstacles when adopting Rust, and how to overcome them,
  • Provide the necessary knowledge to build a strong value judgment of the Rust language for production.


Experienced software engineers (any language will do). The focus of the course is the field of systems programming, so experience in this field is highly beneficial.


This course is provided in two afternoon sessions within two weeks (i.e. approximately 9 hours total).

Part 0

Course introduction: trainer and trainee introductions, learn about the layout and premise of the training.

Part 1

Introduction to Rust: in this part we will build an overview understanding of the Rust programming language; what are the main features and semantics, what are the application domains, and we introduce the tooling ecosystem around the language itself.

Part 2

Functional programming primer: as Rust firmly builds on concepts from function programming, it may sometimes alienate programmers that are unfamiliar with these concepts. In this (optional) part, we will make sure all trainees have a base understanding of the most common functional programming concepts.

Part 3

In-depth look at Rust: in this part we will dig deeper into the language. Using the overview understanding of the language acquired in the previous parts, we will be able to grasp the details of mechanisms like control flow structures, result and error handling, traits and generics, concurrency at large and unsafe Rust.

Part 4

The Rust tooling ecosystem: compared to other existing languages in systems programming, Rust has a very tightly integrated and rich tooling system to aid developers in their work. We will focus on the base tools, package ecosystem and standard library, as well as possibilities for augmenting the tool box with custom tools.

Part 5

Course recap and look forward: adopting Rust can be challenging, and is best approached strategically. In this part we will look at adoption strategies, potential hurdles and how to overcome them for successful adoption. Of course, we will also provide handles for further learning and development.

Large homework exercises

For those who are interested, there are a couple of larger homework exercises to choose from. Each of the exercises build up to a fully functional application in a number of smaller steps. These exercises are accompanied with explanation slides, solution code and extensive descriptions of the solution steps.

The large homework exercises are publicly available and can be found via this link.

High Tech Institute

This training is provided through High Tech Institute, more information here.