Fondasi Go
untuk Developer JS & PHP

Bukan karena hype, tapi karena cocok untuk backend yang kamu mau bangun.

Bayangkan Go sebagai sepeda gunung: sedikit gigi, rangka kokoh, dan kamu langsung tahu cara kerjanya. Berbeda dari kabin pesawat penuh tombol.

Sebagai developer React, kamu terbiasa dengan ekosistem JavaScript yang kaya tetapi sering kewalahan: ratusan dependency, konfigurasi build yang berlapis, dan perdebatan tanpa akhir soal gaya kode. Go mengambil arah berlawanan. Bahasanya kecil, satu cara penulisan baku (lewat gofmt), dan hasil akhirnya satu file biner yang bisa langsung dijalankan di server tanpa runtime tambahan.

Go diciptakan di Google untuk menyelesaikan masalah skala: build lambat, dependency berantakan, dan kode yang sulit dibaca tim besar. Hasilnya bahasa yang sengaja dibuat membosankan dalam arti baik, mudah dibaca orang lain enam bulan kemudian. Untuk backend API, worker, dan layanan jaringan, kombinasi kompilasi cepat, konkurensi murah (goroutine), dan deployment sesederhana menyalin satu biner membuat Go jadi pilihan populer.

Kenapa ini relevan untukmu secara spesifik? Karena kamu datang dengan dua bekal kuat: pola pikir komponen dan state dari React, serta pola arsitektur berlapis (controller, service, model) dari Laravel. Go akan memakai kedua bekal itu, hanya dengan aturan main yang lebih tegas dan eksplisit.

Empat pergeseran mental yang paling sering bikin kaget.

Sebagian besar frustrasi awal di Go bukan soal sintaks, melainkan empat asumsi dari JS/PHP yang perlu kamu lepaskan.

1. Dikompilasi jadi satu biner, bukan ditafsirkan

Node butuh node plus node_modules; PHP butuh php-fpm plus vendor. Go mengompilasi semuanya menjadi satu file biner statis yang sudah memuat runtime dan garbage collector di dalamnya. Deploy berarti menyalin satu file lalu menjalankannya.

2. Statis dan tegas saat kompilasi

TypeScript memberi tipe yang hilang saat runtime; PHP punya tipe opsional. Di Go, tipe itu nyata dan dicek compiler. Lebih dari itu, hal yang di JS/PHP cuma peringatan, di Go bisa jadi error kompilasi. Import yang tidak dipakai dan variabel lokal yang tidak dipakai membuat build gagal, bukan sekadar warning ESLint.

3. Error itu nilai biasa, bukan exception

Tidak ada try/catch untuk alur normal. Fungsi yang bisa gagal mengembalikan dua nilai: hasil dan error. Kamu memeriksanya dengan if err != nil. Ini terasa cerewet di awal, tapi membuat jalur kegagalan terlihat jelas di setiap baris.

4. Satu format baku, tanpa debat

Tidak ada .prettierrc, tidak ada perang tab vs spasi (jawabannya tab). gofmt adalah format resmi yang tidak bisa dikonfigurasi. Semua kode Go di dunia terlihat konsisten, jadi membaca kode orang lain terasa familiar.

Lima perintah yang akan kamu pakai setiap hari.

Setelah memasang Go, hampir semua pekerjaan harian hanya butuh lima sub-perintah go.

Unduh Go versi stabil terbaru dari go.dev/dl (per Februari 2026 seri stabilnya Go 1.26, rilis baru tiap Februari dan Agustus). Sejak Go 1.16, Go Modules aktif secara default, jadi kamu tidak perlu lagi repot dengan GOPATH seperti tutorial lama.

Begini bentuk go.mod, berkas yang mendeklarasikan nama modul dan versi Go:

go.modSalin
module github.com/kamu/skincare-backend

go 1.26

require (
	github.com/go-chi/chi/v5 v5.3.0
	github.com/jackc/pgx/v5 v5.10.0
)

