Rust changed me as a developer
Rust’s emphasis on strong typing, ownership, and sum types is portrayed as a catalyst for rethinking program design, error handling, and defensive coding compared with C, C++, and garbage-collected languages. Commenters broaden this to a wider point: tackling substantial projects across multiple language paradigms (ML-family, Lisp, Erlang/BEAM, HDLs, array languages, etc.) fundamentally reshapes how developers model problems, even if many “modern” ideas long predate Rust. Others question how much this kind of deep language learning still matters in an era of LLM-assisted coding, but many argue that understanding the underlying concepts and tradeoffs—safety vs. power, explicit nullability, macro- and type-system design—remains crucial for robust software.
Learning Across Language Families
- Many argue that doing a substantial project in each major language paradigm (Lisp, ML/FP, OO, logic, array, HDL, Forth, etc.) reshapes how you think, independent of Rust specifically.
- “Major project” is variously defined as: ~10k LOC, something you can’t fit in your head, lasts longer than a month, or is under real pressure and change. Others say even smaller but nontrivial projects (e.g., Sudoku solver, toy HTTP server, chat system) are valuable.
- Some push back that you don’t need “every” family; others report that trying many languages (Erlang/BEAM, Haskell, Elixir, HolyC, array languages, HDLs) was uniquely mind-expanding.
Rust’s Type System, Enums, and Comparisons
- Several note that many “Rust innovations” (sum types, pattern matching, strong static typing) were long present in ML-family languages and Haskell.
- Sum types are widely praised: any language without them “feels impoverished” to some.
- Detailed debate about Rust enums vs Zig/Ada-style “separate tag + union/variant record”:
- Critics: Rust conflates tag and payload; you can’t reuse discriminant types or refer to “the kind” without data, leading to workarounds (macros, separate enums to keep in sync).
- Defenders: you can model this with traits, generics, unit/never types,
std::mem::discriminant, and macros; separation is niche and mostly solvable with tooling, though more verbose.
Error Handling, Nulls, and Safety Culture
- Rust is praised for forcing explicit handling of failure (
Option,Result, newtypes), treating human error as expected rather than a “skill issue.” - Some liken this to what unit tests and past language features have always tried to do: constrain errors earlier.
- Debate over null vs optionals:
- Some claim null shouldn’t exist and optionals are an “annoying hack”; others argue optionals are the principled way to represent “value or nothing,” while null/sentinel defaults hide states from the type system and are bug-prone.
- Sentinel values like empty string or 0 as “unset” are widely criticized as unsafe and ambiguous.
- There’s disagreement over syntax ergonomics: explicit
Option/ monadic chains vs null-coalescing operators; some prefer brevity, others clarity and early parsing/validation.
History, Hype, and Changing Context (LLMs, C Era, etc.)
- Several emphasize knowing history: many Rust ideas predate it; hype sometimes erases earlier work (ML, Scala, PL/I, older compilers, etc.).
- Some see Rust as part of a long trend from “power with no checks” (C in the 80s) toward stronger safety and abstractions; hardware limits that motivated C’s design are less relevant now.
- A few question whether language epiphanies still matter in a world dominated by LLMs, while others insist deep understanding and multiple paradigms remain valuable, analogous to learning advanced math despite calculators.
Languages, Thinking, and Tools
- Multiple comments connect language to thought (Sapir–Whorf / linguistic relativity), arguing it’s more true for programming languages than for natural ones due to much larger differences in expressiveness.
- Others frame languages as tools: the “right” one includes what teammates know and what leads to clearer models, not just what’s theoretically powerful.