Introduction

Rust is a modern, statically typed, compiled programming language designed for performance, safety, and reliability.

Rust is mainly known for memory safety without a garbage collector. This means Rust helps developers write fast and low-level programs while reducing many common memory-related bugs that are often seen in languages like C and C++.

Rust is used in systems programming, command-line tools, backend services, WebAssembly, embedded systems, networking software, game engines, security-sensitive applications, and performance-critical software.

In this lesson, students will learn what Rust is, its history, features, syntax style, strengths, limitations, use cases, and how Rust compares with other popular programming languages.

Easy Real-Life Example

Hotel key system:
One owner controls the room key.
Others may borrow only under safe rules.
No one can use an invalid key.
No two people can make unsafe changes at the same time.

Rust:
One owner controls a value.
Borrowing follows compiler-checked rules.
Invalid memory access is prevented.
Unsafe data races are reduced at compile time.

Rust’s ownership and borrowing system works like a strict safety manager for memory.

What is Rust?

Rust is a general-purpose programming language that focuses on speed, memory safety, and concurrency.

Rust is especially useful when developers need performance close to C or C++, but also want stronger protection from common memory problems such as dangling pointers, double frees, use-after-free errors, and data races.

Simple Definition

Rust is a compiled, statically typed programming language
designed for performance, memory safety, and safe concurrency
without using a traditional garbage collector.

Brief History of Rust

Rust was originally created by Graydon Hoare. It began as a personal project and later received support from Mozilla.

Rust was developed to solve problems common in systems programming, especially memory safety and concurrency problems. The language became popular because it offers low-level control while preventing many unsafe programming mistakes at compile time.

Rust is a Compiled Language

Rust is a compiled language. The Rust compiler checks the code and converts it into an executable program before it runs.

Rust Program Flow:

Rust Source Code (.rs)
        ↓
Rust Compiler
        ↓
Executable Program
        ↓
Program Runs

Rust’s compiler is strict. It may feel challenging for beginners, but this strictness helps prevent many bugs before the program runs.

Key Features of Rust

Rust Memory Management

Rust’s memory management is one of its most important concepts.

Some languages use manual memory management, where developers must allocate and free memory themselves. Some languages use garbage collection, where a runtime system automatically cleans unused memory. Rust uses a different approach called ownership.

Ownership in Rust

Ownership is the core rule system Rust uses to manage memory safely.

In Rust, each value has one owner. When the owner goes out of scope, the value is automatically cleaned up.

fn main() {
    let message = String::from("Hello Rust");

    println!("{}", message);
}

In this example, message owns the string value. When message goes out of scope, Rust automatically cleans the value.

Move Concept in Rust

In Rust, assigning some values to another variable can move ownership.

fn main() {
    let first = String::from("Rust");
    let second = first;

    println!("{}", second);

    // println!("{}", first); // Not allowed after move
}

After first is moved to second, first can no longer be used. This prevents double-free and invalid memory access problems.

Borrowing in Rust

Borrowing allows a function or part of a program to use a value without taking ownership of it.

fn print_length(text: &String) {
    println!("Length: {}", text.len());
}

fn main() {
    let message = String::from("Hello");

    print_length(&message);

    println!("{}", message);
}

Here, print_length() borrows message. Ownership remains with the original variable.

Mutable Borrowing

Rust also allows mutable borrowing, but with strict rules to prevent unsafe changes.

fn update_message(text: &mut String) {
    text.push_str(" Rust");
}

fn main() {
    let mut message = String::from("Hello");

    update_message(&mut message);

    println!("{}", message);
}

The &mut symbol means the value is borrowed with permission to modify it.

Lifetimes in Rust

Lifetimes help Rust ensure that references remain valid.

Beginners do not need to master lifetimes immediately, but they should understand that lifetimes are part of Rust’s safety system for references.

Lifetime idea:
A reference should not live longer than the value it refers to.

Rust compiler checks:
- Is the reference valid?
- Is the original value still available?
- Could this reference become unsafe?

Basic Structure of a Rust Program

A basic Rust program starts with a main() function.

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

Explanation

Variables in Rust

Rust variables are immutable by default. This means once a value is assigned, it cannot be changed unless the variable is declared as mutable.

fn main() {
    let name = "Rahul";
    let mut marks = 85;

    marks = 90;

    println!("{}", name);
    println!("{}", marks);
}

The keyword mut allows the value of marks to be changed.

Immutability by Default

Rust encourages safer code by making variables immutable by default.

Data Types in Rust

Rust provides common data types for numbers, text, Boolean values, and collections.

fn main() {
    let age: i32 = 20;
    let price: f64 = 99.50;
    let is_passed: bool = true;
    let grade: char = 'A';

    println!("{}", age);
    println!("{}", price);
    println!("{}", is_passed);
    println!("{}", grade);
}

Function Example in Rust

fn add_numbers(first_number: i32, second_number: i32) -> i32 {
    return first_number + second_number;
}

fn main() {
    let result = add_numbers(10, 20);

    println!("{}", result);
}

This function takes two numbers and returns their sum.

Structs in Rust

Rust uses structs to group related data together.

struct Student {
    name: String,
    marks: i32,
}

fn main() {
    let student1 = Student {
        name: String::from("Rahul"),
        marks: 85,
    };

    println!("{}", student1.name);
    println!("{}", student1.marks);
}

