Cara Kerja Compiler Go

Salah satu alasan mengapa Golang dikenal cepat adalah karena proses kompilasinya yang sederhana dan efisien. Pada artikel ini, Anda akan mempelajari bagaimana Go mengubah source code menjadi executable, memahami perbedaan antara go run dan go build, mengenal konsep binary serta cross compile, hingga menghasilkan aplikasi yang dapat dijalankan di berbagai sistem operasi.

Pendahuluan

Ketika pertama kali belajar Go, kebanyakan developer hanya menjalankan perintah seperti go run main.go tanpa benar-benar memahami apa yang terjadi di balik layar. Program memang berjalan, tetapi muncul pertanyaan seperti: mengapa Go menghasilkan file executable? Apa bedanya go run dengan go build? Mengapa aplikasi Go bisa dijalankan di server tanpa harus menginstal Go terlebih dahulu?

Memahami cara kerja compiler bukan hanya sekadar teori. Dalam dunia backend, proses deployment hampir selalu melibatkan hasil kompilasi aplikasi. Ketika sebuah service akan dijalankan di server, Docker, atau platform cloud seperti AWS dan Google Cloud, yang dipindahkan bukan lagi source code, melainkan binary hasil kompilasi.

Oleh karena itu, memahami proses compile, build, dan binary akan membantu Anda memahami bagaimana aplikasi Go dipersiapkan sebelum dijalankan di lingkungan produksi.

Tujuan Pembelajaran

Setelah menyelesaikan artikel ini, Anda akan memahami bagaimana compiler Go bekerja dalam mengubah source code menjadi executable. Anda juga akan mampu membedakan proses compile, build, dan run, mengetahui fungsi binary yang dihasilkan Go, melakukan cross compile untuk sistem operasi lain, serta menghasilkan executable pertama dari project Go yang telah dibuat.

Konsep Dasar

Bayangkan Anda sedang menulis sebuah buku.

Naskah yang Anda tulis menggunakan Microsoft Word belum bisa langsung dicetak menjadi buku yang dijual di toko. Naskah tersebut harus melalui proses layout, editing, hingga akhirnya dicetak menjadi buku fisik.

Go bekerja dengan konsep yang hampir sama.

Source code yang Anda tulis hanyalah "naskah". Agar komputer dapat memahaminya, compiler Go akan menerjemahkan seluruh kode tersebut menjadi bahasa mesin (machine code) yang kemudian disimpan dalam sebuah file executable atau binary.

Alur sederhananya dapat digambarkan seperti berikut.

Developer
     │
     ▼
Source Code (.go)
     │
     ▼
Go Compiler
     │
     ▼
Binary Executable
     │
     ▼
Program Berjalan

Keunggulan Go adalah compiler-nya dirancang sangat cepat. Bahkan untuk project berukuran besar, waktu kompilasinya tetap relatif singkat dibandingkan beberapa bahasa lain.

Apa Itu Compiler?

Compiler adalah program yang bertugas menerjemahkan source code menjadi bahasa mesin sehingga dapat dijalankan oleh sistem operasi.

Saat Anda menulis kode berikut:

package main

import "fmt"

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

Komputer sebenarnya tidak memahami sintaks tersebut.

Compiler Go akan membaca seluruh file .go, memeriksa apakah terdapat kesalahan sintaks, kemudian menghasilkan file executable yang dapat dijalankan oleh sistem operasi.

Karena proses inilah, aplikasi Go memiliki performa yang tinggi dan tidak memerlukan interpreter saat dijalankan.

Compile, Build, dan Run

Ketiga istilah ini sering dianggap sama, padahal memiliki tujuan yang berbeda.

Compile

Compile adalah proses menerjemahkan source code menjadi machine code.

Pada tahap ini compiler akan melakukan berbagai pemeriksaan, seperti validasi sintaks, pengecekan tipe data, hingga optimasi kode sebelum menghasilkan binary.

Compile merupakan inti dari seluruh proses pembangunan aplikasi Go.

Build

Build merupakan proses menghasilkan file executable dari source code.

Perintah yang digunakan adalah:

go build

Setelah selesai, Anda akan melihat file baru pada direktori project.

belajar-go/
├── go.mod
├── main.go
└── belajar-go

Pada Windows, file tersebut biasanya memiliki ekstensi .exe.

Binary inilah yang nantinya didistribusikan ke server produksi.

Run

Berbeda dengan go build, perintah berikut:

go run .

tidak menghasilkan file executable permanen.

Go akan melakukan proses compile terlebih dahulu, membuat binary sementara (temporary binary), menjalankannya, kemudian menghapus binary tersebut setelah program selesai dieksekusi.

Ilustrasinya seperti berikut.

Source Code
      │
      ▼
Compile
      │
      ▼
Temporary Binary
      │
      ▼
Program Berjalan
      │
      ▼
Binary Dihapus

Karena itulah go run sangat cocok digunakan selama proses pengembangan.

Memahami Binary

Binary adalah hasil akhir dari proses kompilasi.

File ini sudah berisi seluruh instruksi yang dapat dijalankan langsung oleh sistem operasi.

Sebagai contoh, setelah menjalankan:

go build

Anda dapat menjalankan aplikasi tersebut tanpa perlu menginstal Go lagi.

Pada Linux atau macOS:

./belajar-go

Sedangkan pada Windows:

.\belajar-go.exe

Inilah salah satu alasan mengapa deployment aplikasi Go menjadi sangat sederhana. Anda cukup mengirimkan satu file binary ke server, kemudian menjalankannya.

Cross Compile

