High-Performance Computing In Rust

Why? Rust is increasingly used as a safe alternative to C++, particularly for systems, embedded and network programming as well as IoT and scalable web and micro-services. It is a fast memory-efficient multi-paradigm programming language with a modern compact syntax, provides safe and efficient memory management and concurrency, support for abstraction (e.g. via traits) and generics, solid package management. excellent library within a natively compiled language which does not use garbage collection.

For whom is the course?

  • Software developers who would like to learn how to write quality code in Rust.
  • Lead Developers who want to be able to provide guidance in software development projects which use Rust as one of the technologies.
  • Software Architects who would like to understand the benefits and risks around using Rust for high-performance systems.


  • Course attendees should have programmed in another programming language.

Course Content

  • Understand the capabilities, benefits and uses of Rust
    • the Rust Eco System and the core language features of Rust
    • the relative benefits of using Rust compared to other programming languages and when to consider using Rust.
  • Program in Rust
    • Basic language constructs
      • data types, scoping, flow control flow
      • basic and generic functions
    • Safe and efficient memory usage
      • data ownership, borrowing and slicing
      • smart pointers
    • Object-oriented programming
      • including structures, classes, methods, traits, polymorphism and inheritance
    • Functional programming
      • pure and higher order functions, closures, replacing iteration with recursion and lazy evaluation in Rust
    • Exception and error handling
      • errors versus exceptions
      • functions not provided unconditionally
      • raising exceptions by returning error codes
      • handling, partially handling, forwarding and mapping errors
      • panicking on unrecoverable errors
    • IO
      • Console, file and network streaming
    • Concurrency in Rust
      • Spawning and joining threads
      • Inter-thread communication (shared state and data transfer)
      • Executors, thread pooling, futures
      • Core affinity and NUMA
      • inter-process communication via messaging services
  • Organizing code and facilitating distribution and reuse
    • Packaging executables and libraries into crates
    • Modularization for name spaces and scope management
    • Generating API documentation
  • Assessing and managing code quality
    • Contract-based development in Rust
      • Defining contracts and using them for test logic
      • Unit testing by combining test logic with equivalence partition based test data
      • Integration and operational testing
    • Writing tests, tests across levels of granularity, controlling test execution, and mocking frameworks for Rust
    • Enforcing coding standards for simpler, safer and more maintainable code.



The High-Performance Programming using Rust course is part of the

Scroll to Top