Tutorial Rust Dasar (Bahasa Indonesia)

Main ideas & lessons (Rust basics tutorial)

Purpose of the course

• Introduce Rust programming fundamentals.
• Position Rust as “mandatory” for learners who want to master Rust.

Prerequisites before learning Rust

You should ideally be comfortable with:

• Using a computer.
• Installing software on your OS (Windows/Mac/Linux).
• Using the Terminal / Command Prompt.
• Knowing at least one other programming language (examples: Java, Go/Golang, PHP).

Rust overview and history

• Rust began as a personal project around 2006.
• Mozilla started supporting it around 2009 for browser engine work (Servo).
• Public release timeline mentioned as:
  • Public release around 2015.

Rust adoption & ecosystem growth

• Rust is used by major companies, including:
  • Amazon, Discord, Dropbox, Google, Meta, Microsoft
• Around 2022, Rust was mentioned as being supported in Linux Kernel development.
• GitHub statistics (as described) indicate Rust is one of the fastest-growing languages by contribution growth.
• Official website reference: rust-lang.org.

Why learn Rust (key reasons emphasized)

• Memory safety
  • Safe memory processing and fewer risks than manual memory management (typical in C/C++).
• Performance
  • Benchmarking described as aiming close to C/C++.
• Safe concurrency
  • Built-in concurrency features; conceptually compared to Go routines / Java concurrency.
• Good maintenance / clean code
  • Rust enforces clean practices (e.g., unused variables trigger warnings/complaints).

How Rust applications are built and run

• Rust code (.rs) is compiled by the Rust compiler into a binary executable.
• After compilation, you can run/distribute the binary without requiring the Rust compiler/runtime on the target machine (contrast: Java typically needs a runtime).

Tooling setup

• Recommended installer: rustup
• Recommended code editors (choose one):
  • Visual Studio Code + Rust Analyzer extension
  • JetBrains RustRover
  • Eclipse Corrosion

Rust project creation and structure (with Cargo)

Use Cargo to create projects:

• cargo new <project_name>

Generated structure (as described):

• src/
  • Rust source code (default: main.rs)
• Cargo.toml
  • Project configuration
• Cargo.lock and target/
  • Generated/managed by Cargo

Core Rust syntax concepts introduced

• Entry point: main
  • fn main() { ... }
• Printing output
  • println! / print! (tutorial frames these as macro-like)
• Comments
  • Single-line: // ...
  • Multi-line: /* ... */

Cargo build/run modes

• cargo run
  • Builds in debug mode first
  • Runs the program
  • Debug binary output: target/debug
• cargo build --release
  • Builds optimized release
  • Output binary in: target/release

Unit testing basics

Rust testing key points:

• Typically, Rust projects have one main; additional logic is tested via unit tests.
• Add tests using the #[test] attribute.
• Run tests:
  • cargo test (all tests)
  • cargo test <test_name> -- --exact (run one exactly)
• Output behavior:
  • Test output may be captured by default
  • Use -- --nocapture to display println! output during tests

Variables: immutability, mutability, and typing rules

• Default variables are immutable:
  • let x = ...
• Mutable variables:
  • let mut x = ...
• Shadowing:
  • You can redeclare a variable name in an inner scope; the inner one hides the outer one.
• Static typing:
  • Types don’t change after creation (unlike JS/PHP).
• Rust may warn if something is marked mut but never actually mutated.

Data types introduced

• Scalar types
  • Integers, floats, booleans, characters
• Compound types
  • Tuples, arrays
• Tuples
  • Fixed-size heterogeneous groups
  • Access via .0, .1, etc.
  • Destructuring supported (e.g., (a, b, _))
• Arrays
  • Fixed-size same-type elements
  • Access via [index] (index starts at 0)

Numeric details (mentioned):

• Integer types: i8/i16/i32/i64/i128 and unsigned u*
• Floats: f32/f64
• Defaults: integers default to i32, floats to f64
• Conversion note: converting large-to-small types risks overflow.

Operators introduced

