Go: Mastering Google's Go (Golang) Programming

Explore the Go playground to run hello world, learn about package main and func main, and print using the format package while observing unicode runes.

Learn how to structure a Go project with a proper directory layout, set the Go path, build and run programs, and enforce Go formatting for consistent code style.

Explore Go doc and online documentation for Go libraries like the format package. Learn variable declarations with var and :=, types, constants, iota, zero values, and printing with print f.

Master Go strings by indexing, slicing, and iterating with range. Learn len and printing, and explore raw string literals with backticks and escaping double quotes when needed.

Learn Go control structures by handling print return values and errors with inline if declarations, and explore variable scope, short variable declarations, and concise error handling patterns.

Discover how Go's switch statement cleanly handles multiple cases, including errors and bytes printed, with no implicit breaks, and learn to count vowels and consonants using ranges.

Explore how Go uses a single for loop to implement infinite, while-style, and traditional loops. Learn compact multi-variable loops with simultaneous assignment and examples like Hello world.

Learn how to define functions in Go, handle parameters and returns, manage errors, and use defer, named returns, and dot dot dot with range for printing messages.

Explore arrays and slices in Go: arrays are fixed memory and copied when passed, while slices are lightweight, reference-like views into an underlying array you can slice with indices.

Discover how slices replace arrays in go by using make to allocate, append to grow capacity, and copy to create independent data while tracking len and cap.

Explore how Go maps work by mapping month names to days, using make or a map literal, handling missing keys with the comma ok idiom, and iterating or deleting entries.

Explore how byte slices power Go IO by reading from files into a byte slice, converting to strings, and back, with hex printing, error handling, and type conversions.

Explore idiomatic Go error handling by returning and checking errors from functions, using format and errors packages to create custom errors, and understanding why panics are rare.

Start go routines to run concurrently and communicate via channels. Create and close channel, send strings, receive with range, and handle closed channel with ok value.

Learn how to send a channel over a channel in Go, implement a channel of strings, and receive nested channels to asynchronously yield words until the channel closes.

Master Go concurrency by building a parallel web page size downloader using goroutines and channels, with worker pools and channel-based coordination.

Learn how closing a channel coordinates goroutines in Go by broadcasting a signal to start or stop, using a stop channel and select for synchronized, concurrent execution.

Explore using nil channels in Go to make select cases non blocking, disabling receive or send by setting a channel to nil, and time-based control of goroutines.

Explore how buffered channels in Go act as a semaphore to control concurrency by capacity. Track running workers using atomic counters from the sink package.

Define a web page struct with the type keyword, attaching methods and using pointer receivers to mutate url, body, and error. Show a slice sum method.

Explore how Go uses interfaces to implement behavior-based object orientation, requiring Len and Swap for any shuffler, enabling duck-typing style flexibility across int and string slices.

Explore how the empty interface allows handling unknown types at runtime, learn type assertions and type switches to determine and use values safely in Go.

Learn how to structure Go projects with packages, export and import, and initialize packages using init, while building a shuffler package with interfaces and weighted shuffling.

Master the go tool chain to build, install, run, format, vet, and test Go programs, and understand the differences between go install, go build, and go run.

Learn how go test runs unit tests for packages, write and run tests to find and fix bugs in a poetry package that counts vowels, consonants, and punctuation.

Learn how the Go format package uses verbs like %v and %T to print complex types, strings, and booleans, and how to implement Stringer for custom formatting.

Explore go's os, io, and bufio packages to open, read, and write files; use buffered I/O and scanners to handle line oriented data through the io interfaces.

Explore building and testing a simple Go net/http web server, including handle functions, request parsing, query parameters, form values, and basic error handling.

Master Go's encoding/json package to marshal and unmarshal data with encoder and decoder, and load configuration from json to drive a poetry server program.

Learn to manipulate strings with Go's strings package, count words, split and join text, and use strconv and sort to convert data and shuffle lines.

Learn to use the Go sync package to protect a shared cache with mutex and wait group. Explore when channels or synchronization primitives are best.

Learn to use Go's log and log/syslog packages to emit run-time messages, errors, and fatal events with configurable flags (microseconds, prefixes) and output targets (stdout, files, or syslog).

Explore the Go flag package to parse command line options, using string flags and pointer vs value approaches, with examples for default values, usage, and error handling.

Explore how Go's time package handles date and time, formatting, durations, time zones, and nanosecond precision. See practical examples measuring startup time with time.Now, time.Since, and time.Format.