A struct can represent a real-world entity such as a student, employee, product, user, or account.

Methods in Rust

Rust allows methods to be implemented for structs using impl blocks.

struct Student {
    name: String,
    marks: i32,
}

impl Student {
    fn display_result(&self) {
        println!("{} scored {}", self.name, self.marks);
    }
}

fn main() {
    let student1 = Student {
        name: String::from("Rahul"),
        marks: 85,
    };

    student1.display_result();
}

This example combines data and behavior in a Rust-style structure.

Traits in Rust

A trait defines shared behavior. Traits are similar to interfaces in some other languages.

trait Printable {
    fn print_details(&self);
}

struct Student {
    name: String,
}

impl Printable for Student {
    fn print_details(&self) {
        println!("Student name: {}", self.name);
    }
}

fn main() {
    let student1 = Student {
        name: String::from("Rahul"),
    };

    student1.print_details();
}

Traits help Rust support flexible and reusable design.

Error Handling in Rust

Rust does not depend on traditional exception handling in the same way as many languages. Rust commonly uses special types such as Result and Option to handle success, failure, and missing values.

fn divide(a: i32, b: i32) -> Option<i32> {
    if b == 0 {
        None
    } else {
        Some(a / b)
    }
}

fn main() {
    let result = divide(10, 2);

    match result {
        Some(value) => println!("Result: {}", value),
        None => println!("Cannot divide by zero"),
    }
}

This example uses Option to safely handle a possible missing result.

Pattern Matching in Rust

Rust provides powerful pattern matching using match.

fn main() {
    let grade = 'A';

    match grade {
        'A' => println!("Excellent"),
        'B' => println!("Good"),
        'C' => println!("Average"),
        _ => println!("Needs improvement"),
    }
}

Pattern matching helps handle multiple possible cases clearly and safely.

Concurrency in Rust

Rust supports concurrent programming while reducing many unsafe data-sharing problems.

Rust’s ownership and type system help prevent many data races at compile time. This makes Rust useful for building reliable multithreaded applications.

Rust concurrency idea:
- Multiple tasks may run at the same time.
- Shared data must follow strict safety rules.
- The compiler helps prevent unsafe access.
- Many concurrency bugs can be caught early.

Cargo and Crates

Rust projects commonly use Cargo, Rust’s build tool and package manager.

A package or library in Rust is commonly called a crate.

Common Applications of Rust

Rust is used in many areas where performance, reliability, safety, and low-level control are important.

Rust Ecosystem

Rust has a growing ecosystem of tools, libraries, and frameworks.

Strengths of Rust

Limitations of Rust

Rust is powerful, but beginners should understand that it has a learning curve.

Rust Compared with C and C++

Rust is often compared with C and C++ because all three can be used for systems and performance-critical programming.

Rust Compared with Go

Rust and Go are both used in modern backend and systems-related development, but their design goals are different.

Rust Compared with Python and JavaScript

When Should You Choose Rust?

Rust is a strong choice when the project needs high performance, memory safety, reliability, and low-level control.

Example: Conditional Logic in Rust

fn main() {
    let marks = 75;

    if marks >= 40 {
        println!("Pass");
    } else {
        println!("Fail");
    }
}

This example checks whether a student has passed or failed.

Example: Loop in Rust

fn main() {
    let marks = [80, 90, 75];

    for mark in marks {
        println!("{}", mark);
    }
}

This example prints each value from an array.

Example: Vector in Rust

fn main() {
    let marks = vec![80, 90, 75];

    for mark in marks {
        println!("{}", mark);
    }
}

A vector is a growable collection in Rust.

Why Students Should Learn Rust

Rust is valuable for students who want to understand modern systems programming, memory safety, performance, and secure software design.

Suggested Learning Path for Rust

Students can follow this step-by-step learning path.

1. Introduction to Rust
2. Installing Rust and Cargo
3. Rust program structure
4. Variables and mutability
5. Data types
6. Operators
7. Conditional statements
8. Loops
9. Functions
10. Ownership
11. Borrowing and references
12. Mutable references
13. Slices
14. Structs
15. Enums
16. Pattern matching
17. Traits
18. Error handling with Option and Result
19. Collections: vectors and hash maps
20. Modules and packages
21. Testing
22. Concurrency basics
23. Mini CLI or systems project

Common Beginner Mistakes in Rust

Security and Safety Considerations in Rust

Rust is designed with safety in mind, but developers still need secure programming practices.

Rust at a Glance

Practice Activity: Understand a Rust Program

Read the following Rust program and answer the questions.

struct Student {
    name: String,
    marks: i32,
}

fn check_result(student: &Student) -> String {
    if student.marks >= 40 {
        String::from("Pass")
    } else {
        String::from("Fail")
    }
}

fn main() {
    let student1 = Student {
        name: String::from("Rahul"),
        marks: 85,
    };

    let result = check_result(&student1);

    println!("{}", result);
}

Questions

Expected Answers

1. Struct name: Student
2. Fields: name and marks
3. &Student means the function borrows the student instead of taking ownership.
4. It returns Pass or Fail based on marks.
5. Output: Pass

Mini Practice Tasks

Mini Quiz

Interview Questions on Rust Overview

Quick Summary