Okay, hi everybody, I am Scott.

My mentor is Nico. I am from

Perdue University. I am a PhD student.

My talk is on MIR Optimizations. I work on

the rust compiler. So this is the "get

pumped up!" slide. I'm going to tell you

these things and feel free to cheer

whenever you're ready. Do you want faster

programs? Yeah!

[audience cheering "yeah!"]

[audience laughs]

Do you want longer battery life?

[audience cheering "hell yeah!]

Do you want more free memory?

[audience cheering]

We want all these things and how are we

going to get them? We're going to get them

through compiler optimization.

[audience laughs]

Okay, so I need to do some background

before I jump into what I did this summer, but

it's going to be pretty brief and high

level, so I'll go fast just so we're all

on the same page. We start from the Rust

Source, which Cameron talked about Rust

in his previous presentation. Basically

it's a high level systems programming

language. And the compiler doesn't just

compile Rust line by line in the machine

code, it goes through intermediate steps.

It compiles the Rust Source to High Level

Intermediate Representation to LLVM

Intermediate Remediation, and then to

Machine Code. This is pretty much how most

compilers work of high level (incoherent)

languages. You don't want to go from

Source to Machine Code in one step.

What we do recently--actually today the

Rust team flipped the switch and now MIR

is part of the Rust Compiler. MIR stands

for "Middle Intermediate Representation"

and it's coincidentally the same name of a

space ship...that's the space ship.

So what did we do? There's now a tiny

space ship in the compiler and it's

between the High Level and LLVM IR.

So, why would we do this? What's MIR

good for? Basically, it's the simple core

of Rust. It makes things explicit that

were not explicit in Rust's code because

you wouldn't want the [incoherent] to

detect these things out, obviously. Types

of variables should be elighted in certain