DEV Community: Sahal Mahfudh

Debugging Aplikasi Go di VS Code

Sahal Mahfudh — Tue, 06 Oct 2026 08:45:03 +0000

Debugging adalah proses menemukan dan memperbaiki kesalahan atau bug dalam kode sumber. Bagi pengembang Go, mengandalkan fmt.Println() tentu bukan cara yang efektif untuk melacak error atau masalah logika. Di sinilah Anda membutuhkan debugger untuk memeriksa alur eksekusi dan nilai variabel secara real-time.

Mari pelajari cara melakukan debugging aplikasi Go menggunakan VS Code.

Persiapan Project Sederhana

mkdir go-debug
cd go-debug
go mod init go-debug

Buat file main.go menggunakan editor teks atau VS Code, lalu isi dengan kode sederhana ini:

package main

import "fmt"

func main() {
    fmt.Println("Start")

    for i := range 5 {
        hasil := kuadrat(i)
        fmt.Printf("hasil kuadrat dari %v = %v \n", i, hasil)
    }

    fmt.Println("Done")
}

func kuadrat(n int) int {
    return n * n
}

Instalasi Ekstensi Go di VS Code

Buka VS Code.
Masuk ke menu Extensions
Cari dan instal ekstensi Go (dibuat oleh Go Team at Google).

Instalasi Debugger (Delve)

VS Code memerlukan debugger bernama Delve. Jika Anda belum memilikinya, instal dengan menjalankan perintah berikut di terminal:

go install github.com/go-delve/delve/cmd/dlv@latest

Konfigurasi Debug (launch.json)

Agar VS Code tahu bagaimana cara menjalankan aplikasi Anda dalam mode debug, Anda perlu membuat file konfigurasi:

Buka menu Run and Debug di sidebar kiri VS Code
Klik tautan create a launch.json file, lalu pilih Go: Launch Package.

VS Code akan otomatis membuat folder .vscode beserta file launch.json. Pastikan isinya seperti ini:

{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "Launch Package",
            "type": "go",
            "request": "launch",
            "mode": "auto",
            "program": "${workspaceFolder}"
        }
    ]
}

Menjalankan Sesi Debugging

Buka kembali file main.go.
Pasang Breakpoint (titik merah) dengan cara mengklik bagian sebelah kiri nomor baris pada baris kode berikut:

        hasil := kuadrat(i)

Tekan F5 pada keyboard Anda (atau klik Run -> Start Debugging).

Program akan berjalan dan berhenti (pause) tepat di baris yang ada titik merahnya.

Menggunakan Kontrol Debugger

Saat program terjeda di breakpoint, Anda bisa mengamati panel sebelah kiri VS Code:

Variables: Anda bisa melihat nilai variabel i dan hasil saat itu secara real-time.

Tombol Navigasi (di bagian atas):

Lanjutkan atau Jeda F5: Melanjutkan eksekusi program hingga breakpoint berikutnya, atau menjeda program yang sedang berjalan.
Lewati (Step Over) F10: Menjalankan baris kode saat ini tanpa masuk (step into) ke dalam pemanggilan fungsi di baris tersebut.
Masuk (Step Into) F11: Masuk ke dalam definisi fungsi yang dipanggil pada baris kode saat ini.
Keluar (Step Out) ⇧F11: Menyelesaikan fungsi yang sedang berjalan dan menjeda kembali di fungsi pemanggilnya.
Mulai Ulang (Restart) ⇧⌘F5: Menghentikan dan memulai ulang aplikasi dengan konfigurasi debug yang sama.
Berhenti (Stop) ⇧F5: Mengakhiri sesi debugging yang sedang berjalan.

Berikut hasil debug console setelah program selesai dijalankan

Reference:

Getting Started with Go: go run and go build

Sahal Mahfudh — Wed, 23 Sep 2026 08:20:29 +0000

Go is a compiled language. This means your human-readable code must be translated into machine code before the computer can execute it.

When you start your journey with Go, the two most important commands you will use daily are go run and go build. While they might seem similar at first glance, they serve entirely different purposes in the software development lifecycle.

Here is a breakdown of how and when to use them.

Creating a Sample Project

Before testing these commands, you need to set up a basic Go project. Open your terminal, create a new directory for your project, and initialize a Go module:

➔ mkdir golang-project
➔ cd golang-project
➔ go mod init golang-project

Next, create a file named main.go inside that folder and add the following code:

package main

import "fmt"

func main() {
    fmt.Println("go is running")
}

1. go run

The go run command is built for quick testing while you write code. When you execute go run main.go, Go works behind the scenes to:

Compile your code into a temporary file.
Run the program immediately.
Delete the temporary file as soon as the program finishes.

How to use:

➔ go run main.go

Output:

go is running

When to use go run:

Active Development: When you are writing code and want to quickly test if your logic works.
Testing Scripts: When you are using Go to write quick, script-like tools where you don't need a permanent executable file cluttering up your directory.

Note: Because go run has to compile the code every single time you execute it, it is not meant for production environments.

2. go build

Use go build when your application is finished and ready to deploy. When you execute this command, Go will:

Compile your code into a permanent, standalone executable file.
Bundle everything your program needs into that single file.
Allow you to run the program on other computers without needing to install Go.

How to use:

➔ go build

After running this command, you will see a new executable file in your directory. On Linux or macOS, it will be named golang-project, and on Windows, it will be golang-project.exe.

➔ ls
go.mod   golang-project   main.go

Changing the Executable Name:
By default, the binary or executable file name matches your project name. To change the name of the executable file, use the -o flag:

➔ go build -o my-custom-app
➔ ls
go.mod         golang-project main.go        my-custom-app

Running go build -o my-custom-app generates the my-custom-app file directly in your project directory.

How to run the built binary:

# On Linux / macOS
➔ ./golang-project
go is running

# On Windows
golang-project.exe

When to use go build:

Production Deployment: When you are ready to ship your application to a server or to your users.
Performance: Because the code is already compiled, running the binary is extremely fast.

Cross-Compilation with go build
Go has a great feature called cross-compilation, which lets you build an app for a completely different operating system right from your current computer.

Just change the GOOS (Operating System) and GOARCH (Architecture) variables when building.

Here is the complete list of simple commands for the major operating systems:

Building for Windows

GOOS=windows GOARCH=amd64 go build -o my-app.exe

Building for Linux

GOOS=linux GOARCH=amd64 go build -o my-app-linux

Building for macOS (Apple Silicon)

GOOS=darwin GOARCH=arm64 go build -o my-app-mac-m1

Building for macOS (Older Intel Macs)

GOOS=darwin GOARCH=amd64 go build -o my-app-mac-intel

Summary Comparison

Feature	`go run`	`go build`
Primary Use	Local development and testing	Production deployment and distribution
Creates a File?	No (uses a hidden temporary file)	Yes (creates a permanent binary executable)
Execution	Compiles and runs automatically	Only compiles; you must run the file manually
Speed	Slower (compiles every time)	Extremely fast (already compiled)

By understanding the difference between these two commands, you will be well on your way to developing and deploying efficient Go applications.

Reference: