The Rust logo in white on top of a photo of a rusty metal surface

2-3 days on-site or remote

Rust for the Web

Tobias Bieniek
Senior Frontend Engineer, Core teams member

Tobias is a long time Web engineer with experience across the full stack of modern web apps. He is a team leader of the Core Team.

anchorWorkshop overview

  1. What is Rust

    A quick intro into what Rust is, how it came to life and what its core values are.

  2. Installation

    We will go over Rust's main three CLI tools (rustup, cargo and rustc) and how to install them.

  3. Variables

    We will have a look at regular variables, immutable variables, constants, scoping, and shadowing.

  4. Basic Types

    In this stage we will take a look at Rust's fundamental types such as boolean, numbers, and characters.

  5. Functions

    If we only had variables, then applications would be somewhat boring. This stage will teach you all about writing reusable functions in Rust.

  6. Compound Types

    Rust not only offers built-in basic types, but also compound types like structs, tuples, enums and others which will be covered in this stage.

  7. Control Flow

    Besides if conditions, as well as for and while that most developers are familiar with, we will learn about topics like pattern matching and the built-in Option and Result enums in this stage.

  8. Error Handling

    This stage goes into depth on error handling, building on what was learned about the Result enum in the previous stage.

  9. Ownership and Borrowing

    The ownership and borrowing model is a significant aspect of Rust and the main reason for the security guarantees it makes. We will look at a few basic examples and exercises to ensure these basic rules and mechanisms are well understood.

  10. Documentation

    Rust has a built-in documentation generator and in this stage we will see how we can take advantage of that to document our own code.

  11. Testing

    Unit tests, integration tests, documentation tests... after this stage, participants will be able to write all of them with comfort.

  12. Strings

    Rust has a few different types of strings, and each serves a different purpose. This stage will give a basic understanding of when to use which type.

  13. impl

    During this stage, we will look at how to associate functions with structs, basically creating methods.

  14. Traits

    Traits are a little like interfaces in other languages in that they allow to define functions that are implemented by multiple different types. We will see how custom traits can be defined, what traits are built into the standard library, and how they can be automatically derived.

  15. Iterators

    for loops in Rust are more powerful than you might think. In this stage, we will implement custom iterators that can then be used in regular for loops.

  16. Generics

    Generic data structures and behaviors that work with a range of concrete types are a powerful mechanism for structuring code. This stage introduces Rust's generics and how to use them.

  17. Modules

    Putting all code in one file is not great, so Rust provides modules as a way to split and organize code. We will take a look at inline modules, file-based modules, visibility specifiers and other related concepts.

  18. Cargo

    Carge is Rust's build and package management tool. This part will explain the Cargo.toml file, how to add dependencies to projects, and finally how to publish crates to the public package registry.

  19. The std::fs module

    The Rust standard library provides a few APIs to interact with the file system. This stage covers reading and writing files, as well as performing other operations like copying files or creating folders.

  20. Macros

    This stage of the workshop will give a high-level overview of what macros are and how to leverage them for your own code.

  21. CLI

    Rust is great for building command line applications, not just because of the fast startup time, but also because the APIs in the standard library are well-thought-out and there are plenty of third-party crates that make developers' lives easier.

  22. Serialization and Deserialization

    In this stage we will take a look at how data can be serialized and deserialized between formats like JSON and regular Rust structs.

  23. Networking

    This section will give an introduction into building HTTP networking applications with Rust. At the end, you will have built your own simple HTTP server!

anchorCustomized to your team’s needs

We're happy to customize the workshop to precisely fit your team's needs. If you have concrete plans with Rust and are looking for guidance on specific topics, please don't hesitate to reach out to talk about what curriculum would be ideal for you and your team!

Three smiling team members looking at a laptop

Book this workshop

Our mentors look forward to working with your team and unlocking new capabilities.
Get in touch