Pengenalan Go
untuk Backend Developer

Sebelum menulis endpoint, repository, worker, atau Dockerfile, kamu perlu tahu kenapa Go membentuk cara berpikir backend yang berbeda dari JavaScript dan PHP.

Kalau kamu datang dari React dan TypeScript, kamu sudah terbiasa memikirkan bentuk data, state, API contract, dan runtime JavaScript yang fleksibel. Kalau kamu pernah menyentuh Laravel, kamu mungkin juga terbiasa dengan framework yang sangat produktif, banyak konvensi, dan banyak fitur siap pakai.

Go mengambil jalur lain. Ia tidak mencoba menjadi framework besar. Ia memberi bahasa, standard library yang kuat, toolchain rapi, concurrency bawaan, dan gaya desain yang sengaja dibuat sederhana.

Modul ini sengaja belum menumpahkan sintaks. Kita tidak akan menghafal for, if, atau cara deklarasi variabel di sini, karena kamu sudah developer berpengalaman. Yang kita bangun dulu adalah model mental: kenapa Go terasa seperti ini, dan kenapa cara berpikirnya cocok untuk backend yang harus hidup lama di produksi.

Dalam proyek online shop skincare, pilihan bahasa backend bukan sekadar selera. Kita akan membangun katalog produk, keranjang, checkout, inventory, payment callback, background job, email, audit log, dan deploy ke AWS. Bagian-bagian itu butuh kode yang jelas, mudah dites, mudah dibaca ulang, dan tidak terlalu ajaib.

Go adalah bahasa pemrograman compiled, statically typed, garbage-collected, dengan concurrency built-in dan toolchain yang sengaja dibuat sederhana.

Situs resmi go.dev meringkas posisi Go dalam satu kalimat: “Build simple, secure, scalable systems with Go”. Go didukung Google, open-source, mudah dipelajari oleh tim, punya concurrency bawaan, dan standard library yang kuat. Untuk jalur Go Artisan ini, kita memakai Go seri 1.26 sesuai target proyek.

Ada tiga hal yang akan terasa cepat bagi developer JavaScript dan PHP.

Kita tidak memilih Go karena ingin terlihat lebih low-level. Kita memilih Go karena ia memberi cukup kontrol untuk backend serius, tanpa membuat proses development terasa seberat bahasa sistem tradisional.

Go populer di backend karena kombinasi simplicity, performance, concurrency bawaan, compile cepat, dan deployment yang sederhana.

Backend modern sering berisi banyak pekerjaan kecil yang harus stabil: menerima HTTP request, validasi input, bicara ke database, memanggil payment gateway, menulis log, menjalankan worker, dan memantau health check. Go cocok untuk pekerjaan seperti ini karena desain bahasanya mendorong jalur yang eksplisit.

Supaya tidak abstrak, berikut perbandingan langsung tiga pilihan yang mungkin pernah kamu pakai, dilihat dari sudut backend service.

Tabel 1. Bukan soal mana yang terbaik mutlak, tetapi soal trade-off mana yang paling cocok untuk service backend yang harus dioperasikan jangka panjang.

Kenapa bukan Node.js?

Node.js sangat bagus untuk tim yang sudah kuat JavaScript end-to-end, butuh ekosistem npm besar, atau ingin satu bahasa dari frontend sampai backend. Tetapi untuk service backend jangka panjang, Go memberi binary deployment yang lebih sederhana, tipe yang selalu ada saat compile, dan concurrency model yang tidak bergantung pada event loop JavaScript.

Kenapa bukan PHP atau Laravel?

Laravel sangat produktif untuk aplikasi web monolitik, admin panel, dan tim yang ingin fitur framework siap pakai. Tetapi Go lebih menarik saat kita ingin service kecil, worker, CLI, dan proses deployment yang dekat dengan container dan cloud-native tooling.

Perbedaan compiled dan interpreted paling terasa di cara aplikasi dijalankan, cara error ditemukan, dan cara kita mengirim aplikasi ke server.

Di Node.js, file JavaScript biasanya dibaca dan dieksekusi oleh runtime Node.js. Di Go, file .go dikompilasi lebih dulu menjadi executable. Kamu tetap bisa memakai go run saat development, tetapi di balik layar Go tetap melakukan proses compile sebelum menjalankan program.

flowchart TB
  subgraph node["Cara interpreted (Node.js)"]
    direction LR
    A1["main.js + node_modules"] --> A2["Node.js runtime di server"] --> A3["program berjalan"]
  end
  subgraph gobuild["Cara compiled (Go)"]
    direction LR
    B1["main.go"] --> B2["go build"] --> B3["binary mandiri"] --> B4["program berjalan"]
  end

Gambar 1. Node membawa source, dependency, dan runtime ke server. Go memadatkan semuanya menjadi satu binary saat build, lalu server cukup menjalankan binary itu.

Contoh paling kecil.

cmd/hello/main.goSalin
package main

import "fmt"

func main() {
	fmt.Println("Go Artisan: backend online shop skincare")
}

Jalankan dengan mode development.

TerminalSalin
go run ./cmd/hello

Build menjadi binary.

