Tutorial Rust: Memulai dengan bahasa Rust

Selama beberapa tahun terakhir, Rust telah berubah dari rasa ingin tahu yang muncul di lab karyawan Mozilla menjadi pesaing kuat untuk menulis aplikasi asli dan solusi bare-metal generasi berikutnya. Namun kemajuan tersebut datang dari Rust yang menyediakan rantai alat dan sistem manajemen komponennya sendiri — bersama dengan fitur dan kebiasaannya sendiri.

Artikel ini menjelaskan dasar-dasar menyiapkan lingkungan kerja di Rust, mengonfigurasi IDE, dan memanfaatkan set alat yang disediakan Rust untuk pengembangan aplikasi.

Video terkait: Mengembangkan perangkat lunak yang lebih aman dengan Rust

Dapatkan informasi terbaru dengan cepat untuk Rust pendatang baru, yang dirancang untuk membuat perangkat lunak tingkat sistem yang cepat. Penjelasan animasi dua menit ini menunjukkan bagaimana Rust melewati masalah pemrograman yang menjengkelkan dari memori dan manajemen.

Pahami rilis Rust nightly, beta, dan stable

Rantai alat Rust terutama terdiri dari kompiler Rust rustc, bersama dengan alat untuk mengelola instalasi Rust. Karena Rust terus berkembang, rantai alat Rust dirancang agar mudah selalu diperbarui.

Proyek perangkat lunak sering kali disediakan melalui beberapa saluran, untuk memisahkan versi stabil dan beta dari kode. Rantai alat Rust bekerja dengan cara yang sama, menawarkan tiga saluran untuk rantai perkakasnya:

  • Stabil: Rilis poin utama, yang muncul setiap enam minggu atau lebih.
  • Beta: Kandidat untuk rilis poin utama berikutnya, yang muncul lebih sering.
  • Nightly: Bangunan paling cepat, dengan akses ke fitur-fitur mutakhir tetapi tidak ada jaminan untuk stabilitasnya.

Seperti yang ditunjukkan oleh pengembang Karol Kuczmarski, yang terbaik adalah menganggap saluran Rust setiap malam sebagai bahasanya sendiri. Beberapa fitur Rust, seperti kompilasi ke WebAssembly, hanya tersedia di saluran malam, dan mereka hanya dapat diaktifkan dengan arahan kompilator khusus. Dengan kata lain, mereka bahkan tidak akan mengkompilasi pada saluran beta atau stabil. 

Itu memang desainnya, karena tidak ada jaminan fitur nightly akan didukung di tempat lain. Namun, banyak dari fitur tersebut yang pada akhirnya keluar dari saluran nightly dan beralih ke rilis beta dan stabil. (Mengompilasi ke WebAssembly, misalnya, berfungsi dengan stabil sejak Rust 1.30.)

Pendeknya:

  1. Gunakan stabil untuk pekerjaan produksi yang sebenarnya.
  2. Gunakan beta untuk menguji perangkat lunak saat ini terhadap versi yang akan datang untuk melihat apakah ada yang rusak dalam peningkatan.
  3. Gunakan hanya setiap malam untuk eksperimen kotak pasir dengan fitur terbaru Rust.

Pilih OS untuk pengembangan Rust

Rust mendukung ketiga platform utama — Windows, Linux, dan MacOS — dalam inkarnasi 32 dan 64-bit, dengan binari resmi untuk masing-masingnya. Banyak platform lain juga memiliki binari resmi, tetapi mereka tidak memiliki tingkat cakupan pengujian otomatis yang sama. Platform kelas dua ini termasuk ARMv6 dan ARMv7 untuk iOS, Android, dan Linux; MIPS Linux dan MIPS64 Linux; X86 iOS, Windows, dan Linux edisi 32-bit; dan WebAssembly. Platform lain, seperti Windows XP atau HaikuOS eksperimental, didukung melalui build tidak resmi.

