Tutorial Go (Golang) untuk Pemula: Dari Instalasi hingga ‘Hello, World!’

Pendahuluan

Bayangkan kamu sedang membangun sebuah jembatan. Kamu bisa memilih kayu yang ringan namun mudah lapuk, atau baja yang kuat namun berat dan mahal. Lalu ada pilihan ketiga: material komposit modern yang ringan, kuat, dan mudah dikerjakan. Itulah analogi tepat untuk Go (atau Golang) di dunia bahasa pemrograman.

Go diciptakan oleh Google pada 2009 dan dirilis ke publik pada 2012. Sejak saat itu, Go menjadi pilihan utama para engineer yang membutuhkan performa tinggi dengan kode yang sederhana. Jika kamu pernah belajar Pengenalan Python: Instalasi dan Hello World dan merasa Python terlalu lambat untuk kebutuhan tertentu, atau mencoba C++ dan merasa terlalu rumit, maka Go adalah titik tengah yang sempurna.

Artikel ini akan membimbingmu mulai dari nol: instalasi Go, memahami konsep dasarnya, hingga menjalankan program pertamamu. Tidak perlu pengalaman sebelumnya dengan Go — cukup semangat dan editor teks!

Mengenal Go: Apa dan Mengapa?

Go adalah bahasa pemrograman yang dikompilasi (compiled), bertipe statis (statically typed), dan dirancang untuk efisiensi serta kemudahan penggunaan. Tapi apa artinya itu semua untuk kamu?

Dikompilasi berarti kode Go diubah langsung menjadi file executable yang bisa dijalankan mesin. Ini seperti membuat resep masakan lalu mencetak buku petunjuknya — sekali cetak, siapa pun bisa mengikutinya tanpa perlu “penerjemah” di tengah-tengah.

Bertipe statis berarti setiap variabel harus memiliki tipe data yang jelas sejak awal. Ini mencegah banyak bug yang biasanya baru muncul saat program sudah berjalan. Mirip dengan konsep Variabel dan Tipe Data di Python, namun di Go pengecekan dilakukan saat kompilasi, bukan saat runtime.

Mengapa Memilih Go?

Jika kamu ingin membangun layanan backend seperti yang digunakan Gojek atau Tokopedia — sistem yang harus melayani jutaan permintaan secara bersamaan — Go adalah kandidat kuat karena kemampuan concurrency-nya yang luar biasa.

Instalasi dan Konfigurasi Lingkungan Go

Langkah 1: Unduh Go

Kunjungi situs resmi Go dan unduh installer sesuai sistem operasimu:

• Windows: File .msi (installer grafis)
• macOS: File .pkg (installer grafis) atau via Homebrew
• Linux: Arsip .tar.gz

Untuk macOS dengan Homebrew:

# Instal Go menggunakan Homebrew
brew install go

# Cek apakah Go berhasil terpasang
go version

Output yang diharapkan:

go version go1.22.0 darwin/arm64

Untuk Linux (Ubuntu/Debian):

# Masuk ke folder tempat file installer Go berada
cd ~/Downloads

# Hapus instalasi Go lama jika sudah ada
sudo rm -rf /usr/local/go

# Ekstrak file Go ke /usr/local
sudo tar -C /usr/local -xzf go1.22.0.linux-amd64.tar.gz

# Tambahkan Go ke PATH untuk sesi terminal berikutnya
echo 'export PATH=$PATH:/usr/local/go/bin' >> ~/.bashrc

# Muat ulang konfigurasi bash agar PATH langsung aktif
source ~/.bashrc

# Cek apakah Go berhasil terpasang
go version

Output yang diharapkan:

go version go1.22.0 linux/amd64

Langkah 2: Verifikasi Instalasi

Buka terminal atau command prompt, lalu jalankan:

go version

Jika berhasil, kamu akan melihat output seperti:

go version go1.22.0 linux/amd64

Langkah 3: Konfigurasi Editor

Untuk pengalaman terbaik, gunakan Visual Studio Code dengan ekstensi Go (oleh Google). Ekstensi ini menyediakan:

• Autocomplete cerdas
• Linting otomatis
• Debugging terintegrasi
• Format kode otomatis saat menyimpan

Setelah instalasi ekstensi, VS Code akan meminta izin menginstal tools pendukung seperti gopls dan dlv. Setujui semua.

Memahami GOPATH dan Modul Go

Sejak Go 1.11, Go menggunakan sistem modul untuk manajemen dependensi. Kamu tidak perlu mengkhawatirkan GOPATH seperti dulu. Setiap proyek adalah modul mandiri yang didefinisikan oleh file go.mod.

