Who Am I?

https://haltcondition.net

@tarka.haltcondition.net

Getting out of trouble by Understanding Git

Continuous Deployment for a Billion Dollar Order System

xcp: experimental accelerated & pluggable unix copy

@tarkasteve@hachyderm.io

How I Learned to Stop Worrying and Love the Borrow Checker

https://haltcondition.net

@tarkasteve@hachyderm.io

@tarka.haltcondition.net

Recap: Mutability Rules

https://haltcondition.net

@tarkasteve@hachyderm.io

@tarka.haltcondition.net

 fn mult_mut_example() {
    let mut x = 1;
    let mx1 = &mut x;
	let mx2 = &mut x;
 
    *mx1 = 2;
    println!("X = {}", mx2);
}

 | let mx1 = &mut x;                                                                         ▐
|           ------ first mutable borrow occurs here
| let mx2 = &mut x;
|           ^^^^^^ second mutable borrow occurs here

Recap: Mutability Rules

https://haltcondition.net

@tarkasteve@hachyderm.io

@tarka.haltcondition.net

 fn mut_immut_example() {
    let mut x = 1;
	let rox = &x;
    let mx1 = &mut x;
 
    *mx1 = 2;
    println!("X = {}", rox);
 }

 | let rox = &x;
|           ^^ immutable borrow occurs here
| let mx1 = &mut x;
|           ------ mutable borrow occurs here
|
| *mx1 = 2;
| -------- mutable borrow later used here

Recap: Move & Borrow

https://haltcondition.net

@tarkasteve@hachyderm.io

@tarka.haltcondition.net

 fn my_fn() {
    let person = get_person();
    save_person(person);
    println!("Name = {}", person.name);
}

 fn save_person(person: Person) {
    DB::write(person);
}

 | let person = Person { name: "test" };
|     ------ move occurs because `person` has type `Person`,
|            which does not implement the `Copy` trait
|
| save_person(person);
|             ------ value moved here
| println!("Name is {}", person.name);
|                        ^^^^^^^^^^^ value borrowed here after move

Recap: Move & Borrow

https://haltcondition.net

@tarkasteve@hachyderm.io

@tarka.haltcondition.net

 fn my_fn() {
    let person = get_person();
    let person2 = save_person(person);
    println!("Name = {}", person2.name);
}

 fn save_person(person: Person) {
    DB::write(person);
    return person;
}

Recap: Move & Borrow

https://haltcondition.net

@tarkasteve@hachyderm.io

@tarka.haltcondition.net

 fn my_fn() {
    let person = get_person();
    save_person(&person);
    println!("Name = {}", person.name);
}

 fn save_person(person: &Person) {
    DB::write(person);
}

Garbage Collection

https://haltcondition.net

@tarkasteve@hachyderm.io

@tarka.haltcondition.net

All languages are Garbage Collected

https://haltcondition.net

@tarkasteve@hachyderm.io

@tarka.haltcondition.net

All languages are Garbage Collected

https://haltcondition.net

@tarkasteve@hachyderm.io

@tarka.haltcondition.net

All languages are Garbage Collected

https://haltcondition.net

@tarkasteve@hachyderm.io

@tarka.haltcondition.net

 void func() {
    int myNumbers[] =
        {1, 2, 3, ...};
   	int num = 512;
 
	int *ptr1 = 
    	(int*)malloc(n * sizeof(int));
 
	int *ptr2 = 
    	(int*)malloc(n / 2 * sizeof(int));
    
	// Some stuff with ptrs
 
	free(ptr1);
}

The Borrow Checker is GC

https://haltcondition.net

@tarkasteve@hachyderm.io

@tarka.haltcondition.net

 fn my_fn() {
    let person = get_person();
    save_person(person);
    println!("Name = {}", person.name);
}

 fn save_person(person: Person) {
    DB::write(person);
}

The Compiler is GC

free(person);

https://haltcondition.net

@tarkasteve@hachyderm.io

@tarka.haltcondition.net

The Compiler is Resource Management

 pub trait Drop {
    fn drop(&mut self);
}

