Video summary

Rust 2026: $400K Salaries, Java, AI & Why It's Not Everywhere (Yet) — Jon Gjengset Explains

Main summary

Key takeaways

Technology

Summary

Jon Gjengset discusses Rust’s design, industry adoption, developer tools, and the effects of AI on software engineering. The interview draws on analysis and personal experience rather than presenting a step-by-step tutorial or product review.

Why Rust—and why adoption is gradual

  • Rust aims to combine memory safety, performance, and ergonomics—a difficult balance for languages that rely on a runtime and garbage collector.
  • Rust remains highly admired but is used by a minority of developers. Gjengset attributes slow company adoption mainly to migration costs: retraining staff, maintaining existing code, porting components, and ensuring suitable libraries and expertise are available.
  • Large migrations are not automatically worthwhile. Rust may be a poor fit when a system relies heavily on C++ libraries or when a mature application already works reliably and rarely changes.
  • At AWS, Rust adoption grew from teams requesting it rather than from a top-down push. Gjengset worked on AWS’s Rust build system, including security and provenance integration, IDE support, and better build and test logs. He says Rust can help reduce startup and tail-latency issues associated with runtime-based languages.

Where Rust is used and how it compares

Gjengset identifies three areas with notable Rust adoption:

  1. Embedded development, where Rust offers a safer, more modern alternative to C and C++.
  2. Command-line tools, helped by the clap crate for building command-line interfaces.
  3. Safety-critical systems, including defense, automotive, and some space applications.

His comparisons emphasize different strengths:

  • Against Go: Rust’s richer type system can express more guarantees at compile time, reducing some runtime failures and making programs more expressive, though Rust is more complex.
  • Against C++: Rust’s strongest distinction is its ability to prevent many concurrency errors statically. C++ may still be preferable when a project depends extensively on complex C++ libraries.
  • Migration trade-off: Rust can offer safety and performance benefits, but the value must justify the cost of rewriting and maintaining the new code.

Borrow checker, types, and compiler tools

  • The borrow checker enforces rules about ownership, references, and lifetimes. Gjengset says learning this model is challenging but valuable: it helps programmers reason about data flow, object lifetimes, and program structure—even when working in languages that do not enforce those rules.
  • Rust’s type system can encode domain-specific constraints. For example, Gjengset describes a library for 3D coordinate transformations that uses types to prevent mixing coordinates from different reference frames. He argues that this kind of compile-time guarantee is difficult to represent in Python’s type system.
  • He praises Rust compiler error messages for being concise and helpful, while noting that some errors still require consulting documentation or the Rust book.
  • He considers Cargo a strong build and package tool, especially compared with tools in many other languages, though some advanced areas—such as flags and cross-compilation—can be confusing.
  • He notes ongoing pain points: compilation time, disk usage, and debugging and CI integration. Generic monomorphization and procedural macros can add build costs. Procedural macros can improve library ergonomics, but their compile-time overhead is a trade-off.
  • Rust interoperation is common through C-compatible interfaces, including Rust modules used by Python and Ruby. C++ interoperability is improving but remains less seamless; Java’s JNI route can also be cumbersome.

Hiring, salaries, and work choices

  • Gjengset says Rust job candidates include many junior developers but fewer senior engineers. Companies need experienced Rust engineers to establish projects and mentor newer hires.
  • He estimates that a senior Rust engineer in Norway might earn around 150,000 a year, while a senior role at Amazon in the U.S. could have total compensation around $400,000. He stresses that these are rough estimates and that U.S. compensation comes with higher expenses; European salaries and remote-work norms also differ.
  • He says he chose work partly based on its perceived positive impact. He finds crypto and blockchain technically interesting but is unconvinced by their real-world benefits. He sees Rust’s use in cryptography as a clearer safety-related application.

AI and software engineering

  • Gjengset thinks current AI tools are impressive at producing fluent outputs and reusing familiar patterns, but he is skeptical that they genuinely understand underlying concepts or reason reliably about unfamiliar systems.
  • He expects AI to help with repetitive, well-documented coding—such as common integrations with cloud services—while developers review the output. He is less confident about tasks requiring novel design or deep understanding of type systems and program structure.
  • He considers the impact on jobs uneven: routine work such as template creation may be more exposed, while novel research and complex engineering are less straightforward to automate. He encourages developers to treat AI as a tool that can increase their capabilities, while acknowledging that the disruption and risk are real.
  • Rust may be harder for code-generation models because correct Rust requires handling ownership and lifetimes, not merely producing code with familiar syntax.
  • For machine learning, Gjengset favors Python for research and rapid experimentation, and Rust for production systems where reliability and safety matter. He cites ONNX Runtime and Candle as ways to bridge research models and Rust-based production.

Rust community and ecosystem

  • Gjengset sees Rust’s evolution as broadly positive and says its direction is shaped more by community contributors than by corporate control.
  • He acknowledges frustrations with third-party crates that are useful but no longer actively maintained. He expects ecosystem maturity to improve with wider adoption.
  • He uses Neovim, preferring a terminal-centered workflow. He says he tried RustRover for about 30 minutes but had not found a reason to leave his existing setup. This is a brief personal impression, not a detailed review.
  • He closes by signing a copy of his book, Rust for Rustaceans.

Guides, reviews, or tutorials

  • No formal tutorial or step-by-step guide is presented; the interview includes explanations of Rust concepts, especially the borrow checker and compile-time type guarantees.
  • No in-depth product review is provided. RustRover is mentioned only in passing.

Main speakers and sources

  • Jon Gjengset — Rust educator, author of Rust for Rustaceans, and principal engineer at Helsing; discussed his experience at MIT and AWS and his views on Rust and AI.
  • JetBrains interviewer — asks the questions and introduces topics including Rust adoption, salaries, tooling, and AI.

Rate this summary

Your feedback will help improve summaries.

Improve this summary

Reprocess with a stronger model when the summary feels incomplete or inaccurate.

Pro

Translate summary in another language

Pro

Ask questions to this video

Chat for follow-up questions, clarifications, and source-backed answers.

Coming soon

Share this summary

Original video