Membuat Program ‘Hello, World!’ Pertama Anda

Langkah 1: Buat Folder Proyek

# Membuat folder proyek baru
mkdir hello-go
cd hello-go

Langkah 2: Inisialisasi Modul Go

# Inisialisasi modul Go baru bernama hello-go
go mod init hello-go

Perintah ini membuat file go.mod yang berisi metadata proyek:

module hello-go

go 1.22.0

Langkah 3: Buat File Program

Buat file bernama main.go dan isi dengan kode berikut:

package main

import "fmt" // Mengimpor paket fmt untuk menampilkan teks ke layar

func main() {
    // Menampilkan pesan ke terminal
    fmt.Println("Hello, World!")
}

Mari kita bedah baris per baris:

package main Setiap file Go harus dimulai dengan deklarasi package. Package main adalah titik masuk program — Go tahu bahwa file ini adalah program yang bisa dijalankan, bukan sekadar library.

import "fmt" Ini adalah cara Go mengimpor paket standar. fmt adalah kependekan dari format, berisi fungsi untuk menampilkan output ke layar.

func main() { ... } Fungsi main adalah titik awal eksekusi program, sama seperti main() di C/C++ atau blok utama di Python. Semua program Go yang bisa dijalankan harus punya fungsi ini.

fmt.Println("Hello, World!") Println adalah fungsi dari paket fmt yang mencetak teks diikuti baris baru (newline). Mirip dengan print() di Python.

Langkah 4: Jalankan Program

Ada dua cara menjalankan program Go:

Cara 1: Langsung jalankan (tanpa kompilasi manual)

go run main.go

Output:

Hello, World!

Cara 2: Kompilasi dulu, lalu jalankan

# Kompilasi file main.go menjadi binary bernama hello
go build -o hello main.go

# Jalankan binary hasil kompilasi
./hello

Output:

Hello, World!

Cara kedua menghasilkan file executable yang bisa didistribusikan tanpa perlu Go terinstal di mesin target. Inilah salah satu keunggulan besar Go!

Variasi: Program dengan Input Pengguna

package main

import (
    "bufio"
    "fmt"
    "os"
    "strings"
)

func main() {
    // Membuat reader untuk membaca input dari keyboard
    reader := bufio.NewReader(os.Stdin)

    // Menampilkan pertanyaan ke pengguna
    fmt.Print("Siapa namamu? ")

    // Membaca input sampai pengguna menekan Enter
    nama, err := reader.ReadString('\n')
    if err != nil {
        fmt.Println("Terjadi kesalahan saat membaca input.")
        return
    }

    // Menghapus spasi dan baris baru di akhir input
    nama = strings.TrimSpace(nama)

    // Menampilkan sapaan dengan nama yang dimasukkan
    fmt.Printf("Halo, %s! Selamat datang di dunia Go!\n", nama)
}

Jalankan dengan go run main.go, masukkan namamu, dan lihat hasilnya:

Siapa namamu? Budi
Halo, Budi! Selamat datang di dunia Go!

Contoh Kasus Nyata

Kalkulator Sederhana

Mari buat program yang sedikit lebih kompleks — kalkulator dasar:

package main

import "fmt"

// tambah mengembalikan hasil penjumlahan dua angka.
func tambah(a, b float64) float64 {
    return a + b
}

// kurang mengembalikan hasil pengurangan dua angka.
func kurang(a, b float64) float64 {
    return a - b
}

// kali mengembalikan hasil perkalian dua angka.
func kali(a, b float64) float64 {
    return a * b
}

// bagi mengembalikan hasil pembagian.
// Jika pembagi 0, fungsi akan mengembalikan error.
func bagi(a, b float64) (float64, error) {
    if b == 0 {
        return 0, fmt.Errorf("tidak bisa membagi dengan nol")
    }
    return a / b, nil
}

func main() {
    var angka1, angka2 float64
    var operasi string

    // Meminta pengguna memasukkan angka pertama.
    fmt.Print("Masukkan angka pertama: ")
    fmt.Scan(&angka1)

    // Meminta pengguna memilih operasi matematika.
    fmt.Print("Pilih operasi (+, -, *, /): ")
    fmt.Scan(&operasi)

    // Meminta pengguna memasukkan angka kedua.
    fmt.Print("Masukkan angka kedua: ")
    fmt.Scan(&angka2)

    // Menjalankan operasi sesuai pilihan pengguna.
    switch operasi {
    case "+":
        fmt.Printf("Hasil: %.2f\n", tambah(angka1, angka2))
    case "-":
        fmt.Printf("Hasil: %.2f\n", kurang(angka1, angka2))
    case "*":
        fmt.Printf("Hasil: %.2f\n", kali(angka1, angka2))
    case "/":
        hasil, err := bagi(angka1, angka2)
        if err != nil {
            fmt.Println("Error:", err)
            return
        }
        fmt.Printf("Hasil: %.2f\n", hasil)
    default:
        fmt.Println("Operasi tidak dikenal!")
    }
}

