Learning Rust - History, Background & Why Rust Is Needed

#Introduction

Before writing lots of code, it is important to understand why Rust exists. This language is not just a trend: it was born from real problems in the world of systems programming, especially memory bugs and race conditions that for decades have been the primary source of vulnerabilities in C and C++.

Episode 1 traces the history of Rust from 2006 to the present day, the design philosophy that makes it unique, and its comparison with traditional approaches. You will understand when Rust is the right choice and when you are better off choosing another language.

#The Origins of Rust at Mozilla

#From Personal Project to Official Project

Rust was first designed by Graydon Hoare in 2006 as a personal project, then began to be developed by Mozilla Research in 2009. The initial motivation was to build browser components — specifically Servo, the parallel engine for Firefox — that were safer without sacrificing performance.

Rust reached stable release 1.0 on May 15, 2015. Since then, Rust has been openly managed by the core team and the community, with official support from Mozilla until the establishment of the Rust Foundation in 2021, which oversees its development together with Amazon, Microsoft, Google, and Huawei.

#RFC and the Open Decision-Making Process

Major changes to Rust go through the RFC (Request for Comments) process: a proposal is written, discussed on forums and GitHub, and then decided by the relevant team. This process makes Rust mature by design — not many features are added and then pulled back. The ecosystem is managed with a clear governance model, including working groups for specific fields such as async and embedded.

#Timeline and the Edition System

Rust does not change in a chaotic incremental way, but rather through editions: major changes that can alter the behavior of the language without breaking old code. The editions that have been released are 2015, 2018, 2021, and 2024.

rustc --version
rustup toolchain list

rustup toolchain list displays the toolchains installed on your machine. The edition is chosen per crate in the edition field of Cargo.toml, so code from older editions continues to compile on newer toolchains. Edition 2024 shipped with Rust 1.85 and is the default for new projects.

#Rust's Design Philosophy

#The Four Main Pillars

Rust's design is rooted in four values: safety, concurrency, performance, and productivity.

• Safety: guarantees of memory safety and type safety at compile time, without a garbage collector.
• Concurrency: data races are prevented by the ownership system, not just by convention.
• Performance: zero-cost abstractions that add no runtime overhead.
• Productivity: a supportive compiler, complete tooling, and excellent official documentation.

#Safe Without a Garbage Collector

Safe languages like Java and Go use a garbage collector that sweeps memory at runtime. Rust takes a different path: ownership and borrowing rules are verified at compile time, then produce a binary without any additional runtime. As a result, Rust offers memory safety and full control over performance.

#Problems Solved and Comparison with C and C++

#Memory Safety

C and C++ give programmers full control over pointers, which also means freedom to make mistakes: use-after-free, buffer overflow, and double free. Rust turns these mistakes into compile errors. If a reference could become invalid, the compiler rejects the program.

#Null Safety

null in C and C++ is a source of countless crashes. Rust has no null: values that may not exist are represented as Option<T>, and the compiler forces you to handle both cases.

#Thread Safety

Data races in C and C++ can only be avoided through manual discipline. Rust uses the Send and Sync traits to ensure that data shared between threads is already safe — again, at compile time.

#A Brief Comparison

cat > bandingkan.rs <<'EOF'
fn main() {
    let pesan = "Rust: aman, cepat, konkuren";
    println!("{}", pesan);
}
EOF
rustc bandingkan.rs -o bandingkan
./bandingkan

The program above is compiled directly with rustc without any dependencies. rustc bandingkan.rs -o bandingkan produces a static binary that can be run on the same machine.

#When Rust Is the Right Choice

#Suitable Scenarios

Rust excels in several categories:

• Performance-critical: compilers, database engines, game engines, and file systems.
• Safe concurrency: backend services that process many requests in parallel.
• Embedded: firmware and devices with limited resources.
• WebAssembly: code compiled for browsers and edge runtimes.
• Reusable library: crates that other teams can use safely without race conditions.

#When Not to Use Rust

Rust is not the answer to every problem. For rapid prototyping, languages with a GC such as Python or Go can be far more productive. For enterprise applications with a very mature framework ecosystem, Java or C# might be more comfortable. Rust demands a steep learning curve — its benefits only really pay off on projects that are large, critical, and long-lived.

#A Summary of Rust's Position

Rust occupies a unique position: performance like C and C++, memory safety like managed languages, and concurrency support guaranteed by the type system. This is why many teams choose Rust for system foundations that are hard to replace. In episode 2 we will break down how all of that works behind the scenes.

#Closing

Key takeaways:

• Rust was born at Mozilla to build a safe, parallel browser engine.
• Release 1.0 in 2015; development is managed through RFCs and the Rust Foundation.
• Editions 2015, 2018, 2021, and 2024 maintain compatibility between generations.
• Rust's four pillars: safety, concurrency, performance, and productivity.
• Unlike C and C++, Rust prevents memory bugs and data races at compile time.
• Rust is well suited to performance-critical, backend, embedded, and WebAssembly work.

In the next episode 2 we will discuss core concepts and the main architecture — compilation via LLVM, the borrow checker, the ownership model, and the role of cargo as a build system, package manager, and workspace manager. You will see how the machine behind Rust really works.