Rust Programming is a foundation course in the Rust language, from Cargo, ownership, borrowing, structs, enums, traits and error handling to asynchronous code with Tokio. It suits developers who want to build web services in Rust and backend developers looking for a fast, memory-safe language, and you leave able to build a web API with Axum and PostgreSQL.
Rust delivers performance on a par with C and C++ while preventing memory errors at compile time, without a garbage collector. That is why it is increasingly used for systems work, command-line tools and backends that need both speed and stability. Beginners, however, often get stuck on ownership, borrowing and lifetimes, ideas that other languages do not have, and never get as far as building something real.
This course lays the foundations of Rust with the 2024 edition: Cargo, data types, ownership and borrowing, structs, enums, pattern matching, error handling, traits, generics and iterators, together with the code quality tools Clippy and rustfmt. Learners then put it all to work in a real web API with Tokio and Axum, connect to PostgreSQL with SQLx and add user accounts and authentication, before closing with a workshop that builds a RESTful service running on Docker. (2 days, 6 hours per day, 12 hours in total, Beginner-Intermediate level.)
Course Details
This course is a 2026 edition that replaces the previous Rust Programming course, which taught Actix Web with Diesel. It has been rewritten for the Rust 2024 edition. It runs for 2 days, 6 hours per day (12 hours in total, 09:00-16:00), as lectures with labs. Beginner-Intermediate level. Day one builds solid language foundations, especially ownership, borrowing and error handling. Day two builds a real web API with Tokio, Axum 0.8 and SQLx with PostgreSQL on Docker, including authentication and testing. Every lab runs on the learner's own machine with open source tools. Learners take home a lab guide, sample code for every lab and the RESTful service project from the workshop.
Section 1: Lab: Getting Started with Rust and Cargo
Section 2: Data Types and Control Flow
Section 3: Ownership, Borrowing and Lifetimes
Section 4: Lab: Structs, Enums and Pattern Matching
Section 5: Systematic Error Handling
Section 6: Lab: Traits, Generics, Closures and Iterators
Section 7: Modules, Crates and Testing
Section 8: Async with Tokio
Section 9: Lab: A Web API with Axum
Section 10: Lab: PostgreSQL with SQLx
Section 11: User Accounts and Authentication
Section 12: Workshop: A RESTful Service with Docker
Rust manages memory through ownership: each value has one owner at a time, and when the owner goes out of scope the memory is freed immediately, with no garbage collector. To let other code use a value without moving ownership, you borrow it through references: many read-only references (&T) or a single mutable reference (&mut T) at once. The compiler enforces these rules, preventing data races and dangling pointers before the program ever runs.
Cargo is Rust's project and package manager. You create a project with cargo new, check code quickly with cargo check, run it with cargo run, compile for production with cargo build --release and test with cargo test. External libraries, called crates, are listed in Cargo.toml and Cargo downloads them from crates.io. cargo fmt formats code, cargo clippy points out code that could be improved and cargo doc generates documentation from code comments.
Add tokio, axum, serde and sqlx to Cargo.toml, then write an async main function that creates a PostgreSQL connection pool and runs the migrations. Build a Router that binds routes to handlers and share the pool with every handler through State. Each handler takes its input through extractors such as Path or Json, reads or writes data with SQLx's query! macro, which checks the SQL at compile time, and returns JSON with the right status code.
It suits developers who want to build web services in Rust, backend developers who use another language and want something faster and safer, people who want a language focused on performance and memory safety, and systems engineers who want to write tools that work closer to the system. You should be able to program in at least one language and understand web basics such as HTTP, JSON and REST APIs.
You will be able to write Rust with a sound grasp of ownership, borrowing and lifetimes, design code with structs, enums, traits and generics, handle errors systematically, manage projects with Cargo, Clippy and tests, write async code with Tokio, build web APIs with Axum, connect to PostgreSQL with SQLx, add user authentication and package a service as a Docker image. Participants who complete the training receive a Certificate of Completion with its own number, which can be verified online.
Yes. It can be run in-house for your team, with examples adapted to your own work, such as building a Rust RESTful service around data or systems your team already manages. You can request a quotation from this page, or contact us on LINE @itgenius or by phone on 02-570-8449.
The data that organisations and researchers collect, from customer records and sales to surveys and exam results, holds many hidden patterns. Data mining is the work of finding those patterns to make predictions, group similar records or uncover…
Much of the work in organisations that run Oracle Database involves multi-step data processing, such as payroll calculations, end-of-day closing or moving data between tables. Written as one SQL statement at a time from the application side, this work is…
ASP.NET Core is Microsoft's main framework for building web applications and APIs on .NET, and it runs on Windows, macOS and Linux. Today .NET 10 is the LTS release that organisations choose for the long term, yet many books and code samples still follow the…
