Overview

# Overview

---

```rust []
fn main() {
    let random_number = generate_random_number();
    let mut my_choice = 10;
    my_choice += random_number;
    println!("{my_choice}");
}

fn generate_random_number() -> i32 {
    4 // chosen by dice roll, guaranteed to be random
}
```

---
## What is Rust?

Rust is an empathic systems programming language that is determined to not let you shoot yourself in the foot.

---
## A Little Bit of History

-   Rust began around 2008
-   An experimental project by Graydon Hoare
-   Adopted by Mozilla
-   Presented to the general public as version 0.4 in 2012
-   Looked a bit Go-like back then

---
## Focus

-   Rust has lost many features from 2012 to 2014
    -   Garbage collector
    -   evented runtime
    -   complex error handling
-   Orientation towards a usable systems programming language

---
## Development

-   Always together with a larger project (e.g. Servo)
-   Early adoption of regular releases, deprecations and an RFC process

---
## Release Method

-   Nightly releases
-   experimental features are only present on nightly releases
-   Every 6 weeks, the current nightly is promoted to beta
-   After 6 weeks of testing, beta becomes stable
-   Guaranteed backwards-compatibility
-   Makes small iterations easier

Note:

- Cargo's "stabilization" section https://doc.crates.io/contrib/process/unstable.html#stabilization
- Crater tool
- Editions

---
## Goals

-   Explicit over implicit
-   Predictable runtime behaviour
-   Supporting stable software development for programming at large
-   Pragmatism and easy integration
-   Approachable project

Many examples in this course are very small, which is why we will also
spend time discussing the impact of many features on large projects.

---
## The Four Words

-   Safe
-   Concurrent
-   Fast
-   Pragmatic

---
## Safe

-   Rust is memory-safe
-   No illegal memory access
-   Deallocation is automated
-   Warning: memory leaks are **safe** by that definition!

Note:

- Memory safety: use-after-free, double-free
- Type safety, Thread safety
- Memory leaks: `Box::leak()`

---
## Concurrent

-   "Concurrency without fear"
-   The type system detects concurrent access to data and requires
    synchronization
-   Also: Rust detects when unsynchronized access is safely possible
-   Protection from data races

---
## Fast

-   These properties are guaranteed at compile time and have no runtime
    cost!
-   Optimizing compiler based on LLVM
-   Features with runtime cost are explicit and hard to activate "by
    accident"
-   No reflection
-   Zero-cost abstractions
-   "Pay what you use": Rust has features with a runtime cost in an
    explicit and visible way. Unused features do not come with an
    associated cost.

---
## Pragmatic

-   User-focused tooling
-   Sublanguage for unsafe memory access and techniques to handle these
-   FFI support to interface with existing systems
-   Compiler gives helpful error messages

---
## Where do Rustaceans come from?

From diverse backgrounds:

-   Dynamic languages (JS, Rubyists and Pythonistas)
-   Functional languages like Haskell and Scala
-   C/C++
-   Safety critical systems