Lalu sesi terminal pertamamu kira-kira seperti ini:

TerminalSalin
# Buat folder proyek dan inisialisasi modul
mkdir skincare-backend && cd skincare-backend
go mod init github.com/kamu/skincare-backend

# Tambah dependency (mengunduh dan mencatat ke go.mod + go.sum)
go get github.com/go-chi/chi/v5

# Jalankan, lalu rapikan dan periksa
go run .
go fmt ./...
go vet ./...

Konvensi resmi yang menggantikan kebiasaan folder Laravel.

Di Laravel, struktur folder ditentukan framework. Di Go, kamu yang menata, tetapi ada dua konvensi resmi yang akan menyelamatkanmu: cmd/ dan internal/.

Dokumentasi resmi Go merekomendasikan menaruh program (entry point) di dalam cmd/, dan kode yang tidak boleh diimpor proyek lain di dalam internal/. Aturan internal/ ini ditegakkan oleh compiler: paket di dalamnya hanya bisa diimpor dari dalam modul yang sama. Inilah pondasi gaya modular monolith yang akan kita pakai untuk online shop.

Konsep paling 'Go' yang tidak ada di JS: zero value.

Deklarasi variabel Go akan terasa akrab, kecuali satu hal yang akan sering menggigitmu: zero value.

Ada dua cara mendeklarasikan variabel. var eksplisit dengan tipe, dan := yang menyimpulkan tipe (hanya di dalam fungsi). Tipe ditulis setelah nama, kebalikan dari TypeScript.

internal/product/types.goSalin
package product

// Tipe ditulis SETELAH nama (kebalikan dari TypeScript). Di level package pakai `var`.
var name string = "Serum Niacinamide"

// Tipe kustom: bikin makna lebih jelas, dicek compiler.
type Rupiah int64
type SKU string

var total Rupiah = 298000

// `:=` menyimpulkan tipe otomatis, TAPI hanya boleh DI DALAM fungsi.
func contoh() {
	price := 149000      // disimpulkan jadi int
	inStock := true      // disimpulkan jadi bool
	_ = price
	_ = inStock
}

Pola if err != nil yang mendefinisikan rasa menulis Go.

Inilah pergeseran terbesar dari JS/PHP: tidak ada exception untuk alur normal. Fungsi mengembalikan hasil dan error berdampingan.

Fungsi Go bisa mengembalikan banyak nilai. Konvensinya, nilai terakhir bertipe error. Jika error itu nil, berarti sukses.

internal/order/service.goSalin
package order

import (
	"errors"
	"fmt"
)

// Sentinel error: nilai error yang bisa dibandingkan, seperti io.EOF.
var ErrEmptyCart = errors.New("keranjang kosong")

// Mengembalikan (hasil, error). Perhatikan urutan tipe setelah parameter.
func CalculateTotal(items []CartItem) (Rupiah, error) {
	if len(items) == 0 {
		return 0, ErrEmptyCart
	}
	var total Rupiah
	for _, it := range items {
		if it.Qty < 0 {
			// Bungkus error dengan %w supaya bisa di-"unwrap" pemanggil.
			return 0, fmt.Errorf("qty tidak valid untuk %s: %w", it.SKU, ErrInvalidQty)
		}
		total += it.Price * Rupiah(it.Qty)
	}
	return total, nil
}

Pemanggil memeriksa error secara eksplisit, lalu memutuskan apakah menangani atau meneruskannya ke atas:

internal/order/handler.goSalin
total, err := CalculateTotal(cart.Items)
if err != nil {
	if errors.Is(err, ErrEmptyCart) {
		http.Error(w, "keranjang kosong", http.StatusBadRequest)
		return
	}
	// error tak terduga: catat lalu kembalikan 500 (handler net/http tidak me-return error)
	log.Printf("checkout: hitung total: %v", err)
	http.Error(w, "terjadi kesalahan internal", http.StatusInternalServerError)
	return
}
_ = total // lanjut proses checkout dengan total

