Choosing Rust: Beyond the technical decision
When we choose a programming language, the decision is driven by it’s technical fit. Rust is, from that perspective, a strong and modern option: reliable, efficient, and safe. But that’s not the only reason I push for it.
Because even rational, technical decisions shape the culture of an organization. The tools we use influence how we think, how we collaborate, and how we solve problems together. And in this sense, pushing for Rust is not only a technical argument — it’s a cultural one.
Rust embodies principles that align closely with the way we want to work as an organization guided by the Beta Codex: open, transparent, trust-based, and self-organizing.
Beyond Technical Excellence
Rust is more than just a toolchain or syntax. It represents a way of thinking about problems — one that combines precision with empathy. You can see it in the way the compiler communicates, in the quality of the ecosystem, and in how the community approaches learning and collaboration.
These are not just technical choices — they are reflections of cultural values.
Rust is built on the belief that we can have performance and safety, innovation and empathy, rigor and humanity. It proves that we don’t have to trade care for speed, or people for performance.
And that belief — that balance — mirrors what we aim for as an organization.
Alignment With Beta Codex Principles
Rust is a language that manages to be both strict and empathic — a combination that’s rare in technology, and even rarer in organizations. It enforces clear rules, but it also reasons with you. When you make a mistake, it doesn’t just say “no” — it explains why something doesn’t work and how to fix it.
That combination of clarity and empathy is what makes Rust culturally aligned with the Beta Codex.
In a Beta-style organization, structure is not about control — it’s about enabling freedom within clarity. People are trusted to act autonomously, as long as the shared principles and boundaries are clear. Rust does exactly the same in software: it provides a clear framework of ownership, borrowing, and safety — and within those boundaries, you have full creative freedom.
To illustrate this, we can use a metaphor of governance styles (purely figuratively, of course):
C and C++ are the laissez-faire languages — they let you do almost anything, but they won’t protect you from yourself.
Ada, on the other hand, could be seen as authoritarian by design: it enforces correctness through strict formal rules and leaves little room for flexibility. This makes sense, given Ada’s origins in safety-critical and defense systems.
Rust finds the middle ground. It’s clear, open, and empathic — but still strict when you step outside its safety principles.
And Rust even gives you a conscious way to do that. The unsafe keyword allows you to go beyond the rules when you must — but the responsibility is entirely yours. It’s the language’s way of saying:
“You may leave the safe zone, but you must understand and own the consequences.”
This aligns beautifully with the Beta Codex mindset:
Clear agreements and visible boundaries
Freedom and trust within those boundaries
Empathy and transparency in communication
A system that teaches instead of punishes
Rust’s compiler feels like a coach, not a guard. It holds you accountable, but it helps you understand why the rules exist. That’s how Beta organizations also work — they trust people to act intelligently within a shared set of principles, supported by clarity instead of control.
Why I Advocate for Rust
I push for Rust not just because it’s technically sound, but because it fits the way we want to work. It’s a language that attracts developers who value ownership, clarity, and collaboration. It fosters an ecosystem where openness and empathy are part of the engineering process — not afterthoughts.
In that sense, choosing Rust supports the same culture we strive to cultivate internally: a culture that values autonomy, responsibility, and learning.
When our tools and our organizational principles point in the same direction, they reinforce one another. That’s when technology stops being just an enabler — and starts becoming part of the culture itself.
Shaping the Culture We Want
Every decision we make, large or small, contributes to the culture we build. Programming languages are no exception. They embody assumptions about collaboration, control, and trust — and they subtly shape how we work together.
Culture itself cannot be managed or directly changed
It’s like a shadow — a reflection of how we act and the decisions we make every day. You can’t “work on culture” as an abstract goal. What truly changes culture are the decisions we take and how consistently they align with the culture we want to see.
That’s why technical decisions matter. They are not neutral. Choosing tools, processes, or structures that reflect our values is the most effective way to shape the culture we want — not by talking about it, but by living it through our actions.
Rust, much like the Beta Codex, is built on trust, transparency, and self-organization. It aligns with the culture we want to strengthen: one that believes in people, clarity, and shared responsibility.
That’s why I advocate for Rust. Not only because it’s a technically strong tool, but because it supports the kind of culture I want to work in — and the kind of future I want to help build.