Introduction to Golang

Go was created at Google in 2009 because existing languages could not keep up with the demands of large distributed systems. Today, Go powers Docker, Kubernetes, Terraform, and Prometheus. In this block you will explore why Go dominates cloud infrastructure and backend development, and which design decisions (fast compilation, static linking, built-in concurrency) make that possible.

You set up your Go workspace in the DevNinjas Dojo and get familiar with the essential commands: go run, go build, go mod init, and go fmt. By the end of this block you will have created your own module, compiled your first program, and understood how Go projects are organized.

Go is statically typed, yet feels lightweight thanks to type inference (:=). You will work with primitive types, constants, pointers, and the control structures if, switch, and for. Special attention goes to Go-specific choices: for as the only loop, switch without break, and why Go deliberately omits while and ternary operators.

Functions in Go can return multiple values, which fundamentally shapes error handling. You will write functions with named return values, variadic parameters, and closures. Then you organize code into packages and learn Go's visibility rule: uppercase = exported, lowercase = internal.

Slices and maps are the workhorses of everyday Go programming. You will learn the difference between arrays and slices, how append works internally, and why that matters for performance. For maps, you cover initialization, iteration, and when a map is the better choice over a slice. Finally: strings, runes, and UTF-8 in Go.

Go has no classes, but structs with methods provide everything you need for clean data models. You define custom types, attach methods to structs, and decide between pointer receivers and value receivers. Instead of inheritance, Go uses embedding: you compose structs together and see how behavior builds up compositionally.

In Go, a type implements an interface without explicitly declaring it. This principle makes Go code flexible and loosely coupled. You work with the most important standard library interfaces (io.Reader, io.Writer, fmt.Stringer, error) and write your own interfaces that enable real decoupling between packages.

Go has no exceptions. Instead, functions return errors as a second value. You implement the error interface, create custom error types, and use errors.Is, errors.As, and fmt.Errorf with %w for wrapping. You will also learn when panic and recover are appropriate (rarely) and how professional Go code propagates errors in a structured way.

Concurrency is Go's core feature. You start goroutines, communicate via channels, and control data flow with the select statement. Using concrete examples, you build typical patterns: fan-out for parallel processing, pipelines for multi-stage data flows, and buffered channels for controlled decoupling.

Not everything is best solved with channels. You use sync.WaitGroup to wait for goroutines and sync.Mutex for shared data access. The race detector (go run -race) helps you find hidden race conditions. Then you work with context.Context for timeouts and cancellation, the standard mechanism in every Go-based cloud API.

Go ships with one of the best built-in testing frameworks through its testing package. You write unit tests, use table-driven tests as Go's standard pattern, and measure performance with testing.B benchmarks. You also check code coverage with go test -cover and see how tests integrate into CI/CD pipelines.

With Go's net/http package you build a REST-capable HTTP server without any external framework. You define handler functions, use the enhanced routing from Go 1.22+, and serialize data with encoding/json. By the end of this block your own server with multiple endpoints is running in the Dojo, ready for further development.

Professional Go projects follow a clear structure. You work with go.mod and go get for dependency management, understand semantic versioning, and learn the established layout with cmd/, internal/, and pkg/. You also use go vet and golangci-lint to ensure code quality from the start.

Many of the best-known cloud tools (kubectl, docker, helm, terraform) are Go CLIs. You build your own command-line tool using os.Args and the flag package, implement subcommands, and work with exit codes. The result: a compiled binary with no external dependencies that you can run directly on any system.

To wrap up, you assess where Go stands in the cloud ecosystem and which directions are worth pursuing next. From database access with database/sql to gRPC for microservice communication to developing your own Kubernetes operators: you get a concrete roadmap for your next steps after the workshop.