Sebastian Aaltonen

UTF-8 formatted strings! Awesome :)

Yay! No exceptions. Rust functions return error codes. You get a compiler warning if you forget to use the return value :)

A single standard build tool with dependency tracking. Downloads proper versions of used libraries (crates) and all their dependencies. C/C++ still has no de-facto standard for either. People copy paste code under random directories to their own repositories.

Rust has strong static type system. Compiler is also able to track resource ownership and threading issues. Big improvement over C++. Reduces need of unit tests. I wouldn’t call unit tests ”automatic” as you need to write + maintain them. Compiler is automatic, no added inertia.

Rust has binary literals: 0b1111_0000_0101_0101. No need to decrypt hex numbers in your head to understand bit masks. You can also use underscores in numeric literals to improve readability.

If is an expression, no need for messy ”cond ? A : B” syntax. All brackets (code blocks) are expressions too. Value is the final expression inside the code block (no semicolor after it). Allows writing expressions with internal named temp variables (naming is good for reading).

Only one allowed mutable ref (or N immutable refs) mechanism is ingenious! Guarantees no aliasing (allows better codegen) and guarantees no race conditions. Heap is RAII with auto move (similar to unique_ptr), but compiler tracks vars & refs -> error for misuse. Huge improvement.

Rust has nice features such as enumerate for iter. Returns tuple of both index and element (item). Nice when you need to know the index of the loop iteration. for (i, &item) in bytes.iter().enumerate() ...

Rust has good built-in tuples, and destructuring tuples has nice syntax. For example function returning tuple (multiple values) + destructuring the return value to a and b: fn addsub(x: i32, y: i32) -> (i32, i32) { (x + y, x - y) } let (a, b) = addsub(1, 2);

C++ lacks span type (ptr + size) until C++20. We’ve had our own span impl and it’s very nice. Rust is even better with built-in slice types (array & string). Rust borrow rules apply also to slices (compile error for stale slices)! Syntax is nice: &a[..] <-whole &a[3..7] <-sub

I love how Rust separates struct data from methods. Easy to see the data layout and add more methods later without bloating the struct. struct Rectangle { width: u32, height: u32, } impl Rectangle { fn area(&self) -> u32 { self.width * self.height } }

Rust doesn’t have null pointers. No need to add null safety checks or null asserts anywhere. For the special cases where some data may not exist, you use Option<T>. You can’t accidentally use Option<T> when it is None. You usually use ”match” to handle both Some and None cases.

In Rust ”match” is the equivalent of C++ switch case, but with broad pattern match capability. Compiler will give you error if you don’t handle all cases (some pattern in missing). This is nice. Also with Option<T> it means that None case needs to be handled to make code compile.

Rust generics are not duck typed like C++ templates. The compiler actually validates that your code compiles regardless of type T. You use trait bounds to define the ”interface” of T. If you do potentially illegal operations to type T the compiler gives you an error.

Trait bounds also offer a nice compile time interface mechanism. Compiler is able to track the actual type under the hood without needing to add any runtime code. Generates faster code than C++ interfaces with virtual functions. And type safety is better.

I really love how Rust forces the programmer to think about lifetimes, mutable data and races (mutable data accessible by other ref). Compiler validation gives programmer immediate feedback. Try using mutable globals, and you will rethink soon after fighting the compiler :)

C++ obj life time bugs, overflow bugs and thread races silently corrupt memory (likely crash later). Can’t reliably catch these with unit tests (incl must crash). Rust enforces life times, disallows races and overflow = panic. Unit tests are more reliable, esp failure tests.

Rust needs less (hand written) unit tests and debugging than C++, because Rust: A) is a strongly typed language, B) generics are not duck typed, C) obj/ref lifetime issues = compiler error, D) data races = compiler error. E) array overflows = panic...

Like C/C++, Rust uses stack for vars/structs by default. Built-in growing containers (Vec/String) internally alloc elem array from heap, because size is not known at compile time. Stack as default -> similar perf to C/C++. Safety is also better than most slow heap/GC based langs.

Rust does compile time borrow checking for variables, refs, String, Vec<T>, Box<T> (unique_ptr)... but Rc<T> (shared_ptr) refs are immutable to prevent races. RefCell<T> can be used inside Rc<T> to allow mutation with runtime borrow checking (panic if potential race).