Tools dan Setup Rust: Semua yang Kamu Butuhkan

Saat mulai belajar Rust, kamu langsung mendengar banyak nama baru sekaligus: rustup, rustc, cargo, clippy, rustfmt, rust-analyzer. Rasanya seperti butuh sepuluh tool dulu sebelum bisa menulis satu baris kode. Kabar baiknya: satu installer sudah memberimu hampir semuanya, dan setiap tool punya satu tugas yang jelas.

Bayangkan sebuah dapur. rustup adalah toko yang mengirim dan mengganti peralatanmu. cargo adalah koki yang mengatur semuanya. clippy adalah guru ramah yang mengintip dari balik bahumu, dan rustfmt menjaga meja dapur tetap rapi. Halaman ini menjelaskan setiap tool, apa yang kamu butuhkan di sistem operasimu, dan bagaimana developer Rust memakainya sehari-hari.

Kalau kamu belum menginstal Rust, langkah instalasi dan proyek pertamamu ada di Mulai dengan Rust. Dasar-dasar cargo (cargo new, cargo add, Cargo.toml) ada di Cargo dan crate. Halaman ini melanjutkan keduanya.

Gambaran besarnya

Ini seluruh kotak peralatan dalam satu tabel:

Tool	Fungsinya	Ikut terinstal dengan rustup?
rustup	Menginstal Rust, meng-update-nya, dan berganti antarversi	Ini adalah installer-nya
rustc	Compiler: mengubah file .rs kamu menjadi program	Ya
cargo	Mem-build, menjalankan, mengetes, dan menambahkan crate. Kamu memakainya untuk hampir semua hal	Ya
rustup doc	Membuka dokumentasi standard library dan Rust Book secara offline di browser	Ya (profil default)
clippy	Linter: menunjukkan bug dan cara yang lebih sederhana untuk menulis kodemu	Ya (profil default)
rustfmt	Formatter: menulis ulang kodemu dengan gaya standar	Ya (profil default)
rust-analyzer	“Otak editor”: autocompletion, error langsung di baris kode, petunjuk tipe, go to definition	Tidak secara default. Extension VS Code membawa salinannya sendiri
Debugger	Menghentikan program di satu baris dan melihat isi variabelnya	Tidak. Kamu menginstal LLDB atau GDB (atau extension editor yang sudah menyertakannya)

Profil adalah sekumpulan komponen yang diinstal rustup. Instalasi biasa memakai profil default, yang menambahkan dokumentasi, clippy, dan rustfmt di atas compiler dan cargo. Kalau komputermu di-setup orang lain dengan profil minimal, cargo clippy akan bilang tool itu belum terinstal. Satu perintah memperbaikinya: rustup component add clippy rustfmt.

Coba sekali jalankan rustup doc --std. Perintah ini membuka dokumentasi lengkap standard library langsung dari disk-mu, jadi tetap bisa dipakai di pesawat atau saat koneksi lambat. Untuk dokumentasi proyekmu sendiri dan semua crate yang dipakainya, jalankan cargo doc --open (lebih lanjut di Dokumentasi).

Sebelum menginstal: kebutuhan tiap OS

Rust meng-compile kodemu, tapi di tahap paling akhir ia butuh linker: program yang menggabungkan potongan-potongan hasil compile menjadi satu file yang bisa dijalankan. Rust memakai linker yang disediakan oleh tool C di sistemmu. Itulah sebabnya setiap OS butuh satu langkah tambahan kecil.

OS	Yang perlu diinstal	Caranya
Windows (disarankan)	C++ tools dari Visual Studio: linker MSVC dan Windows SDK	Pilih workload Desktop development with C++ di installer Visual Studio
Windows (alternatif)	Toolchain GNU (MinGW)	rustup toolchain install stable-gnu
Windows (pilihan lain)	WSL, Linux sungguhan di dalam Windows	wsl --install, lalu ikuti langkah untuk Linux
macOS	Command line tools dari Apple (termasuk compiler C dan linker)	xcode-select --install
Debian / Ubuntu	Compiler C dan linker	sudo apt install build-essential
Fedora	Compiler C dan linker	sudo dnf install gcc

Beberapa catatan jujur:

• Windows dan Visual Studio. Kamu tidak perlu mencarinya sendiri: kalau Visual Studio belum ada, rustup-init.exe akan menawarkan untuk menginstalnya. Yang diinstal adalah Visual Studio Community, yang gratis untuk perorangan, pelajar, dan proyek open source, tapi tidak untuk semua perusahaan. Kalau kamu menginstalnya di kantor, tanyakan edisi mana yang dipakai perusahaanmu. Memilih workload “Desktop development with C++” sudah memberi semua yang dibutuhkan Rust.
• Windows dan GNU. Toolchain MSVC adalah default-nya dan paling cocok dengan software Windows lain. Toolchain GNU tidak butuh Visual Studio untuk program sederhana, tapi banyak crate yang berisi kode C tidak akan bisa di-build sampai kamu juga menginstal MSYS2 dengan MinGW. Kebanyakan orang sebaiknya tetap memakai MSVC.
• WSL adalah pilihan bagus kalau kamu ingin lingkungan Linux di Windows (misalnya karena server-mu memakai Linux). Di dalam WSL, kamu menginstal Rust dengan perintah Linux biasa, terpisah dari instalasi Windows mana pun.
• Tambahan untuk Linux. Beberapa crate populer berkomunikasi dengan library sistem. Kalau build gagal dengan pesan tentang pkg-config atau OpenSSL, di Ubuntu instal juga pkg-config dan libssl-dev.

Setelah itu, ikuti langkah instalasi di Mulai dengan Rust.

Memakai rustup sehari-hari

Setelah Rust terinstal, rustup adalah tool untuk merawatnya. Versi stable Rust yang baru keluar setiap enam minggu, jadi meng-update adalah kebiasaan yang normal:

rustup update     # update semua toolchain yang terinstal (dan rustup sendiri)
rustup show       # apa saja yang terinstal, dan toolchain mana yang aktif di sini

rustup show mencetak kira-kira seperti ini (dipersingkat):

Default host: x86_64-unknown-linux-gnu

installed toolchains
--------------------
stable-x86_64-unknown-linux-gnu (active, default)

active toolchain
----------------
name: stable-x86_64-unknown-linux-gnu
active because: it's the default toolchain

Stable, beta, dan nightly

Toolchain adalah satu set lengkap rustc, cargo, dan kawan-kawannya. Rust punya tiga release channel (jalur rilis):

Channel	Apa itu	Pakai saat
stable	Rilis resmi, setiap enam minggu	Hampir selalu. Inilah yang kamu mau
beta	Rilis stable berikutnya, yang sedang dites	Kamu ingin mengecek proyekmu sebelum rilis berikutnya
nightly	Di-build setiap malam, dengan fitur eksperimental	Ada tool atau crate yang memintanya, atau kamu ingin mencoba fitur baru

Kamu bisa menginstal beberapa toolchain berdampingan:

rustup toolchain install nightly   # instal nightly di samping stable
cargo +nightly build               # pakai nightly untuk satu perintah ini saja
rustup default stable              # pilih toolchain yang dipakai di mana-mana

Mengunci toolchain per proyek

Kadang sebuah proyek butuh versi Rust tertentu. Taruh file bernama rust-toolchain.toml di folder proyek, dan rustup akan otomatis berganti versi setiap kali kamu bekerja di folder itu:

[toolchain]
channel = "1.97.0"
components = ["clippy", "rustfmt"]
targets = ["wasm32-unknown-unknown"]

Commit file ini ke git. Dengan begitu semua orang di timmu (dan CI-mu) memakai compiler yang persis sama, dan rustup menginstalkannya untuk mereka kalau belum ada. Kebanyakan proyek kecil sama sekali tidak butuh file ini; cukup pakai versi stable terbaru.

Komponen dan target

Komponen adalah bagian tambahan dari sebuah toolchain. Target membuatmu bisa meng-compile untuk jenis mesin lain:

rustup component add clippy rustfmt rust-src   # rust-src: source code std, dipakai rust-analyzer
rustup component list --installed              # lihat apa yang sudah kamu punya
rustup target add wasm32-unknown-unknown       # compile Rust untuk browser

Target wasm32-unknown-unknown adalah yang kamu butuhkan untuk WebAssembly.

Editor dan IDE