https://haltcondition.net

@tarkasteve@hachyderm.io

@tarka.haltcondition.net

The Compiler is Resource Management

 pub trait Drop {
    fn drop(&mut self);
}

 struct File {
	fd: u64;
}
 
impl File {
	fn open(path: String) -> File {
    	let fd = libc::open(path);
        File { fd }
    }
}

 impl Drop for File {
	fn drop(&self) {
    	libc::close(self.fd);
    }
}

https://haltcondition.net

@tarkasteve@hachyderm.io

@tarka.haltcondition.net

The Compiler is Resource Management

 pub trait Drop {
    fn drop(&mut self);
}

 impl Drop for File {
	fn drop(&self) {
    	libc::close(self.fd);
    }
}

 fn sum_file(path: String) -> u64 {
	let file = File::open(path);
 
	let sum = file.iter().sum();
	sum
}

🚫 libc::close(self.fd);

https://haltcondition.net

@tarkasteve@hachyderm.io

@tarka.haltcondition.net

The Compiler is Resource Management

 fn do_lots_of_stuff() -> bool {
 
	let data = generate_data();
 
    {
    	let file = File::open(path);
        file.write(data.raw());
    } // 🚫 File closed here
    
	println!("SHA256 of data is {}", data.sha256());
}

'file

https://haltcondition.net

@tarkasteve@hachyderm.io

@tarka.haltcondition.net

The Compiler is Resource Management

 fn do_lots_of_stuff() -> bool {
 
	let data = {
    	let file = File::open(path);
        file.read_all()
    }; // 🚫 File closed here
    
	println!("SHA256 of data is {}", data.sha256());
}

'file

https://haltcondition.net

@tarkasteve@hachyderm.io

@tarka.haltcondition.net

The Compiler is Resource Management

 fn do_lots_of_stuff() -> bool {
 
	let data = {
    	let file = File::open(path);
        file.read_all()
    }; // 🚫 File closed here
    
	println!("SHA256 of data is {}",
 			 data.sha256());
}

 fn do_lots_of_stuff() -> bool {
 
	let file = File::open(path);
	let data = file.read_all();
 
	drop(file); // 🚫 File closed
    
	println!("SHA256 of data is {}",
 			 data.sha256());
}

'file

Stack & Heap

https://haltcondition.net

@tarkasteve@hachyderm.io

@tarka.haltcondition.net

Stack & Heap

https://haltcondition.net

@tarkasteve@hachyderm.io

@tarka.haltcondition.net

  
void func() {
    int myNumbers[] =
        {1, 2, 3, ...};
    
    
    
	int num = 512;
 
 
	int *ptr1 = 
    	(int*)malloc(n * sizeof(int));
 
	int *ptr2 = 
    	(int*)malloc(n / 2 * sizeof(int));
    
	// Some stuff with ptrs
 
	free(ptr1);
}

Stack

Heap

Stack & Heap

https://haltcondition.net

@tarkasteve@hachyderm.io

@tarka.haltcondition.net

array

integer

ptr1

ptr2

data

  
void func() {
    int myNumbers[] =
        {1, 2, 3, ...};
    
    
    
	int num = 512;
 
 
	int *ptr1 = 
    	(int*)malloc(n * sizeof(int));
 
	int *ptr2 = 
    	(int*)malloc(n / 2 * sizeof(int));
    
	// Some stuff with ptrs
 
	free(ptr1);
}

Stack

Heap

Stack & Heap

https://haltcondition.net

@tarkasteve@hachyderm.io

@tarka.haltcondition.net

array

integer

ptr1

ptr2

data

  
void func() {
    int myNumbers[] =
        {1, 2, 3, ...};
    
    
    
	int num = 512;
 
 
	int *ptr1 = 
    	(int*)malloc(n * sizeof(int));
 
	int *ptr2 = 
    	(int*)malloc(n / 2 * sizeof(int));
    
	// Some stuff with ptrs
 
	free(ptr1);
}

Stack

Heap

Stack & Heap

https://haltcondition.net

@tarkasteve@hachyderm.io

