Learning Golang - History, Background & Why You Need Golang

#Introduction

Before memorizing syntax, it's important to understand why Go exists. Every language is born to solve real problems, and Go was born out of a Google team's frustration with slow compilation times, complicated concurrency, and large codebases that were hard to maintain.

Episode 1 takes you through Go's history from 2007 to today, the design philosophy that underpins it, an honest comparison with other popular languages, and when you should choose Go. Understanding this context will make the architectural decisions in later episodes feel much more reasonable.

#The Origins of Go at Google

#The Birth in 2007

Go was designed in 2007 by Robert Griesemer, Rob Pike, and Ken Thompson — three veterans with backgrounds in Unix, Plan 9, and distributed systems. They complained about C++ build speed at Google, dependency management complexity, and the potential for bugs from languages with too many features.

Go's first public release came in 2009, and the stable 1.0 version followed in March 2012. Since then, the commitment to backward compatibility has been very strong: Go 1.0 code can be recompiled with Go 1.23 without significant changes. Check your toolchain version with go version.

#Version Timeline

Each minor release brings significant features. Go 1.5 introduced the concurrent garbage collector, Go 1.11 brought the module system, Go 1.18 introduced generics, Go 1.21 added the slices and maps packages, and Go 1.22 updated net/http routing with methods and path wildcards. Version 1.23 strengthened iteration with the iter feature for range over functions.

#Language Philosophy: Simplicity, Concurrency, and Tooling

#Simplicity as the Core Feature

Go deliberately limits the number of keywords and features. There is no class inheritance, no complex generics at first, and no exceptions. The Go team believes that easy-to-read code is more valuable than expressive code that is hard to understand.

package main
 
import "fmt"
 
func main() {
	for i := 1; i <= 3; i++ {
		fmt.Println("iterasi", i)
	}
}

#Concurrency as a First-Class Citizen

Concurrency is the core of Go's identity. The go keyword in front of a function starts a goroutine, a lightweight thread managed by the runtime rather than the operating system. Go's scheduler handles millions of goroutines with far less memory than native threads.

package main
 
import (
	"fmt"
	"time"
)
 
func main() {
	go fmt.Println("dari goroutine")
	time.Sleep(10 * time.Millisecond)
	fmt.Println("dari main")
}

#Built-in Tooling

Go ships with a unified toolchain: go fmt for automatic formatting, go vet for static analysis, go test for testing, go mod for dependencies, and go tool pprof for profiling. You don't need to install dozens of separate tools.

#Differences from Other Languages

#Java and C++

Compared to Java, Go has no class hierarchy and no exceptions, which means faster build cycles and smaller binaries. Compared to C++, Go removes templates and manual memory management — the garbage collector handles it, while pointers remain available for allocation control.

#Python and Rust

Python excels at development speed and the data science ecosystem, but it is slow and depends on an interpreter in production. Rust offers memory control without a GC through ownership, but the learning curve is much steeper. Go sits in the middle: as easy to learn as Python, as fast as C for many workloads, and safe enough for production without sacrificing productivity.

#When Go Is the Right Choice

#Backend, Cloud-native, and Network Systems

Go is an excellent fit for server-side work: HTTP servers, REST APIs, gRPC, CLI tools, and data pipelines. The cloud-native ecosystem — Kubernetes, Docker, Terraform, Prometheus, and Grafana — is written in Go. Single static binary support makes deploying to containers trivial.

#Microservices and Distributed Systems

For microservice architectures, Go offers an ideal compromise between performance, ease of use, and a low footprint. Compile-time type safety reduces production bugs, while net/http and the rich standard library reduce external dependencies.

CGO_ENABLED=0 go build -o app main.go
file app

The output of file app shows statically linked — a binary with no system dependencies. That means you can copy this file into a distroless container or a machine without any runtime.

#Closing

Episode 1 explains why Go exists and where it stands among other languages. You now understand Go's history at Google, the philosophy of simplicity and concurrency, its differences from Java, C++, Python, and Rust, and the criteria for when Go is the right choice for backend, cloud-native, and microservices.

Key takeaways:

• Go was born in 2007 to address slow builds and the complexity of Google's codebases.
• Backward compatibility has been strictly maintained since Go 1.0.
• Its core philosophy: simplicity, concurrency, and built-in tooling.
• Goroutines are lightweight threads managed by the Go runtime.
• Static binaries make Go ideal for containers and deployment.
• The cloud-native stack, including Kubernetes and Prometheus, is written in Go.

In the next episode we will discuss core concepts and the key architecture — how the Go runtime works behind the scenes, such as the garbage collector and goroutine scheduler, the main standard packages like fmt, net/http, and context, and how modules and go mod shape your project architecture. This is the technical foundation before you write real programs in episode 3.