Contoh sesi penggunaan:

Masukkan angka pertama: 10
Pilih operasi (+, -, *, /): *
Masukkan angka kedua: 5
Hasil: 50.00

Contoh ini memperkenalkan beberapa konsep Go yang penting:

• Fungsi dengan multiple return values — bagi() mengembalikan hasil DAN error sekaligus. Ini pola idiomatis Go untuk error handling.
• Switch statement — lebih bersih dari rentetan if-else.
• fmt.Scan() — membaca input dari terminal.

Bayangkan kamu membangun backend untuk aplikasi fintech seperti GoPay: setiap transaksi perlu divalidasi (apakah saldo cukup? apakah penerima valid?). Pola multiple return values Go sangat berguna untuk kasus seperti ini.

Pertanyaan yang Sering Diajukan

Apa perbedaan go run dan go build?

go run mengkompilasi dan langsung menjalankan program dalam satu langkah — cocok untuk pengembangan dan eksperimen. go build menghasilkan file executable yang bisa didistribusikan dan dijalankan tanpa Go terinstal. Untuk produksi, selalu gunakan go build.

Mengapa Go tidak memiliki exception seperti Python atau Java?

Go memilih pendekatan berbeda: error diperlakukan sebagai nilai biasa yang dikembalikan fungsi, bukan exception yang “dilempar”. Ini membuat alur kode lebih eksplisit dan mudah diprediksi. Kamu selalu tahu fungsi mana yang bisa gagal karena error-nya ada di return value.

Apakah Go cocok untuk pemula yang belum pernah coding sama sekali?

Go bisa dipelajari pemula, namun idealnya kamu sudah memiliki sedikit fondasi pemrograman dasar. Jika benar-benar dari nol, pertimbangkan belajar Python terlebih dahulu karena sintaksnya lebih sederhana, lalu lanjut ke Go. Python juga memiliki komunitas belajar yang sangat besar di Indonesia.

Apa itu goroutine yang sering disebut saat membahas Go?

Goroutine adalah “utas ringan” (lightweight thread) yang dikelola oleh runtime Go. Kamu bisa menjalankan ribuan goroutine secara bersamaan dengan konsumsi memori yang jauh lebih kecil dibanding thread OS biasa. Ini adalah fitur unggulan Go untuk membangun sistem yang harus melayani banyak permintaan secara bersamaan — topik yang akan kita bahas lebih dalam di artikel lanjutan.

Apakah Go bisa digunakan untuk membuat aplikasi mobile atau web frontend?

Go terutama digunakan untuk backend, CLI tools, dan sistem terdistribusi. Untuk web frontend, Go bisa dikompilasi ke WebAssembly (WASM), namun ini masih jarang digunakan di produksi. Untuk mobile, ada proyek seperti Gomobile, tapi ekosistemnya belum semature Swift/Kotlin. Go paling bersinar di sisi server-side.

Kesimpulan

Kamu telah menyelesaikan langkah pertama perjalanan Go-mu! Dalam artikel ini, kita telah:

• Memahami apa itu Go dan mengapa ia populer untuk sistem berskala besar
• Berhasil menginstal Go dan mengkonfigurasi lingkungan pengembangan
• Menulis dan menjalankan program Hello, World! pertamamu
• Membuat kalkulator sederhana yang memperkenalkan fungsi, switch, dan error handling Go

Go memang memiliki kurva belajar, terutama jika kamu datang dari bahasa yang lebih dinamis seperti Python atau JavaScript. Namun investasi waktu ini sangat sepadan — terutama jika kamu bercita-cita membangun sistem backend yang performa tinggi.

Langkah selanjutnya yang disarankan:

1. Pelajari tipe data dan variabel di Go (var, :=, tipe primitif)
2. Kuasai struktur kontrol: for, if, switch
3. Pelajari array, slice, dan map
4. Mulai eksplorasi goroutine dan channel untuk concurrency

Selamat coding, dan sampai jumpa di artikel berikutnya!