• The Rust compiler is built on top of LLVM.
  • Rust is a statically-typed language.
    • Rust has optional types for handling null and the compiler requires the None case to be handled.
    • Rust requires top-level items like function arguments and constants to have explicit types while allowing type inference inside of function bodies.
  • Rust’s strong type system and memory safety are all enforced at compile time!
    • Rust does not need to have a garbage collector!
    • Rust gives you the choice of storing data on the stack or on the heap.
    • Rust determines at compile time when memory is no longer needed and can be cleaned up.
  • Rust projects can be used as libraries by other programming languages via foreign-function interfaces.
    • This allows existing projects to incrementally replace performance-critical pieces with Rust code without the memory safety risks.
  • Rust is an ideal language for embedded and bare-metal development.
  • Borrow checker is the part of the compiler ensuring that references do not outlive the data they refer to.
  • When safe Rust is not able to express some concept, you can use unsafe Rust.
    • This enables more power, but the programmer is responsible for ensuring that the code is truly safe.
    • The unsafe code can be wrapped in higher-level abstractions which guarantee that all uses of the abstraction are safe.
  • Many aspects of creating and maintaining production-quality software such as testing, dependency management, documentation, etc. are first-class citizens in Rust.
  • Prototyping solutions in Rust can be challenging since Rust requires covering 100% of the conditions!