Gorgo Go for Java Programmers

Bridges Java to Go for working programmers. Covers everything from types and control flow through interfaces, goroutines, and idiomatic Go.

Full book PDF Answer key PDF Read as single page

• Author Intro
• 0. How to use this booklet
  • Code Review Rules
  • Idioms
  • Callouts
  • Function Signatures
  • Try It
  • Exercises
• 1. Hello, Go
  • Program Structure
  • Import Blocks
  • Modules
  • Building and Running
  • Exported vs Unexported Identifiers
  • The fmt Package
  • Command-Line Arguments
  • Try It
  • Key Points
  • Exercises
• 2. Types and Variables
  • Basic Types
  • var Declarations and :=
  • Zero Values
  • Integer Literal Prefixes and the Digit Separator
  • Constants
  • Type Casts
  • Type Definitions
  • Type Aliases
  • new and make
  • Built-in min, max, and clear (Go 1.21)
  • The Blank Identifier
  • Structs
  • Pointers
  • Try It
  • Key Points
  • Exercises
• 3. Strings, Bytes, and Runes
  • What a String Really Is
  • byte and rune
  • Indexing and Iteration
  • String Literals
  • Converting Between Strings, Bytes, and Runes
  • The strings Package
  • The strconv Package
  • The unicode/utf8 Package
  • The bytes Package
  • Try It
  • Key Points
  • Exercises
• 4. Control Flow
  • if / else
  • for — the Only Loop
  • range
  • switch
  • Labeled break and continue
  • defer
  • Try It
  • Key Points
  • Exercises
• 5. Functions
  • Function Syntax
  • Multiple Return Values
  • Named Return Values
  • Variadic Functions
  • First-Class Functions
  • Closures
  • init()
  • Function Types as Parameters
  • Pointer vs Value Semantics
  • When Mutation Requires a Pointer
  • Escape Analysis
  • Try It
  • Key Points
  • Exercises
• 6. Objects using Methods and Embedding
  • Receivers and Methods
  • Constructors
  • Destructors
  • Embedding
  • Embedding vs Inheritance
  • Try It
  • Key Points
  • Exercises
• 7. Maps and Slices
  • Maps
  • Arrays
  • Slices
  • Slice Literals and make
  • append
  • copy
  • Slicing Expressions
  • Slice Aliasing
  • Passing Slices to Functions
  • Multidimensional Slices
  • The slices Package (Go 1.21+)
  • clear on a Slice (Go 1.21)
  • Try It
  • Key Points
  • Exercises
• 8. Interfaces
  • Implicit Interface Satisfaction
  • Interface Composition
  • any — The Top Type
  • Type Assertions
  • Type Switches
  • Key Standard Library Interfaces
  • Accept Interfaces, Return Structs
  • The Interface Nil Trap
  • Try It
  • Key Points
  • Exercises
• 9. Error Handling
  • The error Interface
  • Creating Errors
  • Wrapping Errors
  • errors.Is and errors.As
  • errors.Join — Combining Multiple Errors
  • Sentinel Errors
  • Custom Error Types
  • panic and recover
  • The must Idiom
  • Go Error-Handling Proverbs
  • Try It
  • Key Points
  • Exercises
• 10. Goroutines and Channels
  • Goroutines
  • Channels
  • Buffered vs Unbuffered Channels
  • Closing a Channel
  • The select Statement
  • Share Memory by Communicating
  • Try It
  • Key Points
  • Exercises
• 11. Synchronization
  • The Go Memory Model
  • sync.Mutex and sync.RWMutex
  • sync.WaitGroup
  • sync.Once
  • sync.Cond
  • sync/atomic
  • The Race Detector
  • Try It
  • Key Points
  • Exercises
• 12. Context and Concurrency Patterns
  • context.Context
  • Cancellation, Deadlines, and Timeouts
  • context.WithValue
  • Context as First Parameter
  • errgroup — Fan-Out with Error Collection
  • Goroutine Leak Detection
  • GOMAXPROCS
  • Worker Pool
  • Rate Limiting
  • Try It
  • Key Points
  • Exercises
• 13. Packages and Modules
  • Package Naming
  • Exported vs Unexported Symbols
  • go.mod and go.sum
  • go get, go mod tidy, go mod vendor
  • Internal Packages
  • Standard Project Layout
  • Go Workspaces
  • Major Version Suffixes
  • Build Tags
  • //go:embed
  • Try It
  • Key Points
  • Exercises