@tarka.haltcondition.net

data

Stack

Heap

Heap in Rust

https://haltcondition.net

@tarkasteve@hachyderm.io

@tarka.haltcondition.net

 fn do_boxed() {
	let array = 
        [1, 2, 3, 4, ...];
 
 
	let boxed =
    	Box::new(array);
 
 
	println!("Box size is {}", 
    	     boxed.len());
             
}

array

Stack

Heap

Heap in Rust

https://haltcondition.net

@tarkasteve@hachyderm.io

@tarka.haltcondition.net

 fn do_boxed() {
	let array = 
        [1, 2, 3, 4, ...];
 
 
	let boxed =
    	Box::new(array);
 
 
	println!("Box size is {}", 
    	     boxed.len());
             
}

array

boxed

Stack

Heap

Heap in Rust

https://haltcondition.net

@tarkasteve@hachyderm.io

@tarka.haltcondition.net

 fn do_boxed() {
	let array = 
        [1, 2, 3, 4, ...];
 
 
	let boxed =
    	Box::new(array);
 
 
	println!("Box size is {}", 
    	     boxed.len());
             
}

Stack

Heap

'boxed

Heap GC in Rust

https://haltcondition.net

@tarkasteve@hachyderm.io

@tarka.haltcondition.net

 impl<T> Box<T> {
    /// Allocates memory on the heap
    /// and then places `x` into it.
    pub fn new(x: T) -> Self {
        #[rustc_box]
        // Compiler inserts malloc()
        // magic here.
    }
}
 
impl Drop for Box<T> {
    fn drop(&mut self) {
    	self.ptr.deallocate();
    }
}

 fn my_fn() {
	let data = ...;
    let boxed = Box::new(data);
    
    // Do some stuff
 
}

🚫 deallocate();

Box in std

https://haltcondition.net

@tarkasteve@hachyderm.io

@tarka.haltcondition.net

Vec<> and vec![]

String

Rc<>

Arc<>

Sharing

https://haltcondition.net

@tarkasteve@hachyderm.io

@tarka.haltcondition.net

https://haltcondition.net

@tarkasteve@hachyderm.io

@tarka.haltcondition.net

Sharing & Lifetimes

 struct First<'a> {
    image: &'a Vec<u8>,
    // Other stuff
}
 
struct Second<'b> {
    image: &'b Vec<u8>,
    // Different stuff
}

 fn main() {
	let image = load_image();
 
	let first = First {
		image: &image
	};
	let second = Second {
		image: &image
	};
    
   	process_first(first);
  	process_second(second);
}

'a

'image

'b

https://haltcondition.net

@tarkasteve@hachyderm.io

@tarka.haltcondition.net

Rc<>

  
let array = [1, 2, 3, 4, ...];

array

Stack

Heap

https://haltcondition.net

@tarkasteve@hachyderm.io

@tarka.haltcondition.net

Rc<>

  
let array = [1, 2, 3, 4, ...];
 
 
let rc = Rc::new(array);

array

rc

Stack

Heap

https://haltcondition.net

@tarkasteve@hachyderm.io

@tarka.haltcondition.net

Rc<>

  
let array = [1, 2, 3, 4, ...];
 
 
let rc = Rc::new(array);
 
 
let rc2 = rc.clone();

rc

rc2

Stack

Heap

array

https://haltcondition.net

@tarkasteve@hachyderm.io

@tarka.haltcondition.net

Rc<>

  
let array = [1, 2, 3, 4, ...];
 
 
let rc = Rc::new(array);
 
 
let rc2 = rc.clone();
 
drop(rc);

rc2

Stack

Heap

array

https://haltcondition.net

@tarkasteve@hachyderm.io

@tarka.haltcondition.net

Rc<>

  
let array = [1, 2, 3, 4, ...];
 
 
let rc = Rc::new(array);
 
 
let rc2 = rc.clone();
 
drop(rc);
drop(rc2);

Stack

Heap

array

https://haltcondition.net

@tarkasteve@hachyderm.io

@tarka.haltcondition.net

