Getting Started with Rust: Key Syntax and Essentials for Beginners

Amza

06 Feb 2025 — 4 min read

Rust is a systems programming language that blends performance with safety. It’s designed to be fast, reliable, and easy to learn—once you get the hang of it! In this article, we’ll introduce you to the core concepts of Rust syntax in a hands-on, practical way. By the end, you’ll have built a small, working program and gained an understanding of how variables, data types, functions, and control flow work in Rust.

Let’s dive in!

Step-by-Step Code Build

We’ll start by writing a minimal Rust program and gradually enhance it step-by-step. Ready? Let’s start with the classic “Hello, World!” program.

fn main() {
    println!("Hello, World!");
}

This is the simplest Rust program. It prints "Hello, World!" to the console. Now, let’s break it down.

1. Functions in Rust

The fn main() line defines a function named main. Every Rust program needs a main function. It’s the entry point for execution.

fn is short for "function" and tells the compiler that we are defining a function.
main is the name of the function. In Rust, the main function is special—it’s where the program starts executing.
() after the function name represents the function’s parameters (we’ll get to them later).

In this simple example, we don't have any parameters or return values. The function simply prints something to the screen.

2. The println! Macro

Inside the main function, we have println!("Hello, World!");. This is a macro (note the exclamation mark), not a regular function. Macros in Rust are more powerful and flexible than functions, allowing operations like formatting strings, printing to the console, and more.

println! is a macro that prints text to the console. It takes a string as an argument and outputs it.
The string "Hello, World!" is the argument we pass to println!.

If you run this program, you should see Hello, World! printed to your console. It’s that simple!

3. Variables in Rust

Next, let’s introduce variables. Rust variables are immutable by default, meaning you can’t change their value once they’re set. If you want to create a variable that can be changed, you’ll need to make it mutable using the mut keyword.

Let’s enhance our program to store a value in a variable.

fn main() {
    let greeting = "Hello, Rust!";
    println!("{}", greeting);
}

let is used to declare variables in Rust.
greeting is the variable name.
"Hello, Rust!" is the value we’re assigning to the variable.
println!("{}", greeting); prints the value of greeting using curly braces {} as a placeholder.

Challenge 1:

Try changing the value of greeting to something else (e.g., "Hello, Rustaceans!"). Re-run the program and see the output change.

4. Data Types

Rust is a statically-typed language, meaning the type of each variable is known at compile time. Let’s explore the basic types by modifying our program to use different data types.

fn main() {
    let greeting = "Hello, Rust!";  // String slice (immutable)
    let year = 2025;                // Integer (i32 by default)
    let pi = 3.14159;               // Floating point (f64 by default)
    let is_rust_fun = true;         // Boolean value

    println!("{}, Year: {}, Pi: {}, Is Rust fun? {}", greeting, year, pi, is_rust_fun);
}

String slice (&str): greeting is a reference to a string slice.
Integer (i32): year is an integer. Rust’s default integer type is i32.
Floating point (f64): pi is a floating-point number, with f64 as the default type.
Boolean (bool): is_rust_fun is a Boolean value, either true or false.

Rust has many other types, but these are the most common ones you’ll use for basic programs.

Challenge 2:

Try declaring a variable of type char (a single character) and print it. Use this declaration:

let letter = 'R';

5. Control Flow: Conditionals

Now that we have variables, let's control the flow of our program using conditionals.

We’ll modify the program to make it greet us differently based on the current year.

fn main() {
    let year = 2025;

    if year < 2025 {
        println!("The future is early!");
    } else if year == 2025 {
        println!("Welcome to 2025!");
    } else {
        println!("The future is now!");
    }
}

if: This starts the conditional block. If the condition is true, the code inside the block runs.
else if: This allows you to check additional conditions if the previous ones were false.
else: If none of the previous conditions were true, this block will run.

The program checks if the year is less than 2025, equal to 2025, or greater than 2025 and prints a message accordingly.

Challenge 3:

Modify the program to check whether year is an even or odd number, and print the corresponding message.

6. Loops: Repeating Code

Rust offers several ways to repeat code, with the most common being the loop, for, and while loops.

Let’s look at a simple for loop to print the first 5 years.

fn main() {
    for year in 2021..2026 {
        println!("The year is: {}", year);
    }
}

for year in 2021..2026: This loop will iterate through the years from 2021 to 2025 (note that the range 2021..2026 is exclusive of 2026).
println!("The year is: {}", year);: On each iteration, it prints the current value of year.

Challenge 4:

Modify the loop to print only even years from 2021 to 2025.

Recap and Conclusion

In this tutorial, we’ve covered the following key Rust concepts:

Functions: We defined the main function, which is the entry point of every Rust program.
Variables and Data Types: We learned how to declare variables and assign values, and explored basic data types like integers, strings, booleans, and floating-point numbers.
Control Flow: We used if, else if, and else to make decisions in our program based on conditions.
Loops: We explored the for loop to repeat code multiple times.

Next Steps

Now that you’ve got the basics, try building on this program! Experiment with more Rust data types, create your own functions, and tackle more complex logic. You can dive deeper into Rust’s documentation and resources like the Rust Book for more advanced topics.

Keep coding, and happy Rusting!