Add ch03-01 translation

src/ch03-01-variables-and-mutability.md

@@ -1,188 +1,203 @@
-## Variables and Mutability
+## Variabel dan Mutabilitas
 
-As mentioned in the [“Storing Values with
-Variables”][storing-values-with-variables]<!-- ignore --> section, by default,
-variables are immutable. This is one of many nudges Rust gives you to write
-your code in a way that takes advantage of the safety and easy concurrency that
-Rust offers. However, you still have the option to make your variables mutable.
-Let’s explore how and why Rust encourages you to favor immutability and why
-sometimes you might want to opt out.
+Sebagaimana disinggung di bagian ["Menyimpan Nilai dengan 
+Variabel"][storing-values-with-variables]<!-- ignore -->, secara baku, 
+variabel itu immutable. Ini adalah satu dari banyak dorongan yang Rust berikan
+kepada Anda untuk menulis kode dengan cara yang memanfaatkan keamanan dan
+konkurensi mudah yang ditawarkan oleh Rust. Namun Anda masih punya pilihan
+untuk membuat variabel Anda mutable. Mari kita eksplorasi bagaimana dan
+mengapa Rust mendorong Anda agar lebih suka atas imutabilitas dan mengapa
+kadang Anda perlu untuk tidak memilihnya.
 
-When a variable is immutable, once a value is bound to a name, you can’t change
-that value. To illustrate this, generate a new project called *variables* in
-your *projects* directory by using `cargo new variables`.
+Ketika suatu variabel immutable, sekali suatu nilai diikat ke sebuah nama,
+Anda tidak bisa mengubah nilai tersebut. Untuk mengilustrasikan ini, buatlah
+sebuah proyek baru bernama *variables* dalam direktori *projects* Anda dengan
+memakai `cargo new variables`.
 
-Then, in your new *variables* directory, open *src/main.rs* and replace its
-code with the following code, which won’t compile just yet:
+Lalu, dalam direktori *variables* baru Anda, buka *src/main.rs* dan ganti
+kodenya dengan kode berikut, yang kini belum bisa dikompilasi:
 
 <span class="filename">Filename: src/main.rs</span>
 
 ```rust,ignore,does_not_compile
 {{#rustdoc_include ../listings/ch03-common-programming-concepts/no-listing-01-variables-are-immutable/src/main.rs}}
 ```
 
-Save and run the program using `cargo run`. You should receive an error message
-regarding an immutability error, as shown in this output:
+Simpan dan jalankan program memakai `cargo run`. Anda mestinya memperoleh
+pesan kesalahan terkait kesalahan imutabilitas, seperti ditunjukkan dalam
+keluaran ini:
 
 ```console
 {{#include ../listings/ch03-common-programming-concepts/no-listing-01-variables-are-immutable/output.txt}}
 ```
 
-This example shows how the compiler helps you find errors in your programs.
-Compiler errors can be frustrating, but really they only mean your program
-isn’t safely doing what you want it to do yet; they do *not* mean that you’re
-not a good programmer! Experienced Rustaceans still get compiler errors.
-
-You received the error message `` cannot assign twice to immutable variable `x`
-`` because you tried to assign a second value to the immutable `x` variable.
-
-It’s important that we get compile-time errors when we attempt to change a
-value that’s designated as immutable because this very situation can lead to
-bugs. If one part of our code operates on the assumption that a value will
-never change and another part of our code changes that value, it’s possible
-that the first part of the code won’t do what it was designed to do. The cause
-of this kind of bug can be difficult to track down after the fact, especially
-when the second piece of code changes the value only *sometimes*. The Rust
-compiler guarantees that when you state that a value won’t change, it really
-won’t change, so you don’t have to keep track of it yourself. Your code is thus
-easier to reason through.
-
-But mutability can be very useful, and can make code more convenient to write.
-Although variables are immutable by default, you can make them mutable by
-adding `mut` in front of the variable name as you did in [Chapter
-2][storing-values-with-variables]<!-- ignore -->. Adding `mut` also conveys
-intent to future readers of the code by indicating that other parts of the code
-will be changing this variable’s value.
-
-For example, let’s change *src/main.rs* to the following:
+Contoh ini menunjukkan bagaimana compiler membantu Anda menemukan kesalahan
+dalam program Anda. Kesalahan compiler bisa membuat frustrasi, tetapi 
+sebenarnya mereka hanya berarti bahwa program Anda belum secara aman
+melakukan apa yang Anda ingin dia lakukan; mereka *bukan* berarti bahwa Anda 
+bukanlah programmer yang baik! Rustacean yang berpengalaman masih mendapat
+kesalahan compiler.
+
+Anda menerima pesan kesalahan `` cannot assign twice to immutable variable `x`
+`` karena Anda mencoba menugaskan suatu nilai kedua ke variabel `x` yang
+immutable.
+
+Penting bahwa kita mendapat kesalahan saat compile ketika kita mencoba
+mengubah suatu nilai yang ditugaskan sebagai immutable karena situasi seperti
+ini dapat mengarah ke bug. Bila satu bagian dari kode kita beroperasi pada
+asumsi bahwa suatu nilai tidak akan pernah berubah dan bagian lain dari kode
+kita mengubah nilai tersebut, mungkin bahwa bagian pertama kode tidak akan
+melakukan apa yang itu dirancang untuk melakukannya. Penyebab bug jenis ini
+bisa sulit dilacak setelah fakta, khususnya ketika penggalan kedua kode
+hanya *kadang-kadang* mengubah nilai. Compiler Rust menjamin bahwa ketika
+Anda menyatakan bahwa suatu nilai tidak akan berubah, itu benar-benar tidak
+akan berubah, sehingga Anda tidak perlu melacaknya sendiri. Maka kode Anda
+lebih mudah dipahami.
+
+Tapi mutabilitas bisa sangat berguna, dan dapat membuat kode lebih nyaman
+ditulis. Walaupun variabel secara default immutable, Anda dapat membuat mereka
+mutable dengan menambahkan `mut` di depan nama variabel seperti yang telah
+Anda lakukan dalam [Bab 2][storing-values-with-variables]<!-- ignore -->. 
+Menambahkan `mut` juga menyampaikan maksud ke pembaca kode di masa depan
+dengan mengindikasikan bahwa bagian lain dari kode akan mengubah nilai
+variabel ini.
+
+Sebagai contoh, mari kita ubah *src/main.rs* menjadi yang berikut:
 
 <span class="filename">Filename: src/main.rs</span>
 
 ```rust
 {{#rustdoc_include ../listings/ch03-common-programming-concepts/no-listing-02-adding-mut/src/main.rs}}
 ```
 
-When we run the program now, we get this:
+Saat kita sekarang menjalankan program, kita memperoleh ini:
 
 ```console
 {{#include ../listings/ch03-common-programming-concepts/no-listing-02-adding-mut/output.txt}}
 ```
 
-We’re allowed to change the value bound to `x` from `5` to `6` when `mut` is
-used. Ultimately, deciding whether to use mutability or not is up to you and
-depends on what you think is clearest in that particular situation.
+Kita diizinkan mengubah nilai yang diikat ke `x` dari `5` ke `6` ketika 
+`mut` dipakai. Pada akhirnya, menentukan apakah memakai mutabilitas atau 
+tidak terserah padamu dan tergantung kepada apa yang Anda pikir paling 
+jelas dalam situasi tersebut.
 
-### Constants
+### Konstanta
 
-Like immutable variables, *constants* are values that are bound to a name and
-are not allowed to change, but there are a few differences between constants
-and variables.
+Seperti variable yang immutable, *konstanta* adalah nilai-nilai yang terikat
+ke suatu nama dan tidak diizinkan berubah, tapi ada beberapa perbedaan
+antara konstanta dan variabel.
 
-First, you aren’t allowed to use `mut` with constants. Constants aren’t just
-immutable by default—they’re always immutable. You declare constants using the
-`const` keyword instead of the `let` keyword, and the type of the value *must*
-be annotated. We’ll cover types and type annotations in the next section,
-[“Data Types”][data-types]<!-- ignore -->, so don’t worry about the details
-right now. Just know that you must always annotate the type.
+Pertama, Anda tidak diizinkan memakai `mut` dengan konstanta. Konstanta tidak
+hanya sekadar immutable secara baku — mereka selalu immutable. Anda
+mendeklarasikan konstanta memakai kata kunci `const` bukan kata kunci `let`,
+dan tipe nilai *harus* dianotasikan. Kita akan membahas tipe dan anotasi tipe
+dalam bagian selanjutnya, ["Tipe Data,"][data-types]<!-- ignore -->, jadi
+jangan khawatir tentang detilnya sekarang. Ketahui saja bahwa Anda mesti selalu
+menganotasi tipe.
 
-Constants can be declared in any scope, including the global scope, which makes
-them useful for values that many parts of code need to know about.
+Konstanta dapat dideklarasikan dalam sebarang skup, termasuk skup global, yang
+membuat mereka berguna untuk nilai-nilai yang banyak bagian kode perlu tahu
+tentangnya.
 
-The last difference is that constants may be set only to a constant expression,
-not the result of a value that could only be computed at runtime.
+Perbedaan terakhir adalah konstanta dapat diatur hanya ke suatu ekspresi
+konstan, bukan hasil dari suatu nilai yang hanya dapat dihitung saat runtime.
 
-Here’s an example of a constant declaration:
+Ini adalah sebuah contoh dari deklarasi konstanta:
 
 ```rust
 const THREE_HOURS_IN_SECONDS: u32 = 60 * 60 * 3;
 ```
 
-The constant’s name is `THREE_HOURS_IN_SECONDS` and its value is set to the
-result of multiplying 60 (the number of seconds in a minute) by 60 (the number
-of minutes in an hour) by 3 (the number of hours we want to count in this
-program). Rust’s naming convention for constants is to use all uppercase with
-underscores between words. The compiler is able to evaluate a limited set of
-operations at compile time, which lets us choose to write out this value in a
-way that’s easier to understand and verify, rather than setting this constant
-to the value 10,800. See the [Rust Reference’s section on constant
-evaluation][const-eval] for more information on what operations can be used
-when declaring constants.
-
-Constants are valid for the entire time a program runs, within the scope in
-which they were declared. This property makes constants useful for values in
-your application domain that multiple parts of the program might need to know
-about, such as the maximum number of points any player of a game is allowed to
-earn, or the speed of light.
-
-Naming hardcoded values used throughout your program as constants is useful in
-conveying the meaning of that value to future maintainers of the code. It also
-helps to have only one place in your code you would need to change if the
-hardcoded value needed to be updated in the future.
+Nama konstantanya adalah `THREE_HOURS_IN_SECONDS` dan nilainya diatur ke
+hasil perkalian 60 (banyaknya detik dalam satu menit) dengan 60 (banyaknya
+menit dalam satu jam) dengan 3 (banyaknya jam yang ingin kita hitung dalam
+program ini). Konvensi penamaan Rust bagi konstanta adalah memakai huruf besar
+dengan garis bawah antara kata. Compiler dapat mengevaluasi set operasi
+terbatas saat compile, yang memungkinkan kita memilih menulis nilai ini dalam
+suatu cara yang lebih mudah dipahami dan diverifikasi, daripada menata
+konstanta ini ke nilai 10.800. Lihat [Bagian Referensi Rust tentang evaluasi
+konstanta][const-eval] untuk informasi lebih banyak tentang operasi apa yang
+dapat dipakai saat mendeklarasikan konstanta.
+
+Konstanta valid bagi seluruh waktu suatu program dijalankan, dalam skup
+tempat mereka dideklarasikan. Properti ini membuat konstanta berguna untuk
+nilai-nilai dalam domain aplikasi Anda yang berbagai bagian dari program
+mungkin perlu tahu, seperti banyaknya maksimum nilai yang diizinkan diperoleh
+seorang pemain, atau kecepatan cahaya.
+
+Menamai nilai-nilai ter-*hardcode* yang dipakai dalam seluruh program Anda
+sebagai konstanta berguna dalam menyampaikan makna nilai itu ke pemelihara
+kode di masa mendatang. Itu juga membantu agar hanya satu tempat dalam kode
+Anda yang perlu diubah bila nilai ter-*hardcode* perlu diperbarui nanti.
 
 ### Shadowing
 
-As you saw in the guessing game tutorial in [Chapter
-2][comparing-the-guess-to-the-secret-number]<!-- ignore -->, you can declare a
-new variable with the same name as a previous variable. Rustaceans say that the
-first variable is *shadowed* by the second, which means that the second
-variable is what the compiler will see when you use the name of the variable.
-In effect, the second variable overshadows the first, taking any uses of the
-variable name to itself until either it itself is shadowed or the scope ends.
-We can shadow a variable by using the same variable’s name and repeating the
-use of the `let` keyword as follows:
+Sebagaimana Anda lihat dalam tutorial permainan tebakan dalam
+[Bab 2][comparing-the-guess-to-the-secret-number]<!-- ignore -->, Anda dapat 
+mendeklarasikan suatu variabel baru dengan nama sama seperti variabel
+sebelumnya. Rustacean mengatakan bahwa variabel pertama *di-shadow* oleh yang
+kedua, yang berarti bahwa variabel kedua adalah yang akan dilihat oleh
+compiler ketika Anda memakai nama variabel tersebut. Efeknya, variabel
+kedua menutupi yang pertama, mengambil sebarang penggunaan dari nama variabel
+ke dirinya sendiri dengan memakai nama variabel yang sama dan mengulangi
+penggunaan kata kunci `let` sebagai berikut:
 
 <span class="filename">Filename: src/main.rs</span>
 
 ```rust
 {{#rustdoc_include ../listings/ch03-common-programming-concepts/no-listing-03-shadowing/src/main.rs}}
 ```
 
-This program first binds `x` to a value of `5`. Then it creates a new variable
-`x` by repeating `let x =`, taking the original value and adding `1` so the
-value of `x` is then `6`. Then, within an inner scope created with the curly
-brackets, the third `let` statement also shadows `x` and creates a new
-variable, multiplying the previous value by `2` to give `x` a value of `12`.
-When that scope is over, the inner shadowing ends and `x` returns to being `6`.
-When we run this program, it will output the following:
+Program ini pertama mengikat `x` ke suatu nilai `5`. Lalu itu membuat
+sebuah variabel baru `x` dengan mengulangi `let x =`, mengambil nilai asli
+dan menambahkan `1` sehingga nilai `x` lalu menjadi `6`. Kemudian, di dalam
+skup dalam yang dibuat dengan kurung kurawal, pernyataan `let` ketiga juga
+membayang `x` dan membuat sebuah variabel baru, mengalikan nilai sebelumnya
+dengan `2` untuk menghasilkan suatu nilai `12`. Ketika skup itu berakhir, 
+bayang dalam berakhir dan `x` kembali menjadi `6`. Ketika kita menjalankan
+program ini, itu akan mengeluarkan yang berikut:
 
 ```console
 {{#include ../listings/ch03-common-programming-concepts/no-listing-03-shadowing/output.txt}}
 ```
 
-Shadowing is different from marking a variable as `mut` because we’ll get a
-compile-time error if we accidentally try to reassign to this variable without
-using the `let` keyword. By using `let`, we can perform a few transformations
-on a value but have the variable be immutable after those transformations have
-been completed.
+Shadowing berbeda dari menandai suatu variabel sebagai `mut` karena kita akan
+memperoleh suatu galat saat compile bila kita secara tidak sengaja mencoba
+menugaskan ulang ke variabel ini tanpa memakai kata kunci `let`. Dengan
+memakai `let`, kita bisa melakukan beberapa transformasi pada suatu nilai
+tapi memiliki variabel yang immutable setelah transformasi itu selesai.
 
-The other difference between `mut` and shadowing is that because we’re
-effectively creating a new variable when we use the `let` keyword again, we can
-change the type of the value but reuse the same name. For example, say our
-program asks a user to show how many spaces they want between some text by
-inputting space characters, and then we want to store that input as a number:
+Perbedaan lain antara `mut` dan shadowing adalah karena kita secara efektif
+membuat sebuah variabel baru ketika kita memakai kata kunci `let` lagi, kita
+dapat mengubah tipe nilai tapi memakai ulang nama yang sama. Misalnya, 
+katakanlah program kita meminta pengguna untuk menunjukkan berapa banyak spasi
+yang mereka inginkan antara beberapa teks dengan memasukkan karakter spasi,
+lalu kita ingin menyimpan masukan itu sebagai suatu bilangan:
 
 ```rust
 {{#rustdoc_include ../listings/ch03-common-programming-concepts/no-listing-04-shadowing-can-change-types/src/main.rs:here}}
 ```
 
-The first `spaces` variable is a string type and the second `spaces` variable
-is a number type. Shadowing thus spares us from having to come up with
-different names, such as `spaces_str` and `spaces_num`; instead, we can reuse
-the simpler `spaces` name. However, if we try to use `mut` for this, as shown
-here, we’ll get a compile-time error:
+Variabel `spaces` pertama bertipe string dan variabel `spaces` kedua bertipe
+angka. Maka *shadowing* membebaskan kita dari mencari nama lain, seperti
+misalnya `spaces_str` dan `spaces_num`; sebagai gantinya, kita dapat memakai
+ulang nama `spaces` yang lebih sederhana. Namun, bila kita mencoba memakai
+`mut` untuk ini, seperti yang ditunjukkan di sini, kita akan memperoleh 
+kesalahan waktu compile:
 
 ```rust,ignore,does_not_compile
 {{#rustdoc_include ../listings/ch03-common-programming-concepts/no-listing-05-mut-cant-change-types/src/main.rs:here}}
 ```
 
-The error says we’re not allowed to mutate a variable’s type:
+Kesalahannya mengatakan bahwa kita tidak diizinkan untuk memutasi suatu
+tipe variabel:
 
 ```console
 {{#include ../listings/ch03-common-programming-concepts/no-listing-05-mut-cant-change-types/output.txt}}
 ```
 
-Now that we’ve explored how variables work, let’s look at more data types they
-can have.
+Kini setelah kita mengeksplorasi bagaimana variabel bekerja, mari kita 
+melihat lebih banyak tipe data yang dapat mereka miliki.
 
 [comparing-the-guess-to-the-secret-number]:
 ch02-00-guessing-game-tutorial.html#comparing-the-guess-to-the-secret-number