TerminalSalin
go build -o bin/skincare ./cmd/hello
./bin/skincare

Untuk backend production, pola go build sangat nyaman. Kita bisa build binary di CI, bungkus ke Docker image, lalu jalankan di ECS, EC2, atau service lain. Modul deploy akan membahas detailnya, tetapi pola pikirnya dimulai dari sini.

TypeScript memberi rasa aman di atas JavaScript, sedangkan Go menjadikan tipe sebagai bagian asli dari bahasa dan proses compile.

TypeScript membantu developer React menghindari bug bentuk data, props, response API, dan union state. Tetapi TypeScript akhirnya dikompilasi menjadi JavaScript, sehingga tipe tidak menjadi bagian dari runtime JavaScript. Go berbeda. Tipe adalah bagian inti bahasa dan compiler akan menolak program yang melanggar kontrak tipe.

Contoh kontrak data produk skincare.

internal/product/product.goSalin
package product

type Product struct {
	ID          int64
	Name        string
	Brand       string
	SkinType    string
	PriceRupiah int64
	Stock       int
	IsPublished bool
}

func CanBeSold(p Product) bool {
	return p.IsPublished && p.Stock > 0 && p.PriceRupiah > 0
}

Kalau kamu mencoba mengisi PriceRupiah dengan string di dalam kode Go, compiler akan protes sebelum aplikasi jalan.

internal/product/broken_example.goSalin
package product

func BrokenProduct() Product {
	return Product{
		ID:          101,
		Name:        "Hydrating Toner",
		Brand:       "Glow Lab",
		PriceRupiah: "129000", // error: cannot use "129000" (untyped string) as int64
	}
}

Kode di atas gagal dikompilasi karena PriceRupiah butuh int64, bukan string. Ini terasa cerewet di awal, tetapi sangat membantu saat proyek mulai punya banyak fitur dan banyak kontributor.

Tidak ada undefined, yang ada zero value

Salah satu kebiasaan JavaScript yang perlu dilepas adalah refleks mengecek undefined dan null di mana-mana. Di Go, setiap variabel yang dideklarasikan selalu punya nilai awal yang pasti sesuai tipenya. Tidak ada keadaan “belum terdefinisi” yang mengambang.

internal/product/zero_value.goSalin
package product

func DraftProduct() Product {
	var p Product // semua field langsung terisi zero value

	// p.Name == ""        (string)
	// p.Stock == 0        (int)
	// p.PriceRupiah == 0  (int64)
	// p.IsPublished == false (bool)

	return p
}

Go sengaja memilih bahasa yang kecil dan pola yang eksplisit supaya program jangka panjang mudah dirawat.

Effective Go menekankan bahwa menulis Go dengan baik berarti memahami properti, idiom, dan konvensi Go. Ini penting karena Go tidak hanya soal sintaks, tetapi juga gaya berpikir: lebih sedikit magic, lebih banyak alur yang terlihat.

Bagi developer React, ini mirip saat tim sepakat memakai pola state management yang jelas, bukan setiap halaman punya arsitektur berbeda. Bagi developer Laravel, ini berbeda dari framework yang menyediakan banyak magic lewat container, facade, model lifecycle, dan convention over configuration.

Contoh gaya eksplisit saat mengambil produk.

internal/product/service.goSalin
package product

import "context"

type Repository interface {
	FindByID(ctx context.Context, id int64) (Product, error)
}

type Service struct {
	repo Repository
}

func NewService(repo Repository) *Service {
	return &Service{repo: repo}
}

func (s *Service) Detail(ctx context.Context, id int64) (Product, error) {
	p, err := s.repo.FindByID(ctx, id)
	if err != nil {
		return Product{}, err
	}

	return p, nil
}

Perhatikan pola yang akan sering muncul di modul berikutnya: context.Context sebagai parameter pertama, dependency lewat interface kecil, constructor mengembalikan struct, dan error dikembalikan sebagai nilai.

Go nyaman dipakai untuk REST API, background job, worker, CLI, dan infrastructure tooling.

Dalam proyek nyata, backend bukan hanya satu web server. Ada API yang menerima request dari frontend, worker yang mengerjakan pekerjaan lambat, CLI untuk maintenance, dan tool kecil untuk migrasi atau seed data. Go bisa mengisi semuanya dengan bahasa dan toolchain yang sama.

Untuk REST API, gambaran konkretnya kira-kira seperti ini. Kita belum membangunnya sekarang, tetapi bentuk endpoint inilah yang akan kita kejar di Roadmap 2.

Di proyek kita, Go akan menjadi API layer dan worker layer yang menghubungkan frontend React, PostgreSQL, payment provider, dan layanan pendukung.

Diagram berikut menunjukkan gambaran awal. Kita belum bicara chi, pgx, Docker, atau AWS secara detail, tetapi kamu sudah bisa melihat kenapa Go cocok berada di pusat backend.

flowchart LR
  FE["React Frontend"] -->|HTTP JSON| API["Go API Layer"]
  API -->|service domain| Domain["Service Layer"]
  Domain -->|SQL via pgx| DB[("PostgreSQL")]
  API -->|enqueue task| Queue["Job Queue"]
  Queue --> Worker["Go Worker Layer"]
  Worker -->|email, sync stok, retry webhook| External["Email / Payment / Inventory"]
  Worker --> DB

