Follow the slides at the URL on the FlipChart

Copy source code into http://play.integer32.com

Don't hesitate to ask questions.

Long discussion at the end.

Rust is a systems programming language that runs blazingly fast, prevents segfaults, and guarantees thread safety.

Control + Performance

Safety

C

C++

Java

JS

Python

Ruby

fn main() {
    println!("Hello, world!");
}

Hello, World!

Everything is an Expression

fn add_one(x: i32) -> i32 {
    x + 1
}

Functions

fn main() {
    let x = 5;
    x = 6;
    println!("{}", x);
}

Immutability by default

Zero allocations by default

• no implicit copies
• parameters passed by move per default
• types are noncopyable by defalut
• implicit and explicit copies possible via marker traits

Rust is safe

Ownership + Borrowing

• unique (as of September 2016) feature of the rust programming language
• each memory address is assigned a single scope that owns the memory
• memory is deallocated when scope ends
• compiler checks correctness at compile time
• automatic memory management with zero runtime overhead (as opposed to Garbage Collection)

fn take(x: Vec<i64>) {
    // what happens in here is not important
}

Ownership

fn take(x: Vec<i64>) -> Vec<i64> {
    // what happens in here is
    // not important
    x
}

Ownership transfer

Any borrow must last for a scope no greater than that of the owner. Second, you may have one or the other of these two kinds of borrows, but not both at the same time:

1. one or more references (&T) to a resource
2. exactly one mutable reference (&mut T).

Borrowing

fn append2(x: &mut Vec<i64>) {
    x.push(2);
}

fn main() {
    let mut x = vec![5, 6, 7];
    append2(&mut x);
    println!("{:?}", x);
}

// output: [5, 6, 7, 2]

Borrowing

fn main() {
    let mut x = 5;

    let y = &mut x;    // -+ &mut borrow of x starts here
                       //  |
    *y += 1;           //  |
                       //  |
    println!("{}", x); // -+ - try to borrow x here
}                      // -+ &mut borrow of x ends here

Borrow Checking

Borrow Checking

Objects

struct Data {
    number: i64,
}

Iterator Trait

// from rusts std library
trait Iterator<T> {
    fn next() -> Option<T>;
}

fn main() {
    let v = vec![1, 12, 8, 17, 34, 19, 2, 1, 19, 32, 37]
        .into_iter()             // convert vector into iterator
        .filter(|x| x % 2 == 0)  // filter even numbers 
        .map(|x| x / 2)          // divide numbers by two
        .collect::<Vec<_>>();    // collect iterator into vector
    println!("{:?}", v);
}

// output: [6, 4, 17, 1, 16]

Let's build an unique() iterator adapter

struct UniqueIterator<I,T>
{
    iter: I,
    seen_elements: HashSet<T>,
}

Let's build an unique() iterator adapter

trait UniqueIteratorAdapter<T>: Iterator<Item = T> + Sized
    where T: Hash + Eq + Clone
{
    fn unique(self) -> UniqueIterator<Self, T> {
        UniqueIterator {
            iter: self,
            seen_elements: HashSet::new(),
        }
    }
}

impl<I, T> UniqueIteratorAdapter<T> for I
    where I: Iterator<Item = T> + Sized,
          T: Hash + Eq + Clone
{
}

fn main() {
    let data = vec![1, 12, 15, 1, 12, 3, 5].into_iter().unique().collect::<Vec<_>>();
    println!("{:?}", data);
}
// output:
[1, 12, 15, 3, 5]

Concurrency

Prelude: Closures

fn main() {
    let plus_one = |x: i32| x + 1;

    let y = plus_one(1);
    println!("{}", y);
}
// output: 2

Rusts Concurrency Story

• like C++ (but unlike other languages like Go), Rust does not have much in the language itself to leverage concurrency
• but Rust is a great language for writing concurrent programs!
• type system features that enable Rust to avoid segfaults also enable safe usage of concurrency
• safe usage of concurrency means: no data races, no dangling pointers, no undefined behavior, no shutdown bugs, ....

Threads

fn main() {
    thread::spawn(
        || println!("Hello from another thread!"));
}

