Rust is a programming language focused on three things: speed, memory safety, and concurrency. Think of it like building a high-performance race car, but with an incredibly thorough safety inspector checking your work at every step. This inspector, the Rust compiler, catches common errors before your program even runs. This prevents entire categories of bugs that plague other languages.

This focus on safety doesn't slow you down. Rust is designed for performance-critical services, running on embedded devices, and powering browser engines. Its strong guarantees make it excellent for writing concurrent programs, where multiple parts of your code execute independently at the same time.

Installing Rust is straightforward. The primary tool you'll use is rustup, which is the Rust installer and version manager. It not only installs the Rust compiler (rustc) but also comes with Cargo, Rust's powerful build tool and package manager. Cargo handles building your code, downloading the libraries your code depends on, and running your projects.

Once rustup is installed, you have everything you need to compile and run Rust programs. To start a new project, you can simply run cargo new project_name in your terminal.

Let's create the classic "Hello, world!" program. After running cargo new hello_world, Cargo creates a new directory with a simple project structure. Inside the src folder, you'll find a file named main.rs. This is where your code lives.

Let's break this down.

fn main() defines the main function. This function is special; it's always the first code that runs in every executable Rust program.

Inside the function, println!("Hello, world!"); prints text to the screen. You'll notice the ! at the end of println. This means we're calling a Rust macro, not a normal function. We'll explore the difference later, but for now, just know that macros provide more advanced functionality than functions.

Finally, the line ends with a semicolon (;). This marks the end of the expression.

To run this program, navigate into your hello_world directory in your terminal and type cargo run. Cargo will compile and execute your program, and you should see "Hello, world!" printed.

Now that you've run a program, let's look at some fundamental concepts. In Rust, you declare variables using the let keyword. By default, variables are immutable, which means once they have a value, you can't change it. This is one of Rust's features that encourages writing safer code.

If you need a variable you can change, you must use the mut keyword.

Rust is a statically typed language, which means it must know the types of all variables at compile time. However, the compiler can usually infer the type based on the value you assign. For example, it knows 5 is an integer and true is a boolean.

Here are some basic data types:

• Integers: i32 (32-bit signed integer) is the default. Others include u8 (8-bit unsigned), i64 (64-bit signed), etc.
• Floating-Point Numbers: f64 (64-bit float) is the default. There's also f32.
• Booleans: bool, which can be true or false.
• Characters: char, for single Unicode characters.

You've already seen the main function. You can define your own functions using the fn keyword. Rust code uses snake_case as the conventional style for function and variable names.

Notice the add_numbers function. We declare the type of each parameter, and after an arrow ->, we declare the type of the value it returns. The final line a + b is an expression. In Rust, the last expression in a function is automatically returned, so you can omit the return keyword and the semicolon.

To control the flow of your program, you use if expressions and loops. An if expression allows you to branch your code depending on a condition.

Rust has several kinds of loops, but the most common is loop, which creates an infinite loop that you can break out of.

This covers the very basics of writing a Rust program. You can now install the tools, create a new project, and understand the fundamental syntax for variables, functions, and control flow.