Rust 101 | CSCE-550

What is Rust?

Rust is a system programming language that focuses on speed, memory safety, and parallelism. It was developed by Mozilla and has been gaining popularity for its ability to provide memory safety without using a garbage collector.

Why Should You Care About Rust?

1. Complementing Your Skills: you could use Rust to write high-performance backend services or algorithms that are CPU-bound and need to manage memory efficiently.

2. Expanding into Systems Programming: If you ever want to dive deeper into systems programming (software that interacts directly with the hardware, such as operating systems, game engines, or embedded systems), Rust is a safer and more modern alternative to C/C++.

• Memory Safety Without Garbage Collection: Rust eliminates issues like memory leaks and dangling pointers at compile time, offering C/C++-level performance without runtime overhead.

3. WebAssembly: Rust has first-class support for compiling to WebAssembly (Wasm). This is particularly relevant for full-stack developers looking to run high-performance applications in the web browser alongside JavaScript.

What is WebAssembly?

A binary instruction format that allows running code at near-native speeds in the browser.

4. Machine Learning and Data Processing: In situations where performance and low-latency are critical. It’s also excellent for building data processing pipelines that can handle large volumes of data more efficiently than Python.

While JavaScript and Python are sufficient for a wide range of applications,

Rust provides you with tools to tackle problems where control over system resources and performance is necessary.

It’s an investment in a skill that broadens your capabilities and opens up new possibilities for system-level programming, high-performance web applications, and more reliable concurrency.

Key Features of Rust:

1. Memory Safety: Rust uses a borrow checker to enforce memory safety at compile time. This means it prevents bugs such as buffer overflows, null pointer dereferences, and data races, which are common in other systems programming languages like C or C++.
2. Ownership Model: One of Rust’s unique features is its ownership model, where variables "own" their data, and this ownership can be transferred but not shared freely, preventing dangling pointers and memory leaks.
3. Zero-Cost Abstractions: Rust provides abstractions such as iterators, which are as efficient at runtime as writing lower-level code. This means you can write high-level code without sacrificing performance.
4. Ecosystem and Tooling: Rust has a growing ecosystem with a package manager and build tool called Cargo that makes it easy to manage dependencies, run tests, and package your software.
5. Concurrency: Rust’s ownership model naturally avoids many common concurrency problems seen in other languages. It makes concurrent programming more approachable and less error-prone.

Core Concept: Memory Safety and Ownership

Analogy of printer:

Imagine an office where there are no strict rules about printer usage. Employees can start print jobs whenever they want, even if someone else is already using the printer. This can lead to conflicts like

1. paper jams
2. mixed-up printouts.

Using C & C++

Technical Explanation: 

In C and C++, memory management is manual. Programmers use malloc and free for dynamic memory allocation and deallocation. Like in the analogy, this freedom allows for powerful control but requires meticulous management to avoid issues like

1. Memory leaks (forgetting to refill paper)
2. Dangling pointers (trying to use the printer after it has been designated for repairs).

Risk:

The lack of built-in safety mechanisms makes it easy to introduce bugs such as

1. double frees (two employees trying to cancel the same print job)
2. buffer overflows (sending more print jobs than the printer's memory can handle).

Using Java:

 In this office, there is an administrative assistant who keeps track of printer use. Employees submit their print jobs to the assistant, who queues them and manages the printer on their behalf.

Technical Explanation:

Java handles memory management through automatic garbage collection. Programmers do not need to explicitly free memory. Instead, the Java Virtual Machine (JVM) keeps track of objects and reclaims memory once there are no references to an object, similar to an assistant who checks if anyone is still waiting for a job before turning off the printer at night.

Benefit and Drawback:

This reduces the risk of memory leaks and dangling pointers but at the cost of less control over memory and unpredictable garbage collection times, which might delay an urgent print job.

Rust:

The Rigorous Office Manager

Analogy:

Imagine an office where a very meticulous office manager oversees the use of the printer. This manager enforces strict rules:

• Only one person (the "owner" of a print job) can control the printer at any given time.
• If someone else needs to use the printer, the original person must finish their job or explicitly hand over their job to the next person.
• If someone just needs to check the status of an ongoing job, they can ask for permission to view it, but they can't modify the job unless given explicit permission.

In the analogy:

The printer represents the computer's memory system.

The prints or print jobs are like the data being processed and stored within that memory.

Technical Explanation:

Rust enforces memory safety through its ownership system combined with the borrow checker:

• Ownership: Each piece of data in Rust has a single owner. The ownership can be transferred, but at any one time, only one entity can own a piece of data. This is similar to our office manager ensuring that only one person has control over the printer.

Role of the Borrow Checker in Rust:

• Memory Safety Guarantees: It ensures that any references to data adhere to two key rules: only one mutable reference (which allows data modification) or multiple immutable references (which only allow reading data) can exist at any one time.
• Preventing Data Races: By enforcing that a mutable reference cannot coexist with any other references, the borrow checker effectively prevents data races.

A data race occurs when two or more threads access the same memory location concurrently, and at least one of the accesses is a write.

In our office analogy, this would be like two people trying to change the printer settings at the same time, which the scheduling system disallows.

• Avoiding Buffer Overflows and Other Bugs: Buffer overflow is a common bug in other languages where programs write data beyond the bounds of allocated memory. By managing access to memory through strict borrowing rules, Rust's borrow checker helps ensure that operations on data structures do not exceed their memory bounds.