Rc<>

  
let array = [1, 2, 3, 4, ...];
 
 
let rc = Rc::new(array);
 
 
let rc2 = rc.clone();
 
drop(rc);
drop(rc2);

Stack

Heap

https://haltcondition.net

@tarkasteve@hachyderm.io

@tarka.haltcondition.net

Rc<> vs Lifetimes

 struct First {
    image: Rc<Vec<u8>>,
}
 
struct Second {
    image: Rc<Vec<u8>>,
}

 let image = load_image();
 
let img_rc = Rc::new(image);
 
let ms1 = First {
	image: img_rc.clone()
};
let ms2 = Second {
	image: img_rc.clone()
};
 
drop(img_rc);
 
// First & Second carry on existing

Threads

https://haltcondition.net

@tarkasteve@hachyderm.io

@tarka.haltcondition.net

https://haltcondition.net

@tarkasteve@hachyderm.io

@tarka.haltcondition.net

Threads

 use std::thread;
 
struct Config {
    go_fast: bool,
    avatar: Vec<u8>
}
 
let config = Config {
	go_fast: true,
    avatar: load_avatar(),
};

https://haltcondition.net

@tarkasteve@hachyderm.io

@tarka.haltcondition.net

Threads

 fn main() {
	let config = Config {
		go_fast: true,
    	avatar: load_avatar(),
	};
    let ref1 = &config;
 
	let backend_thread = thread::spawn(move || backend(ref1) );
    
    backend_thread.join().unwrap();
}

 error[E0597]: `config` does not live long enough
|
| let config = Config {
|     ------ binding `config` declared here
...
| let ref1 = &config;
|            ^^^^^^^ borrowed value does not live long enough

'config

'?

https://haltcondition.net

@tarkasteve@hachyderm.io

@tarka.haltcondition.net

Threads & Rc<>

 let config = Config {
	go_fast: true,
    avatar: load_avatar(),
};
let rc = Rc::new(config);
let rc2 = rc.clone();
 
let backend_thread = thread::spawn(move || backend(rc2) );

 | let backend_thread = thread::spawn(|| backend(rc) );
|                      ------------- --^^^^^^^^^^^^^^^^^^^
|                      |             |
|                      |             `Rc<Config>` cannot be sent between threads safely
|                      required by a bound introduced by this call
|
= help: the trait `std::marker::Send` is not implemented for `Rc<Config>`

Traits & Markers

https://haltcondition.net

@tarkasteve@hachyderm.io

@tarka.haltcondition.net

https://haltcondition.net

@tarkasteve@hachyderm.io

@tarka.haltcondition.net

Traits as Constraint Marker

 pub fn spawn<F, T>(f: F) -> JoinHandle<T>
where
    F: FnOnce() -> T,
    F: Send + 'static,
    T: Send + 'static,
{
    Builder::new().spawn(f).expect("failed to spawn thread")
}

https://haltcondition.net

@tarkasteve@hachyderm.io

@tarka.haltcondition.net

Send + Sync

 pub unsafe auto trait Sync {
    // Empty
}

 pub unsafe auto trait Send {
    // empty
}

Data is Send if it can be sent between threads safely.

This means No Unsafe Mutable.

Data is Sync if it can be shared between threads safely.

It promises that data is Mutable Safely. i.e. Mutexes & Atomics.

https://haltcondition.net

@tarkasteve@hachyderm.io

@tarka.haltcondition.net

Send + Sync

 pub unsafe auto trait Sync {
    // Empty
}

 pub unsafe auto trait Send {
    // empty
}

The compiler will auto-apply Send/Sync if all fields are Send/Sync.

Data is Send if it can be sent between threads safely.

This means No Unsafe Mutable.

Data is Sync if it can be shared between threads safely.

It promises that data is Mutable Safely. i.e. Mutexes & Atomics.

https://haltcondition.net

@tarkasteve@hachyderm.io

@tarka.haltcondition.net

'static

 fn get_name() -> &'static str {
	"Steve"
}

 struct StaticData {
    avatar: Vec<u8>,
    uuid: String,
}
 
