Course Description

The Ultimate Rust Foundations class starts with an introduction to Rust, and why you benefit from using – both as a foundation, and within your existing ecosystem.

Course Outline

• Rust includes Cargo, a swiss-army knife tool that can:
• Using Rust without Cargo
• Rust’s Safety Guarantees
• “Hello World” application – the foundation of most languages.
• Arrays, vectors and slices.
• Strict types and strong typing.
• Serializing and De-Serializing data.
• Iterative Programming – using iterators to combine operations.
• Working with Strings
• Protection from data races
• Easy multi-threaded concurrency with Rayon
• Ultimate control with raw threads
• High-performance Input/Output with Asynchronous design and Tokio.
• Build a CPU bound program with Rayon, and use all of your CPU power.
• Manage raw-threads and shared data.
• Spin up a simple server in 10 minutes.
• The classic Object-Oriented Programming example of different objects printing different text – but with traits.
• Designing a simple generic function with ToString.
• Stacked traits – traits that depend upon one another, combined with generic programming.

Course Description

Rust doesn’t have to be an all or nothing proposition. Rust is very good at sliding into an existing platform, allowing you to focus on optimizing – both for speed and safety – the parts that matter without throwing away all of your existing hard work.

Course Outline

• Introducing FFI, the Foreign Function Interface.
• Consuming a C library from Rust:
• From C to Rust:
• Calling Go from Rust
• Building a Rust FFI Crate
• Consume the Rust crate from C
• Consume the Rust crate from Go
• Managing Your Build Process – Practical Observations
• Porting Parts to Rust
• Build an HTTP authentication service with Actix in under 200 lines of Rust.
• Build an efficient, binary protocol server with Tokio.
• Combining asynchronous high-performance I/O with CPU-bound computation.
• Event tracing
• Use a Unikernel to host a Rust service as a single-purpose virtual machine.
• Use WebAssembly (WASM) to host high-performance code in the browser.
• Build without a standard library for embedded targets

Course Description

The Rust compiler catches many bugs for you that are common in other languages. Use the tools to avoid bugs and use Rust’s error system to pass meaningful errors and handle them appropriately.

Optimizing Rust

• Measure First: the importance of knowing what to optimize
• Use Rust’s built-in benchmark system to test component performance.
• Use a Profiler to find hotspots.
• When NOT to optimize
• Optimize the Algorithm First
• Optimization levels, Safety, Link Time Optimization.
• Understanding your cache: When Optimizing for Size is faster than Optimizing for Speed.
• Using unsafe safely.
• Profile-Guided Optimization.
• Compiler hints and inlining.
• Tracing distributed components
• Is your microservice too micro?
• Blocking Operations
• Waiting for Databases, File and Network I/O
• Fast, Efficient Logging

Debugging Rust

• Using your tools
• Debugging with println statements.
• Faster printing: tracing with tokio, and fast logging.
• Types of bug
• Attaching a debugger
• Unit testing to avoid bugs in the first place.
• Use Rust’s error system to pass meaningful errors—-and handle them appropriately.
• Avoiding Bugs with the Rust Type System.
• Strong Types, compile-time checking.
• Strong Types, run-time checking.
• Floating point errors.
• Unicode errors.
• Type-conversion errors.
• Always test in debug mode to catch overflow and out-of-bounds errors.
• Memory Issues
• Great Documentation with Rust.
• Integration testing with library examples.