Golang: Menjalankan Kode Pertama “Hello World!” ~ FUN PROGRAMMING

Selamat datang di dunia Go (alias Golang)!
Kalau kamu sampai di artikel ini, kemungkinan besar kamu baru saja menyelesaikan dua hal penting:

Menginstal Go (dan sempat panik sedikit waktu buka terminal pertama kali),
Dan sekarang pengen segera bikin kode pertama.

Santai, kita akan jalan bareng pelan-pelan tapi pasti.
Kita bakal bikin program klasik yang jadi ritual wajib semua programmer baru di dunia: “Hello, World!”

Tapi jangan salah, di balik satu baris kecil itu, ada banyak hal menarik untuk dipelajari.
Kita bakal bahas semua dari struktur kode Go, cara menjalankan program, sampai tips biar kamu gak salah arah di awal perjalanan jadi Gopher sejati.

Kenapa Semua Orang Mulai dari “Hello, World”?

Sebelum kita nulis kode apa pun, mari kita jawab pertanyaan filosofis:
Kenapa sih harus “Hello, World”?

Jawabannya simpel: karena itu cara paling cepat buat memastikan semuanya berfungsi.
Kalau kode sederhana seperti itu bisa jalan, berarti:

Go berhasil diinstal dengan benar ✅
Compiler dan environment-mu beres ✅
Terminal kamu gak lagi trauma dengan error merah panjang ✅

Selain itu, “Hello, World” juga jadi momen simbolis:

“Selamat datang di dunia baru, programmer muda!”

Struktur Dasar Program Go

Sekarang, mari lihat contoh paling sederhana dari program Go yang akan kita buat:

package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}

Sekilas, kelihatannya gampang banget.
Tapi tiap baris di atas punya arti penting. Yuk, kita bedah satu-satu.

🧱 `package main`

Baris pertama:

package main

Setiap file Go harus dimulai dengan deklarasi package.
Package di Go mirip dengan “folder atau namespace” digunakan untuk mengelompokkan kode.

Tapi kenapa main?

Karena main adalah package spesial.
Kalau kamu pakai package main, itu artinya Go akan tahu:

“Oke, ini program utama yang bisa dijalankan (bukan cuma library).”

Kalau kamu menulis package something_else, programnya tidak bisa dijalankan langsung.

Jadi, ingat ya — kalau kamu mau bikin executable (bukan library), awali dengan:

package main

`import "fmt"`

Baris berikutnya:

import "fmt"

import artinya kita sedang mengambil library (package) dari Go.
fmt adalah singkatan dari format, dan digunakan untuk input/output teks — seperti mencetak tulisan ke layar.

Ibaratnya, fmt ini semacam alat komunikasi antara kamu dan terminal:

Kamu ngomong ke fmt: “tolong tulis ini di layar!”
dan fmt menjawab: “siap, bos!”

`func main()`

Baris berikutnya:

func main() {

func artinya kamu sedang mendefinisikan fungsi (atau “function” dalam bahasa pemrograman lain).
Nah, main() juga spesial seperti package main tadi.

Go akan selalu mulai menjalankan program dari fungsi main().
Bisa dibilang, main() adalah pintu utama dari program kamu.
Kalau main() hilang, Go bakal bingung mau mulai dari mana.

`fmt.Println("Hello, World!")`

Nah, inilah baris paling legendaris dalam dunia pemrograman.
fmt.Println() digunakan untuk menampilkan teks ke layar (standard output), dan otomatis menambahkan baris baru di akhir (karena ada ln = line).

Jadi hasilnya:

Hello, World!

Kalau kamu ingin tanpa baris baru, bisa pakai:

fmt.Print("Hello, World!")

Atau kalau kamu ingin mencetak beberapa nilai sekaligus:

fmt.Println("Halo,", "nama saya", "Gopher!")

Output-nya:

Halo, nama saya Gopher!

Menulis dan Menjalankan Program Hello World

Sekarang waktunya praktik.
Buka text editor favorit kamu bisa VS Code, GoLand, Sublime, atau bahkan Notepad++ (asal jangan Word ya, nanti jadi skripsi).

Buat file baru dengan nama:

hello.go

Lalu tulis kode ini:

package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}

Simpan file-nya, lalu buka terminal di folder tempat kamu menyimpannya.

Jalankan Program

Kamu bisa menjalankan kode Go dengan dua cara:

Langsung dijalankan tanpa build:

go run hello.go

Hasilnya akan muncul:

Hello, World!

Ini cara cepat kalau kamu cuma ingin tes program kecil.

Dikompilasi menjadi file executable:

go build hello.go