struct NotStatic<'a> {
    image: &'a Vec<u8>,
}

"A reference lifetime 'static indicates that the data pointed to by the reference lives for the remaining lifetime of the running program."

"A 'static trait bound means the type does not contain any non-static references."

https://haltcondition.net

@tarkasteve@hachyderm.io

@tarka.haltcondition.net

Threads and Rc

 pub fn spawn<F, T>(f: F) -> JoinHandle<T>
where
    F: FnOnce() -> T,
    F: Send + 'static,
    T: Send + 'static,
{
	// ...
}
 
let rc = Rc::new(config);
 
let backend_thread = thread::spawn(|| backend(rc) );

https://haltcondition.net

@tarkasteve@hachyderm.io

@tarka.haltcondition.net

Threads and Rc

 impl<T> !Send for Rc<T> {}
 
impl<T> !Sync for Rc<T> {}

https://haltcondition.net

@tarkasteve@hachyderm.io

@tarka.haltcondition.net

Threads and Rc

 let config = Config {
	go_fast: true,
    avatar: load_avatar(),
};
let arc1 = Arc::new(config);
let arc2 = rc.clone();
 
let backend_thread = thread::spawn(move || backend(arc1) );
let frontend_thread = thread::spawn(move || frontend(arc2) );

https://haltcondition.net

@tarkasteve@hachyderm.io

@tarka.haltcondition.net

Arc is Atomic

 struct ArcInner<T> {
    strong: atomic::AtomicUsize,
 
	weak: atomic::AtomicUsize,
 
    data: T,
}

 unsafe impl<T: Sync + Send> Send for Arc<T> {}
unsafe impl<T: Sync + Send> Sync for Arc<T> {}

Async

https://haltcondition.net

@tarkasteve@hachyderm.io

@tarka.haltcondition.net

Async

https://haltcondition.net

@tarkasteve@hachyderm.io

@tarka.haltcondition.net

https://emschwartz.me/async-rust-can-be-a-pleasure-to-work-with-without-send-sync-static/

https://haltcondition.net

@tarkasteve@hachyderm.io

@tarka.haltcondition.net

Conclusion & Links

Rustonomicon

Rust Design Patterns

Evan Schwartz

https://haltcondition.net

@tarkasteve@hachyderm.io

