FOMO is nigh

FOMO

Breaking point

Wisdom

Your very own programming language

Your very own prog. lang. tooling

Terminals ❤️ GPU

Reinventing the wheel POSIX

WebAssembly everywhere

🔪🔪 VSCode 🔥🔥

Are we game yet

🔪🔪 Electron 🔥🔥

The last frontier

And more

I’m convinced!

• I want to reinvent the wheel
• I just feel like it
• I might have a use case for it…?     ⬅️ mostly about this

Performance

What is different about systems programming?

Many things: precise control over data layout, memory management, raw access to hardware, ...

Hey, hey, hey...
Just say "performance"

Byte munching

struct Person {
  employee_id: usize,
  shirt_color: [u8; 3]
}

let contents = std::fs::read_to_string("config.json")?;

foo_read_something(&contents);

fn foo_read_something(source: &str) {
  // ...
}

fn bar_traverse_something(iter: impl IntoIterator) {
  /* ... */
}

bar_traverse_something(vec![1, 2, 3]);
bar_traverse_something(&['a', 'b', '💩']);

Can’t we have nice things?

std::thread::spawn(|| {
  do_stuff();
});

fn poll(fut: Pin<&mut Fut>) -> /* ... */ {
  unsafe {
    let data = fut.get_unchecked_mut();
    data.do_something();
  }
}

let name: &str = "Jia Tan";
let owned: String = name.to_string();
let c_name: CString = CString::new(name)?;
let os_name: OSString = OsString::from(owned);
let path_name: &Path = Path::new(name);

bool p;

if (p) {
    puts("p is true");
}

if (!p) {
    puts("p is false");
}

p is true
p is false

🙃🙃🙃🙃

vector<char> v(1, 'a');

char* first = &v[0];

v.push_back('b');
v.push_back('c');

std::cout << "*first (v[0]) = " << *first << std::endl;

If after the operation the new size() is greater than old capacity() a reallocation takes place, in which case all iterators (including the end() iterator) and all references to the elements are invalidated. Otherwise only the end() iterator is invalidated

Meet the borrow checker

let mut v = vec!['a'];

let first = &v[0];

v.push('b');
v.push('c');

println!("first (v[0]) = {first}");

error: cannot borrow `v` as mutable because it is also borrowed as immutable
   |
   | let first = &v[0];
   |              - immutable borrow occurs here
   |
   | v.push('b');
   | ^^^^^^^^^^^ mutable borrow occurs here
...
   |  println!("first (v[0]) = {first}");
   |                           ------- immutable borrow later used here

Meet the borrow checker

let mut counter = 0;

let shared = &mut counter;

for _ in 0..10 {
  std::thread::spawn(|| {
*shared += 1;
  });
}

error: two closures require unique access to `*shared` at the same time
   |
   |     std::thread::spawn(|| {
   |     -                  ^^ closures are constructed here in different iterations of loop
   |  ___|
   | |
   | |     *shared += 1;
   | |     ------- borrows occur due to use of `*shared` in closure
   | |   });
   | |____- argument requires that `*shared` is borrowed for `'static`