Kamu bisa menulis Rust di editor teks apa saja, tapi editor dengan rust-analyzer (atau mesin sejenis) membuat perbedaan besar. Kamu melihat error selagi mengetik, tipe variabelmu muncul di sebelahnya, dan kamu bisa melompat ke definisi fungsi mana pun. Bagi pemula, umpan balik seperti itu rasanya seperti punya tutor yang sabar.

Editor	Harga	Dukungan Rust	Cocok untuk
VS Code + rust-analyzer	Gratis	Extension rust-analyzer resmi	Kebanyakan orang. Ini pilihan paling populer, dan sebagian besar panduan menganggap kamu memakainya
RustRover (JetBrains)	Gratis untuk penggunaan non-komersial (belajar, proyek hobi, open source yang tidak dibayar). Pekerjaan komersial butuh langganan berbayar	Sudah bawaan, dengan mesin Rust milik JetBrains sendiri dan debugger bawaan	Orang yang suka IDE lengkap dengan semuanya sudah tersedia
Zed	Gratis, open source	Sudah bawaan (memakai rust-analyzer, dan CodeLLDB untuk debugging)	Editor modern yang sangat cepat
Neovim / Helix	Gratis, open source	Lewat rust-analyzer. Helix hampir langsung jalan; Neovim butuh sedikit konfigurasi	Orang yang senang bekerja di terminal
Visual Studio	Edisi berbayar, plus Community yang gratis	Tidak ada dukungan Rust resmi	Kurang cocok untuk Rust. Kamu hanya butuh C++ Build Tools-nya untuk linker

Ketentuan lisensi RustRover bisa berubah, jadi cek halaman RustRover (bahasa Inggris) untuk aturan terbaru sebelum memakainya di kantor.

Untuk Neovim, Helix, dan editor lain, instal program rust-analyzer-nya sendiri dengan rustup component add rust-analyzer.

Extension VS Code yang disarankan

Kalau kamu memakai VS Code, empat extension ini sudah mencakup hampir semuanya:

• rust-analyzer — yang wajib: completion, error, petunjuk, refactoring.
• CodeLLDB — debugger untuk breakpoint dan menjalankan kode langkah demi langkah. Sudah menyertakan salinan LLDB-nya sendiri.
• Even Better TOML — memberi warna dan mengecek Cargo.toml kamu.
• Error Lens (opsional) — menampilkan pesan error langsung di barisnya, bukan hanya saat kursor diarahkan ke sana. Ada yang suka sekali, ada juga yang merasa terlalu ramai.

Debugging

Breakpoint dengan CodeLLDB

Setelah rust-analyzer dan CodeLLDB terinstal di VS Code, kamu akan melihat link kecil Run | Debug di atas fn main dan di atas setiap test. Klik di sebelah kiri nomor baris untuk memasang titik merah breakpoint, lalu klik Debug. Program akan berhenti di breakpoint-mu, dan kamu bisa melihat setiap variabel serta menjalankan kode baris demi baris.

Kalau kamu ingin setup yang bisa dipakai ulang (misalnya untuk memberikan argumen command-line), buat file .vscode/launch.json:

{
  "version": "0.2.0",
  "configurations": [
    {
      "type": "lldb",
      "request": "launch",
      "name": "Debug task_queue",
      "cargo": {
        "args": ["build", "--bin=task_queue"]
      },
      "args": [],
      "cwd": "${workspaceFolder}"
    }
  ]
}

Bagian cargo memberi tahu CodeLLDB untuk mem-build programmu dengan cargo dulu, baru menjalankannya di debugger. Ganti task_queue dengan nama package-mu, dan taruh argumen program di "args". Tekan F5 untuk mulai.

Cek cepat dengan dbg!

Kamu tidak selalu butuh debugger lengkap. Makro dbg! mencetak sebuah ekspresi, nilainya, serta file dan baris tempat kamu menulisnya. Makro ini juga mengembalikan nilainya, jadi kamu bisa membungkus hampir apa saja dengannya tanpa mengubah perilaku kodemu:

fn apply_discount(price: u32, percent: u32) -> u32 {
    price - price * percent / 100
}

fn main() {
    let prices = [120, 45, 80];

    let total: u32 = dbg!(prices.iter().sum());
    let final_price = dbg!(apply_discount(total, 10));

    println!("Total setelah diskon 10%: {final_price}");
}

Output:

Total setelah diskon 10%: 221

▶ Coba sendiri

Ke mana perginya baris-baris dari dbg!? dbg! mencetak ke stderr (aliran error), bukan ke stdout seperti println!. Dengan begitu catatan debug-mu terpisah dari output yang sebenarnya. Di terminal, atau di bagian “Standard Error” pada Playground, kamu juga akan melihat:

[src/main.rs:8:22] prices.iter().sum() = 245
[src/main.rs:9:23] apply_discount(total, 10) = 221

Hapus panggilan dbg! setelah selesai. Itu untukmu, bukan untuk pengguna programmu.

Menjaga kualitas kode setiap hari

Tiga perintah ini menjaga kodemu tetap sehat. Semuanya cepat, jadi jalankan sesering mungkin.

cargo check: umpan balik cepat

cargo check mencari error compile tanpa mem-build program yang bisa dijalankan, jadi jauh lebih cepat daripada cargo build. Banyak developer menjalankannya setiap beberapa menit. (rust-analyzer di editormu menjalankan pengecekan seperti ini setiap kali kamu menyimpan file.)

cargo fmt: tidak perlu berdebat soal gaya

cargo fmt menulis ulang semua file di proyekmu dengan gaya Rust standar. Tidak ada lagi orang di timmu yang perlu memikirkan spasi atau baris baru. Perintah ini mengubah kode seperti ini:

struct Player{name:String,score:u32}
fn top(players:&[Player])->Option<&Player>{players.iter().max_by_key(|p|p.score)}

menjadi seperti ini:

struct Player {
    name: String,
    score: u32,
}
fn top(players: &[Player]) -> Option<&Player> {
    players.iter().max_by_key(|p| p.score)
}

Kebanyakan editor bisa menjalankannya setiap kali kamu menyimpan file. Di VS Code, aktifkan setting “Format On Save”.

cargo clippy: code review yang ramah

Clippy mengenal ratusan pola kode yang salah, lambat, atau sekadar lebih sulit dibaca daripada seharusnya. Ini program kecil yang sebenarnya berjalan baik:

fn main() {
    let tasks: Vec<&str> = vec!["tulis dokumentasi", "perbaiki bug"];

    if tasks.len() == 0 {
        println!("Tidak ada tugas!");
    } else {
        println!("{} tugas menunggu", tasks.len());
    }
}

Tapi cargo clippy punya saran:

warning: length comparison to zero
 --> src/main.rs:4:8
  |