@tarka.haltcondition.net

	fn mult_mut_example() {
	let mut x = 1;
	let mx1 = &mut x;
	let mx2 = &mut x;

	*mx1 = 2;
	println!("X = {}", mx2);
	}

	\| let mx1 = &mut x; ▐
	\| ------ first mutable borrow occurs here
	\| let mx2 = &mut x;
	\| ^^^^^^ second mutable borrow occurs here

	fn mut_immut_example() {
	let mut x = 1;
	let rox = &x;
	let mx1 = &mut x;

	*mx1 = 2;
	println!("X = {}", rox);
	}

	\| let rox = &x;
	\| ^^ immutable borrow occurs here
	\| let mx1 = &mut x;
	\| ------ mutable borrow occurs here
	\|
	\| *mx1 = 2;
	\| -------- mutable borrow later used here

	fn my_fn() {
	let person = get_person();
	save_person(person);
	println!("Name = {}", person.name);
	}

	\| let person = Person { name: "test" };
	\| ------ move occurs because `person` has type `Person`,
	\| which does not implement the `Copy` trait
	\|
	\| save_person(person);
	\| ------ value moved here
	\| println!("Name is {}", person.name);
	\| ^^^^^^^^^^^ value borrowed here after move

	fn my_fn() {
	let person = get_person();
	let person2 = save_person(person);
	println!("Name = {}", person2.name);
	}

	fn save_person(person: Person) {
	DB::write(person);
	return person;
	}

	fn my_fn() {
	let person = get_person();
	save_person(&person);
	println!("Name = {}", person.name);
	}

	void func() {
	int myNumbers[] =
	{1, 2, 3, ...};
	int num = 512;

	int *ptr1 =
	(int)malloc(n sizeof(int));

	int *ptr2 =
	(int)malloc(n / 2 sizeof(int));

	// Some stuff with ptrs

	free(ptr1);
	}

	struct File {
	fd: u64;
	}

	impl File {
	fn open(path: String) -> File {
	let fd = libc::open(path);
	File { fd }
	}
	}

	fn sum_file(path: String) -> u64 {
	let file = File::open(path);

	let sum = file.iter().sum();
	sum
	}

	fn do_lots_of_stuff() -> bool {

	let data = generate_data();

	{
	let file = File::open(path);
	file.write(data.raw());
	} // 🚫 File closed here

	println!("SHA256 of data is {}", data.sha256());
	}

	fn do_lots_of_stuff() -> bool {

	let data = {
	let file = File::open(path);
	file.read_all()
	}; // 🚫 File closed here

	println!("SHA256 of data is {}", data.sha256());
	}

	fn do_lots_of_stuff() -> bool {

	let file = File::open(path);
	let data = file.read_all();

	drop(file); // 🚫 File closed

	println!("SHA256 of data is {}",
	data.sha256());
	}

	fn do_boxed() {
	let array =
	[1, 2, 3, 4, ...];


	let boxed =
	Box::new(array);


	println!("Box size is {}",
	boxed.len());

	}

	impl<T> Box<T> {
	/// Allocates memory on the heap
	/// and then places `x` into it.
	pub fn new(x: T) -> Self {
	#[rustc_box]
	// Compiler inserts malloc()
	// magic here.
	}
	}

	impl Drop for Box<T> {
	fn drop(&mut self) {
	self.ptr.deallocate();
	}
	}

	fn my_fn() {
	let data = ...;
	let boxed = Box::new(data);

	// Do some stuff

	}

	struct First<'a> {
	image: &'a Vec<u8>,
	// Other stuff
	}

	struct Second<'b> {
	image: &'b Vec<u8>,
	// Different stuff
	}

	fn main() {
	let image = load_image();

	let first = First {
	image: &image
	};
	let second = Second {
	image: &image
	};

	process_first(first);
	process_second(second);
	}

Understanding Rust


	let array = [1, 2, 3, 4, ...];


	let rc = Rc::new(array);


	let rc2 = rc.clone();

	struct First {
	image: Rc<Vec<u8>>,
	}

	struct Second {
	image: Rc<Vec<u8>>,
	}

	let image = load_image();

	let img_rc = Rc::new(image);

	let ms1 = First {
	image: img_rc.clone()
	};
	let ms2 = Second {
	image: img_rc.clone()
	};

	drop(img_rc);

	// First & Second carry on existing

	use std::thread;

	struct Config {
	go_fast: bool,
	avatar: Vec<u8>
	}

	let config = Config {
	go_fast: true,
	avatar: load_avatar(),
	};

	error[E0597]: `config` does not live long enough
	\|
	\| let config = Config {
	\| ------ binding `config` declared here
	...
	\| let ref1 = &config;
	\| ^^^^^^^ borrowed value does not live long enough

	\| let backend_thread = thread::spawn(\|\| backend(rc) );
	\| ------------- --^^^^^^^^^^^^^^^^^^^
	\| \| \|
	\| \| `Rc<Config>` cannot be sent between threads safely
	\| required by a bound introduced by this call
	\|
	= help: the trait `std::marker::Send` is not implemented for `Rc<Config>`

	pub fn spawn<F, T>(f: F) -> JoinHandle<T>
	where
	F: FnOnce() -> T,
	F: Send + 'static,
	T: Send + 'static,
	{
	Builder::new().spawn(f).expect("failed to spawn thread")
	}

	struct StaticData {
	avatar: Vec<u8>,
	uuid: String,
	}

	struct NotStatic<'a> {
	image: &'a Vec<u8>,
	}

	struct ArcInner<T> {
	strong: atomic::AtomicUsize,

	weak: atomic::AtomicUsize,

	data: T,
	}

	unsafe impl<T: Sync + Send> Send for Arc<T> {}
	unsafe impl<T: Sync + Send> Sync for Arc<T> {}