GoLang Course in Pune
Go Programming, Concurrency & Cloud-Native Backend Development

Go's syntax is intentionally minimal — the designers removed features rather than adding them, resulting in a language where there is typically only one correct way to do something. This predictability is one of Go's great strengths in team environments, and it means the language is genuinely fast to learn once you stop expecting it to resemble Java or Python.

The Go toolchain: go run (compile and execute), go build (compile to binary), go fmt (format code), go vet (static analysis), go test (run tests), go mod (dependency management), and the workspace concept. Go's type system: basic types (int, int8, int16, int32, int64, uint variants, float32, float64, complex128, bool, string, byte, rune), type inference with := inside functions, typed vs untyped constants, and iota for enumeration. Go's package system: the GOPATH and module-based development (go.mod), packages as the unit of code organisation, package naming conventions, and the init() function. Functions: multiple return values (Go's idiomatic error handling pattern), named return values, variadic functions, first-class functions and closures, and defer (executing a function call when the surrounding function returns). Arrays vs slices: slices as the primary collection type — length and capacity, the make function, append and the growth strategy, slice expressions, and the common gotcha of two slices sharing the same underlying array. Maps: creation with make and literal syntax, the comma-ok idiom for checking key existence, deleting keys, and iterating with range. Pointers: Go uses pointers but not pointer arithmetic — the & and * operators, passing by value vs passing a pointer, and when to use each. Structs: field definition, struct literals, embedded structs, and anonymous fields.

Go's interface system is fundamentally different from Java or C# interfaces — and understanding this difference is what makes Go code genuinely idiomatic. Go's error handling is explicit by design — and understanding why the designers chose this approach changes how you think about robust software. This module covers both with the depth they deserve.

Interfaces in Go: interface satisfaction is implicit — there is no implements keyword. Any type that has the methods of an interface satisfies it automatically. This enables loosely coupled code and easy mocking for testing. The io.Reader and io.Writer interfaces as the canonical example of Go's interface philosophy. Empty interface (any): when to use it and the type assertions needed to work with it safely. Type switches for handling multiple types. Stringer interface and how the fmt package uses interfaces for formatting. Interface composition: embedding interfaces to create new ones. The error interface: in Go, errors are just values — any type implementing the Error() string method satisfies error. The idiomatic error handling pattern: if err != nil { return nil, err }. Creating custom error types with additional context. Error wrapping with fmt.Errorf and %w, and errors.Is() and errors.As() for unwrapping. Sentinel errors vs error types. The panic and recover mechanism: when to use panic (truly unrecoverable situations, programming errors), and how recover() in a deferred function catches panics. Why panic is not for normal error handling in Go. Generics (Go 1.18+): type parameters, constraints, and the practical use cases — generic data structures, generic utility functions — without the complexity that generics bring in other languages.

This is the module that makes Go developers valuable. Go's concurrency model — goroutines and channels — is one of the most productive approaches to concurrent programming in any mainstream language. The Go motto for concurrency: "Do not communicate by sharing memory; instead, share memory by communicating." Understanding this principle and implementing it with channels is what Go concurrency mastery looks like.

Goroutines: launching with the go keyword, the Go scheduler and how it multiplexes goroutines onto OS threads (M:N threading model), goroutine lifecycle, and goroutine leaks — the silent bug where goroutines accumulate because nothing ever stops them. Channels: creating buffered and unbuffered channels, sending and receiving, channel direction in function signatures (chan<- for send-only, <-chan for receive-only), closing channels and ranging over them, the nil channel. The select statement: multiplexing over multiple channel operations, the default case for non-blocking operations, and using select with a context for cancellation. Common concurrency patterns: fan-out (distributing work across multiple goroutines), fan-in (merging results from multiple goroutines), worker pools (limiting concurrency to N workers), pipeline stages (chaining goroutines with channels), and the done channel pattern for cancellation. The sync package: WaitGroup for waiting on a group of goroutines, Mutex and RWMutex for protecting shared state when channels are not the right tool, Once for one-time initialisation, and atomic operations with sync/atomic. Race condition detection with go run -race: Go's built-in race detector that catches data races at runtime. The context package: context.Background(), context.WithCancel(), context.WithTimeout(), and context.WithDeadline() for propagating cancellation signals through goroutine trees — the standard pattern for every Go HTTP server and database operation.

Go's standard library net/http package is powerful enough to build production HTTP servers without any framework — and understanding it is important. But for most API projects, the Gin framework provides routing, middleware, validation, and response helpers that dramatically reduce boilerplate while adding negligible overhead. Gin is the most popular Go web framework and a standard choice for Go REST APIs.

Building a raw HTTP server with net/http first: http.HandleFunc, http.ListenAndServe, reading request bodies and writing responses, and the http.Handler interface. Understanding why Go's standard library HTTP server is itself already concurrent — each request is handled in a separate goroutine automatically. Gin setup: gin.Default() vs gin.New() and the difference, router groups for versioning (/api/v1), the Context object (c.JSON, c.Bind, c.ShouldBind, c.Param, c.Query, c.Header). Middleware: writing custom middleware with gin.HandlerFunc, the Logger and Recovery middleware, CORS middleware with gin-contrib/cors, and rate limiting. Request validation with go-playground/validator: struct tags for validation rules, binding and validation together, and custom validators. Response standardisation: a consistent JSON response envelope, HTTP status code helpers, and the gin.H shorthand. Authentication middleware: JWT token extraction and validation, attaching the user to the Gin context, and protecting routes with middleware groups. File upload handling in Gin. API documentation with Swagger using swaggo/swag: annotating handlers with Swagger comments and generating OpenAPI documentation automatically. Graceful shutdown: using context and OS signals to drain in-flight requests before shutting down the server.

Go's approach to database access is different from Python's SQLAlchemy or Java's Hibernate. The Go community generally favours closer-to-SQL approaches rather than heavy ORMs — and SQLC, which generates fully type-safe Go code from SQL queries, represents the most idiomatic and production-popular approach for Go + PostgreSQL development.

Database/sql package: the standard library interface for SQL databases, the pgx PostgreSQL driver, connection pool configuration (MaxOpenConns, MaxIdleConns, ConnMaxLifetime), prepared statements, and transaction handling with db.BeginTx. SQLC: the tool that reads your SQL schema and query files and generates type-safe Go functions — no more strconv conversions from interface{}, no runtime SQL errors because of column name typos. Writing SQLC schema files, query files (with -- name: QueryName :one/:many/:exec annotations), and understanding the generated code. CRUD operations with SQLC: the generated structs, Create/Get/List/Update/Delete functions, and how to use them in service layer code. Database migrations with golang-migrate: creating versioned up/down migration files, running migrations programmatically at application startup, and integrating with CI/CD pipelines. Transactions in SQLC: db.BeginTx, defer tx.Rollback() pattern, and tx.Commit() — the Go idiom for safe transaction management. PostgreSQL-specific features from Go: JSONB columns, arrays, NULL handling with pgtype, and full-text search. Connection string management with environment variables and the viper configuration library. The repository pattern in Go: defining an interface for all database operations and implementing it with SQLC-generated code — enabling easy mock testing.

Secure authentication and performant caching are requirements for every production API. This module covers both with the implementation depth that professional Go development demands.

Password hashing with bcrypt in Go: golang.org/x/crypto/bcrypt — bcrypt.GenerateFromPassword for hashing and bcrypt.CompareHashAndPassword for verification, cost factor selection. JWT authentication with golang-jwt/jwt: generating signed tokens with custom claims, parsing and validating tokens, refresh token rotation. Paseto (Platform-Agnostic SEcurity TOkens) as a modern JWT alternative: why Paseto is more secure than JWT by default (no algorithm confusion attacks, no Base64 JSON tampering), the token package for implementing Paseto v4 in Go, and why many Go API projects prefer Paseto. Secure token storage: httpOnly cookies vs Authorization header — the tradeoffs for different client types. Role-based access control in Go: adding a role field to the user model, middleware that checks the role from the token claims. Input sanitisation and SQL injection prevention in Go: why SQLC's parameterised queries make SQL injection impossible, and validating and sanitising user input before database operations. Rate limiting in Go: the golang.org/x/time/rate token bucket implementation for per-IP and per-user rate limiting. Redis with go-redis: connecting to Redis, String commands (SET, GET, SETEX, DEL), Hash commands for session storage, and implementing a caching layer middleware that checks Redis before hitting PostgreSQL for expensive queries. Cache invalidation strategies and TTL management.

REST over HTTP/JSON is simple and universally understood — but it has performance costs for service-to-service communication inside a system. gRPC uses HTTP/2 and Protocol Buffers (a binary serialisation format 5-10x smaller and faster than JSON) for inter-service communication. Go was the first language with first-class gRPC support, and gRPC + Go is a combination used at scale by Google, Uber, Lyft, and many high-throughput systems.

Protocol Buffers: the IDL (Interface Definition Language) for defining services and messages in .proto files, field types, field numbers (why they matter for backward compatibility), optional vs required fields (and why Proto3 removed required), nested messages, enums, and the oneof field for sum types. Generating Go code from .proto files with protoc and the protoc-gen-go and protoc-gen-go-grpc plugins. gRPC service types: Unary RPC (one request, one response — like REST), Server Streaming RPC (one request, stream of responses), Client Streaming RPC, and Bidirectional Streaming RPC. Implementing a gRPC server in Go: registering service implementations, starting the gRPC server, and handling interceptors (middleware for gRPC). Implementing a gRPC client in Go: creating a connection, calling unary and streaming RPCs, and handling errors. gRPC metadata: the equivalent of HTTP headers — sending authentication tokens and custom metadata with requests. gRPC error handling: the status package, error codes (OK, NotFound, PermissionDenied, InvalidArgument), and converting between gRPC errors and HTTP status codes when exposing gRPC services via a REST gateway. The gRPC-Gateway plugin: generating a RESTful HTTP proxy in front of a gRPC service so that browser clients can use familiar REST endpoints while internal services use efficient gRPC.

Go's compiled-to-binary nature makes it uniquely well-suited to container deployment. A Go application with zero external runtime dependencies can be packaged into a Docker image using a scratch (empty) base — producing containers under 10MB that start in milliseconds. This module covers containerisation and orchestration with the detail that production Go deployments require.

Multi-stage Docker builds for Go: Stage 1 uses a full Go builder image to compile the binary. Stage 2 uses a distroless or scratch base image containing only the compiled binary. The result is a tiny, secure container with no shell, no package manager, and no unnecessary software. Configuring the Go binary for container environments: CGO_ENABLED=0 and GOOS=linux for cross-compilation, COPY with explicit file permissions, and non-root users. Docker Compose for local development: running the Go API, PostgreSQL, and Redis together with a single command, health checks for dependencies, and volume mounts for development hot-reload with air. Kubernetes fundamentals: Pods (the smallest deployable unit), Deployments (desired state and rolling updates), Services (ClusterIP, NodePort, LoadBalancer), ConfigMaps (non-sensitive configuration), and Secrets (sensitive configuration like database passwords). Writing Kubernetes manifests for a Go microservice: Deployment with resource limits and requests, readiness and liveness probes pointing to the Go API health endpoint, and HorizontalPodAutoscaler for automatic scaling based on CPU. Kubernetes namespaces and RBAC basics. Deploying to Google Cloud Run: a serverless container service that automatically scales Go services to zero when idle and handles HTTPS, domains, and load balancing. GitHub Actions CI/CD pipeline: building the Docker image, pushing to Google Container Registry or Docker Hub, and deploying to Cloud Run on every push to main.

Production Go services need comprehensive testing, observability (knowing what is happening inside a running service), and engineers who can discuss the language and system design confidently in interviews. This module covers all three.

Go testing package: unit tests (func TestXxx(t *testing.T)), table-driven tests (the Go idiom for testing multiple input/output cases with a single test function), test helpers and t.Helper(), test coverage with go test -cover, and the -race flag for detecting race conditions in tests. Mocking in Go: the mockery tool for generating mocks from interfaces — mocking the repository layer to test service logic without a real database, and using gomock for expectations-based mocking. Integration testing with testcontainers-go: spinning up real PostgreSQL and Redis containers from within test code for integration tests that test the actual database interactions. Observability: structured logging with the zerolog library (JSON log output with fields, level-based filtering), distributed tracing concepts (trace ID propagation through request context), and metrics with the Prometheus Go client (counters, gauges, histograms, exposing the /metrics endpoint). Profiling Go applications with pprof: CPU profiling, memory profiling, goroutine dumps, and using the go tool pprof UI to identify hotspots. Capstone project: students build a complete Go microservice of their choice — a payment processing API, a URL shortener with analytics, a real-time notification service using goroutines and Server-Sent Events, or a distributed task queue. The project includes a full test suite, a Dockerfile, a Kubernetes deployment manifest, and a GitHub Actions CI/CD pipeline. Go interview preparation: the most common Go interview questions (goroutines vs threads, channels, defer, interfaces, the context package, garbage collection, memory model), system design in Go (designing a rate limiter, designing a job queue), and LeetCode Go problem solving practice.