4 |     if tasks.len() == 0 {
  |        ^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `tasks.is_empty()`
  |
  = note: `#[warn(clippy::len_zero)]` on by default

Pesan dari Clippy selalu dalam bahasa Inggris. Intinya: membandingkan panjang dengan nol lebih jelas ditulis sebagai tasks.is_empty(). Setiap warning punya nama (di sini len_zero) yang bisa kamu cari di daftar lint Clippy (bahasa Inggris) untuk penjelasan yang lebih panjang. Ini versi yang sudah diperbaiki:

fn main() {
    let tasks: Vec<&str> = vec!["tulis dokumentasi", "perbaiki bug"];

    if tasks.is_empty() {
        println!("Tidak ada tugas!");
    } else {
        println!("{} tugas menunggu", tasks.len());
    }
}

Output:

2 tugas menunggu

▶ Coba sendiri

cargo clippy --fix bisa menerapkan banyak saran untukmu. Clippy tidak selalu benar untuk situasimu, tapi cukup sering benar sehingga membaca setiap warning-nya adalah cara cepat untuk belajar menulis Rust yang idiomatis.

Kebiasaan yang baik

Sebelum setiap commit, jalankan cargo fmt, cargo clippy, dan cargo test. Di CI, pakai cargo fmt --check dan cargo clippy -- -D warnings, yang menggagalkan build alih-alih mengubah file. Lihat Testing untuk cara menulis test-nya.

Tool cargo tambahan yang berguna

Siapa pun bisa menambahkan subcommand cargo baru. Kamu menginstalnya dengan cargo install, yang mengunduh source code-nya, meng-compile-nya, lalu menaruh programnya di ~/.cargo/bin (di Windows, %USERPROFILE%\.cargo\bin). Di hari pertama kamu belum butuh satu pun dari tool ini, tapi ada baiknya kamu tahu:

Tool	Fungsinya	Instal	Jalankan
bacon	Menjalankan ulang check, clippy, atau test setiap kali kamu menyimpan, di terminal terpisah	cargo install --locked bacon	bacon, bacon clippy, bacon test
cargo-watch	Menjalankan perintah cargo apa saja saat file disimpan. Masih berfungsi, tapi sudah tidak di-update lagi; pembuatnya menyarankan bacon	cargo install --locked cargo-watch	cargo watch -x check
cargo-nextest	Test runner yang lebih cepat dengan output yang lebih jelas	cargo install --locked cargo-nextest	cargo nextest run
cargo-audit	Mengecek Cargo.lock kamu terhadap daftar celah keamanan yang sudah diketahui	cargo install cargo-audit	cargo audit
cargo-outdated	Menampilkan dependency yang punya versi lebih baru	cargo install --locked cargo-outdated	cargo outdated
cargo-edit	Menambahkan cargo upgrade, yang menaikkan versi di Cargo.toml (cargo add sudah bawaan)	cargo install cargo-edit	cargo upgrade
cargo-expand	Menunjukkan kode hasil dari makro dan #[derive] kamu	cargo install cargo-expand	cargo expand
cargo-binstall	Mengunduh binary yang sudah jadi alih-alih meng-compile, jadi instalasi hanya butuh beberapa detik	cargo install cargo-binstall	cargo binstall bacon

cargo install meng-compile dari source code, jadi instalasi pertama tool yang besar bisa makan waktu beberapa menit. Itu normal. Untuk meng-update tool nanti, jalankan lagi perintah instal yang sama. Untuk melihat apa saja yang sudah kamu instal, jalankan cargo install --list. Untuk tool yang fokus pada kecepatan seperti profiler dan benchmark, lihat Performa.

Tanpa instalasi sama sekali: Rust Playground

Rust Playground menjalankan Rust di browser-mu. Setiap tombol “Coba sendiri” di situs ini membukanya. Playground sangat cocok untuk eksperimen cepat, berbagi potongan kode saat kamu minta bantuan, atau belajar di komputer yang tidak mengizinkanmu menginstal apa pun.

Yang bisa dilakukannya:

• Menjalankan kodemu di stable, beta, atau nightly, sebagai build debug atau release.
• Memakai 100 crate yang paling banyak diunduh dari crates.io (plus crate yang dipakai oleh Rust Cookbook, beserta dependency-nya), seperti serde, rand, regex, dan tokio.
• Menjalankan rustfmt dan Clippy dari menu Tools.
• Membagikan kodemu sebagai link.

Yang tidak bisa dilakukannya:

• Punya lebih dari satu file. Tidak ada Cargo.toml, jadi kamu tidak bisa memilih crate atau versi lain.
• Mengakses jaringan. Kode yang mengunduh halaman web akan gagal.
• Bekerja dengan file milikmu sendiri, atau berjalan dalam waktu lama. Waktu dan memorinya dibatasi.
• Nyaman untuk program interaktif. Saat program berjalan, ada kotak kecil untuk mengetik input, tapi itu canggung untuk apa pun selain tes singkat. Contoh-contoh di situs ini tidak pernah membaca input, jadi semuanya jalan dengan sekali klik.

Kalau Playground sudah tidak cukup, proyek lokal dengan cargo new hanya berjarak satu menit.

Checklist awal untuk komputer baru

Sedang menyiapkan komputer baru? Jalani daftar ini sekali saja:

• Instal prasyarat OS-mu: C++ tools dari Visual Studio (Windows), xcode-select --install (macOS), atau build-essential / gcc (Linux).
• Instal Rust dari rustup.rs, lalu buka terminal baru.
• Cek hasilnya: rustc --version dan cargo --version.
• Pastikan tool sehari-hari sudah ada: rustup component add clippy rustfmt.
• Instal editor dengan rust-analyzer. Kalau memakai VS Code, tambahkan extension rust-analyzer dan CodeLLDB.
• Aktifkan format on save di editormu.
• Buat proyek percobaan dengan cargo new hello, lalu jalankan cargo run, cargo clippy, dan cargo fmt di dalamnya.
• Pasang pengingat untuk menjalankan rustup update setiap satu atau dua bulan.
• Opsional: cargo install --locked bacon untuk umpan balik instan selagi kamu ngoding.

Latihan

1. Cek kotak peralatanmu

Di komputermu sendiri, jalankan setiap perintah berikut dan pastikan tidak ada yang bilang “not installed”: rustup show, cargo clippy --version, cargo fmt --version. Lalu buka dokumentasi standard library offline dan cari halaman untuk Vec. Petunjuk: rustup doc bisa menerima sebuah topik, misalnya path lengkap sebuah tipe.

Lihat solusi

rustup show
cargo clippy --version
cargo fmt --version
rustup doc std::vec::Vec

Setiap perintah --version mencetak nomor versi. Kalau ada yang malah mencetak error, instal bagian yang hilang dengan rustup component add clippy atau rustup component add rustfmt. Perintah terakhir membuka halaman Vec di browser-mu, langsung dari disk. Kalau muncul pesan bahwa rust-docs belum terinstal, jalankan rustup component add rust-docs dulu.

2. Biarkan Clippy mengajarimu

Di proyek baru, tempel versi pertama program tugas dari bagian Clippy ke src/main.rs. Jalankan cargo clippy, baca warning-nya, lalu biarkan Clippy memperbaikinya untukmu. Petunjuk: ada flag yang menerapkan saran-sarannya secara otomatis.

Lihat solusi

cargo new task_queue
cd task_queue
# tempel programnya ke src/main.rs, lalu:
cargo clippy
cargo clippy --fix --allow-dirty
cargo clippy

cargo clippy yang pertama menampilkan warning len_zero. cargo clippy --fix mengubah tasks.len() == 0 menjadi tasks.is_empty(). Flag --allow-dirty mengizinkannya mengubah file yang belum kamu commit ke git. Saat dijalankan terakhir kali, tidak ada warning lagi.

Ringkasan

• rustup menginstal dan meng-update Rust serta berganti toolchain; cargo mem-build, menjalankan, mengetes, dan menambahkan crate; rustc adalah compiler di baliknya.
• Setiap OS butuh linker dulu: C++ tools dari Visual Studio di Windows, xcode-select --install di macOS, build-essential atau gcc di Linux.
• Tetaplah di stable. Pakai rust-toolchain.toml hanya kalau sebuah proyek harus mengunci versi, dan cargo +nightly untuk perintah nightly sekali pakai.
• Pakai editor dengan rust-analyzer. VS Code dengan rust-analyzer dan CodeLLDB adalah setup yang paling umum.
• Jalankan cargo check sesering mungkin, serta cargo fmt dan cargo clippy sebelum setiap commit. Pakai dbg! untuk melihat sekilas, dan debugger untuk bug yang lebih sulit.
• Playground bagus untuk eksperimen dan berbagi kode, tapi hanya satu file, tanpa jaringan, dan hanya crate yang paling populer.

Kuis singkat

Kuis singkat

1. Tool mana yang kamu pakai untuk menginstal toolchain nightly di samping stable?

cargo install nightly rustc --nightly rustup toolchain install nightly

2. Build-mu di Windows gagal karena linker tidak ditemukan. Apa yang kemungkinan besar belum ada?

C++ build tools dari Visual Studio (workload "Desktop development with C++") Extension rust-analyzer Komponen rust-src Clippy

3. Ke mana dbg! mencetak output-nya?

Ke stdout, seperti println! Ke stderr, beserta nama file dan barisnya Hanya di dalam debugger Tidak ke mana-mana di build debug

4. Mana yang TIDAK bisa dilakukan Rust Playground?

Menjalankan Clippy dan rustfmt Memakai crate populer seperti serde Mengunduh halaman web dari internet Menjalankan kode di nightly

Skor: 0 / 4

Bacaan lebih lanjut

• Install Rust — rust-lang.org (bahasa Inggris): installer resmi untuk semua platform, plus catatan tentang Windows, PATH, dan cara uninstall.
• The rustup book (bahasa Inggris): toolchain, channel, komponen, profil, rust-toolchain.toml, dan target cross-compilation.
• The Cargo Book (bahasa Inggris): semua hal tentang cargo, termasuk cargo install dan opsi setiap perintah.
• Manual rust-analyzer (bahasa Inggris): cara setup rust-analyzer di VS Code, Neovim, Helix, Emacs, dan lainnya, beserta semua setting-nya.
• Dokumentasi Clippy (bahasa Inggris): cara menjalankan dan mengonfigurasi Clippy, dengan link ke daftar lengkap lint dan arti masing-masing.