Pemodelan data tanpa class, tanpa inheritance.

Go tidak punya class. Kamu memodelkan data dengan struct, lalu menempelkan perilaku lewat method dengan receiver.

internal/product/model.goSalin
package product

import "time"

// Struct = bentuk data. Tag backtick mengatur (de)serialisasi JSON.
type Product struct {
	ID        int64     `json:"id"`
	SKU       SKU       `json:"sku"`
	Name      string    `json:"name"`
	Price     Rupiah    `json:"price"`
	Active    bool      `json:"active"`
	CreatedAt time.Time `json:"created_at"`
}

// Method dengan VALUE receiver: dapat salinan, tidak mengubah aslinya.
func (p Product) Label() string {
	return string(p.SKU) + " - " + p.Name
}

// Method dengan POINTER receiver: bisa mengubah struct aslinya.
func (p *Product) Deactivate() {
	p.Active = false
}

Tidak ada extends atau super. Untuk komposisi, Go memakai embedding, dan untuk “konstruktor” konvensinya adalah fungsi pabrik NewProduct(...).

Tujuan akhir jalur ini, supaya setiap konsep punya tempat berlabuh.

Semua modul Go Artisan membangun satu hal yang sama: backend online shop skincare, dari fondasi Go sampai berjalan di AWS.

Daripada belajar fitur lepas-lepas, kita mengarah ke satu sistem nyata. Frontend (React) dan aplikasi mobile berbicara ke API ini lewat HTTP, dan tugas berat seperti notifikasi diproses worker terpisah.

flowchart LR
  FE["Frontend React / Mobile"] -->|HTTP JSON| API["Go API (chi)"]
  API --> SVC["Service (logika bisnis)"]
  SVC --> REPO["Repository (pgx)"]
  REPO --> DB[("PostgreSQL")]
  SVC -->|enqueue job| Q[["Antrian / SQS"]]
  Q --> WK["Go Worker"]
  WK --> DB

Gambar 1. Arsitektur tingkat tinggi: API menangani request cepat, worker memproses tugas lambat di belakang layar.

Sebagian permukaan API yang akan kita rancang dan bangun bertahap:

Hal yang benar di JS/PHP tetapi menggigit di Go.

Empat jebakan ini hampir selalu menimpa pendatang dari JS/PHP. Kenali sekarang, hemat berjam-jam debugging nanti.

Slice berbagi array di belakang layar

Tidak seperti Array.prototype.slice() di JS yang selalu menyalin, mengiris slice di Go menghasilkan view ke array yang sama. Menulis ke hasil irisan bisa diam-diam mengubah slice asal.

jebakan: aliasing sliceSalin
a := []int{1, 2, 3, 4}
b := a[1:3]   // b berbagi memori dengan a
b[0] = 99     // ini juga mengubah a[1] menjadi 99!
// Selalu reassign hasil append: a = append(a, x)

Menulis ke map nil bikin panic

Map yang dideklarasikan tanpa make bernilai nil. Membacanya aman (mengembalikan zero value), tetapi menulisnya membuat program panic saat runtime.

jebakan: nil mapSalin
var m map[string]int   // nil
_ = m["x"]             // aman, hasilnya 0
m["x"] = 1             // PANIC: assignment to entry in nil map
// Perbaikan: m := make(map[string]int)

Peta cepat sebelum lanjut ke Roadmap berikutnya.

Kamu kini punya kerangka mental Go yang dibangun di atas pengetahuan JS/PHP-mu. Inilah inti yang perlu menempel.

Berikutnya di jalur ini kita masuk ke Roadmap 1 lanjutan (control flow, slice, map, interface, dan konkurensi dasar), lalu Roadmap 2 membangun HTTP API nyata dengan net/http dan chi. Setiap langkah tetap dijembatani dari yang sudah kamu kuasai, dan tetap mengarah ke backend online shop yang sama.