Rust for beginners

Create my notebook

Rust for beginners

Rust is a systems programming language built for performance, memory safety, and explicit control. It is used for command-line tools, servers, developer tooling, embedded systems, and performance-critical components where low-level control matters but classic memory bugs are costly. The language was first released as Rust 1.0 in 2015 through the Rust project hosted by the Mozilla Foundation, and it has since grown into a widely used open-source ecosystem with an official package manager, a strong standard library, and extensive community documentation .

This course is structured as a cumulative path. It starts with the toolchain and the edit-build-run loop, then moves through syntax, types, and functions before reaching the idea that defines Rust for many learners: ownership. From there, it expands into data modeling with structs and enums, practical work with collections and strings, error handling, project organization, and a first look at traits and generics. Each later section depends on earlier mental models, especially the distinction between owned data and borrowed data.

The course is hands-on by design. The goal is not to memorize isolated rules, but to build enough fluency to read small Rust programs, predict what they do, and write programs that compile for reasons you understand. Early examples stay small. Later sections combine those pieces into a command-line application so the language stops feeling like separate topics and starts feeling like one coherent system.

Rust rewards precision early so programs stay reliable later.

Setting up Rust and writing your first program

The easiest way to install Rust is

Variables, types, and control flow

Rust programs start to become interesting when values can be named, changed, compared, and used to steer execution. The keyword

Functions and basic program decomposition

Functions turn a growing program into understandable pieces. In Rust, a function has a name, a list of parameters, and an optional return type. The syntax is direct, but it teaches an important discipline: inputs and outputs should be visible in the function signature.

fn add(a: i32, b: i32) -> i32 {
    a + b
}

This function says exactly what it needs and what it gives back. It takes two i32 values and returns one i32. Rust requires parameter types. Return types are also explicit when a function returns something other than the default unit value (). For beginners, that explicitness reduces guesswork. A function becomes easier to read because its contract is written at the top.

Return values and block expressions

Rust functions return the value of their final expression when that expression has no semicolon.

fn square(n: i32) -> i32 {
    n * n

Ownership, borrowing, and references

This is the section that makes Rust feel different from most beginner languages.

Ownership is Rust's core rule for memory management. Instead of relying on a garbage collector or leaving memory control entirely manual, Rust tracks which variable is responsible for a value and when that value should be cleaned up. Every value has an owner, and when the owner goes out of scope, Rust drops the value automatically . That is how Rust can offer memory safety without a garbage collector .

At a beginner level, it helps to separate two ideas:

  • The stack stores data with a known, fixed size and fast allocation behavior.

  • The heap stores data whose size may be determined at runtime.

A simple integer like i32 behaves differently from a heap-allocated

Structs, enums, and pattern matching

Once a program has more than a few loose values, it needs better ways to model information. Rust gives beginners three essential tools for that job: structs, enums, and pattern matching. Together, they let code describe data shape clearly and then handle each shape explicitly.

A struct groups related fields into one named type. It is the Rust answer to "these values belong together."

struct User {
    username: String,
    active: bool,
    sign_in_count: u64,
}

This is more meaningful than passing three separate values around a program. A User says what the data is, not just what types happen to appear side by side. That improves readability and makes functions easier to design.

Structs as records

A struct is best understood as a labeled record. Each field has a name and a type. Creating a value means filling those fields deliberately:

let user1 = User {
    username: String::from("alice"),
    active: true,
    sign_in_count: 1,
};

This encourages a strong beginner habit: model the domain first, then write logic around it. Instead of scattering related variables, create a type that reflects the real concept.

Enums as alternatives

A struct says "all these fields exist together." An enum says "this value is one of several possible variants."

enum Direction {
    Up,
    Down,
    Left,
    Right,
}

That is already useful, but enums become especially powerful when variants carry data:

enum Message {
    Quit,
    Write(String),
    Move { x: i32, y: i32 },
}

Now a Message can represent different situations with different associated information. This is one of Rust's most expressive features. It lets data shape encode program logic instead of leaving meaning to comments and conventions.

match and exhaustive handling

Once code has enum variants, it needs a way to branch on

Collections, strings, and iteration

Most useful programs manage groups of values, text, and repeated operations over data. In Rust, the first collection most

Error handling with Result and panic!

Reliable programs do not assume everything works. Files may be missing, input may be malformed, network requests may fail, and user actions may be incomplete. Rust treats error handling as a first-class part of program design, not an afterthought. The key distinction is between recoverable errors and unrecoverable failures.

A recoverable error is something the program can respond to. An unrecoverable failure is something serious enough that continuing would be incorrect or

Modules, crates, and project organization

A one-file Rust program is fine for learning syntax, but real projects outgrow main.rs quickly. Rust organizes larger codebases with packages, crates, and modules. These words sound abstract at first, but the distinction becomes clear once code is split across files.

According to the official book, a package is what Cargo manages, a crate is a compilation unit, and a module organizes code within a crate . A package can contain one or more crates, though beginners usually start with one binary crate created by cargo new.

The basic vocabulary

  • Package: the project described by Cargo.toml

  • Crate: a binary or library that Cargo compiles

  • Module: a namespace inside a

Traits and generic thinking without going too far

At some point, beginner Rust code starts to repeat itself. Two types may support the same operation. Two functions may differ only in the concrete type they handle. Rust addresses this with traits and generics, but the beginner version should stay grounded: traits describe shared behavior, and generics let code work over more than one type.

A trait is a collection of method signatures that a type can implement. The standard library uses traits everywhere, which is why even a beginner needs a basic mental model for them .

trait Describe {
    fn describe(&self) -> String;
}

A type can then implement that trait:

struct Book {
    title: String,
}

impl Describe for Book {
    fn describe(&self) -> String {
        format!("Book: {}", self.title)
    }
}

Now Book has behavior defined through the trait. This is useful because it separates the idea of "what can be done" from the concrete type doing it.

impl

A first Rust project: building a command-line app

The course should end with a program that is small enough to finish and real enough to feel like software.

A good first project is a command-line task tracker. It can read a command like add, list, or done, store tasks in memory for now, and print useful output. This is not ambitious software, and that is the point. The project should be small enough to complete in one sitting or one weekend, while still using the major Rust ideas from the course in one integrated flow.

What the project should include

A beginner command-line app should touch these concepts on purpose:

  • Input parsing from command-line arguments or simple text input

  • Structs to represent domain data such as a task

  • Enums to represent commands such as Add, List, and Done

  • Functions to separate parsing, execution, and display

  • Collections like Vec<Task> to store items

  • Modules to keep parsing and task logic