doc/tutorial: terjemahkan "Tutorial: Create a module"

Tutorial ini berisi topik-topik singkat yang memperkenalkan fungsi,
penanganan eror, array, map, unit tes, dan mengompilasi Go modul.

12 files changed, 1196 insertions, 1 deletions

diff --git a/_content/doc/index.adoc b/_content/doc/index.adoc
index 912ed91..f2ba9a4 100644
--- a/_content/doc/index.adoc
+++ b/_content/doc/index.adoc
@@ -26,6 +26,12 @@ Instruksi untuk mengunduh dan memasang Go.
 Tutorial singkat "Hello, world" untuk mulai dari awal.
 Mempelajari secara singkat tentang kode, perkakas, paket, dan modul pada Go.
 
+[#create-module-tutorial]
+===  link:/doc/tutorial/create-module/[Tutorial: Membuat sebuah modul]
+
+Sebuah tutorial tentang topik-topik singkat yang memperkenalkan fungsi,
+penanganan eror, array, map, unit tes, dan mengompilasi.
+
 [#code]
 ===  link:/doc/code.html[Cara menulis kode Go]
 
diff --git a/_content/doc/tutorial/add-a-test/index.adoc b/_content/doc/tutorial/add-a-test/index.adoc
new file mode 100644
index 0000000..beb4f34
--- /dev/null
+++ b/_content/doc/tutorial/add-a-test/index.adoc
@@ -0,0 +1,166 @@
+= Membuat sebuah tes
+
+Sekarang setelah kode kita menjadi stabil, tambahkan sebuah tes.
+Menguji kode Anda selama pengembangan dapat menangkap _bug_ yang mungkin
+terjadi saat perubahan dilakukan.
+Dalam topik ini, kita akan menambahkan sebuah tes untuk fungsi `Hello`.
+
+NOTE: Topik ini adalah bagian dari seri tutorial yang dimulai dengan
+link:/doc/tutorial/create-module/[Membuat sebuah Go modul^].
+
+Dukungan bawaan Go untuk unit tes membuat pengembang mudah membuat dan
+melakukan tes.
+Khususnya, dengan konvensi penamaan, paket "testing", dan perintah "go test",
+kita dapat dengan cepat menulis dan mengeksekusi tes.
+
+. Dalam direktori "greetings", buatlah sebuah berkas bernama
+  "greetings_test.go"
++
+--
+Dengan mengakhiri sebuah nama berkas dengan "_test.go" berarti memberitahu
+perintah "go test" bahwa berkas tersebut berisi fungsi-fungsi tes.
+--
+
+. Dalam "greetings_test.go", salin lah kode berikut ke dalam berkas dan
+  simpan.
++
+--
+----
+package greetings
+
+import (
+	"testing"
+	"regexp"
+)
+
+// TestHelloName memanggil greetings.Hello dengan sebuah nama, memeriksa
+// kembalian yang valid.
+func TestHelloName(t *testing.T) {
+	name := "Gladys"
+	want := regexp.MustCompile(`\b`+name+`\b`)
+	msg, err := Hello("Gladys")
+	if !want.MatchString(msg) || err != nil {
+		t.Fatalf(`Hello("Gladys") = %q, %v, want match for %#q, nil`, msg, err, want)
+	}
+}
+
+// TestHelloEmpty memanggil greetings.Hello dengan string kosong,
+// memeriksa jika ada eror.
+func TestHelloEmpty(t *testing.T) {
+	msg, err := Hello("")
+	if msg != "" || err == nil {
+		t.Fatalf(`Hello("") = %q, %v, want "", error`, msg, err)
+	}
+}
+----
+
+Dalam kode tersebut, kita:
+
+* Mengimplementasikan fungsi tes dalam paket yang sama dengan kode yang akan
+  kita uji.
+* Membuat dua fungsi tes untuk menguji fungsi "greetings.Hello".
+  Nama fungsi untuk tes haruslah dengan format `Test__Nama__`, yang mana
+  __Nama__ menyatakan apa yang akan diuji.
+  Fungsi-fungsi tes menerima sebuah pointer ke
+  https://pkg.go.dev/testing/#T[tipe `testing.T`]
+  sebagai parameter.
+  Kita menggunakan method-method pada parameter ini untuk melaporkan dan
+  mencatat hasil dari pengujian.
+* Mengimplementasikan dua tes:
+** `TestHelloName` memanggil fungsi `Hello` dengan mengirim sebuah nama.
+Fungsi tersebut seharusnya mengembalikan sebuah pesan yang valid.
+Jika pemanggilan mengembalikan eror atau sebuah pesan respon yang tidak
+diharapkan (misalnya pesan yang tidak berisi nama), kita akan gunakan
+https://pkg.go.dev/testing/#T.Fatalf[method `Fatalf`]
+pada parameter `t` untuk mencetak sebuah pesan ke layar dan mengakhiri
+pengujian.
+** `TestHelloEmpty` memanggil fungsi `Hello` dengan string kosong.
+Tes ini dirancang untuk mengonfirmasi bahwa penanganan eror berjalan dengan
+benar.
+Jika kembalian dari fungsi `Hello` berupa string yang tidak kosong tanpa ada
+eror, kita panggil method `Fatalf` dari parameter `t` untuk mencetak pesan dan
+mengakhiri pengujian.
+--
+
+. Dari _terminal_, dalam direktori "greetings", jalankan
+  link:/cmd/go/#hdr-Test_packages[perintah `go test`^]
+  untuk mengeksekusi tes.
++
+--
+Perintah "go test" mengeksekusi fungsi-fungsi tes (yang namanya dimulai dengan
+`Test`) dalam berkas-berkas tes (yang namanya berakhir dengan `_test.go`).
+Anda dapat menambahkan opsi `-v` untuk menampilkan pesan tambahan yang
+mencetak semua fungsi tes dan hasilnya.
+
+Pengujian seharusnya berhasil dengan sukses.
+
+----
+$ go test
+PASS
+ok      example.com/greetings   0.364s
+
+$ go test -v
+=== RUN   TestHelloName
+--- PASS: TestHelloName (0.00s)
+=== RUN   TestHelloEmpty
+--- PASS: TestHelloEmpty (0.00s)
+PASS
+ok      example.com/greetings   0.372s
+----
+--
+
+. Ganti fungsi "greetings.Hello" supaya tes gagal.
++
+--
+Fungsi tes `TestHelloName` memeriksa nilai kembalian berdasarkan nama yang
+kita kirim sebagai parameter ke fungsi `Hello`.
+Untuk dapat melihat hasil tes yang gagal, ubah fungsi "greetings.Hello" supaya
+mengembalikan pesan tanpa nama.
+
+Dalam "greetings/greetings.go", salin lah kode berikut mengganti fungsi
+`Hello` yang sudah ada.
+Kode yang baru ini mengganti nilai yang dikembalikan oleh fungsi, anggap
+seperti argumen nama secara tidak sengaja dihapus.
+
+----
+// Hello mengembalikan sebuah salam untuk nama seseorang.
+func Hello(name string) (string, error) {
+	// Jika nama kosong, kembalikan sebuah eror dengan pesan.
+	if name == "" {
+		return name, errors.New("empty name")
+	}
+	// Buat sebuah pesan dengan format yang acak.
+	// message := fmt.Sprintf(randomFormat(), name)
+	message := fmt.Sprint(randomFormat())
+	return message, nil
+}
+----
+--
+
+. Pada _terminal_, di dalam direktori "greetings", jalankan "go test" untuk
+  mengeksekusi tes.
++
+--
+Kali ini, jalankan "go test" tanpa opsi `-v`.
+Keluaran dari perintah tersebut berupa hasil tes yang gagal, yang berguna bila
+kita memiliki banyak tes.
+Tes pada `TestHelloName` seharusnya gagal, sementara `TestHelloEmpty` tetap
+berhasil.
+----
+$ go test
+--- FAIL: TestHelloName (0.00s)
+    greetings_test.go:15: Hello("Gladys") = "Hail, %v! Well met!", <nil>, want match for `\bGladys\b`, nil
+FAIL
+exit status 1
+FAIL    example.com/greetings   0.182s
+----
+--
+
+Pada topik selanjutnya (dan yang terakhir), kita akan melihat bagaimana
+mengompilasi dan memasang kode supaya dapat dijalankan secara lokal.
+
+Lanjut: link:/doc/tutorial/compile-install/[Mengompilasi dan memasang
+aplikasi].
+
+Balik: link:/doc/tutorial/greetings-multiple-people/[Mengembalikan salam untuk
+beberapa orang].
diff --git a/_content/doc/tutorial/call-module-code/index.adoc b/_content/doc/tutorial/call-module-code/index.adoc
new file mode 100644
index 0000000..1880d5e
--- /dev/null
+++ b/_content/doc/tutorial/call-module-code/index.adoc
@@ -0,0 +1,189 @@
+= Memanggil kode dari modul lain
+
+Pada
+link:/doc/tutorial/create-module/[bagian sebelumnya],
+kita telah membuat sebuah modul "greetings".
+Pada bagian ini, kita akan menulis kode, dalam bentuk aplikasi yang bisa
+dieksekusi, yang memanggil fungsi `Hello` dalam modul tersebut.
+
+NOTE: Topik ini adalah bagian dari seri tutorial yang dimulai dengan
+link:/doc/tutorial/create-module/[Membuat sebuah Go modul^].
+
+. Buat sebuah direktori "hello" untuk sumber kode modul Go.
+  Di direktori ini kita akan menulis kode yang memanggil modul sebelumnya.
++
+--
+Setelah membuat direktori tersebut, Anda seharusnya memiliki dua direktori:
+"hello" dan "greetings" dengan hirarki yang sama, seperti berikut:
+
+----
+<home>/
+ |-- greetings/
+ |-- hello/
+----
+
+Misalnya, jika _terminal_ sekarang berada dalam direktori "greetings", Anda
+dapat menggunakan perintah berikut:
+
+----
+cd ..
+mkdir hello
+cd hello
+----
+--
+
+. Aktif kan pelacakan dependensi pada kode yang akan kita tulis.
++
+--
+Pelacakan dependensi dapat diaktifkan dengan menjalankan perintah "`go mod
+init`", dengan memberikan nama dari modul tempat kode akan disimpan.
+
+Dalam tutorial ini, kita menggunakan "example.com/hello" sebagai path modul.
+
+----
+$ go mod init example.com/hello
+go: creating new go.mod: module example.com/hello
+----
+--
+
+. Dalam direktori "hello", buatlah sebuah berkas bernama "hello.go".
+
+. Tulis lah kode yang memanggil fungsi `Hello`, kemudian cetak nilai kembalian
+  dari fungsi tersebut.
++
+--
+Salin lah kode berikut ke dalam berkas "hello.go".
+
+----
+package main
+
+import (
+	"fmt"
+
+	"example.com/greetings"
+)
+
+func main() {
+	// Ambil pesan salaman dari fungsi Hello dan cetak ke layar.
+	message := greetings.Hello("Gladys")
+	fmt.Println(message)
+}
+----
+
+Dalam kode ini, kita:
+
+* Mendeklarasikan paket `main`.
+  Dalam Go, kode yang dieksekusi sebagai aplikasi _haruslah_ berada dalam
+  paket `main`.
+* Meng-impor dua paket: "example.com/greetings" dan "`fmt`".
+  Dengan ini kode kita dapat mengakses fungsi-fungsi di dalam paket-paket
+  tersebut.
+  Mengimpor "`example.com/greetings`" (paket di dalam modul yang kita buat
+  sebelumnya) membolehkan kita mengakses fungsi `Hello`.
+  Kita juga mengimpor "`fmt`", yang berisi fungsi-fungsi yang menangani teks
+  input dan output (seperti pencetakan teks ke layar).
+* Ambil pesan salaman dengan memanggil fungsi `Hello` dari paket "greetings".
+--
+
+. Sunting modul "example.com/hello" supaya menggunakan modul
+  "example.com/greetings" yang ada di lokal Anda.
++
+--
+Untuk penggunaan dalam lingkungan _production_, Anda sebaiknya menerbitkan
+modul "example.com/greetings" pada sebuah repositori (dengan path modul yang
+merefleksikan lokasi diterbitkan), yang mana perkakas Go dapat temukan untuk
+mengunduhnya.
+Untuk sekarang, karena kita belum menerbitkan modul, kita harus mengadaptasi
+modul "example.com/hello" supaya dapat menemukan kode "example.com/greetings"
+dalam sistem berkas lokal Anda.
+
+Untuk melakukan hal tersebut, gunakan perintah "go mod init" untuk menyunting
+modul "example.com/hello" supaya mengarahkan perkakas Go dari path modul-nya
+ke direktori lokal.
+
+. Dari _terminal_, masih dalam direktori "hello", jalankan perintah berikut:
++
+--
+----
+$ go mod edit -replace=example.com/greetings=../greetings
+----
+
+Perintah tersebut memberitahu supaya mengganti "example.com/greetings" dengan
+"../greetings" saat mencari lokasi dependensi.
+Setelah perintah dijalankan, berkas "go.mod" dalam direktori "hello" akan
+berisi sebuah direktif "replace":
+
+----
+module example.com/hello
+
+go 1.16
+
+replace example.com/greetings => ../greetings
+----
+--
+
+. Dari _terminal_, masih di dalam direktori "hello", jalankan perintah "go mod
+  tidy" untuk men-sinkronisasi dependensi modul "example.com/hello",
+  menambahkan modul-modul yang dibutuhkan oleh kode tetapi belum dilacak
+  oleh modul.
++
+--
+----
+$ go mod tidy
+go: found example.com/greetings in example.com/greetings v0.0.0-00010101000000-000000000000
+----
+
+Setelah perintah selesai, berkas "go.mod" dalam modul "example.com/hello" akan
+berisi seperti berikut:
+
+----
+module example.com/hello
+
+go 1.16
+
+replace example.com/greetings => ../greetings
+
+require example.com/greetings v0.0.0-00010101000000-000000000000
+----
+
+Perintah tersebut menemukan modul lokal dalam direktori "greetings", kemudian
+menambahkan
+link:/doc/modules/gomod-ref#require[direktif "require"]
+untuk menspesifikasikan bahwa "example.com/hello" membutuhkan
+"example.com/greetings".
+Kita memakai dependensi ini saat kita mengimpor paket "greetings" dalam
+"hello.go".
+
+Angka setelah path modul adalah versi-palsu -- sebuah angka yang dibangkitkan
+sebagai pengganti dari angka versi semantik (yang belum gunakan oleh modul
+"greetings").
+
+Untuk mengarahkan ke modul yang telah diterbitkan, sebuah berkas go.mod
+tidak menggunakan direktif "replace" tapi hanya menggunkan direktif "require"
+dengan angka versi dibagian belakangnya.
+
+----
+require example.com/greetings v1.1.0
+----
+
+Untuk informasi lebih lanjut tentang angka versi, lihat
+link:/doc/modules/version-numbers[Angka versi pada modul].
+--
+--
+
+. Pada _terminal_, masih di dalam direktori "hello", jalankan kode Anda untuk
+  memastikan ia bekerja dengan benar.
++
+----
+$ go run .
+Hi, Gladys. Welcome!
+----
+
+Selamat!
+Anda telah menulis dua modul yang berfungsi dengan benar.
+
+Pada topik selanjutnya, kita akan menambahkan beberapa penanganan eror.
+
+Lanjut: link:/doc/tutorial/handle-errors/[Mengembalikan dan menangani eror]
+
+Balik: link:/doc/tutorial/create-module/[Membuat sebuah Go modul]
diff --git a/_content/doc/tutorial/compile-install/index.adoc b/_content/doc/tutorial/compile-install/index.adoc
new file mode 100644
index 0000000..04308e2
--- /dev/null
+++ b/_content/doc/tutorial/compile-install/index.adoc
@@ -0,0 +1,136 @@
+= Mengompilasi dan memasang aplikasi
+
+Pada topik terakhir ini, kita akan mempelajari beberapa perintah `go`.
+Bila perintah "go run" berguna sebagai cara singkat untuk mengompilasi dan
+menjalankan sebuah program, ia tidak menghasilkan sebuah berkas yang bisa
+dieksekusi.
+
+Topik ini memperkenalkan dua perintah tambahan untuk membangun kode:
+
+* link:/cmd/go/#hdr-Compile_packages_and_dependencies[Perintah `go build`^]
+  mengompilasi paket-paket, bersama dengan dependensi-nya, tetapi tidak
+  memasang hasil kompilasi.
+* link:/ref/mod#go-install[Perintah `go install`^] mengompilasi dan memasang
+  paket-paket.
+
+NOTE: Topik ini adalah bagian dari seri tutorial yang dimulai dengan
+link:/doc/tutorial/create-module/[Membuat sebuah Go modul^].
+
+. Pada _terminal_, dalam direktori "hello", jalankan perintah "go build" untuk
+  mengompilasi kode menjadi sebuah program.
++
+--
+----
+$ go build
+----
+
+Perintah tersebut menghasilkan sebuah berkas program bernama "hello" (atau
+"hello.exe" pada Windows).
+--
+
+. Pada _terminal_, dalam direktori "hello", jalankan program `hello` untuk
+  memastikan bahwa kode bekerja dengan benar.
++
+--
+Berkas program hasil Anda bisa berbeda bergantung pada apakah Anda mengubah
+kembali "greetings.go" setelah kita melakukan pengujian.
+
+* Pada Linux atau Mac:
++
+----
+$ ./hello
+map[Darrin:Great to see you, Darrin! Gladys:Hail, Gladys! Well met! Samantha:Hail, Samantha! Well met!]
+----
+
+* Pada Windows:
++
+----
+$ hello.exe
+map[Darrin:Great to see you, Darrin! Gladys:Hail, Gladys! Well met! Samantha:Hail, Samantha! Well met!]
+----
+
+Kita telah mengompilasi aplikasi menjadi sebuah program supaya dapat
+dijalankan.
+Namun supaya dapat berjalan dengan benar, direktori _terminal_ kita haruslah
+berada dalam direktori yang sama dengan program, atau dengan menspesifikasikan
+path dari program.
+
+Selanjutnya, kita akan memasang program tersebut supaya dapat dijalankan
+tanpa menspesifikasikan path.
+--
+
+. Temukan path pemasangan dari Go, di mana perintah `go` akan memasang
+  paket-paket hasil kompilasi.
++
+--
+Kita dapat mengetahui path pemasangan dengan menjalankan
+link:/cmd/go/#hdr-List_packages_or_modules[perintah `go list`^],
+seperti pada contoh berikut:
+
+----
+$ go list -f '{{.Target}}'
+----
+
+Contohnya, keluaran dari perintah tersebut bisa berbentuk
+"/home/gopher/bin/hello", artinya program akan dipasang ke direktori
+"/home/gopher/bin/".
+Kita akan membutuhkan direktori pemasangan ini pada langkah selanjutnya.
+--
+
+. Tambahkan direktori pemasangan Go ke sistem path.
++
+--
+Dengan cara ini, kita dapat menjalankan program tanpa menspesifikasikan path
+di mana program tersebut berada.
+
+* Pada Linux atau Mac, jalankan perintah berikut:
++
+----
+$ export PATH=$PATH:/path/ke/direktori/pemasangan
+----
+
+* Pada Windows, jalankan perintah berikut:
++
+----
+$ set PATH=%PATH%;C:\path\ke\direktori\pemasangan
+----
+
+Sebagai alternatif, jika Anda telah memiliki direktori "$HOME/bin" dalam path
+sistem dan Anda ingin supaya Go memasang program ke sana, Anda dapat mengubah
+target direktori pemasangan dengan men-set variabel lingkungan `GOBIN`
+menggunakan
+link:/cmd/go/#hdr-Print_Go_environment_information[perintah `go env`^]:
+
+----
+$ go env -w GOBIN=/path/to/your/bin
+----
+
+atau pada Windows,
+
+----
+$ go env -w GOBIN=C:\path\to\your\bin
+----
+--
+
+. Setelah path sistem di-set, jalankan perintah "go install" untuk
+  mengompilasi dan memasang paket.
++
+----
+$ go install
+----
+
+. Jalankan program Anda cukup dengan mengetikan namanya.
+  Buka _terminal_ yang baru dan jalankan program `hello` di direktori yang
+  berbeda.
++
+----
+$ hello
+map[Darrin:Hail, Darrin! Well met! Gladys:Great to see you, Gladys! Samantha:Hail, Samantha! Well met!]
+----
+
+Dengan ini tutorial Go kita berakhir!
+
+Lanjut: link:/doc/tutorial/module-conclusion/[Kesimpulan dan informasi lebih
+lanjut].
+
+Balik: link:/doc/tutorial/add-a-test/[Menambahkan sebuah tes].
diff --git a/_content/doc/tutorial/create-module/function-syntax.png b/_content/doc/tutorial/create-module/function-syntax.png
new file mode 100644
index 0000000..63d29b6
--- /dev/null
+++ b/_content/doc/tutorial/create-module/function-syntax.png
diff --git a/_content/doc/tutorial/create-module/index.adoc b/_content/doc/tutorial/create-module/index.adoc
new file mode 100644
index 0000000..cc56958
--- /dev/null
+++ b/_content/doc/tutorial/create-module/index.adoc
@@ -0,0 +1,196 @@
+= Tutorial: Membuat sebuah Go modul
+:toc:
+:sectanchors:
+:sectlinks:
+
+Artikel ini adalah bagian pertama dari seri tutorial yang memperkenalkan
+beberapa fitur fundamental dari bahasa Go.
+Jika Anda baru saja memulai belajar Go, pastikan membaca
+link:/doc/tutorial/getting-started/[Tutorial: Go dari awal]
+terlebih dahulu,
+yang secara singkat mengenalkan perintah `go`, modul Go, dan kode Go.
+
+Dalam tutorial ini kita akan membuat dua modul.
+Modul yang pertama adalah sebuah pustaka yang mana nanti akan di-impor oleh
+pustaka atau aplikasi yang lain.
+Modul yang kedua adalah aplikasi yang akan menggunakan modul yang pertama.
+
+Seri tutorial ini mengikutkan tujuh topik yang tiap-tiapnya memaparkan bagian
+berbeda dari bahasa Go.
+
+. Membuat sebuah modul -- Menulis sebuah modul yang fungsi-fungsinya dapat
+  dipanggil dari modul lain.
+. link:/doc/tutorial/call-module-code/[Memanggil kode dari modul lain^] --
+  Impor dan gunakan modul yang baru.
+. link:/doc/tutorial/handle-errors/[Mengembalikan dan menangani eror^] --
+  Menambahkan penanganan eror sederhana.
+. link:/doc/tutorial/random-greeting/[Mengembalikan salam acak^] -- Penanganan
+  data dalam slice (array dengan ukuran dinamis pada Go).
+. link:/doc/tutorial/greetings-multiple-people/[Mengembalikan salam untuk
+  beberapa orang^] -- Menyimpan pasangan kunci-nilai dalam sebuah `map`.
+. link:/doc/tutorial/add-a-test[Membuat sebuah tes^] -- Penggunaan fitur
+  unit tes Go untuk menguji kode kita.
+. link:/doc/tutorail/compile-install/[Mengompilasi dan memasang aplikasi^] --
+  Mengompilasi dan memasang kode kita secara lokal.
+
+NOTE: Untuk tutorial lainnya, lihat link:/doc/tutorial/[Tutorial^].
+
+
+[#prerequisites]
+== Kebutuhan
+
+* *Pengalaman memrogram kode*.  Kode yang dicontohkan di sini cukup
+  sederhana, namun akan lebih membantu bila pembaca paham tentang fungsi,
+  pengulangan, dan array.
+* *Alat untuk menyunting kode*.  Penyunting teks apa pun dapat digunakan.
+  Kebanyakan penyunting teks memiliki dukungan untuk Go.
+  Yang paling terkenal yaitu VSCode (gratis), GoLand (berbayar), dan Vim
+  (gratis).
+* *Terminal*.  Go bekerja dengan baik menggunakan terminal apa pun di
+  Linux dan Mac, dan PowerShell atau `cmd` di Windows.
+
+
+[#start]
+== Membuat modul yang bisa digunakan orang lain
+
+Memulai dengan membuat sebuah Go modul.
+Dalam sebuah modul, kita mengumpulkan satu atau lebih paket untuk sekumpulan
+fungsi yang diskret dan berguna.
+Contohnya, kita bisa membuat sebuah modul untuk paket-paket yang memiliki
+fungsi-fungsi yang melakukan analisis finansial sehingga orang lain yang
+membuat aplikasi finansial dapat menggunakan karya kita.
+Untuk informasi lebih lanjut tentang pengembangan dengan modul, lihat
+link:/doc/modules/developing/[Membangun dan menerbitkan modul^].
+
+Kode Go dikelompokkan ke dalam paket-paket, dan paket-paket dikelompokkan ke
+dalam modul.
+Modul menspesifikasikan dependensi yang dibutuhkan untuk menjalankan semua
+kode dalam paket-paket, termasuk versi Go dan sekumpulan modul lain yang
+dibutuhkan.
+
+Saat kita menambahkan atau memperbaiki fungsionalitas dalam modul, kita
+menerbitkan versi terbaru dari modul.
+Pengembang lain yang memanggil fungsi dalam modul kita dapat meng-impor
+paket-paket yang diperbarui dari modul kita dan mengujinya dengan versi yang
+terbaru sebelum menggunakan untuk _production_.
+
+. Buka _terminal_ dan pindah (`cd`) ke direktori _home_.
++
+--
+Di Linux atau Mac:
+
+----
+cd
+----
+
+Di Windows:
+
+----
+cd %HOMEPATH%
+----
+--
+
+. Buat direktori "greetings" untuk menyimpan sumber kode Go.
++
+--
+Contohnya, dari dalam direktori _home_ jalankan perintah berikut:
+
+----
+mkdir greetings
+cd greetings
+----
+--
+
+. Buatlah Go modul menggunakan perintah link:/ref/mod#go-mod-init[`go mod
+  init`^]
++
+--
+Jalankan perintah "`go mod init`", dengan memberikan parameter path modul --
+pada contoh ini, gunakan "`example.com/greeting`".
+Jika Anda ingin menerbitkan modul, path modul ini haruslah _path_ yang bisa
+diunduh oleh perkakas Go, yaitu repositori kode Anda.
+
+----
+$ go mod init example.com/greetings
+go: creating new go.mod: module example.com/greetings
+----
+
+Perintah "`go mod init`" membuat sebuah berkas `go.mod` untuk melacak
+dependensi dari kode Anda.
+Sejauh ini, berkas tersebut mengikutkan hanya nama dari modul dan versi Go
+yang didukung oleh kode Anda.
+Namun, saat Anda menambahkan dependensi, berkas go.mod tersebut akan berisi
+daftar modul orang lain berikut versinya yang kode Anda butuhkan.
+Hal ini membuat pembangunan dari kode Anda dapat direka-ulang dan memberikan
+Anda kontrol penuh terhadap versi modul yang digunakan.
+--
+
+. Dalam direktori "greetings" tersebut, buatlah sebuah berkas untuk menyimpan
+  kode Go dengan nama "greetings.go".
+
+. Salin lah kode berikut ke dalam berkas "greetings.go" dan simpan.
++
+--
+----
+package greetings
+
+import "fmt"
+
+// Hello mengembalikan sebuah salam untuk nama orang tertentu.
+func Hello(name string) string {
+	// Kembalikan sebuah salam yang berisi `name` dalam sebuah pesan.
+	message := fmt.Sprintf("Hi, %v. Welcome!", name)
+	return message
+}
+----
+
+Ini adalah kode pertama Anda dalam modul.
+Ia berisi sebuah fungsi `Hello` yang mengembalikan sebuah salam untuk setiap
+pemanggilan.
+Kita akan menulis kode yang memanggil fungsi tersebut di langkah selanjutnya.
+
+Dalam kode ini, kita:
+
+* Mendeklarasikan sebuah paket bernama "`greetings`" yang berisi fungsi-fungsi
+  yang berkaitan dengan salam.
+* Mengimplementasikan sebuah fungsi `Hello` yang mengembalikan sebuah pesan
+  salaman.
++
+--
+Fungsi ini menerima sebuah parameter `name` bertipe string.
+Fungsi ini mengembalikan sebuah string.
+Dalam Go, sebuah fungsi yang namanya diawali dengan huruf kapital dapat
+dipanggil oleh fungsi dari paket yang berbeda.
+Dalam Go hal ini dikenal dengan nama yang diekspor.
+Untuk lebih lanjut tentang nama-nama yang diekspor, lihat
+https://tour.golang-id.org/basics/3[Nama-nama yang diekspor]
+dalam tur Go.
+
+image:/doc/tutorial/create-module/function-syntax.png[]
+--
+
+* Mendeklarasikan sebuah variabel `message` yang menyimpan salam.
++
+--
+Dalam Go, operator `:=` adalah cara singkat untuk mendeklarasikan dan
+menginisiasi sebuah variabel dalam satu baris (Go menggunakan nilai pada
+sebelah kanan untuk menentukan tipe dari variabel).
+Cara panjangnya, bisa ditulis seperti berikut:
+
+----
+var message string
+message = fmt.Sprintf("Hi, %v. Welcome!", name)
+----
+--
+
+* Menggunakan https://pkg.go.dev/fmt/#Sprintf[fungsi Sprintf] dari paket `fmt`
+  untuk membuat pesan salaman yang disimpan dalam `message`.
+  Argumen yang pertama dari fungsi tersebut yaitu format dari string, dan
+  `Sprintf` akan mengganti format "`%v`" dengan nilai dari parameter `name`.
+
+* Mengembalikan teks salam yang telah di-format ke pemanggil.
+--
+
+Pada langkah selanjutnya, kita akan memanggil fungsi ini dari modul yang lain.
+
+Lanjut: link:/doc/tutorial/call-module-code/[Memanggil kode dari modul lain].
diff --git a/_content/doc/tutorial/getting-started/index.adoc b/_content/doc/tutorial/getting-started/index.adoc
index 60e204e..a3f7b33 100644
--- a/_content/doc/tutorial/getting-started/index.adoc
+++ b/_content/doc/tutorial/getting-started/index.adoc
@@ -16,7 +16,7 @@ NOTE: Untuk tutorial lainnya, lihat link:/doc/tutorial/[Tutorial].
 [#prerequisites]
 == Kebutuhan
 
-* *Pengalaman pemrograman kode*.  Kode yang dicontohkan di sini cukup
+* *Pengalaman memprogram kode*.  Kode yang dicontohkan di sini cukup
   sederhana, namun akan lebih membantu bila pembaca paham tentang fungsi pada
   pemrograman.
 * *Alat untuk menyunting kode*.  Penyunting teks apa pun dapat digunakan.
diff --git a/_content/doc/tutorial/greetings-multiple-people/index.adoc b/_content/doc/tutorial/greetings-multiple-people/index.adoc
new file mode 100644
index 0000000..4d09cd9
--- /dev/null
+++ b/_content/doc/tutorial/greetings-multiple-people/index.adoc
@@ -0,0 +1,180 @@
+= Mengembalikan salam untuk beberapa orang
+:toc:
+
+Pada bagian ini, kita akan menambah fungsionalitas pada modul "greetings"
+supaya dapat mengembalikan pesan salam untuk beberapa orang dalam satu
+pemanggilan.
+Dengan kata lain, kita akan menangani input dengan banyak nilai, kemudian
+memasangkan nilai input tersebut dengan nilai output.
+Untuk melakukan hal ini, kita akan mengirim sekumpulan nama ke sebuah fungsi
+yang dapat mengembalikan salam untuk setiap nama tersebut.
+
+NOTE: Topik ini adalah bagian dari seri tutorial yang dimulai dengan
+link:/doc/tutorial/create-module/[Membuat sebuah Go modul^].
+
+Namun ada sedikit masalah.
+Mengubah parameter fungsi `Hello` dari satu nama menjadi beberapa nama akan
+mengubah _signature_ dari fungsi tersebut.
+Jika Anda telah menerbitkan modul "example.com/greetings" sebelumnya dan user
+telah menulis kode yang telah memanggil `Hello`, perubahan tersebut akan
+membuat program mereka gagal dikompilasi.
+
+Dalam situasi ini, pilihan yang terbaik yaitu membuat sebuah fungsi baru
+dengan nama yang berbeda.
+Fungsi yang baru tersebut akan menerima satu atau lebih nilai.
+Dengan ini kita menjaga fungsi yang lama demi menjaga kompatibilitas.
+
+. Dalam "greetings/greetings.go", ubah lah kode Anda supaya seperti berikut.
++
+--
+----
+package greetings
+
+import (
+	"errors"
+	"fmt"
+	"math/rand"
+	"time"
+)
+
+// Hello mengembalikan sebuah salam untuk nama seseorang.
+func Hello(name string) (string, error) {
+	// Jika nama kosong, kembalikan sebuah eror dengan pesan.
+	if name == "" {
+		return name, errors.New("empty name")
+	}
+	// Buat sebuah pesan salam dengan format acak.
+	message := fmt.Sprintf(randomFormat(), name)
+	return message, nil
+}
+
+// Hellos mengembalikan sebuah map yang mengasosiasikan setiap nama orang
+// dengan sebuah pesan salam.
+func Hellos(names []string) (map[string]string, error) {
+	// Sebuah map yang memetakan nama dengan pesan.
+	messages := make(map[string]string)
+
+	// Iterasi slice "names", panggil fungsi Hello untuk mendapatkan
+	// sebuah pesan untuk setiap nama.
+	for _, name := range names {
+		message, err := Hello(name)
+		if err != nil {
+			return nil, err
+		}
+		// Di dalam map, asosiasikan nama (kunci) dengan pesan (nilai).
+		messages[name] = message
+	}
+	return messages, nil
+}
+
+// init men-set pengacak angka.
+func init() {
+	rand.Seed(time.Now().UnixNano())
+}
+
+// randomFormat mengembalikan sekumpulan pesan acak.  Pesan yang dikembalikan
+// dipilih secara acak.
+func randomFormat() string {
+	// Slice dari sekumpulan format pesan.
+	formats := []string{
+		"Hi, %v. Welcome!",
+		"Great to see you, %v!",
+		"Hail, %v! Well met!",
+	}
+
+	// Kembalikan salah satu format pesan secara acak.
+	return formats[rand.Intn(len(formats))]
+}
+----
+
+Dalam kode ini, kita:
+
+* Menambah fungsi `Hellos` dengan parameter sebuah slice string bukan sebuah
+  nama.
+  Kita juga mengubah tipe kembalian dari sebuah string menjadi sebuah map
+  supaya kita dapat mengasosiasikan parameter nama dengan pesan salam.
+* Membuat fungsi `Hellos` yang memanggil fungsi `Hello` yang sudah ada.
+  Hal ini cukup membantu mengurangi duplikasi kode.
+* Membuat sebuah map ucapan salam yang mengasosiasikan setiap nama yang
+  diterima (sebagai kunci) dengan pesan yang dibangkitkan (sebagai sebuah
+  nilai).
+  Dalam Go, kita menginisiasi map dengan sintaksis berikut:
+  `make(map[tipe-key]tipe-nilai)`.
+  Kita membuat fungsi `Hellos` untuk mengembalikan map tersebut ke pemanggil.
+  Untuk informasi lebih lanjut tentang map lihat
+  link:/blog/maps[Cara kerja map pada Go].
+* Melakukan pengulangan terhadap daftar nama yang diterima fungsi `Hellos`,
+  memeriksa apakah nilainya tidak kosong, kemudian mengasosiasikan setiap
+  pesan dengan nama yang dikirim.
+  Dalam pengulangan ini, perintah `range` mengembalikan dua nilai: indeks dari
+  item dan salinan dari nilai item.
+  Karena kita tidak membutuhkan indeks, maka digunakan identifikasi kosong
+  ('_') untuk mengindahkannya.
+  Untuk informasi lebih lanjut tentang identifikasi kosong, lihat
+  link:/doc/effective_go.html#blank[pengidentifikasi kosong] dalam Efektif Go.
+--
+
+. Dalam "hello.go", ubah kode Anda menjadi seperti berikut.
++
+--
+----
+package main
+
+import (
+	"fmt"
+	"log"
+
+	"example.com/greetings"
+)
+
+func main() {
+	// Set properti dari Logger, termasuk prefiks dan opsi untuk mematikan
+	// pencetakan waktu, sumber berkas, dan nomor baris.
+	log.SetPrefix("greetings: ")
+	log.SetFlags(0)
+
+	// Sebuah slice yang berisi nama-nama.
+	names := []string{"Gladys", "Samantha", "Darrin"}
+
+	// Panggil fungsi Hellos untuk mendapatkan pesan salam untuk setiap nama.
+	messages, err := greetings.Hellos(names)
+	if err != nil {
+		log.Fatal(err)
+	}
+	// Jika tidak ada eror, cetak map yang diterima dari ke layar.
+	fmt.Println(messages)
+}
+----
+
+Dalam perubahan ini, kita:
+
+* Membuat variabel `names` bertipe slice yang menyimpan tiga nama.
+* Mengirim variabel `names` sebagai argumen ke fungsi `Hellos`.
+--
+
+. Pada _terminal_, pindah lah ke direktori yang menyimpan "hello/hello.go",
+  kemudian jalankan "go run" untuk memastikan kode bekerja dengan benar.
++
+--
+Keluaran dari perintah tersebut harusnya representasi dari nama dan pesan
+salam, kurang lebih seperti berikut:
+
+----
+$ go run .
+map[Darrin:Hail, Darrin! Well met! Gladys:Hi, Gladys. Welcome! Samantha:Hail, Samantha! Well met!]
+----
+
+Topik kali ini memperkenalkan map yang merepresentasikan pasangan kunci dan
+nilai.
+Topik ini juga memperkenalkan ide tentang menjaga kompatibilitas dengan
+mengimplementasikan sebuah fungsi baru untuk fungsionalitas yang baru atau
+yang berubah dalam sebuah modul.
+Untuk informasi lebih lanjut tentang menjaga kompatibilitas, lihatlah
+link:/blog/module-compatibility[Menjaga modul tetap kompatibel].
+
+Selanjutnya, kita akan menggunakan fungsi bawaan Go untuk membuat sebuah unit
+tes dalam kode kita.
+
+Lanjut: link:/doc/tutorial/add-a-test/[Membuat sebuah tes]
+
+Sebelumnya: link:/doc/tutorial/randomg-greeting/[Mengambalikan salam acak]
diff --git a/_content/doc/tutorial/handle-errors/index.adoc b/_content/doc/tutorial/handle-errors/index.adoc
new file mode 100644
index 0000000..5bcbd57
--- /dev/null
+++ b/_content/doc/tutorial/handle-errors/index.adoc
@@ -0,0 +1,137 @@
+= Mengembalikan dan menangani eror
+:toc:
+
+Penanganan eror adalah fitur penting pada kode yang solid.
+Pada bagian ini, kita akan menambahkan sedikit kode yang mengembalikan sebuah
+eror pada modul "greetings", kemudian menangani-nya pada sisi pemanggil (modul
+"hello").
+
+NOTE: Topik ini adalah bagian dari seri tutorial yang dimulai dengan
+link:/doc/tutorial/create-module/[Membuat sebuah Go modul^].
+
+. Di dalam "greetings/greetings.go", perbarui kode menjadi seperti di bawah.
++
+--
+Tidak masuk akal bila mengucapkan salam bila kita tidak tahu siapa yang akan
+kita salami.
+Maka, kembalikan sebuah eror jika si pemanggil fungsi `Hello` mengirim `name`
+yang kosong.
+Salin kode berikut ke "`greetings.go`" dan simpan berkas tersebut.
+
+----
+package greetings
+
+import (
+	"errors"
+	"fmt"
+)
+
+// Hello mengembalikan sebuah salaman untuk nama seseorang.
+func Hello(name string) (string, error) {
+	// Jika name kosong, kembalikan sebuah eror dengan pesan tertentu.
+	if name == "" {
+		return "", errors.New("empty name")
+	}
+
+	// Jika nama tidak kosong, kembalikan sebuah pesan salam yang menanam
+	// nama tersebut.
+	message := fmt.Sprintf("Hi, %v. Welcome!", name)
+	return message, nil
+}
+----
+
+Dalam kode tersebut, kita:
+
+* Mengubah fungsi `Hello` sehingga mengembalikan dua nilai: sebuah string dan
+  sebuah eror.
+  Yang memanggil fungsi tersebut akan memeriksa nilai kembalian kedua untuk
+  mengetahui jika ada eror yang terjadi.
+  (Fungsi pada Go dapat mengembalikan banyak nilai.
+  Untuk informasi lebih lanjut, lihat
+  link:/doc/effective_go.html#multiple-returns[Efektif Go^].)
+* Impor paket "errors" dari pustaka standar supaya dapat menggunakan
+  https://pkg.go.dev/errors/#example-New[fungsi `errors.New`^].
+* Menambahkan perintah `if` untuk memeriksa pemanggilan yang tidak valid (pada
+  kasus ini yaitu nama yang kosong) dan mengembalikan sebuah eror jika
+  pemanggilan tidak valid.
+  Fungsi `errors.New` mengembalikan sebuah eror dengan pesan di dalamnya.
+* Menambahkan `nil` (artinya tidak ada eror) sebagai nilai kedua pada saat
+  kembalian sukses.
+  Dengan cara ini, pemanggil fungsi dapat memeriksa bila mana fungsi sukses.
+--
+
+. Dalam berkas "hello/hello.go", tangani kembalian eror dari fungsi `Hello`,
+  berikut juga nilai yang tidak eror.
++
+--
+Salin kode berikut ke "hello.go".
+
+----
+package main
+
+import (
+	"fmt"
+	"log"
+
+	"example.com/greetings"
+)
+
+func main() {
+	// Set properti dari Logger, termasuk prefiks dan flag untuk
+	// menon-aktifkan pencetakan waktu, sumber berkas, dan nomor baris.
+	log.SetPrefix("greetings: ")
+	log.SetFlags(0)
+
+	// Ambil pesan salam.
+	message, err := greetings.Hello("")
+
+	// Jika ada eror, cetak ke layar dan keluar dari program.
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Jika tidak ada eror, cetak pesan yang dikembalikan ke layar.
+	fmt.Println(message)
+}
+----
+
+Dalam kode tersebut, kita:
+
+* Mengonfigurasi
+  https://pkg.go.dev/log/[paket `log`^] untuk mencetak nama perintah
+  ("greetings: ") di awal pesan log, tanpa penanda waktu atau informasi sumber
+  berkas.
+* Menyimpan nilai kembalian dari `Hello`, termasuk eror, ke variabel.
+* Mengubah argumen ke fungsi `Hello` dari string "Glady" ke string kosong,
+  supaya kita dapat mencoba kode pas penanganan eror.
+* Memeriksa nilai eror yang tidak nil.
+  Jika eror, stop program.
+* Gunakan fungsi dari paket `log` untuk menampilkan informasi eror.
+  Jika ada error, gunakan
+  https://pkg.go.dev/log?tab=doc#Fatal[fungsi `Fatal`^] pada paket `log` untuk
+  mencetak eror dan menghentikan program.
+--
+
+. Pada _terminal_, di dalam direktori "hello", jalankan "hello.go" untuk
+  memeriksa apakah kode berjalan dengan benar atau tidak.
++
+--
+Sekarang, karena kita mengirim nama yang kosong, kita akan mendapatkan sebuah
+eror.
+
+----
+$ go run .
+greetings: empty name
+exit status 1
+----
+--
+
+Contoh penanganan eror tersebut sangat umum dalam Go: Kembalikan sebuah eror
+sebagai nilai supaya pemanggil dapat memeriksanya.
+
+Selanjutnya, kita akan menggunakan sebuah slice untuk mengembalikan pesan
+salam yang dipilih secara acak.
+
+Lanjut: link:/doc/tutorial/random-greeting/[Mengembalikan salam acak].
+
+Balik: link:/doc/tutorial/call-module-code/[Memanggil kode dari modul lain].
diff --git a/_content/doc/tutorial/index.adoc b/_content/doc/tutorial/index.adoc
new file mode 100644
index 0000000..bf0dd06
--- /dev/null
+++ b/_content/doc/tutorial/index.adoc
@@ -0,0 +1,17 @@
+= Tutorial
+
+Jika Anda baru belajar tentang Go, bacalah tautan tutorial di bawah ini.
+
+Jika Anda belum pernah memasang Go sebelumnya, lihat
+link:/doc/install/[Unduh dan pasang^].
+
+link:/doc/tutorial/getting-started/[Go dari awal^]::
+  Membuat program "Hello, World!" dengan Go.
+
+link:/doc/tutorial/create-module/[Membuat sebuah modul Go^]::
+  Tutorial dengan beberapa langkah yang memperkenalkan fitur bahasa
+  pemrograman umum dari perspektif Go.
+
+https://tour.golang-id.org/welcome/1[Tur Go^]::
+  Pengenalan interaktif untuk Go: sintaksis dan struktur data dasar; method
+  dan interface; dan primitif konkurensi pada Go.
diff --git a/_content/doc/tutorial/module-conclusion/index.adoc b/_content/doc/tutorial/module-conclusion/index.adoc
new file mode 100644
index 0000000..dceb5d1
--- /dev/null
+++ b/_content/doc/tutorial/module-conclusion/index.adoc
@@ -0,0 +1,17 @@
+= Kesimpulan
+
+Dalam tutorial ini, kita telah menulis fungsi-fungsi dipaketkan ke dalam dua
+modul: satu modul untuk fungsi mendapatkan ucapan salam (modul "greetings");
+dan satu modul yang memakai modul "greetings" tersebut (modul "hello").
+
+NOTE: Topik ini adalah bagian dari seri tutorial yang dimulai dengan
+link:/doc/tutorial/create-module/[Membuat sebuah Go modul^].
+
+Untuk informasi lebih lanjut tentang mengatur dependensi dalam kode, lihat lah
+link:/doc/modules/managing-dependencies/[Mengatur dependensi^].
+Untuk informasi lebih lanjut tentang pengembangan modul untuk dapat digunakan
+oleh orang lain, lihat
+link:/doc/modules/developing/[Mengembangkan dan menerbitkan modul^].
+
+Untuk pendahuluan tentang fitur-fitur dari bahasa Go, coba lah
+https://tour.golang-id.org/welcome/1[Tur Bahasa Go^].
diff --git a/_content/doc/tutorial/random-greeting/index.adoc b/_content/doc/tutorial/random-greeting/index.adoc
new file mode 100644
index 0000000..d19dea9
--- /dev/null
+++ b/_content/doc/tutorial/random-greeting/index.adoc
@@ -0,0 +1,151 @@
+= Mengembalikan salam acak
+:toc:
+
+Pada bagian ini, kita akan mengubah kode supaya tidak hanya mengembalikan satu
+bentuk salam saja, tetapi mengembalikan satu dari beberapa pesan salam yang
+telah ditentukan.
+
+NOTE: Topik ini adalah bagian dari seri tutorial yang dimulai dengan
+link:/doc/tutorial/create-module/[Membuat sebuah Go modul^].
+
+Untuk melakukan hal ini, kita akan menggunakan sebuah slice.
+Sebuah slice yaitu seperti sebuah array, namun ukurannya dapat berubah secara
+dinamis saat kita menambah atau menghapus item dalam slice.
+Slice adalah salah satu dari tipe yang sangat berguna pada Go.
+
+Kita akan membuat slice berukuran kecil yang berisi tiga pesan salam,
+kemudian kita kembalikan salah satu dari pesan tersebut secara acak.
+Untuk informasi lebih lanjut tentang slice, lihat
+link:/blog/slices-intro/[Go slice].
+
+. Dalam "greetings/greetings.go", ubah kode kita supaya seperti di bawah.
++
+--
+----
+package greetings
+
+import (
+	"errors"
+	"fmt"
+	"math/rand"
+	"time"
+)
+
+// Hello returns a greeting for the named person.
+func Hello(name string) (string, error) {
+	// If no name was given, return an error with a message.
+	if name == "" {
+		return name, errors.New("empty name")
+	}
+	// Create a message using a random format.
+	message := fmt.Sprintf(randomFormat(), name)
+	return message, nil
+}
+
+// init sets initial values for variables used in the function.
+func init() {
+	rand.Seed(time.Now().UnixNano())
+}
+
+// randomFormat returns one of a set of greeting messages. The returned
+// message is selected at random.
+func randomFormat() string {
+	// A slice of message formats.
+	formats := []string{
+		"Hi, %v. Welcome!",
+		"Great to see you, %v!",
+		"Hail, %v! Well met!",
+	}
+
+	// Return a randomly selected message format by specifying
+	// a random index for the slice of formats.
+	return formats[rand.Intn(len(formats))]
+}
+----
+
+Dalam kode tersebut, kita:
+
+* Menambahkan fungsi `randomFormat` yang mengembalikan format untuk pesan
+  salam secara acak.
+  Ingatlah bahwa `randomFormat` diawali dengan huruf kecil, membuatnya hanya
+  dapat diakses oleh kode di dalam paketnya sendiri (dengan kata lain, tidak
+  dieskpor).
+* Dalam `randomFormat`, kita mengisi sebuah slice string dengan tiga format
+  pesan.
+  Saat mendeklarasikan sebuah slice, kita tidak mengisi ukuran dalam tanda
+  kurung siku, seperti ini: `[]string`.
+  Perintah ini mengatakan ukuran dari array di balik slice dapat diubah secara
+  dinamis.
+* Menggunakan
+  https://pkg.go.dev/math/rand/[paket "`math/rand`"^]
+  untuk membangkitkan angka acak untuk memilih sebuah item di dalam slice.
+* Menambahkan fungsi `init` untuk menanam paket `rand` dengan waktu sekarang.
+  Go mengeksekusi fungsi `init` secara otomatis pada saat program berjalan,
+  setelah semua global variabel diinisiasi.
+  Untuk informasi lebih lanjut tentang fungsi `init`, lihat
+  link:/doc/effective_go.html#init[Efektif Go^].
+* Dalam fungsi `Hello`, panggil fungsi `randomFormat` untuk mendapatkan format
+  dari pesan yang akan dikembalikan, kemudian gunakan format tersebut beserta
+  value dari `name` untuk membuat pesan.
+* Kembalikan pesan tersebut (atau sebuah eror) seperti sebelumnya.
+--
+
+. Dalam "hello/hello.go", ubah kode kita supaya seperti di bawah.
++
+--
+Kirim string "Glady" (atau nama apa pun yang Anda sukai) sebagai argumen dari
+fungsi `Hello` dalam hello.go.
+
+----
+package main
+
+import (
+	"fmt"
+	"log"
+
+	"example.com/greetings"
+)
+
+func main() {
+	// Set properti dari Logger, termasuk prefiks dan flag untuk
+	// menon-aktifkan pencetakan waktu, sumber berkas, dan nomor baris.
+	log.SetPrefix("greetings: ")
+	log.SetFlags(0)
+
+	// Ambil pesan salam.
+	message, err := greetings.Hello("Gladys")
+
+	// Jika ada eror, cetak ke layar dan keluar dari program.
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Jika tidak ada eror, cetak pesan yang dikembalikan ke layar.
+	fmt.Println(message)
+}
+----
+--
+
+. Pada _terminal_, di dalam direktori "hello", jalankan "hello.go" untuk
+  memastikan program berjalan.
+  Jalankan beberapa kali, untuk melihat perubahan pada pesan salam yang
+  dihasilkan.
++
+----
+$ go run .
+Great to see you, Gladys!
+
+$ go run .
+Hi, Gladys. Welcome!
+
+$ go run .
+Hail, Gladys! Well met!
+----
+
+Selanjutnya, kita akan menggunakan slice untuk membuat pesan salam untuk
+beberapa orang.
+
+Lanjut: link:/doc/tutorial/greetings-multiple-people/[Mengembalikan salam
+untuk beberapa orang].
+
+Balik: link:/doc/tutorial/handle-errors/[Mengembalikan dan menangani eror].