I’m reading the Rust Book.

• Rust is a systems programming language: its main purpose is to provide the same level of control over system resources as traditional systems programming languages like C and C++, but with a strong emphasis on safety, speed, and concurrency.
  • Rust prevents invalid data access at compile time, so it guarantees that your program is memory-safe without imposing any runtime costs.
• Rust has a strong, static type system. However, it also has type inference.
  • statically typed language ⇒ it must know the types of all variables at compile time (aka, as I prefer to say, it’s a “compile-time type checking” language).
• Rust is an ahead-of-time compiled language, meaning you can compile a program and give the executable to someone else, and they can run it even without having Rust installed.

Chapter 1 - Getting Started

• The main function is special: it’s always the first code that runs in every executable Rust program
• Using a ! means that you’re calling a *macro* instead of a normal function; macros don’t always follow the same rules as functions, and they return code instead of returning data. Macros are often used to simplify common patterns.

println!("Hello, world!"); 
// println! is a macro, not a normal function

Cargo

Cargo is the Rust package manager.

• cargo new to create a new project
  • add --lib to create a library
  • --bin is the default project type, which is a standalone application (a “binary”)
• cargo build to build the project
  • the executable binary will be under ./target/debug/
  • cargo build --release to compile with optimizations (will be slower!)
• cargo run to run the executable directly in one single command
  • need a main function in order to have something to run…
• cargo test to execute the test suite.
• cargo check is a quick way to make sure the code compiles (without producing an executable).
• cargo fmt to format the source code according to the official Rust style guide.
• cargo doc --open to view the docs related to all your project’s dependencies.

Chapter 2 - Programming a Guessing Game

• use statement to import a library explicitly (e.g. use std::io;)
• The prelude is Rust’s standard library that is implicitly imported into the scope of every program. It contains many common types, functions, and macros (e.g. println!) that provide a lot of functionality for writing Rust programs.