Rust Engineers Reject Hybrid Codebases to Demand Total System Rewrites

Kai Lentit

While advocating for total system oxidation and elite memory safety, developers ultimately abandon Rust in favor of Gluon.

AI-assisted summary of Interview with Senior Rust Developer — original source. Check the original for full context.

Source published: 2023-07-01

Key ideas

The senior developer frames Rust adoption around inverting pragmatic software advice into 'choose the right job for the tool,' pointing to Microsoft telemetry that 70% of vulnerabilities stem from memory safety defects. (0:00)
Rust classifies memory leaks—such as those produced by std::mem::forget—as memory-safe behavior because leaking unreferenced resources prevents memory corruption, even if it leads to OS-level resource exhaustion. (2:30)
The commercial Rust hiring landscape remains heavily concentrated in speculative blockchain and cryptocurrency startups characterized by rapid turnover and frequent bankruptcy. (5:00)
Idiomatic patterns for shared ownership and error extraction often degenerate into heavy boilerplate, requiring deep wrapper nesting like Option<Rc<RefCell<T>>> and repeated method chaining with .into() and .unwrap(). (7:15)

Detailed notes

## Background Published by Kai Lentit on YouTube on July 1, 2023, the video presents an interview with a senior Rust developer named Jester Hartman. The page description frames the piece as developer humor and satire exploring Rust memes, language quirks, traits, and the infamous unsafe command.

## TL;DR In this deadpan parody, an uncompromising senior Rust developer extols the absolute superiority of the language, equating personal self-worth to prevented CVEs while dismissing all other programming ecosystems. He humorously defends Rust's infamous steep learning curve and verbose syntax, explaining how he replaces unsafe code with a `trust_me!` macro, considers memory leaks completely safe, and insists on rewriting everything from operating systems to the color blue. The discussion touches upon the ecosystem's reliance on doomed crypto startups, endless crate dependency trees, and deeply nested types like `Option<Rc<RefCell<T>>>`. After haughtily gatekeeping the language as a tool strictly for the elite, he subverts his entire dogmatic monologue by casually confessing that his team actually uses Gluon.

## Atmosphere & style The video delivers a dry, deadpan mockumentary vibe where tech elitism is cranked up to farcical heights with completely straight-faced delivery. The dynamic pits an inquisitive interviewer against a zealously dogmatic developer whose unyielding arrogance only amplifies the underlying absurdity. It feels like an affectionate inside joke for software engineers, blending sharp, accurate technical observations with an escalating narrative of cultish developer obsession.

## Bulletin - [00:00](https://www.youtube.com/watch?v=TGfQu0bQTKc&t=0s) The senior developer frames Rust adoption around inverting pragmatic software advice into 'choose the right job for the tool,' pointing to Microsoft telemetry that 70% of vulnerabilities stem from memory safety defects. - [02:30](https://www.youtube.com/watch?v=TGfQu0bQTKc&t=150s) Rust classifies memory leaks—such as those produced by std::mem::forget—as memory-safe behavior because leaking unreferenced resources prevents memory corruption, even if it leads to OS-level resource exhaustion. - [05:00](https://www.youtube.com/watch?v=TGfQu0bQTKc&t=300s) The commercial Rust hiring landscape remains heavily concentrated in speculative blockchain and cryptocurrency startups characterized by rapid turnover and frequent bankruptcy. - [07:15](https://www.youtube.com/watch?v=TGfQu0bQTKc&t=435s) Idiomatic patterns for shared ownership and error extraction often degenerate into heavy boilerplate, requiring deep wrapper nesting like Option<Rc<RefCell<T>>> and repeated method chaining with .into() and .unwrap().

## Key takeaways - [00:00](https://www.youtube.com/watch?v=TGfQu0bQTKc&t=0s) Rust developer philosophy subverts standard engineering pragmatism by asserting that projects should be adapted to the language rather than selecting the best tool for the job. - [00:00](https://www.youtube.com/watch?v=TGfQu0bQTKc&t=0s) Microsoft security telemetry attributing 70% of all CVEs to memory corruption is cited as justification for replacing developer discretion with the borrow checker. - [00:00](https://www.youtube.com/watch?v=TGfQu0bQTKc&t=0s) Rust's strict aliasing model is pedantic enough that its compiler has exposed long-standing optimization bugs inside LLVM itself. - [00:00](https://www.youtube.com/watch?v=TGfQu0bQTKc&t=0s) The Rust ecosystem exhibits an engineering imbalance in gamedev, resulting in an estimated 50 game engines supporting only five completed games. - [02:30](https://www.youtube.com/watch?v=TGfQu0bQTKc&t=150s) Developers create satirical workarounds like a trust_me! macro to bypass compiler restrictions via the unsafe keyword. - [02:30](https://www.youtube.com/watch?v=TGfQu0bQTKc&t=150s) Rust's design philosophy blends concepts from dozens of disparate languages, prioritizing absolute memory safety over code readability. - [02:30](https://www.youtube.com/watch?v=TGfQu0bQTKc&t=150s) Dropping destructors and leaking memory is officially considered safe in Rust, as leaking does not generate undefined behavior or invalid pointer dereferences. - [05:00](https://www.youtube.com/watch?v=TGfQu0bQTKc&t=300s) Community dispute resolution in Rust projects frequently suffers from prolonged stagnation, with GitHub issues lingering for years until project owners step down. - [05:00](https://www.youtube.com/watch?v=TGfQu0bQTKc&t=300s) A substantial portion of the Rust ecosystem consists of rewrite projects designed to clone established tooling from other languages, such as Zola, Deno, and Sniffnet. - [05:00](https://www.youtube.com/watch?v=TGfQu0bQTKc&t=300s) The commercial Rust job market is dominated by short-lived Web3 and blockchain startups that frequently shut down within a year. - [07:15](https://www.youtube.com/watch?v=TGfQu0bQTKc&t=435s) Proponents of Rust often reject incremental adoption or hybrid kernels, instead advocating for complete ground-up rewrites of legacy platforms. - [07:15](https://www.youtube.com/watch?v=TGfQu0bQTKc&t=435s) Rust culture actively indulges in elitism and gatekeeping, expecting newcomers to already possess fluency in functional paradigms like Haskell or OCaml. - [07:15](https://www.youtube.com/watch?v=TGfQu0bQTKc&t=435s) Handling complex ownership graphs necessitates awkward wrapper types such as Option<Rc<RefCell<T>>> combined with exhaustive chains of .unwrap() and .into().

