in 10 mins

the new C++ ?

impossible in 10 min !

It's "new"

  • was born in 2006 - Graydon Hoare
  • 2009      ----------------------->
  • 2010 announced
  • 2012 alpha version
  • 1.0 released in 2015  => 
  • 1.15 February 2, 2017
  • 1.29.2 October 10, 2018
  • 1.30.0 October 25, 2018

 

most loved programming language in:

2016, 2017 and 2018

- StackOverflow Survey

Multiparadigm

  • Imperative
  • Structured
  • Functional
  • Concurrent
  • Generic
  • Compiled
fn  function            (i: i32) -> i32 { i + 1 }
let closure_annotated = |i: i32| -> i32 { i + 1 };
let closure_inferred  = |i     |          i + 1  ;
Control flexibility
Double free
Dangling pointers
Buffer overflow
Data races

Comparison among other languages

Static Strong Typing

Inference

All variables are immutable by default

let elem = 5u8; //annotated as u8 type

let mut vec = Vec::new(); //growable array of something

vec.push(elem); // compiler knows now => Vec<u8>

Who's using it

  • Amazon - Building tools in Rust.
  • Atlassian - Using Rust in the backend.
  • Dropbox - Using Rust in both the FE/BE.
  • Facebook - Tools for source control.
  • Google - As part of the Fuchsia project.
  • Microsoft - Using Rust in part of their new Azure IoT work.
  • npm - Using Rust in some of the npm core services.
  • Red Hat - Creating a new storage system
  • Reddit - Using Rust in its comment processing
  • Twitter - As part of the build team support for Twitter.

Redox OS

  • Good abstraction

  • Memory safety ~ No GC

  • Good concurrency Handling

What provides Rust

Memory vulnerabilities

  • One owner per value
  • Assignments move ownership
  • Value is freed automatically when owner returns

Memory safety in Rust

fn main() {
  let name = String::new();
  save(name);
  save(name);  // Error: name was moved
}

fn save(name: String) {
  // this is taking ownership
  // then frees memory allocated for 'name'
}

shared

  • Others can read
  • No writers
  • Locks till it goes out of scope

mutable

  • No other readers or writers
  • Locks till it goes out of scope

when a reference is

Never have reader and writer at the same time

All is checked at compile time

fn main() {

  let immutable_box = Box::new(5u32);

  println!("immutable_box is {}", immutable_box); // 5

    // *Move* the box (change the ownership)
    // (and mutability)
  let mut mutable_box = immutable_box;

    // error! it's not owner
    // println!("immutable_box is {}", immutable_box);
    
  println!("mutable_box is {}", mutable_box); // 5

  *mutable_box = 4;
  println!("mutable_box now is {}", mutable_box); // 4

}

example

Good Abstraction

// Example 1
enum Event {
  Load,
  KeyPress(char),
  Click { x: i64, y: i64 }
}

fn print_event(event: Event) {
  match event {
    Event::Load => println!("Loaded"),
    Event::KeyPress(c) => println!("Key {} pressed", c),
    Event::Click {x, y} => println!("Clicked at x={}, y={}", x, y),
  }
}

// Example 2
fn load_images(paths: &[PathBuf]) -> Vec<Image> {
  paths.iter()
     .map(|path| Image::load(path))
     .collect()
}

// Example 3
fn main() {
  struct Dot { x: (u32, u32), y: u32 }
  let dot = Dot { x: (1, 2), y: 3 };
  let Dot { x: (a, b), y } = dot;
  println!("a: {}, b: {},  y: {} ", a, b, y);
}

Generics

Traits

Closures

High order Functions

Macros

Builtins

Unit Tests

Fast code

Cross-lang interoparation

Lifetimes

   Sharing

+ Mutation

+ No ordering

________________

    Data race

Rust does not allow both at the same time

and verifies it

at compile time

Concurrency

Use cases

  • WebAssembly (Wasm)
  • Microcontrollers & IoT
  • Low level
    • Operating Systems
    • Browsers
    • Servers
    • Tooling
    • ... more

Tooling


 
rustup nvm
cargo npm
rustfmt
clippy		 ~eslint
Rust Playground node REPL

Adoption

Last

1..1_000 thanks

Made with Slides.com