Perintah ini akan membuat file baru bernama hello (atau hello.exe di Windows).
Kamu bisa jalankan:

./hello

atau di Windows:

hello.exe

Output-nya tetap sama, tapi kali ini programmu sudah jadi file mandiri.
Artinya, kamu bisa kirim file itu ke orang lain, dan mereka bisa jalankan tanpa perlu menginstal Go.

Apa yang Terjadi Saat Kamu Jalankan “go run”?

Di balik layar, go run sebenarnya melakukan dua hal:

Mengompilasi kode kamu jadi binary sementara,
Menjalankan binary itu langsung.

Bedanya, kalau pakai go build, file binary-nya disimpan permanen di folder kamu.
Kalau go run, file itu cuma sementara dan dihapus setelah program selesai.

Tips Menulis Program Go Pertama

Selalu mulai dari package main dan func main.
Tanpa itu, program gak akan jalan.
Gunakan huruf kapital dengan benar.
Di Go, huruf besar dan kecil punya makna penting.
Misal, fungsi dengan huruf kapital di awal (Println) artinya fungsi itu bisa diakses dari luar package.
Jangan lupa import package yang dibutuhkan.
Kalau kamu tulis fmt.Println tapi lupa import "fmt", Go bakal langsung protes:
```
undefined: fmt
```
Gunakan go fmt untuk merapikan kode.
Go punya tool bawaan untuk mempercantik kode.
Cukup jalankan:
```
go fmt hello.go
```
Semua indentation dan spasi akan dirapikan otomatis.
Jadi, gak perlu khawatir kode kamu “berantakan kayak meja kerja pas deadline.”

Struktur Folder (Go Modules vs GOPATH)

Kalau kamu sudah membaca artikel sebelumnya tentang GOPATH & GOROOT, kamu tahu bahwa Go punya cara tersendiri menyimpan proyek.

Tapi untuk proyek modern, disarankan kamu menggunakan Go Modules.

Buat folder proyek:

mkdir belajar-hello
cd belajar-hello

Inisialisasi modul:

go mod init belajar-hello

Buat file main.go berisi:

package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}

Lalu jalankan:

go run .

Boom
Go akan otomatis mengenali file utama dan menjalankan programmu.

Bonus: Eksperimen dengan Hello World

Sekarang kita udah paham dasar-dasarnya. Yuk, coba eksperimen sedikit.

Ubah Pesannya

Ubah teks di dalam Println:

fmt.Println("Selamat datang di dunia Go!")

Tambahkan Variabel

package main

import "fmt"

func main() {
    name := "John"
    age := 25
    fmt.Println("Halo,", name, "! Umurmu", age, "tahun.")
}

Output:

Halo, John ! Umurmu 25 tahun.

Tambahkan Operasi

fmt.Println("2 + 3 =", 2+3)

Output:

2 + 3 = 5

Go akan otomatis mengenali tipe datanya. Kamu gak perlu menulis tipe secara eksplisit kalau gak mau.

Troubleshooting (Kalau Gak Jalan)

Kalau program kamu gak mau jalan, cek hal-hal berikut:

Masalah Umum	Solusi
`go: command not found`	Pastikan Go sudah diinstal dan PATH sudah diset
`undefined: fmt`	Tambahkan `import "fmt"`
`package main: cannot find package`	Pastikan kamu menjalankan `go run` di folder yang benar
`syntax error`	Periksa tanda kurung `{}` dan `"` Go sangat sensitif terhadapnya

Langkah Selanjutnya

Selamat!
Kamu baru saja menulis dan menjalankan program Go pertamamu.

Langkah berikutnya yang bisa kamu pelajari:

Variabel dan tipe data di Go
Fungsi dan parameter
Struktur kontrol (if, for, switch)
Package dan modul
Handling error dan logging

Kalau kamu udah paham ini, kamu sudah punya fondasi kuat buat lanjut ke hal-hal keren seperti:

Web API pakai net/http
Aplikasi CLI
Dan bahkan microservice super cepat pakai Go

Menjalankan “Hello, World” di Go bukan cuma soal mengetik teks di layar.
Ini langkah pertama untuk memahami:

Struktur dasar program Go
Fungsi main() dan package
Cara kerja import dan fmt
Serta kebiasaan coding yang rapi dan efisien

Go diciptakan dengan prinsip sederhana, cepat, dan eksplisit, jadi jangan heran kalau kamu merasa kodenya bersih dan enak dibaca.

Jadi, kalau kamu berhasil menampilkan tulisan:

Hello, World!

artinya kamu sudah resmi jadi bagian dari komunitas para Gopher.

FUN PROGRAMMING

Sponsored

🔔 Your Support Means a Lot!