Rust - Speaker Deck

Slide 1

Slide 1 text

No content

Slide 2

Slide 2 text

a systems language pursuing the trifecta safe, concurrent, fast

Slide 3

Slide 3 text

No content

Slide 4

Slide 4 text

No content

Slide 5

Slide 5 text

No content

Slide 6

Slide 6 text

No content

Slide 7

Slide 7 text

No content

Slide 8

Slide 8 text

github.com/mozilla/servo

Slide 9

Slide 9 text

$ hg clone http://hg.mozilla.org/mozilla-central ... 66238 files updated, 0 files merged, 0 files removed, 0 files unresolved $ cd mozilla-central $ find . -name '*.c' -or -name '*.cpp' -or -name '*.h' -or -name '*.tbl' | xargs wc -l | fgrep total | awk '{total = total + $1}END{print total}' 5433119

Slide 10

Slide 10 text

2009: Graydon starts full-time work on Rust 2010: Team begins to grow 2011: Self-hosting via LLVM 2012: 0.1, 0.2, 0.3, 0.4 (soon), and beyond...

Slide 11

Slide 11 text

♥ The Rust Team Brian Anderson • Tim Chevalier • Graydon Hoare • Niko Matsakis • Patrick Walton Interns and Alumni Michael Bebenita • Ben Blum • Rafael Espíndola • Roy Frostig • Marijn Haverbeke • Eric Holk • Lindsey Kuper • Elliott Slaughter • Paul Stansifer • Michael Sullivan

Slide 12

Slide 12 text

• stack allocation • data ownership • monomorphisation and inlining • actors • message-passing • failure • type safety • pattern matching • type classes • no null

Slide 13

Slide 13 text

PERFORMANCE CONCURRENCY TYPES

Slide 14

Slide 14 text

FAST

Slide 15

Slide 15 text

“Sometimes, cleaning up your code makes it slower even when it shouldn’t.” — Robert O’Callahan “Abstraction Penalties, Stack Allocation and Ownership Types” http://j.mp/abstraction-penalties

Slide 16

Slide 16 text

let vec = [1, 2, 3]; vec.each(|item| { print(fmt!("%d ", item)); true });

Slide 17

Slide 17 text

let vec = [1, 2, 3]; for vec.each |item| { print(fmt!("%d ", item)); }

Slide 18

Slide 18 text

fn from_origin(x: float, y: float) -> float { let x0 = 0.0, y0 = 0.0; dist(x, y, x0, y0) }

Slide 19

Slide 19 text

struct Point { x: float, y: float }

Slide 20

Slide 20 text

fn from_origin(p: Point) -> float { let origin = Point { x: 0.0, y: 0.0 }; dist(p, origin) }

Slide 21

Slide 21 text

fn print_point(p: &Point) { match *p { Point {x,y} => println(fmt!("(%f, %f)", x, y)) } }

Slide 22

Slide 22 text

fn print_point(p: &Point) { match *p { Point {x,y} => println(fmt!("(%f, %f)", x, y)) } } fn f() { let p = Point { ... }; print_point(&p); }

Slide 23

Slide 23 text

let p = @Point { ... }; print_point(p);

Slide 24

Slide 24 text

let p = ~Point { ... }; print_point(p);

Slide 25

Slide 25 text

let p = ~Point { ... }; box.topLeft = move p; // deinitialized print_point(p); // error

Slide 26

Slide 26 text

let p; // uninitialized print_point(p); // error p = ~Point { ... };

Slide 27

Slide 27 text

Rust C++ &T! T& @T! shared_ptr ~T! unique_ptr

Slide 28

Slide 28 text

CONCURRENT

Slide 29

Slide 29 text

heap

Slide 30

Slide 30 text

heap

Slide 31

Slide 31 text

heap

Slide 32

Slide 32 text

No content

Slide 33

Slide 33 text

Shared Heap

Slide 34

Slide 34 text

Shared Heap

Slide 35

Slide 35 text

Shared Heap

Slide 36

Slide 36 text

let (ch, port) = pipes::stream(); do spawn |move ch| { let s = ~Point { x: 1.0, y: 2.0 }; ch.send(s); } let s = port.recv(); assert s.x == 1.0; assert s.y == 2.0;

Slide 37

Slide 37 text

SAFE

Slide 38

Slide 38 text

fn is_empty(v: &[T]) -> bool { v.len() == 0 }

Slide 39

Slide 39 text

struct Monster { name: &str, mut health: int } struct Player { mut health: int }

Slide 40

Slide 40 text

impl Monster { fn attack(&self, player: &Player) { player.health -= 10; } } monster.attack(&player);

Slide 41

Slide 41 text

trait ToJSON { fn to_json(&self) -> ~str; }

Slide 42

Slide 42 text

impl Monster : ToJSON { fn to_json(&self) -> ~str { fmt!(...) } } impl Player : ToJSON { fn to_json(&self) -> ~str { fmt!(...) } }

Slide 43

Slide 43 text

fn save(x: &T, file: &str) { let writer = file_writer(...).get(); writer.write(x.to_json()); } save(&player, "p.json"); save(&monster, "m.json");

Slide 44

Slide 44 text

struct Chan { ... } impl Chan { fn send(&self, x: T) { ... } }

Slide 45

Slide 45 text

struct ARC { ... }

Slide 46

Slide 46 text

let img: Image = load_image(); let handle0: ARC = ARC(move img); for N.times { let handle = handle0.clone(); do spawn |move handle| { display_image(handle); } }

Slide 47

Slide 47 text

Modula-3 unsafe module Java native sun.misc.Unsafe Ocaml Obj.magic Haskell unsafePerformIO Rust unsafe { ... }

Slide 48

Slide 48 text

regions, region subtyping & polymorphism, arenas traits as existentials mutability tracking, purity, and borrow checking freezing/thawing data structures task-local storage linked failure one-shot closures macros

Slide 49

Slide 49 text

Good reads smallcultfollowing.com/babysteps pcwalton.github.com

Slide 50

Slide 50 text

Join us rust-lang.org [email protected] irc.mozilla.org :: #rust

Slide 51

Slide 51 text

Thank you.

Slide 52

Slide 52 text

Image credits Sean Martell http://blog.seanmartell.com Martyn http://www.flickr.com/photos/martyn/438111857/in/set-102261 Ian Kobylanski http://www.flickr.com/photos/iankobylanski/6151659680 Sudhir Naik http://www.flickr.com/photos/sudhirnaik/4890017884/ Thomas Gibbard http://www.flickr.com/photos/22305783@N06/3947478553