Tim pengembang Rust telah menyatakan bahwa bukanlah salah satu misi Rust untuk menjadi portabel seluas mungkin. Misalnya, meskipun Rust tersedia di banyak arsitektur ARM, tidak ada jaminan bahwa Rust akan didukung secara resmi pada platform perangkat keras kelas bawah.

Meskipun demikian, harus ada build Rust yang didukung yang tersedia untuk sebagian besar kasus penggunaan umum yang umum — yaitu Windows 32 dan 64-bit, Linux, dan MacOS.

Jika Anda berencana mengembangkan Rust di Windows, ingatlah rantai alat Anda. Rust mendukung dua rantai alat di Windows:

  • Microsoft Visual C (MSVC) ABI asli
  • Gnu ABI yang digunakan oleh linker GCC.

Karena hampir semua perangkat lunak C / C ++ yang dibangun di Windows menggunakan MSVC, Anda pasti ingin menggunakan rantai alat MSVC sebagian besar waktu. Jika Anda membutuhkan GCC, kemungkinan besar itu untuk beroperasi dengan pustaka pihak ketiga yang dibangun di Windows dengan GCC.

Kabar baiknya adalah bahwa sistem manajemen rantai alat Rust memungkinkan Anda tetap memasang rantai alat MSVC dan GCC, dan memungkinkan Anda beralih di antara keduanya berdasarkan proyek per proyek.

Salah satu target kompilasi Rust adalah WebAssembly, yang berarti Anda dapat menulis di Rust dan menerapkannya ke browser web. WebAssembly sendiri masih kasar, begitu juga dengan dukungan Rust untuk itu. Tetapi jika Anda berambisi dan ingin membuat tangan Anda berantakan, bacalah buku yang disusun oleh Rust dan pengembang WebAssembly yang merinci proses kompilasi WebAssembly ke Rust. Buku ini mencakup tutorial untuk proyek sederhana, implementasi dari Conway's Game of Life, ditulis dalam Rust dan digunakan sebagai WebAssembly.

Mulailah penyiapan Rust Anda dengan rustup

Rust menyediakan penginstal all-in-one dan sistem pemeliharaan rantai alat yang disebut rustup. Unduh rustupdan jalankan; itu akan mendapatkan versi terbaru dari rantai alat Rust dan menginstalnya untuk Anda.

Alat paling penting yang dikelola rustupadalah:

  • rustupdiri. Setiap kali versi baru rustupatau alat lain diterbitkan, Anda dapat menjalankan rustup updatedan memperbarui semuanya secara otomatis.
  • rustc, kompiler Rust.
  • Cargo, manajer paket dan ruang kerja Rust.

Secara default, rustupinstal Rust dari saluran stabil. Jika Anda ingin menggunakan versi beta atau nightly, Anda harus menginstal saluran tersebut (misalnya,  rustup install nightly), dan mengatur Rust untuk menggunakannya secara default ( rustup default nightly). Anda juga dapat secara manual menentukan saluran mana yang akan digunakan saat menyusun aplikasi Rust, jadi Anda tidak perlu menyetel dan menyetel ulang default setiap kali Anda berpindah antar proyek.

Anda juga dapat menggunakan  rustup untuk menginstal dan memelihara rantai alat kustom. Ini biasanya digunakan oleh build Rust pihak ketiga tidak resmi untuk platform yang tidak didukung, karena build tersebut biasanya memerlukan linkernya sendiri atau alat khusus platform lainnya.

Konfigurasi IDE Anda untuk Rust

Meskipun Rust menjadi bahasa yang relatif baru, itu sudah mendapatkan dukungan kuat dari banyak IDE umum. Pengembang Manuel Hoffman mengelola sebuah proyek untuk melacak keadaan dukungan tersebut di situs web areweideyet.com.

Membuat Rust bekerja dengan baik dengan IDE adalah tujuan nyata dari tim pengembangannya, melalui fitur yang disebut Rust Language Server (RLS). RLS memberikan umpan balik langsung tentang kode yang dipermasalahkan dari kompiler Rust sendiri, bukan dari parser pihak ketiga.