Gambar 2. Posisi Go API dan Go Worker di stack backend online shop skincare.

Untuk melihat kenapa pembagian API dan worker itu penting, perhatikan satu alur checkout. API mengerjakan bagian yang harus cepat dan pasti, lalu menyerahkan pekerjaan lambat ke worker.

sequenceDiagram
  participant FE as React Frontend
  participant API as Go API
  participant DB as PostgreSQL
  participant Q as Job Queue
  participant W as Go Worker
  FE->>API: POST /v1/checkout
  API->>DB: Simpan order dan kunci stok (transaksi)
  API->>Q: Antre job kirim email invoice
  API-->>FE: 201 Created (jalur cepat)
  Q->>W: Serahkan job
  W->>W: Kirim email, sinkron stok ke gudang
  W->>DB: Tandai job selesai

Gambar 3. API menahan hanya pekerjaan inti checkout. Email dan sinkronisasi stok dikerjakan worker setelah respons dikirim, sehingga pembeli tidak menunggu pekerjaan lambat.

API layer

API layer adalah pintu masuk dari frontend. Contohnya GET /v1/products, POST /v1/cart/items, dan POST /v1/checkout. Modul Roadmap 2 akan memakai net/http dan chi untuk routing, middleware, dan handler yang rapi. Sejak Go 1.22, net/http bahkan sudah bisa routing berbasis method dan path sederhana, lalu chi melengkapi kebutuhan middleware dan grup rute.

Worker layer

Worker layer menangani pekerjaan yang tidak harus selesai di dalam request utama. Contohnya mengirim email invoice, sinkronisasi stok ke sistem gudang, membersihkan cart kadaluarsa, dan retry notifikasi payment provider.

PostgreSQL

PostgreSQL menjadi sumber data utama. Nanti kita memakai pgx dan pgxpool untuk query, transaksi checkout, lock stok, dan repository layer.

Sekarang kita buat program Go kecil yang mensimulasikan service katalog produk skincare tanpa framework.

Tujuan hands-on ini bukan membangun API production. Tujuannya hanya melihat bagaimana Go memakai module, package, struct, function, compile, dan run.

TerminalSalin
mkdir skincare-backend
cd skincare-backend
go mod init github.com/kamu/skincare-backend
mkdir -p cmd/catalog internal/product

internal/product/product.goSalin
package product

type Product struct {
	ID          int64
	Name        string
	Brand       string
	SkinType    string
	PriceRupiah int64
	Stock       int
	IsPublished bool
}

func CanBeSold(p Product) bool {
	return p.IsPublished && p.Stock > 0 && p.PriceRupiah > 0
}

cmd/catalog/main.goSalin
package main

import (
	"fmt"

	"github.com/kamu/skincare-backend/internal/product"
)

func main() {
	toner := product.Product{
		ID:          101,
		Name:        "Hydrating Toner",
		Brand:       "Glow Lab",
		SkinType:    "dry",
		PriceRupiah: 129000,
		Stock:       12,
		IsPublished: true,
	}

	fmt.Printf("%s bisa dijual: %t\n", toner.Name, product.CanBeSold(toner))
}

TerminalSalin
go fmt ./...
go run ./cmd/catalog
go build -o bin/catalog ./cmd/catalog
./bin/catalog

Output yang diharapkan.

TerminalSalin
Hydrating Toner bisa dijual: true

Developer JS dan PHP biasanya cepat produktif di Go, tetapi beberapa kebiasaan lama perlu ditahan.

1. Mencari framework besar terlalu cepat

Di Laravel, framework adalah pusat gravitasi. Di Go, standard library dan package kecil sering lebih idiomatik. Kita akan memakai chi untuk routing, tetapi tetap menjaga bisnis utama tidak bergantung pada router.

2. Menganggap compiler sebagai musuh

Compiler Go memang cerewet. Import tidak dipakai, variabel tidak dipakai, tipe tidak cocok, semua akan dihentikan. Ini bukan penghambat, ini mekanisme menjaga codebase tetap bersih.

3. Membawa pola any ke Go

Go punya any sebagai alias resmi untuk empty interface sejak Go 1.18, tetapi ia bukan alat default untuk melewati desain tipe. Untuk domain online shop, struct yang jelas lebih aman daripada peta bebas yang isinya ditebak saat runtime.

4. Menyembunyikan error

Di JavaScript dan PHP, error sering ditangani dengan exception atau framework handler global. Di Go, error adalah nilai. Kalau operasi database gagal, service harus memutuskan apakah error diteruskan, dibungkus, atau diterjemahkan ke response yang tepat.

5. Membuat abstraction terlalu awal

Karena terbiasa dengan design pattern, developer sering membuat folder dan interface banyak sebelum ada kebutuhan nyata. Go biasanya lebih suka abstraksi kecil yang muncul dari kebutuhan testing dan boundary yang jelas.

Modul ini memberi fondasi mental sebelum kita masuk ke sintaks, package, function, pointer, error handling, dan HTTP API.