• Arithmetic: + - * / %
• Assignment / compound assignment: +=, -=, etc. (requires mutability)
• Comparisons: return boolean
• Boolean logic:
  • && (and), || (or), ! (not)

Control flow

• if, else, else if
• if can be used with let to assign results (Rust treats it as an expression).

Loops

• loop {} (infinite loop)
  • Stop with break
  • Skip with continue
• while condition {} (repeat while true)
• for loops
  • Iterate over iterables (arrays/ranges)
• Loop labels
  • Labeled break exits an outer loop from inside nested loops.

Functions

• Defined using fn name(...) { ... }
• Called with name(...)
• Parameters require explicit types
• Return values:
  • Can specify a return type
  • Can return early using return <value>
• Examples include factorial (iterative) and recursive variants.

Ownership and memory management (major Rust concept explained)

Rust avoids garbage collection and manual memory management through ownership rules.

Core ownership rules:

• Each value has exactly one owner at a time.
• When the owner goes out of scope, the value is automatically dropped.
• Copy vs move behavior:
  • Fixed-size stack data is copied when assigned.
  • Heap data (e.g., String) is moved; the old owner becomes invalid.
• To duplicate heap data, use cloning (clone()).

Ownership interacting with function parameters:

• Passing stack values tends to copy.
• Passing heap values transfers ownership; the original variable becomes unusable afterward.

String types and mutability

• String slice: &str
  • A typically fixed-size view; slice contents are treated as immutable (by nature of borrowing).
• Owned string: String
  • Growable (heap-allocated)
  • Methods like push() require mutability.

Memory layout explanation (stack vs heap)

• Stack
  • Fixed-size values
  • Stack frames created per function call; removed when the function ends
• Heap
  • Variable/growing data (e.g., strings)
• Cleanup happens when values go out of scope, explaining why GC/manual memory management isn’t required.

---

Methodologies / instruction-style steps included

Installing and verifying Rust (using rustup)

• Install tool:
  • Use rustup
• Install Rust:
  • macOS/Linux: run rustup in Terminal (as shown conceptually in the tutorial)
  • Windows: install via rustup-init (as shown conceptually)
• Verify:
  • rustup check
  • rustc --version
• Update:
  • rustup update

Setting up an editor

Choose one:

• Visual Studio Code + install Rust Analyzer
• JetBrains RustRover
• Eclipse + Corrosion

Make sure Rust tooling is active in the editor.

Creating a Rust project (Cargo)

• Check Cargo:
  • cargo --version
• Create a project:
  • cargo new <project_name>
• Open the project folder in your editor.

Running and building Rust programs

• Run in debug mode:
  • cargo run
• Build release:
  • cargo build --release
• Run the produced binary:
  • Debug: target/debug
  • Release: target/release

Writing and running unit tests

• Create a test:
  • Add #[test] above a function
  • Test functions are ordinary functions (not inside main)
• Run all tests:
  • cargo test
• Run one test exactly:
  • cargo test <test_name> -- --exact
• Show output from tests:
  • Add -- --nocapture

Working with variables (immutability/mutability)

• Immutable by default:
  • let x = ...
• Mutable:
  • let mut x = ...
• println! placeholders:
  • Use {} for interpolation inside println!.

Using loops

• Infinite loop:
  • loop { ... }
  • Stop with break
  • Skip iteration with continue
• Exiting outer loops in nested cases:
  • Label the outer loop and break <label>

Ownership workflows (conceptual “how-to”)

• Assign fixed-size stack data:
  • Expect copy semantics
• Assign/move heap data (e.g., String):
  • Expect move semantics (old owner invalid after move)
• Duplicate heap data when needed:
  • Use .clone()

---

Speakers / sources featured

• Speaker/Instructor: Eko Kurniawan (technical architect; course instructor)

Company/source references mentioned

• Mozilla (Servo, project support, releases)
• GitHub (statistics reference)
• Linux Kernel (Rust support reference)
• Companies used as examples:
  • Amazon, Discord, Dropbox, Google, Meta, Microsoft
• Official website referenced: rust-lang.org