Berikut adalah IDE yang mendukung Rust:

  • Microsoft's Visual Studio Code memiliki ekstensi dukungan bahasa Rust yang dibuat oleh tim alat pengembang Rust sendiri. Tingkat integrasi ini menjadikannya salah satu IDE yang paling didukung untuk Rust. 
  • Pengguna Eclipse dapat mengunduh Eclipse edisi yang sudah dikemas untuk pengembangan Rust, atau menggunakan plugin Korosi mandiri untuk Eclipse Photon. (Paket sebelumnya, RustDT, tidak lagi dipertahankan.)
  • Jika Anda penggemar Emacs atau Vim, pengembang lain seperti Anda telah menulis add-on khusus Rust untuk kedua editor. Emacs memiliki mode khusus Rust, dan Vim memiliki plugin untuk menyediakan penyorotan dan pemformatan sintaks. Dukungan RLS tersedia untuk Emacs dan Vim, tetapi harus ditambahkan dan dikonfigurasi secara manual.
  • Pengguna IntelliJ Idea dan Atom dapat menambahkan plugin untuk melengkapi dukungan Rust.
  • Sublime Text memiliki dukungan sintaks Rust di luar kotak, dan plugin memberikan dukungan yang lebih dalam untuk fitur lainnya.
  • Sebuah proyek untuk membuat IDE sederhana khusus untuk Rust, SolidOak, sedang dalam pengembangan untuk beberapa waktu tetapi terhenti. Taruhan terbaik Anda adalah menggunakan salah satu IDE yang ada yang sudah memiliki dukungan.

Buat proyek Rust pertama Anda

Proyek Rust dimaksudkan untuk memiliki struktur direktori yang konsisten, dengan kode dan metadata proyek yang disimpan di dalamnya dengan cara tertentu. Kode disimpan dalam srcsubdirektori, dan detail tentang proyek disimpan dalam dua file di direktori akar proyek,  Cargo.toml(informasi dasar proyek) dan Cargo.lock(daftar ketergantungan yang dibuat secara otomatis). Anda dapat membuat struktur direktori dan metadata itu dengan tangan, tetapi lebih mudah hanya menggunakan alat Rust sendiri untuk melakukan pekerjaan itu.

Tip:  Panduan online Rust By Example untuk mempelajari Rust menyediakan contoh kode interaktif yang dapat diedit dan dijalankan langsung di browser. Ini menyentuh hampir setiap konsep utama Rust, meskipun beberapa konsep yang lebih penting, seperti peminjaman dan masa pakai, diperkenalkan relatif terlambat dalam diskusi.

Alat Rust's Cargo mengelola baik proyek Rust dan perpustakaan, atau "peti," yang mereka gunakan. Untuk menjalankan proyek Rust baru yang dinamai my_projectdi direktorinya sendiri, ketik cargo new my_project. (Untuk pengembang C # yang bekerja dengan .Net Core, pikirkan dotnet newperintahnya.) Proyek baru muncul di subdirektori dengan nama itu, bersama dengan manifest proyek dasar — Cargo.tomlfile — dan rintisan untuk kode sumber proyek, di srcsubdirektori.

Saat Anda membuat proyek baru,  main.rsfile secara otomatis dibuat di srcdirektori proyek. File ini berisi aplikasi "hello world" dasar, sehingga Anda dapat langsung menguji toolchain Rust dengan menyusun dan menjalankannya.

Kode sumber untuk aplikasi "hello world":

fn main() {

    println!(“Hello World!”);

}

Untuk membangun dan menjalankannya, masukkan root direktori proyek dan ketik cargo run. Perhatikan bahwa secara default, Cargo membangun proyek dalam mode debug. Untuk menjalankan mode rilis, gunakan cargo run --release. Binari dibangun di target/debugatau target/releasesubdirektori proyek, tergantung pada profil kompilasi yang Anda gunakan.

Bekerja dengan peti karat