## Detailed walkthrough ### [00:00](https://www.youtube.com/watch?v=TGfQu0bQTKc&t=0s) The Superiority Complex: Memory Safety, CVEs, and Game Engines

The interview opens with a parody of Henry Ford: “Well, as Harrison Ford once said, if we would have asked the people what they wanted, they would have asked for a faster C++.” The senior Rust developer explains that his journey into Rust began with an absurdly ambitious goal—wanting to write an operating system in three weeks. His initial instinct was to write his own systems programming language, but he reconsidered because he thought that would be too complicated for people to understand. Then he discovered Rust, and now he simply does not mind that it is too complicated for people. Dismissing the common pragmatic advice to “choose the right tool for the job,” he declares the Rust community’s true motto: “In the Rust community, we say, choose the right job for the tool.” Whenever he looks at a C++ developer, all he sees is a “future Rust dev.”

```mermaid flowchart TD accTitle: Memory Handling Across Languages accDescr: Comparison of how different languages manage memory headaches versus Rust's borrow checker. subgraph Traditional["Other Languages"] CPP["C++: Memory Errors"] JAVA["Java: Garbage Collector"] HASK["Haskell: Clone Everything"] JS["JavaScript: Just Worry About JS"] end subgraph RustWay["The Rust Paradigm"] RUST["Rust: Borrow Checker"] end CPP -->|"manual pointers"| RUST JAVA -->|"stop-the-world pauses"| RUST HASK -->|"infinite allocations"| RUST JS -->|"existential dread"| RUST ```

His metric of personal self-worth is strictly tied to prevented CVEs and Pwnie Awards. Citing Microsoft telemetry showing that roughly 70% of all security vulnerabilities stem from memory safety bugs, he contrasts how different ecosystems handle memory. In C++, developers constantly sweat over outright memory corruption; in Java, they worry about garbage collection pauses; in Haskell, they naively clone everything as if system resources were infinite; and in JavaScript, you simply panic because you have to write JavaScript. Rust eliminates memory safety worries by replacing them with the borrow checker. When asked which parts of a software stack he rewrote in Rust—front end or back end—he bluntly answers, “No, the browser.” To enforce discipline, he claims to have authored a custom fork of the Rust compiler with stricter error handling that literally tasers the programmer upon encountering a compilation error.

- Rewriting targets include abstract concepts: he is currently working on rewriting the color blue into Rust. - Rust's aliasing tracking is so pedantic that it actually uncovered bugs inside LLVM itself. - Acknowledged disadvantages: the compiler assumes the human developer cannot track object lifetimes in their head, and there is zero emotional reward when untangling massive Cargo dependency graphs. - State of the ecosystem: “There are currently five games written in Rust and 50 game engines.” - Highlighting frontend tooling performance, he praises Turbopack as being 20 times faster than JavaScript-based bundlers, calling it prime undercover marketing for Rust.

---