Learn how to link Go with C using cgo to call Free Image Library functions for degrading JPEG. Understand cgo directives, ld flags, and converting between Go and C types.

Explore Go syntax through for loops, break and continue, including labeled breaks and range-based counting of even numbers; refactor a switch statement to handle zero, even, and default cases.

Master switch statements in Go by using break, continue, labels, and default cases, handling negative numbers with abort logic and the errors package.

Explore how to declare variables in Go, understand scope and shadowing, and learn redeclaration rules and how to manage multiple declarations in conditionals and slices.

Learn how buffered channels and the select statement implement a leaky buffer pool in Go, reusing up to ten buffers via a worker and controller, with default drops when full.

Explore anonymous structures and anonymous interfaces in Go by using in-line type literals for translations, JSON marshalling, and runtime type assertions.

Explore how Go uses struct embedding to combine fields and methods from parent structures, enabling extended functionality and examples like uppercasing text.

Learn how to use must in Go by employing must compile to panic on errors, eliminate useless code, and ensure fast failure when regex compilation or template setup fails.

Explore how the defer statement in Go closes resources, executes in reverse order, and evaluates arguments early, with an anonymous function for error handling using the errors package.

Learn how to generate and work with errors in Go, using the error type, errors and fmt packages, and custom error types.

Go workspace layout, build and run tools, and simple packages like EE Cummings and Shelter; test with go test, assess coverage with -cover, and inject version data using ldflags.

Learn how comparison works in Go, including basic types, structs, interfaces, and maps, and identify which types are comparable and why slices are not.

Learn how to use maps as sets in Go by using an anonymous empty struct as the key, checking presence with the ok value, and a tri-state boolean approach.

Explore how interfaces serve as map keys in Go by using an io.Writer to boolean map to enable or disable outputs, including buffers and standard streams.

Understand how slices in Go are pointers to an underlying array with length and capacity, and how append and slicing affect memory and references.

Learn to use the pprof tool in Go to identify memory allocations and growth, generate profiles, and visualize hotspots with graphs to optimize garbage collection.

Explore reducing garbage in Go by using a sink pool to recycle buffers across many goroutines. See how automatic pool management stabilizes heap size and improves memory efficiency.

Explore how methods and interfaces in Go use pointer and value receivers, and how method values treat methods as functions, illustrated by the yelling string example.

Examine how Go interfaces can be tested for satisfaction at compile time by assigning to a blank variable, enabling partial implementations and test-scoped interface checks.

Explore how using interfaces in Go simplifies mocking in unit tests, replacing concrete types with an io reader, and testing read and shout functionality with string inputs.

Explore how Go routines synchronize with buffered channels, use read and write channels, and orchestrate termination with context and done channels to prevent deadlocks.

Explore Go tools to improve large codebases, including go fmt, go vet, and go lint, and learn how Go list reveals package information, imports, and dependencies.

Profile a Go program with pprof to identify bottlenecks in a least recently used cache. Replace map-based eviction with a list-based LRU to boost performance.

Learn idiomatic Go by embracing Go fmt, keeping the main flow left with minimal indentation, returning on error, and using switch over long if chains for clarity.

Learn how to manage time in Go using the time duration type, parse durations with the flag package, and avoid unit confusion by using explicit duration values.

Learn go's no-exception approach by returning an error value from functions, using the error type, and avoiding panic, recover, and nil pointers as errors.

Explore how Go's common interfaces, such as stringer, reader, and writer, enable printing, reading, and writing across custom types, and use interfaces to decouple code and simplify testing.

Learn how to write idiomatic Go comments that power Go doc and produce clear package, type, and method documentation, using consistent English sentences.

Explore how Go manages external dependencies with the vendor directory and the vendor experiment. Learn to import via vendor paths, disambiguate copies, and keep dependencies updated within a single workspace.

Build a Go work system with goroutines, channels, and interfaces that reads lines from standard input, creates tasks via a factory, and processes them in parallel with a worker pool.

master the database/sql interface in go by connecting to a database with a driver, preparing and executing queries, scanning rows, and using transactions to update data.

Learn to build a simple Go API that serves and updates a database of scientists using net/http, encoding/json, and database/sql, returning JSON responses for GET and POST requests.

Master Go’s approach to concurrency and build concurrent programs that access web resources and run parallel tasks, while enjoying a fully featured language familiar to C, Python, and Java developers.