The Development Experience Is Different With Rust

# 🦀 The Development Experience Is Different With Rust

Azriel Hoh

---
## Learning Rust

### Learning Rust

```rust ignore [1-4]
fn main() {
    let x = 0;
    x += 1;
}
```

### Learning Rust

For more information about this error, try `rustc --explain E0384`.
warning: `simple` (bin "simple") generated 2 warnings
error: could not compile `simple` (bin "simple") due to 1 previous error; 2 warnings emitted
</pre>

### Learning Rust

```rust ignore [1-4]
fn main() {
    let x = 0;
    x += 1;
}
```

### Learning Rust

```rust ignore [1-4]
fn main() {
    let mut s = "hello ";
    s += "world";
}
```

### Learning Rust

```rust ignore [1-5]
fn main() {
    let mut s = String::from("hello");
    let list = vec![s];
    s += " world";
}
```

### Learning Rust

```rust ignore [1-5]
fn main() {
    let s = String::from("hello");
    let mut list = vec![s];
    list.get_mut(0) += " world";
}
```

### Learning Rust

#### Notes

20. The point is, when you're learning, even for the most basic of things, it can feel like "Rust says no to everything I *know* how to do".

---
## Keep Going

<blockquote>Be adamant: I will beat this computer.</blockquote>

#### Notes

1. Channel your inner rebel.
2. Now you may be thinking, Rust is introducing complexity where there wasn't any before.
3. and you're right!
4. But it also provides clarity.
5. *(excitedly)* Let me show you, let me show you.

### Keep Going: Perspective

#### Notes

21. Though consider the perspective that, you are so used to having compilers only having constraints that prevent 50% of issues,

### Keep Going: Perspective

#### Notes

25. Software that cannot compile is invalid, and therefore, incorrect.

### Keep Going: Perspective

#### Notes

26. Software that successfully compiles is valid, but not necessarily correct.

### Keep Going: Perspective

#### Notes

26. Software that successfully compiles is valid, but not necessarily correct.

### Keep Going: Perspective

#### Notes

27. If more of the incorrect software, can be classified as invalid, then it follows that when your code successfully compiles, it's more likely to be *correct*.

### Keep Going: Perspective

#### Notes

28. Hopefully that makes your learning experience better.

36. Now you may be thinking, Rust is introducing complexity where there wasn't any before.
37. and you're right!
38. But it also provides clarity.
39. *(excitedly)* Let me show you.

---
## Clarity

#### Notes

31. But it also provides clarity.
32. *(excitedly)* Let me show you, let me show you.

### Clarity: Equality

|                    | Equal? 🟢/🟣 |
|--------------------|--------------|
| 123 == 123         |       ❔     |
| "abc" == "abc"     |       ❔     |
| [1] == [1]         |       ❔     |
| Data(1) == Data(1) |       ❔     |

</div>

#### Notes

1. This is how you know you're a software developer.
2. *(take out two canned drinks)*
3. Does this (drink), equal, this? *(smile)*
4. In other words, what does equality mean?

### Clarity: Equality

| Language           | ☕ Java   | 🌐 JS | 🐍 Python | 🦀 Rust |
|--------------------|-----------|-------|-----------|----------|
| 123 == 123         |     🟢    |   🟢  |    🟢    |    ❔    |
| "abc" == "abc"     | sometimes |   🟢  |    🟢    |    ❔    |
| [1] == [1]         |     🟣    |   🟣  |    🟢    |    ❔    |
| Data(1) == Data(1) |     🟣    |   🟣  |    🟣    |    ❔    |

</div>

#### Notes

1. The meaning of the double equals operator varies with the type and the language.
2. I'm going to give you another one to learn.
3. Rust has chosen this definition:

### Clarity: Equality

![](equals_equals.png)

#### Notes

1. Equals equals, equals, equals.

### Clarity: Equality

| Language           | ☕ Java   | 🌐 JS | 🐍 Python | 🦀 Rust |
|--------------------|-----------|-------|-----------|----------|
| 123 == 123         |     🟢    |   🟢  |    🟢    |    🟢    |
| "abc" == "abc"     | sometimes |   🟢  |    🟢    |    🟢    |
| [1] == [1]         |     🟣    |   🟣  |    🟢    |    🟢    |
| Data(1) == Data(1) |     🟣    |   🟣  |    🟣    |    🟢    |

</div>

#### Notes

1. In Rust, the double equals operator, means value equality,
2. which is what you would've thought it means, *before* you were clever.

---
## Clarity: Errors

#### Notes

1. Errors. The way errors have been represented has changed over time.

### Clarity: Errors – Sentinel values

```java [1-15]
int fileSize = readFileSize("file.txt");
if (fileSize != -1) { /* success path */ }
else                { /* error path */ }

Metadata metadata = getMetadata("file.txt");
if (metadata != null) { /* success path */ }
else                  { /* error path */ }

Error error = process("file.txt");
if (error == null) { /* success path */ }
else               { /* error path */ }
```

#### Notes

1. With sentinel values, which is using a special value to mean "error",
2. the caller has to remember to check for the error value, then diverge the code paths for success and failure.