[02:30](https://www.youtube.com/watch?v=TGfQu0bQTKc&t=150s) Memory Management, the `trust_me!` Macro, and Safe Leaks

The conversation shifts toward developer mindset and language mechanics. In Rust, testing is deemed inherently cheaper “because we’re all geniuses,” and developers must learn to view the compiler not as an adversary, but as a caring friend assisting them through their own stupidity. Navigating classic data structures like doubly linked lists requires unlearning bad programming habits imported from inferior languages. For moments when the developer wants to bypass the compiler’s safety guarantees, he shares his personal shortcut: “I actually have a macro for the `unsafe` command. It's called `trust_me!`.”

When pressed on language terminology, he explains the concepts of traits and lifetimes. When the interviewer innocently compares traits to Java interfaces, the developer immediately cuts him off, snapping: “Yeah, we don't mention Java in here.” Rust’s design philosophy is described as taking every individual advantage from every programming language and mashing them together into a single syntax: “Now your code is unreadable, but it's memory safe.”

He also clears up common misconceptions around memory management and crashes. In Rust, memory leaks are explicitly not considered unsafe: dropping destructors without running them via functions like `std::mem::forget` is entirely memory-safe because leaked memory is never referenced again, meaning no memory corruption occurs. While the process might crash if the operating system runs out of physical memory, that is a resource exhaustion issue, not undefined behavior. Regarding language evolution, breaking changes are quarantined into multi-year editions (2015, 2018, 2021), while he proudly brandishes a fictitious “Rust 2023 Signature Edition” allegedly autographed by Rust creator Graydon Hoare himself.

---

[05:00](https://www.youtube.com/watch?v=TGfQu0bQTKc&t=300s) Async Runtimes, Ecosystem Clones, and Blockchain Startups

Addressing real-world drama in the ecosystem, the developer touches on the Tokio runtime fiasco involving dropped `JoinHandle` instances from spawned asynchronous tasks. In his view, there are only two schools of thought on task cancellation: “Some think the task should be aborted. The others don't really think at all.” He asserts that Rust sits unchallenged at the absolute peak of software engineering across systems programming and functional paradigms alike, noting that while the C++ community might boast higher numbers, their cult is far less organized than Rust's. Community issue resolution has its own unique lifecycle: “When Rust users find a bug, they complain about it and GitHub issues for two years before the project owner steps down.”

He contrasts standard programming tutorials with the official Rust documentation: while tutorials in other languages conclude with a trivial Cookie Clicker clone, Rust’s introductory materials end with building a multi-threaded, high-performance web server from scratch. Turning to the job market, he admits that the vast majority of Rust openings are concentrated in speculative cryptocurrency startups: “Yeah, there are a lot of jobs for Rust. Most are for startups to do some blockchain stuff and then go bankrupt in a year. I joined a couple of startups like that in the past months.” He champions the modern software architecture pattern of creating a single Rust monorepo and generating foreign-function interface (FFI) bindings for every other programming language. Expressing an urge to publish his own biological DNA as an open-source crate, he laments that he is blocked solely by Crates.io’s strict 10-megabyte package upload limit.

---

[07:15](https://www.youtube.com/watch?v=TGfQu0bQTKc&t=435s) Elite Gatekeeping, Syntax Boilerplate, and Full Oxidation

The developer explains why software teams should abandon piecemeal adoption in favor of total ground-up rewrites. While advocates promote hybrid incrementalism within kernels, he insists on rewriting entire systems outright—revealing he is currently rewriting Microsoft Windows in Rust to give the operating system some much-needed credibility. He insists there will never be a Rust 2.0 release because the language is already flawless, mocking Python for taking fifteen years just to introduce pattern-matching `case` statements: “You don't adapt the program to the language in Rust. You adapt the language to the program. We decided to make everyone equally unhappy.”

```mermaid flowchart LR accTitle: The Rust Type Wrapper Pipeline accDescr: Visualizing the deep nesting of wrappers and unwraps common in Rust code. subgraph Types["Nested Type Definitions"] O["Option"] --> R["Rc"] --> RC["RefCell<T>"] end subgraph Extraction["Method Chaining Unwrap"] RC -->|"into()"| I["inner()"] -->|"unwrap()"| VAL["Concrete Value"] end ```

He claims Rust is remarkably simple to pick up, mentioning that he is currently drafting a beginner’s introductory tutorial—tailored specifically for readers who are already fluent in Haskell or OCaml. When it is pointed out that almost no mainstream programmers know Haskell, he dismisses them outright: “Come back after you learn Haskell. Normie. We didn't say it's a programming language for everybody, just for the elite.” Rust’s core marketing pitch of picking reliability, speed, and productivity is amended to simply “Pick four.”

- Contrasting Rust with Java through gaming metaphors, he notes that while Java has *Pokémon GO*, Rust has *Pokémon Rust*—where players do not catch Pokémon, but instead capture random runtime exceptions. - He mocks the boilerplate ritual of chaining conversions and error unpacks: `.into().into().into()`, `.inner()`, and `.unwrap().unwrap().unwrap()`. - Complex nested pointer types like `Option<Rc<RefCell<T>>>` are defended as the pinnacle of clean, readable code. - He concludes that he has become “fully oxidized,” with Rust serving as his job, his hobby, his personal ideology, and his avatar profile picture. - Declaring that Rust has permanently halted the endless cycle of web languages—ending JavaScript, TypeScript, CoffeeScript, and MochaScript—he casually undermines his entire thesis in the final seconds: “Actually, we don't use Rust, we use Gluon.”

## Mentioned Bitcoin, C++, Cargo, CoffeeScript, Cookie Clicker, Crates.io, Deno, GitHub, Gluon, Go, Goscript, Graydon Hoare, Harrison Ford, Haskell, Henry Ford, Hugo, Java, JavaScript, Jester Hartman, Kai Lentit, LLVM, Microsoft, Microsoft Windows, MochaScript, Node.js, OCaml, Pokémon GO, Pokémon Rust, Pwnie Awards, Python, Rust, Sniffnet, Solana, Tokio, Turbopack, TypeScript, Wireshark, Zola

## Video description Rust programming language

Full version on patreon Merch posix.store

Interview with a Rust developer with Jester Hartman - aired on © The Rust. Find more Rust opinions under: Full version on paah.vhx.tv

Programmer humor Rust humor Programming jokes Programming memes Rust yew Rust memes Rust jokes unsafe command future traits

#programming #jokes #Rust

[Source](https://www.youtube.com/watch?v=TGfQu0bQTKc)

中文简报

Rust工程师拒绝混合代码库并要求全系统重写开发者在鼓吹全系统Rust化与极致内存安全的同时，最终却弃用Rust转向Gluon。在这则冷幽默讽刺中，一位态度强硬的资深Rust开发者极力推崇该语言的绝对优越性，将个人自我价值与成功规避的CVE漏洞划上等号，同时贬低所有其他编程生态。他诙谐地为Rust出了名的陡峭学习曲线和冗长语法辩护，解释自己如何用`trust_me!`宏替换unsafe代码、将内存泄漏视为绝对安全，并坚称从操作系统到蓝色本身的一切事物都必须重写。讨论还提及该生态系统对注定失败的加密货币初创公司的依赖、无休止的crate依赖树，以及像`Option<Rc<RefCell<T>>>`这样深度嵌套的类型。在傲慢地将这门语言把守为专属于精英的工具后，他却轻描淡写地承认自己的团队实际上在使用Gluon，彻底颠覆了整场教条式的独白。这位资深开发者将采用Rust的过程描述为把实用的软件建议反转为“为工具选择合适的工作”，并指出微软遥测数据显示70%的漏洞源于内存安全缺陷。 (0:00) Rust将内存泄漏（例如由std::mem::forget产生的泄漏）归类为内存安全行为，因为泄漏未引用的资源可以防止内存损坏，即使这会导致操作系统层面的资源耗尽。 (2:30) 商业Rust招聘领域仍然高度集中在投机性的区块链和加密货币初创公司，这些公司的特点是人员流动迅速且经常破产。 (5:00) 用于共享所有权和错误提取的惯用模式往往会退化为繁重死板的样板代码，需要深层的包装嵌套（如Option<Rc<RefCell<T>>>）以及通过.into()和.unwrap()进行反复的方法链式调用。 (7:15)

Reading summary

In a satirical interview published by Kai Lentit, a senior Rust developer argues for Rust's absolute superiority in systems programming, asserting that compile-time memory safety justifies extreme syntactic complexity, an aggressive rewrite culture, and an uncompromising developer mindset. Memory Safety and Rewriting Existing Tooling (0:00) The developer justifies the Rust ecosystem's dogmatism by citing Microsoft telemetry indicating that roughly 70% of security vulnerabilities stem from memory safety bugs. In his view, Rust's borrow checker eliminates the distinct memory failures of other languages, such as manual pointer corruption in C++, garbage collection pauses in Java, and infinite cloning in Haskell. He points out that Rust's aliasing tracking is rigorous enough to have exposed underlying bugs within LLVM itself. Rather than adopting tools to fit problems, the developer embraces an ethos of rewriting existing software entirely in Rust. He points to frontend performance benchmarks, noting that the Rust-based Turbopack runs 20 times faster than JavaScript bundlers. However, he acknowledges significant friction in the ecosystem, including the emotional toll of untangling massive Cargo dependency graphs and an ecosystem imbalance currently skewed toward infrastructure over finished products, citing a landscape of 50 game engines to only five completed games. Language Semantics, Unsafe Overrides, and Leaks (2:30) Addressing core mechanics, the developer describes Rust's design as an amalgamation of features from across programming paradigms that prioritizes memory safety over immediate readability. Developers are expected to unlearn traditional data structure patterns, such as doubly linked lists, to satisfy the compiler's strict lifetime rules. For instances where manual intervention is required, he jokes that he wraps the language's `unsafe` keyword in a custom macro labeled `trust_me!`. The developer also clarifies technical boundaries regarding memory management, noting that memory leaks are safe under Rust's model. Employing functions such as `std::mem::forget` skips destructors without triggering undefined behavior because leaked memory is never re-referenced. While severe leaks risk exhausting physical memory and causing operating system crashes, they do not violate memory safety guarantees. To manage evolution without fracturing the ecosystem, breaking changes are strictly partitioned into multi-year editions (2015, 2018, and 2021). Async Runtime Debates and Blockchain Employment (5:00) Turning to community dynamics, the developer touches on unresolved debates within asynchronous runtimes, specifically referencing controversy surrounding Tokio and whether dropped `JoinHandle` instances should automatically abort spawned tasks. He contrasts standard tutorial outcomes across languages, noting that while other ecosystems culminate in basic clicker games, Rust's foundational materials task beginners with building a multi-threaded web server. He highlights several high-profile Rust replacements of incumbent technologies, including Zola for Hugo, Deno for Node.js, Sniffnet for Wireshark, and Solana for Bitcoin. When discussing career prospects, he frankly admits that despite high demand, commercial Rust jobs remain disproportionately concentrated in speculative cryptocurrency and blockchain startups that frequently face bankruptcy within a year of launch. Syntactic Boilerplate, Gatekeeping, and Full Rewrites (7:15) The developer dismisses incremental adoption models, advocating instead for ground-up rewrites of entire platforms, including Microsoft Windows. He defends Rust's verbose and nested type structures—such as wrapping types in `Option<Rc<RefCell<T>>>` and navigating them through long chains of `.into()`, `.inner()`, and `.unwrap()` calls—characterizing deep boilerplate as the natural cost of guaranteed memory correctness. Openly gatekeeping the language, the developer claims Rust is straightforward primarily for programmers who already possess deep fluency in functional languages like Haskell or OCaml. He scoffs at mainstream adoption efforts and claims Rust has permanently halted the churn of web languages, summarizing his identity as being 'fully oxidized' before ironically undercutting his own narrative by disclosing that his team actually writes their software in Gluon. The interview presents an exaggerated parody of the Rust community's obsession with memory safety, zero-cost abstractions, and systemic rewrites. While highlighting legitimate technical strengths such as compile-time checks and tooling performance, it satirizes the language's steep learning curve, insular elitism, and heavy reliance on blockchain venture capital.

精炼阅读摘要

在 Kai Lentit 发行的访谈节目中，一位资深 Rust 开发者以讽刺幽默的方式剖析了 Rust 社区的技术优越感、借用检查机制与生态现状，强调 Rust 虽以复杂的类型系统与陡峭的学习曲线著称，却通过内存安全根治了底层漏洞。内存安全与借用检查的核心价值 (0:00) 该开发者指出，微软遥测数据显示约 70% 的安全漏洞源于内存安全缺陷。与其他语言相比，C++ 开发者受困于内存损坏，Java 面临垃圾回收停顿，Haskell 依赖过度克隆，而 JavaScript 则充斥着开发痛点。Rust 通过编译期的借用检查器（borrow checker）替代传统内存管理模式，其别名追踪机制严苛到曾协助找出 LLVM 内部的缺陷。即便如此，他也承认该机制暗含代价：编译器假定人类无法在脑海中追踪对象生命周期，且梳理 Cargo 庞大的依赖图谱缺乏情绪正反馈。针对内存泄漏的定义，受访者澄清在 Rust 规范中内存泄漏属于安全行为。例如通过 std::mem::forget 放弃运行析构函数不会引发未定义行为，因为泄漏的内存无法再被访问，由此导致的程序崩溃仅属物理资源耗竭而非内存破坏。对于绕过编译器检查的 unsafe 关键字，他戏称自己定义了 trust_me! 宏来应对。此外，Rust 生态展现出极端的技术重写倾向，尽管应用层成果有限——例如全生态仅有 5 款游戏却开发了 50 个游戏引擎，但在前端工具链上表现突出，如 Turbopack 的构建速度达到 JavaScript 打包工具的 20 倍。社区生态、异步运行时与就业市场 (5:00) 在软件架构与社区生态方面，受访开发者主张构建单一 Rust 代码库并通过外部函数接口（FFI）为其他语言生成绑定的模式。当前生态致力于重写既有工具，包括以 Zola 替代 Hugo、Deno 替代 Node.js、Sniffnet 替代 Wireshark、Solana 替代 Bitcoin 以及 Goscript 替代 Go。关于社区协作与问题修复流程，他讽刺称 Rust 用户在发现缺陷后通常会在 GitHub Issue 中争论长达两年，直至项目维护者辞职。针对 Tokio 异步运行时中丢弃衍生任务 JoinHandle 实例引发的任务取消争议，受访者认为开发者在任务终止逻辑上存在严重分歧。谈及行业真实就业环境时，他直言目前的 Rust 职位大量集中于投机性质的高风险区块链初创公司，这类企业往往在成立一年内倒闭，其本人在过去数月中便接连加入过数家此类团队。同时，官方文档的编写路径也反映了高门槛特征，不同于其他语言以简单应用收尾，Rust 入门教程直接以手写多线程高性能 Web 服务器为终局。精英门槛、语法嵌套与全盘重写哲学 (7:15) 针对系统架构演进，该开发者极力排斥在操作系统内核中进行混合式渐进迁移，主张必须从零开始全盘重写。他断言 Rust 语言机制已趋于完备，因而永远不会推出 Rust 2.0 版本，其核心设计理念在于将各语言特性强行缝合，代码虽晦涩难懂却确保了内存安全；语言的向下兼容破坏性改动则被严格隔离在 2015、2018 及 2021 等多年一度的版本（Editions）中。面对语法复杂度争议，他为 Option<Rc<RefCell<T>>> 等深层类型嵌套以及 .into()、.inner() 和 .unwrap() 的冗长链式调用进行辩护，视其为高质量代码的体现。对于入门门槛，他声称 Rust 仅面向已精通 Haskell 或 OCaml 的精英群体，刻意将主流普通开发者拒之门外，宣称 Rust 彻底终结了 JavaScript 衍生语言的无休止更迭。然而在访谈尾声，他又调侃团队实际上使用的并非 Rust，而是小众语言 Gluon，以此消解了前述的绝对化技术立场。该访谈通过夸张的反讽修辞，既展现了 Rust 根治内存安全缺陷的底层架构优势，也尖锐揭露了社区内部排他性的技术优越感、语法繁琐度以及区块链初创泡沫等现实困境。

Detailed notes — zh

## Background 该视频由 YouTube 频道 Kai Lentit 于 2023 年 7 月 1 日发布。视频内容为一段虚构的采访短剧，采访了一位名为 Jester Hartman 的资深 Rust 开发者，旨在通过密集的编程笑话与互联网梗调侃 Rust 社区的狂热文化。 ## TL;DR 视频以反讽和幽默的方式勾勒了 Rust 程序员群体的刻板印象与生态现状。受访者不仅大肆嘲讽 C++、Java 等语言的内存管理机制，更夸赞 Rust 的借用检查与宏系统，戏称“把所有语言的优点拼在一起后代码彻底不可读，但它是内存安全的”。后半段则进一步深入社区真相，揭露了 Rust 岗位大多集中在容易暴雷的区块链初创公司、爱好者热衷于“把一切软件用 Rust 重写”来赚取社区点赞，以及开发者在 GitHub 抱怨长达数年的生态现象，展现出一种荒诞又真实的硬核极客文化。 ## Atmosphere & style 整个采访充斥着冷面幽默（Deadpan humor）与极度自信的技术优越感，呈现出一种荒诞讽刺的狂热邪教氛围。受访者一本正经地输出各种荒谬绝伦的暴论，将自我调侃与无情嘲弄融为一体，观众在捧腹大笑的同时，又能瞬间共鸣到现实系统编程中的真实痛点与血泪。 ## Bulletin - [00:00](https://www.youtube.com/watch?v=TGfQu0bQTKc&t=0s) 访谈以黑色幽默解构 Rust 社区哲学：打破“为特定工作选合适工具”的常识，主张“为你的工具挑选合适的工作”，并戏称 Rust 是集所有语言优点于一身、兼具不可读性与内存安全的“完美语言”。 - [00:00](https://www.youtube.com/watch?v=TGfQu0bQTKc&t=0s) 针对内存安全机制，Rust 借用检查（Borrow Checker）消除了对内存本身的顾虑，但宏嵌套与类型包装（如 Option<Rc<RefCell<T>>>）带来了新的复杂度，且内存泄漏在 Rust 规范中仍被判定为 Safe 行为。 - [05:00](https://www.youtube.com/watch?v=TGfQu0bQTKc&t=300s) 揭示 Rust 开发者就业现状与重写狂潮：目前大量招聘需求集中在寿命极短的区块链初创公司，而社区在各类底层工具、网络监控和桌面框架领域掀起了全盘 Rust 替代潮。 - [05:00](https://www.youtube.com/watch?v=TGfQu0bQTKc&t=300s) 讽刺 Rust 社区的狂热与傲慢文化，称入门门槛实际上建立在精通 Haskell 或 OCaml 之上，开发者甚至自嘲处于精神“完全氧化（Fully Oxidized）”的布道状态。 ## Key takeaways - [00:00](https://www.youtube.com/watch?v=TGfQu0bQTKc&t=0s) 反转传统工程常识：Rust 社区倡导“为你的工具挑选合适的工作”，而非根据任务需求妥协技术栈。 - [00:00](https://www.youtube.com/watch?v=TGfQu0bQTKc&t=0s) 各语言内存机制讽刺：对比 C++ 的频繁内存错误、Java 的 GC 停顿与 Haskell 的暴力深克隆，Rust 通过借用检查消除了内存管理顾虑。 - [00:00](https://www.youtube.com/watch?v=TGfQu0bQTKc&t=0s) 关于 Rust 内存安全边界：规范中内存泄漏属于 Safe 行为，语言甚至原生提供了 mem::forget 显式通知编译器忽略回收。 - [00:00](https://www.youtube.com/watch?v=TGfQu0bQTKc&t=0s) 宏与可读性代价：Rust 虽然解决了 C 宏的痛点，但嵌套宏与多范式特性融合后，代码已变得极难阅读，唯一的慰藉是“内存安全”。 - [00:00](https://www.youtube.com/watch?v=TGfQu0bQTKc&t=0s) 戏谑的 unsafe 实践：受访者调侃自己使用名为 TrustMe 的宏来封装 unsafe 代码块，以此逃避安全检查心智负担。 - [00:00](https://www.youtube.com/watch?v=TGfQu0bQTKc&t=0s) 游戏生态的现实反差：受访者讽刺 Rust 游戏开发生态处于“全行业只有 5 款游戏，却开发了 50 个游戏引擎”的不均衡状态。 - [05:00](https://www.youtube.com/watch?v=TGfQu0bQTKc&t=300s) 社区行动力与组织纪律：相比普通程序员快速修 bug，Rust 社区在 Issue 追踪与辩论中极度耗费心力，却具备比 C++ 更狂热的社区向心力。 - [05:00](https://www.youtube.com/watch?v=TGfQu0bQTKc&t=300s) 残酷的就业生态真相：目前多数 Rust 商业岗位来自寿命难以撑过一年的区块链初创企业，开发者跳槽频繁。 - [05:00](https://www.youtube.com/watch?v=TGfQu0bQTKc&t=300s) “用 Rust 重写一切”的驱动力：将成熟软件（如 Node.js、Webpack、Wireshark 等）用 Rust 重写往往只是为了社区声量与 Reddit Karma 积分。 - [05:00](https://www.youtube.com/watch?v=TGfQu0bQTKc&t=300s) 关于 Rust 2.0 的断言：受访者断言永远不会有 Rust 2.0，表面借口是“语言已然完美”，实则是语法扩展机制已足够灵活。 - [05:00](https://www.youtube.com/watch?v=TGfQu0bQTKc&t=300s) 自相矛盾的代码简洁性：社区嘴上宣称讨厌重复与晦涩，实操中却充斥着链式 unwrap()、into() 以及多层嵌套的 Option<Rc<RefCell<T>>> 包装。 - [05:00](https://www.youtube.com/watch?v=TGfQu0bQTKc&t=300s) “完全氧化”的狂热心态：受访者自诩生活、工作乃至意识形态均被 Rust 占领，展现了极具讽刺意味的 Rust 原教旨主义。 ## Detailed walkthrough ### [00:00](https://www.youtube.com/watch?v=TGfQu0bQTKc&t=0s) 为什么选择 Rust：重新定义内存安全与编程范式采访以对亨利·福特名言的调侃开场：“正如哈里森·福特曾经说过的，如果我们去问人们想要什么，他们会回答想要更快的 C++。”受访者分享了自己学习 Rust 的初衷——他原本打算在三周内写出一个操作系统，起初想自己发明一门系统级编程语言，但当时觉得这对普通人来说太复杂了；直到后来发现了 Rust，他才改变了想法：“现在我只是不在乎它对人们来说是不是太复杂了。”面对行业中“为特定工作选择合适工具”的常识，Rust 社区的态度截然相反：“在 Rust 社区，我们的说法是：为你的工具挑选合适的工作。” 在内存安全与各大语言的对比上，受访者展开了无情的嘲弄。他提到微软数据显示大约 70% 的 CVE 漏洞都源于内存泄漏，而各语言的应对方式各有千秋：在 C++ 中，你必须时刻担忧内存错误；在 Java 中，垃圾回收器（Garbage Collector）成了你的心头大患；而在 Haskell 中一切都是深克隆（“怎么，我们的硬件资源是无限的吗？”）；在 JavaScript 里，“你得担心内存，因为你必须担心 JavaScript 本身”。Rust 则带来了全新的借用检查机制（Borrowing），直接消除了对内存本身的顾虑。在宏系统方面，C 语言宏带来的痛苦被 Rust 解决了，但取而代之的是“嵌套宏现在成了新的噩梦”。受访者总结道：“这世界上本没有完美语言，Rust 只不过是一门静态类型、底层、多范式、完美的编程语言而已。” ```mermaid flowchart TD accTitle: 编程语言的内存管理机制对比 accDescr: 对比 C++、Java、Haskell、JavaScript 与 Rust 处理内存的不同方式及痛点 subgraph OtherLangs["传统与脚本语言痛点"] CPP["C++: 手动管理<br/>频发内存错误"] Java["Java: 垃圾回收<br/>GC 停顿与开销"] Haskell["Haskell: 暴力深克隆<br/>假定资源无限"] JS["JavaScript: 语言本身就是隐患"] end subgraph RustWay["Rust 的处理哲学"] Borrow["借用检查机制 (Borrow Checker)"] Lifetime["生命周期跟踪 (Lifetimes)"] SafeLeak["内存泄漏属于 Safe 行为<br/>不调用析构函数亦安全"] end OtherLangs -.->|"认知范式转换"| RustWay ``` 受访者进一步指出，Rust 的类型与安全边界甚至涵盖了许多令人哭笑不得的现实： - 当被问及项目的哪一部分是用 Rust 重写时（前端还是后端），受访者回答：“不，是把整个浏览器都重写了。” - 他甚至写了一个定制版的 Rust 编译器，内置极其严苛的错误处理机制：“基本上只要你犯了错，就会被电击枪电击——不然你怎么学底层编程？” - 谈及游戏开发生态，受访者声称 Rust 无所不能：“目前业内大概有 5 款用 Rust 编写的游戏，以及 50 个用 Rust 开发的游戏引擎。” - 面对竞争条件（Race conditions），受访者断言在操作系统层面破损的东西无法修补，“除非你用的操作系统本身就是用 Rust 写的”。 - 针对 `unsafe` 关键字，受访者表示自己专门写了一个宏封装它，宏的名字就叫 `TrustMe`。 - 关于代码可读性与特质（Traits），他犀利地概括道：“Rust 就是把所有语言的优点全揉在一起；现在你的代码彻底不可读了，但它是内存安全的。” - 内存泄漏在 Rust 规范中被认定为是安全的（Safe），即便内存泄露，由于对象再也不会被引用，因此“不会发生崩溃”；为此 Rust 还专门提供了 `mem::forget` 显式通知编译器。 --- ### [05:00](https://www.youtube.com/watch?v=TGfQu0bQTKc&t=300s) 彻底氧化：重写一切与 Rust 社区生态真相进入后半段，受访者探讨了异步生态（如 Tokio 的任务句柄作用域争议）与整个社区文化。“在所有底层 C 或汇编的领域，Rust 都是绝对的霸主，”受访者强调，尽管 C++ 的势力规模庞大，“但 C++ 神教的组织纪律性远不如我们。”对于日常开发修 bug 的流程，他也给出了辛辣的对比：普通程序员发现 bug 会直接去修复它，而 Rust 用户发现 bug 则会“在 GitHub Issues 里抱怨整整两年，直到项目维护者心力交瘁主动退位退网”。此外，各大语言教学文档往往以制作“Cookie Clicker”小游戏收尾，而 Rust 官方教程的终章却是一个“多线程、高性能、全功能就绪的 Web 服务器”。谈到行业就业现实与项目重写狂潮时，受访者揭示了残酷的真相。目前市场上虽然有很多 Rust 岗位，但绝大多数都集中在区块链初创公司：“去搞一些区块链玩意儿，然后在一周年内轰然破产。过去几个月我已经接连跳槽了好几家这种初创企业。”当谈及将所有软件用 Rust 重写时，他直言不讳：“把一切用 Rust 重写非常简单，因为你能在 Reddit 上赚足 Karma 积分。”面对 Rust 会不会发布 2.0 版本的提问，他坚称：“永远不会有 Rust 2.0 版本，因为这门语言已经完美无缺了——虽然技术上的真实原因是其语法扩展性足够强，但前面那种说法听起来更酷。” ```mermaid flowchart LR accTitle: 软件生态全栈 Rust 替代对照 accDescr: 展示现有主流工具及其对应的 Rust 重写版本对照 subgraph Web_Tooling["网络与构建工具"] Node["Node.js"] -->|"替代"| Deno["Deno"] Hugo["Hugo"] -->|"替代"| Zola["Zola"] Webpack["Webpack"] -->|"替代"| Turbopack["Turbopack (快20倍)"] end subgraph Net_Crypto["网络监控与加密货币"] Wireshark["Wireshark"] -->|"替代"| Sniffnet["Sniffnet"] Bitcoin["Bitcoin"] -->|"替代"| Solana["Solana"] end subgraph GUI_And_More["系统与跨平台重写"] Desktop["桌面应用"] -->|"GUI 框架"| Iced["Iced (最完善 GUI)"] WindowsOS["Windows OS"] -->|"重写野望"| RustOS["Rust 重写版 Windows"] end ``` 在社区包容度与语言哲学上，受访者展现出了极端的“精英狂热”与自嘲： - “可靠性、速度、生产力，这三个词你选全部四个。”受访者如此宣扬 Rust 的无可替代。 - 受访者正在编写一本 Rust 入门指南，并声称语言其实极其易学，但他紧接着补了一句：“这本书主要面向已经熟练掌握 Haskell 或 OCaml 的读者。回去先学完 Haskell 再来吧，平庸之辈（Normie）。” - 谈及 Rust 饱受诟病的啰嗦调用，受访者反讽道：“我们在 Rust 里最讨厌重复了——`into()`, `into()`, `into()`, `inner()`, `unwrap()`, `unwrap()`, `unwrap()`；我们讨厌晦涩的代码——`Option<Rc<RefCell<T>>>`。” - 针对跨语言生态重写的狂热，受访者列举了一连串对应软件（如 TurboPack、Sniffnet、Solana），并表示自己正打算将个人 DNA 发布为 crate 包，无奈受到 crates.io 的 10MB 大小限制。 - 最终，受访者形容自己已经处于精神层面的“完全氧化（Fully Oxidized）”状态：“我的工作是 Rust，我的爱好是 Rust，我的意识形态也是 Rust。我们现在甚至正着手用 Rust 来重写现代政治架构。” - 面对坐在对面的采访者，受访者的传教最终落在了一句不可抗拒的提议上：“那么，让我们来看看怎么把你的代码也用 Rust 重写一遍吧。” ## Notable quotes > [00:00](https://www.youtube.com/watch?v=TGfQu0bQTKc&t=0s) Rust 就是把所有语言的优点全揉在一起；现在你的代码彻底不可读了，但它是内存安全的。 — 受访者 > [05:00](https://www.youtube.com/watch?v=TGfQu0bQTKc&t=300s) 在所有底层 C 或汇编的领域，Rust 都是绝对的霸主。 — 受访者 ## Mentioned Rust, C++, Java, Haskell, JavaScript, OCaml, C, Tokio, Microsoft, GitHub, Reddit, crates.io, Node.js, Deno, Hugo, Zola, Webpack, Turbopack, Wireshark, Sniffnet, Bitcoin, Solana, Iced, Windows, Kai Lentit, Jester Hartman ## Video description Rust programming language Full version on patreon Merch posix.store Interview with a Rust developer with Jester Hartman - aired on © The Rust. Find more Rust opinions under: Full version on paah.vhx.tv Programmer humor Rust humor Programming jokes Programming memes Rust yew Rust memes Rust jokes unsafe command future traits #programming #jokes #Rust [Source](https://www.youtube.com/watch?v=TGfQu0bQTKc)

Source quotes

[0:00] 受访者: Rust 就是把所有语言的优点全揉在一起；现在你的代码彻底不可读了，但它是内存安全的。 [5:00] 受访者: 在所有底层 C 或汇编的领域，Rust 都是绝对的霸主。

Original transcript

[0:00] Well, as Harrison Ford once said, if we would have asked the people what they wanted, they would have asked for a faster C++. What made me learn Rust? I wanted to write a... an operating system in three weeks. I first wanted to write my own systems programming language but I thought that's too complicated for people. And then I discovered Rust. And now I just don't mind that it's too complicated for people. People say, choose the right tool for the job. In the Rust community, we say, choose the right job for the tool. I'm a regular contributor to 14 projects. I actually got the original. When I see a C++ Deb, what I see is a future Rust Deb. macro expansion, bounded polymorphism, web assembly, the problem with mediocrity. I let my threads panic for pleasure. Those of you coming from functional programming languages will be pleased. Those of you coming from OOP languages Yeah. will also be pleased. In interpreted languages, you need a lot of imagination. My metric of self-worth is bound to prevented CVEs and Pony awards. Did you know that according to Microsoft, 70% of all CVEs are due to memory leakage? In C++, you need to worry about memory because of memory errors. In Java, you need to worry about memory because of the garbage collector. In Rust, you don't need to worry about memory because you need to worry about borrowing, which is a new concept that in Haskell, everything is just cloned. I mean, what? Do we have infinite resources? In JavaScript, you need because you need to worry about JavaScript. In C, macros were a pain. We solved that in Rust. Now, nested macros are a pain. I mean, there is no such thing as a perfect programming language. Rust is merely a statically typed, low-level, multi-paradigm, perfect programming language. mental sinner asked. And which part did you write in Rust? the front end or the back end. No, the browser. Not everyone learns Rust in a lifetime. I actually wrote a custom new version of the Rust compiler. It's a little stricter with error handling. Essentially, you're being tasered when you make an error. How else are you going to learn low-level programming? I'm currently rewriting the color blue to Rust. The main problem Rust has and solves by itself is the borrow checker references to an object. But if you paralyze, you need to paralyze manually. And that means Well, in other languages, you don't even have parallelization. Rust is so good, it's aliasing, tracking, found LLVM's own bugs. The disadvantages? Rust thinks you can't keep object lifetimes in your head. And there is no reward when dealing with large library dependency graphs. Is Rust good for game development? Rust is good for everything. There are currently five games written in Rust and 50 game engines. Race conditions are fundamentally unsolvable. You can't fix what's broken on the OS level, unless you're using an OS written in Rust, of course. Again, I'm not here to tell you that Rust is the best language. You should have figured by now. The best JS bundler is written in Rust. TurboPack. 20 times faster than any bundler written in JS. That's some undercover marketing right there. You can't trust humans, but you can always trust the code and the compiler. Another superpower of Rust. Testing in Rust is cheaper because we're all geniuses. In Rust, you need to see the compiler as your friend that helps you with your stupidity. Map error exists, but its method trademarks were not satisfied. Link lists. Rust requires unlearning many horrible programs. from other horrible languages. Rust will finally unite C and C++ encoders from all other programming languages. I actually have a macro. for the unsaved command. It's called Trust Me. Welcome to memory management in Rust. We compiled the entire company at runtime. But of course the normal normal kernel dev will come across more difficult challenges. So this is a concept that you haven't heard before Rust. In fact, actually no one has. We have trades, trades, lifetimes, no states. Is this a joke? Yeah, so these are called trades. So it's like interfaces. in Java. Yeah, we don't mention Java in here. Rust is, imagine you would throw all advantages from all languages together. Now your code is unreadable, but it's memory safe. Option, not maybe in Rust. This isn't Haskell, but it could be with a few tweaks. Memory leakage is considered safe. Not calling these structures is considered safe. because memory leakage is considered safe. Even if it leaks, it never gets referenced again. So there's not going to be any crash. The program does crash, but if the memory fills up, you can catch that in some cases. Well, MemForget was introduced to tell the compiler. Anyways, in Rust, all libraries are archived. This isn't JavaScript, but we have left-pad incidents. Breaking changes are only introduced in Rust editions. We have Rust 2015, 2018, 2021 edition. And this is actually Rust 2023. [5:00] signature edition is actually signed by Graydon himself. Well the fiasco with Tokyo is so a joint handle from a task you spawn can get out of scope. Now there are two schools of thought. Some think the task should be aborted. The others don't really think at all. I will say it. Rust is in all things top of the hill. King of the castle. Head of the competition. For all things C or ASM, Rust is good. Yeah for functional programming it's Haskell and Rust. Rust is king of the castle. Yeah they don't The C++ cult is bigger, but not as organized as ours. In Rust development, a lot changes. Usually when you find a bug, you fix it. When Rust users find a bug, they complain about it and get up issues for two years before the project owner steps down. WebAssembly. What was the question? In other programming languages, the documentation ends with a cookie clicker. In Rust, it ends with a multi-threaded, high-performing, fully functional web server. Yeah, there are a lot of jobs for Rust. Most are for startups. to do some blockchain stuff. and then go bankrupt in a year. I joined a couple of startups like that in the past months. All those startups wanting to become unicorns. I'm not crazy about that. We got this as new merch from our company. Mono, Repo and Rust and bindings to all other languages. That's the future of programming. Hugo, Zula. Node, Dino. Wireshark, SniffNet. Bitcoin, Solana. Go, Goscript. Gnu, Haskell. Okay, you can use Haskell. I mean, I would like to publish my DNA as a crate, but crates.io has a 10 megabyte limit. Oh, I use ice. So iced is the best one. It's the most complete one. It is very easy to rewrite everything in Rust, because you get karma points on Reddit. By the way, this code actually also runs on mobile, in a wrapper. that I wrote in Rust. Yeah, Rust is an interesting mix of C++, OCaml, Haskell, Dota, JavaScript. I meant Lisp. Lisp. Oh, is it the... Is it the timer for the coffee? No, I just finished compiling. Map error exists, but it's method trademark. Rust allows for hybrid approaches, allowing for productive kernel incrementalism. instead of whole project rewrite. We'll still do the whole project rewrite. I'm actually rewriting Windows to Rust. This will give it some credit. That will never be a Rust version 2.0 because the language is perfect. Technically it means because the syntax is adaptable, but the other phrase sounds better. Took 15 years for case statements to arrive in Python. Think about it. You don't adapt the program to the language in Rust. You adapt the language to the program. We decided to everyone equally unhappy. Rust is very simple to learn. I'm actually writing an introduction to the language right now. It is mainly aimed at readers already familiar with Haskell or OCaml. Yeah, but nobody knows Haskell. We're all looking to learn to rest. Come back after you learn Haskell. Normie. We didn't say it's a programming language for everybody, just for the elite. But everyone is welcome that is ready to join the cult community. Community. Reliability. Speed. Productivity. Pick four. Why Rust? It has three main benefits. Rust versus Java? Well, that's an easy one. Pokemon Go, we have Pokemon Rust. Yes, we did. And you don't even catch Pokemon. Just random runtime exceptions. We really hate repetitions in Rust. Into, into, into, inner, unwrap, unwrap, unwrap. We don't like unreadable code in Rust. Option, RC, ref cell. There are different types of macros. I don't need to go over them, right? So let's learn another meta programming language called pattern matching. Is that your repo? Thank you. Let's start by setting up cargo. Everyone cares about random tools written in Rust. Everybody cares. Look at all the startups hiring. Although it's mostly startups doing blockchain stuff that will go bankrupt in a year. I joined a couple of those. My job? Rust. My hobby? Rust. My ideology? Rust. Russ, my profile pic? I'm fully oxidized at this point. It's not a cult. We're now actually rewriting politics to Rust. I think Rust is here to stay forever. No more JavaScript, TypeScript, CoffeeScript, MochaScript variations. Rust is the end. Actually, we don't use Rust, we use Gluon. Yeah, I'm actually currently writing a bio. about my programming journey. It starts with So let's see how we can rewrite your code to Rust.