Salah satu fitur unggulan Go adalah kemampuan melakukan cross compile, yaitu membuat executable untuk sistem operasi yang berbeda tanpa harus berpindah perangkat.

Sebagai contoh, Anda sedang menggunakan macOS tetapi ingin menghasilkan executable untuk Linux.

Cukup jalankan:

GOOS=linux GOARCH=amd64 go build

Untuk Windows:

GOOS=windows GOARCH=amd64 go build

Sedangkan untuk macOS:

GOOS=darwin GOARCH=arm64 go build

Setelah proses selesai, Go akan menghasilkan executable sesuai target sistem operasi yang dipilih.

Kemampuan ini sangat membantu ketika proses deployment dilakukan ke server Linux sementara proses development dilakukan di Windows atau macOS.

Implementasi Langkah demi Langkah

Langkah 1 — Membuat Program

Buat file main.go.

package main

import "fmt"

func main() {
    fmt.Println("Belajar Compiler Go")
}

Langkah 2 — Menjalankan Program

Jalankan menggunakan:

go run .

Program akan langsung dijalankan tanpa menghasilkan executable permanen.

Langkah 3 — Build Project

Sekarang jalankan:

go build

Perhatikan bahwa akan muncul sebuah file baru pada folder project.

Jika Anda menggunakan Linux atau macOS:

belajar-go

Sedangkan pada Windows:

belajar-go.exe

Langkah 4 — Menjalankan Binary

Jalankan executable yang telah dihasilkan.

Linux atau macOS:

./belajar-go

Windows:

.\belajar-go.exe

Outputnya akan sama seperti ketika menggunakan go run, tetapi kali ini program dijalankan langsung dari binary yang telah dikompilasi.

Langkah 5 — Generate Binary untuk Sistem Operasi Lain

Sebagai contoh, buat executable Windows dari Linux atau macOS.

GOOS=windows GOARCH=amd64 go build -o belajar-go.exe

Atau buat executable Linux dari Windows.

GOOS=linux GOARCH=amd64 go build -o belajar-go

Perhatikan bahwa Anda tidak perlu memiliki sistem operasi tujuan untuk menghasilkan binary tersebut.

Best Practice Industri

Dalam proses pengembangan sehari-hari, developer biasanya menggunakan go run karena lebih praktis dan tidak meninggalkan file executable pada folder project. Namun ketika aplikasi akan dipublikasikan atau dideploy ke server, gunakan go build untuk menghasilkan binary yang stabil dan siap dijalankan.

Pada proses Continuous Integration (CI) maupun Continuous Deployment (CD), binary biasanya dibangun secara otomatis sebelum didistribusikan ke server. Pendekatan ini memastikan bahwa aplikasi yang dijalankan merupakan hasil kompilasi yang sama dengan yang telah melalui proses pengujian.

Jika aplikasi akan dijalankan pada sistem operasi yang berbeda, manfaatkan fitur cross compile daripada melakukan kompilasi ulang di server tujuan. Selain menghemat waktu, pendekatan ini juga membuat proses deployment menjadi lebih konsisten.

Latihan Mandiri

Tantangan 1

Buat sebuah program sederhana, kemudian jalankan menggunakan go run dan go build. Amati perbedaan file yang dihasilkan.

Tantangan 2

Lakukan cross compile untuk menghasilkan executable Windows atau Linux sesuai sistem operasi yang berbeda dari perangkat Anda, kemudian perhatikan nama file yang dihasilkan.

Tantangan 3

Gunakan opsi -o pada go build untuk menentukan nama executable yang Anda inginkan, misalnya server, api, atau belajar-go.

Ringkasan

Pada artikel ini Anda telah mempelajari bagaimana compiler Go mengubah source code menjadi binary yang dapat dijalankan oleh sistem operasi. Anda juga memahami perbedaan antara proses compile, build, dan run, mengenal konsep binary, serta mencoba menghasilkan executable pertama menggunakan go build.

Selain itu, Anda telah mempelajari kemampuan cross compile yang menjadi salah satu keunggulan Go dalam proses deployment lintas platform. Dengan pemahaman ini, Anda kini mengetahui apa yang sebenarnya terjadi ketika menjalankan aplikasi Go, baik selama proses development maupun ketika aplikasi dipublikasikan ke lingkungan produksi.

Referensi

• Dokumentasi go build: https://pkg.go.dev/cmd/go#hdr-Compile_packages_and_dependencies

• Cross Compilation: https://go.dev/wiki/WindowsCrossCompiling

• Go Command Documentation: https://go.dev/cmd/go/

FAQ

Apa perbedaan go run dan go build?

go run akan mengompilasi program ke binary sementara, menjalankannya, lalu menghapus binary tersebut. Sebaliknya, go build menghasilkan binary permanen yang dapat dijalankan kembali kapan saja.

Apa itu binary pada Go?

Binary adalah file executable hasil kompilasi source code Go yang dapat dijalankan langsung oleh sistem operasi tanpa memerlukan instalasi Go.

Mengapa aplikasi Go mudah dideploy?

Karena Go menghasilkan satu file binary yang telah berisi seluruh kode aplikasi, sehingga proses deployment cukup dilakukan dengan menyalin file tersebut ke server.

Apa itu cross compile?

Cross compile adalah proses menghasilkan binary untuk sistem operasi atau arsitektur yang berbeda dari perangkat yang digunakan untuk melakukan kompilasi.

Kapan sebaiknya menggunakan go build?

Gunakan go build ketika Anda ingin mendistribusikan aplikasi, melakukan deployment ke server, membuat Docker image, atau menghasilkan executable yang akan digunakan oleh pengguna lain.

Artikel Sebelumnya

Cara Kerja Compiler Go