Manajemen paket adalah bagian penting dari setiap lingkungan pemrograman modern. Untuk itu, Rust menyediakan “crates,” yang merupakan pustaka pihak ketiga yang dikemas untuk distribusi dengan alat Rust. Anda dapat menemukan peti di registri paket Rust resmi, Crates.io.

Jika proyek Anda memiliki ketergantungan pada peti tertentu, Anda perlu menentukan peti itu dengan mengedit file proyek Cargo.toml. Cara standar untuk melakukannya adalah secara manual — yaitu, dengan mengedit Cargo.tomllangsung menggunakan editor teks. Saat project dibangun kembali, Rust otomatis mendapatkan dependensi yang diperlukan.

Tips: Dua alat, cargo-editdan cargo-edit-locally, bisa memperbarui dependensi dari baris perintah, meskipun itu adalah proyek pihak ketiga tidak resmi.

Saat Anda membangun proyek Rust yang bergantung pada peti eksternal, Cargo akan mencari peti tersebut di Crates.io secara default; Anda tidak perlu mendapatkannya secara manual. Anda juga dapat merujuk ke peti di proyek Anda dengan URL daripada dengan nama peti, jika Anda memerlukan peti yang tidak dihosting di registri, seperti sesuatu dari repositori pribadi.

Perhatikan bahwa beberapa peti hanya akan dipasang dan dibangun di saluran malam Rust, karena mereka menggunakan fitur eksperimental yang tidak tersedia di saluran lain. Jika Anda berada di saluran rilis dan mencoba memasang peti seperti itu, Anda tidak akan mendapatkan peringatan apa pun sampai kompilasi itu sendiri gagal. Dokumentasi peti biasanya menyebutkan apakah itu membutuhkan saluran malam atau tidak, jadi bacalah sebelum Anda memasukkan, apalagi mengkompilasi.

Peti dapat disertakan dengan binari. Beberapa adalah alat baris perintah yang digunakan dalam pengembangan Rust; yang lainnya adalah alat untuk tujuan umum (seperti  ripgrep). Untuk memasang salah satu peti ini, cukup ketik cargo install . Ini bukan satu - satunya cara untuk mendistribusikan biner yang dibuat dengan Rust, tetapi ini cara mudah bagi pengembang Rust untuk mendapatkannya sebagai bagian dari alur kerja yang melibatkan alat Rust.

Lakukan kompilasi silang Rust ke platform lain

Karena Rust mendukung banyak rantai alat, bahkan dalam instalasi Rust yang sama, Anda dapat mengkompilasi aplikasi Rust ke OS dan lingkungan target yang berbeda dari yang Anda kompilasi.

Kompilasi silang seperti itu membutuhkan rantai alat pada platform yang Anda kerjakan yang sesuai dengan platform target. Terkadang, seperti halnya kompilasi silang ke Linux di Windows atau sebaliknya, ini melibatkan lebih dari sekadar memiliki GCC linker. Tapi di lain waktu, ini lebih kompleks. Untuk kompilasi silang ke MacOS, misalnya, Anda memerlukan pustaka Xcode IDE untuk menyelesaikan pekerjaan — cctools (setara dengan binutils Apple) dan MacOS SDK.

Alat pihak ketiga menawarkan beberapa cara untuk mengatasi kesulitan ini:

  • Salah satu alat tersebut adalah Trust, templat Travis CI dan AppVeyor yang dapat secara otomatis menerbitkan rilis biner dari proyek Rust. Dapat dibangun untuk Linux, Windows, dan MacOS, meskipun memerlukan penggunaan Travis CI dan layanan AppVeyor, dan proyek Anda harus dihosting di GitHub.
  • Proyek lain, Cross, berjalan langsung pada host Linux 64-bit x86, tetapi menyediakan apa yang dijelaskan oleh pembuatnya sebagai kompilasi silang “zero-setup” untuk berbagai macam target, termasuk Windows 64-bit dan MIPS.
  • Proyek crossbuild menyediakan gambar Docker multi-arsitektur yang dapat digunakan untuk membangun silang antara ketiga platform utama.