# Rust design axioms, take 3

I’m still thinking about design axioms.

## Rust’s “sweet spot”

Rust can be used for many things. But it is optimized for programs where

* performance and resource consumption,
* reliability and correctness, and
* long-term maintenance and extensibility

are top priorities.

## A more opinionated take on Rust design axioms

* **If it compiles, it works.** Rust's design emphasizes reliability and long-term maintenance. Memory safety in particular is not negotiable.
* **Leave nothing on the table.** Rust lets you take full advantage of the capabilities of your machine.
* **{Performance, portability} by default.** Rust code written in the natural way performs well and works across all common environments (operating systems, architectures, etc). So yes, you *can* have nice things -- even in your inner loop.
* **Empower the ecosystem.** Rust is not a language that bakes in all its choices. We aim to build general mechanisms that the greater library ecosystem can make use of to build their own abstractions.
* **Good first impressions, supportive tooling.** We try to make the easy thing easy with sensible defaults and quality tooling. We can't always make it easy, but we can support you in figuring out your problem.
* **Not afraid to do the right thing.** It's always good to follow precedent, but Rust is not afraid to chart a difference course if we think it's the right one.

## Strategies for achieving these axioms

* Stability without

## Rust properties

* ⚙️ **Reliability above all**. Rust users want to be sure their program will handle the edge cases that arise in production, not just the happy path. We guarantee memory safety and data-race freedom and look for opportunities to surface other problems wherever we can.
* 🔧 **Low-level control and transparency**. When building systems, it’s often important to know what’s going on underneath the abstractions. Abstractions should still leave the programmer feeling like they’re in control of the underlying system, such as by making it easy to notice (or avoid) certain types of operations.
* 🏎️ **Performant, composable abstractions**. We favor high-level APIs where the most convenient option is also the best one. The default style of writing things should be efficient and portable across operating systems and execution environments. We aren’t explicit for the sake of being explicit, but rather to surface details we believe are needed.
* 🌟 **Extensible and productive**. We empower our users to build their own abstractions. We prefer to let people build what they need than to try (and fail) to give them everything ourselves.
* 🤸🏾 **Accessible and supportive**. Building reliable, efficient programs is ultimately a complex business. We can’t always make Rust easy, but we can make it supportive. Our tooling aims to make “best practices” easy and convenient and, where choices are needed, to explain the choices and their implications as clearly as possible. Using Rust is a great way to level up your understanding of new domain or problem area.

## Strategies for success

## Brainstorming

* Whenever there is an error, user is already annoyed
* help them go in the right direction
* speak your user's language
* Being an expert is not a binary
* can be an expert on Rust, but not on the whole language
* design for "tired you"

---

* **Memory safety is not negotiable.** As much as possible, we try to detect errors.

---

* **Wears well over the long-term.** We optimize for long-term maintenance. We are not afraid to break with tradition if it’s the Right Thing.

---

* **Work incrementally, think globally.**
* **Enabling existing users.**

---

* **Tooling matters.**
* **It’s the whole experience.**

---

* **Supportive and inclusive.**
* **An error message is the first chance to teach the user.** ??

---

* **Stability without stagnation.** Existing Rust code continues to work.
* **If it compiles, it works.** As much as possible, we try to detect errors

---

* **Idiomatic Rust code is fast Rust code.**
* **Predictably low performance.**

---

* **Extensible.**

---

* **You can build anything in Rust.**
* **Expose all system capabilities.**
* **Nothing you can’t do.**
* **Take full advantage of your system.**
* **No limits.**

---

Concepts:

* Errors at monomorphization time - why do we avoid these, by the above priorities?

---

* Easy to get started, and what you learn you build on, not replace
* How fast do problems show up
* Guiding to success -- API design / error messages

---

* Win more friends with honey than vinegar
* Persuasion not proscription
* make it worth their time

---

Editions

* option to do it on your own time
* don't split the ecosystem

---

* Degrees of freedom tend to get pushed to crates.io

---

* Target the 99th percentile

##

Virality of generics