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.
Prerequisites
- 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, life-span declarations
- smart pointers, reference counting, mutable inner state
- 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)
- Mutexes and atomic reference counting
- Executors, thread pooling, futures
- Core affinity and NUMA
- inter-process communication via messaging services
- Event-Driven Programming in Rust
- Basic language constructs
- 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.
- Contract-based development in Rust
Interested?
Certification
The High-Performance Programming using Rust course is part of the