Rust training

I offer innovative and effective training to help you and your team succeed with Rust. I offer training courses for Rust beginners and more experienced users, both open and private (corporate) training. Corporate training can be customised and tailored to your needs. I also offer coaching and mentoring for individuals and teams.

Open training is offered remotely in time zones friendly to Asia, Oceania, and the Americas. Training typically consists of structured presentations, exercises, Q&A using Slack, and/or small group discussions. Optional follow-up chat support is available. I'm currently offering a two-day, intermediate-level training: 'performance engineering using Rust', and a month-long beginner-level course of supported and directed learning. See below for more details and to book.

Corporate and bespoke training

Corporate training courses are the most effective way for teams to learn Rust or improve their use of it. Corporate training consists of training sessions dedicated and specialised for your teams and their needs. Training can be combined with expert support to give your team extended access to my expertise. Training can be adapted from the open trainings below or built new. You can choose the format, tools, material, etc. Training can be offered remotely in any timezone or on-site (subject to local regulations around visas, tax, etc.). I can cater to any level and a broad range of topics.

To learn more or discuss corporate training, get in touch to schedule a chat.

Current open courses

If these dates or times don't suit, I'll be offering them again in the near future, optimised for different time zones. Join my mailing list to keep informed of new dates. If you want them at your own convenience, in-person, or customised for your org, it can be done! Get in touch to discuss!

Performance engineering using Rust

An introduction to performance engineering and high-performance Rust code. This course covers essential background including modern systems architectures, and how that applies to program performance. I teach the tools, techniques, and cultural factors required for fast software. Ideally suited to programmers with little or no background in systems performance moving to Rust from high-level languages such as Go, Python or Java.

Racing cyclists
  • Level: intermediate Rust programmers, new to performance work in systems languages.
  • Dates: TBA (late August), time zone suitable for Oceania and Americas.
  • Duration: two days of tuition, with one day between and one follow-up day of online support (limited option to attend only the second day for Rust-specific content only).
  • Learning outcomes: you'll have an understanding of the fundamentals of performance (system design, algorithms, and the relative costs of IO, memory use, and compute) and how they apply to Rust programs; you'll be able to write high quality benchmarks and profile your Rust code; you'll know the key patterns and idioms for writing performant Rust code and understand why they're important.
  • To book or learn more: please contact me.

The course consists of two taught days, the first covers the fundamentals of performance engineering (using Rust for examples, etc.). The second day covers applying these fundamental principals when using Rust.

During the first day, I take a holistic view of performance engineering covering human and technical aspects. I'll cover designing for performance, prioritising performance, premature optimisation, and being data-driven; and on the technical side: computational complexity and algorithms, architecture of modern CPUs including caches, instruction pipelining and prediction, relative costs of IO, memory, and computation, and how all these things affect software performance. I'll also cover important tools and techniques for benchmarking and profiling.

On the second day, we get specific. We'll go over tools and libraries you'll use with Rust, understanding concepts such as allocation and data layout which have a big impact on Rust performance, and techniques such as buffering, iteration, and data-oriented design. We'll also cover making best use of parallel and asynchronous programming using libraries like Rayon and Tokio.

On both days, there will be breaks from teaching to put things into practice with exercises and experiments.

The course is designed for programmers with some Rust experience, but little experience with performance. The course is not suitable for experienced performance engineers who want to learn Rust. For engineers who have some performance experience in high-level languages and want to learn how to apply that in Rust, there is an option to attend only the second day (however, if you're an experienced C/C++ engineer with a strong background in performance, I don't expect even this option will be worthwhile).

Supported and directed learning: Rust for beginners

Learn Rust at your own pace and in your own style, with high-quality learning support and direction where you need it. We'll cover all the fundamentals required to get you started programming productively and effectively in Rust. You'll have four weeks in an innovative learning environment involving multiple teaching formats with varying degrees of interactivity and synchronicity.

  • Level: for those completely new to Rust, who have just started learning, or who have tried to learn and bounced off.
  • Dates: TBA (possibly October), time zone suitable for most of Asia, Oceania, and the Americas.
  • Duration: four weeks, part-time.
  • Learning outcomes: be able to write, read, and understand small or simple Rust programs, be confident in your ability to keep learning; appreciate idiomatic Rust code and best practices; understand Rust's strengths and be able to leverage them to write safe, fast code.
  • Bookings: coming soon...
Happy baby wearing a Rust onesie

This course will cover the fundamentals of Rust. Since the course is mostly self-directed, you'll cover more or less depending on your time commitment. Detailed curriculum coming soon.

Each week I will provide recommended learning goals, pointers to resources to learn from, and exercises. There will also be a mini-project towards the end of the course for which you'll receive detailed feedback. Each week there will be an hour-long talk/lecture (with lots of opportunities for questions) to give you a deeper understanding of important topics. You'll also be able to attend a small-group discussion/office hour each week. You'll be able to ask questions about any topic (not limited to the curriculum) at any time via Slack, including during a daily hour with 'immediate' response. You'll also be able to discuss and share experiences with a motivated cohort of fellow learners.

Time commitment is flexible and up to you, a realistic minimum is 8 hours per week, recommended is 16 to 20 hours per week. You could even study full-time to make it your own Rust boot camp.

Courses coming soon

I'm currently developing more training material which will probably become the following courses. If you're keen to participate, please let me know so I can prioritise appropriately. You can join my mailing list to get notified when the courses are available. These courses can also be the basis for corporate training.

Rust ownership, borrowing, and lifetimes

Stop fighting the borrow checker! A deep dive into Rust's most unique (and sometimes confusing) aspect, ownership. By exploring this fundamental concept, you'll get a boost along Rust's learning curve, gain a thorough understanding of how Rust works, and learn to write effective and idiomatic Rust code.

Intermediate level, suits Rust programmers with two months to two years Rust experience. The course will cover:

  • The fundamentals of ownership, move semantics, and borrowing.
  • Generic lifetimes and lifetime elision.
  • Techniques for circumventing limitations imposed by the borrow checker.
  • Common lifetime errors, and how to understand and fix them.
  • Advanced topics such as the AsRef and Borrow traits, writing your own smart pointers, and ownership in the context of interoperating with C/C++.

Arriving early 2025. Duration and cost TBA.

Supported and directed learning: intermediate and advanced Rust

A similar teaching and learning style to the beginners course (above), but covering more advanced topics and with a bit more flexibility in what is covered.

Topics are likely to include:

  • async programming,
  • advanced traits,
  • exploring the standard library,
  • understanding ownership and borrowing,
  • some important crates from the ecosystem,
  • macros,
  • API design,
  • unsafe code.

Arriving mid-2025. Four week duration, cost TBA.