• 14. Essential Standard Library
  • fmt — Revisited
  • io — The Glue of Go I/O
  • bufio — Buffered I/O
  • os — Files and the Process Environment
  • os/exec — Running Subprocesses
  • flag — CLI Flag Parsing
  • time — Clocks, Durations, and Timers
  • path/filepath — Cross-Platform Path Manipulation
  • log/slog — Structured Logging
  • regexp — Regular Expressions
  • cmp and maps — Comparison and Map Utilities
  • iter — Iterators
  • encoding/base64 — Base64 Encoding
  • crypto/rand and math/rand/v2 — Random Numbers
  • crypto/sha256, crypto/aes, crypto/cipher — Hashing and Encryption
  • Try It
  • Key Points
  • Exercises
• 15. JSON, HTTP, and the Web
  • Encoding JSON
  • Making HTTP Requests
  • Building an HTTP Server
  • OAuth 2.0
  • Live Profiling with net/http/pprof
  • Encoding XML
  • Raw Networking with net
  • TLS with crypto/tls
  • Try It
  • Key Points
  • Exercises
• 16. gRPC
  • Protocol Buffers
  • The protoc Toolchain
  • Building a gRPC Server
  • Calling a gRPC Server
  • The Four Kinds of RPC
  • Deadlines and Metadata
  • Errors and Status Codes
  • Interceptors
  • TLS
  • Client Authentication
  • Try It
  • Key Points
  • Exercises
• 17. Database Access
  • The sql.DB Connection Pool
  • Querying the Database
  • Scanning Results
  • Nullable Column Values with sql.Null[T]
  • Transactions
  • Prepared Statements
  • Driver Registration
  • pgx — The PostgreSQL Driver
  • Try It: A Small Music Store
  • Key Points
  • Exercises
• 18. Generics
  • Type Parameters
  • Constraints
  • The Tilde Syntax
  • comparable vs any — Map Keys
  • The slices Package (Go 1.21)
  • The maps Package (Go 1.21)
  • The cmp Package (Go 1.21)
  • The iter Package (Go 1.23)
  • The unique Package (Go 1.23)
  • Generic Type Aliases (Go 1.24)
  • When NOT to Use Generics
  • Try It
  • Key Points
  • Exercises
• 19. Testing
  • The testing.T Type
  • Table-Driven Tests
  • t.Helper()
  • t.Cleanup: Teardown the Idiomatic Way
  • Test Contexts and Artifacts
  • t.Parallel: Running Tests Concurrently
  • Deterministic Concurrency with testing/synctest (Go 1.25)
  • Benchmarks
  • Fuzzing
  • Example Tests
  • Testing HTTP Handlers with httptest
  • Race Detector
  • Goroutine Leak Detection
  • Integration Tests and Build Tags
  • Running Tests
  • Try It
  • Key Points
  • Exercises
• Appendix A: Go Proverbs
  • Don’t communicate by sharing memory; share memory by communicating
  • Concurrency is not parallelism
  • The bigger the interface, the weaker the abstraction
  • Accept interfaces, return concrete types
  • Make the zero value useful
  • The empty interface says nothing
  • Errors are values
  • Don’t just check errors, handle them gracefully
  • A little copying is better than a little dependency
  • Clear is better than clever
  • gofmt’s style is no one’s favorite, yet gofmt is everyone’s favorite
  • Cgo is not Go
  • Cgo must always be guarded with build constraints
  • Syscall must always be guarded with build constraints
  • With the unsafe package there are no guarantees
  • Reflection is never clear
• Appendix B: Tooling
  • gofmt and goimports
  • go vet
  • go fix
  • golangci-lint
  • go doc and godoc
  • gopls
  • Delve
  • go build -gcflags=-m
  • Summary
• Appendix C: Go Code Review Rules
  • Formatting
  • Comments
  • Context
  • Copying
  • Cryptographic Randomness
  • Declaring Empty Slices
  • Error Strings
  • Don’t Panic
  • Examples
  • Goroutine Lifetimes
  • Handle Errors
  • Imports
  • Import Blank
  • Import Dot
  • In-Band Errors
  • Indent Error Flow
  • Initialisms
  • Interfaces
  • Line Length
  • Mixed Caps
  • Named Result Parameters
  • Package Comments
  • Package Names
  • Pass Values
  • Receiver Names
  • Receiver Type
  • Synchronous Functions
  • Useful Test Failures
  • Variable Names