Thread Safety

fn main() {
    let mut data = vec![1, 2, 3];

    for i in 0..3 {
        thread::spawn( || {
            data[0] += i;
        });
    }

    thread::sleep(
        Duration::from_millis(50));
}

Thread Safety

fn main() {
    let mut data = vec![1, 2, 3];

    for i in 0..3 {
        thread::spawn(move || {
            data[0] += i;
        });
    }

    thread::sleep(
        Duration::from_millis(50));
}

Thread Safety

fn main() {
    // Rc is a reference counted smart pointer
    let mut data = Rc::new(vec![1, 2, 3]);

    for i in 0..3 {
        // create a new owned reference
        let data_ref = data.clone();

        // use it in a thread
        thread::spawn(move || {
            data_ref[0] += i;
        });
    }

    thread::sleep(Duration::from_millis(50));
}

Thread Safety

fn main() {
    // Arc is a atomic reference counted smart pointer
    let mut data = Arc::new(vec![1, 2, 3]);

    for i in 0..3 {
        // create a new owned reference
        let data_ref = data.clone();

        // use it in a thread
        thread::spawn(move || {
            data_ref[0] += i;
        });
    }

    thread::sleep(Duration::from_millis(50));
}

Thread Safety

fn main() {
    let data = Arc::new(Mutex::new(vec![1, 2, 3]));

    for i in 0..3 {
        let data = data.clone();
        thread::spawn(move || {
            let mut data = data.lock().unwrap();
            data[0] += i;
        });
    }

    thread::sleep(Duration::from_millis(50));
}

Channels

fn main() {
    let (tx, rx) = mpsc::channel();

    for i in 1..10 {
        let tx = tx.clone();
        
        thread::spawn(move || {
            let answer = i * i;

            tx.send(answer).unwrap();
        });
    }

    for _ in 1..10 {
        println!("{}", rx.recv().unwrap());
    }
}

// output: 49 64 81 36 25 16 9 4 1 (order indeterministic)

Futures

Tooling

Developer Productivy

• not does Rust make developers productive by eliminating memory errors and data races
• but it also comes with lots of tooling to make development productive
  • cargo - a package manager, build tool and test runner
  • rustup - installs and runs different rust (cross) toolchains
  • debugging in recent versions of lldb, gdb, Visual Studio
  • rustc can produce static binaries, so docker containers can be very small (~10mb)
  • documentation tooling
  • code formatting
  • static analysis

cargo and crates.io

Error Handling

enum Option<T> {
    None,
    Some(T),
}

Creating a Rust project and using a 3rd party json serialization library

Documentation as tests

/// Circle represents a set of all points that have the same distance
/// to a point (x,y)
///
/// # Examples
///
/// ```
/// let circle = rustdoc_test::Circle{x: 0f64, y: 0f64, r: 10f64, z: 1};
/// println!("area: {}", circle.area());
/// ```
pub struct Circle {
    pub x: f64,
    pub y: f64,
    pub r: f64,
}

impl Circle {
    pub fn area(&self) -> f64 {
        std::f64::consts::PI * self.r * self.r
    }
}

Documentation as Tests

cargo test
   Compiling rustdoc-test v0.1.0 (file:///Users/jupp/projects/rustdoc-test)
    Finished debug [unoptimized + debuginfo] target(s) in 0.25 secs
     Running target/debug/deps/rustdoc_test-bd16c1b47357d9ca

running 0 tests

test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured

   Doc-tests rustdoc-test

running 1 test
test Circle_0 ... FAILED

failures:

---- Circle_0 stdout ----
        error[E0560]: struct `rustdoc_test::Circle` has no field named `z`
 --> <anon>:3:67
  |
3 |     let circle = rustdoc_test::Circle{x: 0f64, y: 0f64, r: 10f64, z: 1};
  |                                                                   ^

error: aborting due to previous error(s)

thread 'Circle_0' panicked at 'Box<Any>', ../src/librustc/session/mod.rs:183
note: Run with `RUST_BACKTRACE=1` for a backtrace.


failures:
    Circle_0

test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured

error: test failed

Thanks, Questions?