Go Programming Masterclass

Topics Covered

• What is Go? History, creators (Google), and philosophy
• Go's design principles: simplicity, reliability, efficiency
• Why Go? Use cases and advantages
• Go vs other languages: Python, Java, Rust, C++
• Go ecosystem and community
• Installing Go (latest stable version)
• GOPATH and Go Modules explained
• Setting up development environment: VS Code with Go extension
• GoLand IDE setup (optional)
• Understanding Go workspace structure

• Your first Go program: Hello, World!
• Go program structure: package, import, main function
• Running and building Go programs
• go run, go build, go install commands
• Comments: single-line (//) and multi-line (/* */)
• Go documentation with godoc
• gofmt for code formatting
• Go conventions and effective Go guidelines

Topics Covered

• Variables: declaration with var keyword
• Short variable declaration with :=
• Variable naming conventions in Go
• Zero values in Go
• Basic data types: bool, string, int, float64
• Integer types: int8, int16, int32, int64, uint variants
• Floating-point types: float32, float64
• Complex numbers: complex64, complex128
• Type inference in Go
• Constants with const keyword

• Iota for enumerated constants
• Type conversion and type assertion
• Operators: arithmetic (+, -, *, /, %, ++, --)
• Comparison operators: ==, !=, <, >, <=, >=
• Logical operators: &&, ||, !
• Bitwise operators: &, |, ^, &^, <<, >>
• Assignment operators: =, +=, -=, *=, /=, %=
• Operator precedence
• String operations and string formatting
• fmt package for formatted I/O

Topics Covered

• If statements in Go (no parentheses required)
• If with initialization statement
• If-else and else-if chains
• Switch statement: more powerful than other languages
• Switch without expression (replaces if-else chains)
• Switch with multiple cases
• Type switch for interface types
• For loop: Go's only loop construct
• Classic for loop with initialization, condition, post
• While-style for loop

• Infinite loops with for
• Range loops for arrays, slices, maps, channels
• Break and continue statements
• Labeled break and continue
• Goto statement (rarely used)
• Functions: first-class citizens in Go
• Function declaration and parameters
• Multiple return values
• Named return values
• Variadic functions with ...
• Anonymous functions and closures
• Functions as values and parameters
• Recursion in Go

Topics Covered

• Arrays: fixed-size sequences
• Array declaration and initialization
• Array literals and zero values
• Iterating arrays with for and range
• Multidimensional arrays
• Slices: dynamic arrays
• Creating slices with make()
• Slice literals
• Slice internals: pointer, length, capacity
• Appending to slices with append()

• Copying slices with copy()
• Slicing operations and reslicing
• Nil slices vs empty slices
• Maps: Go's hash tables
• Creating maps with make() and literals
• Adding, updating, deleting map entries
• Checking key existence with comma ok idiom
• Iterating maps with range
• Maps of structs
• Nested maps
• Common slice and map patterns

Topics Covered

• Structs: custom types in Go
• Struct declaration and fields
• Struct literals and zero values
• Anonymous structs
• Nested structs and embedded fields
• Struct tags for JSON, XML, database
• Methods: functions with receivers
• Value receivers vs pointer receivers
• When to use pointer receivers
• Method sets and interfaces

• Struct composition over inheritance
• Embedding structs for composition
• Promoted fields and methods
• Constructor functions in Go
• Factory patterns
• Encapsulation with exported/unexported fields
• Getters and setters conventions
• String() method for custom string representation
• Comparing structs
• Anonymous struct fields

Topics Covered

• Interfaces: defining contracts
• Interface declaration and implementation
• Implicit interface satisfaction
• Empty interface: interface{}
• Type assertions and type switches
• Interface composition
• Common interfaces: Stringer, error, io.Reader, io.Writer
• Polymorphism through interfaces
• Duck typing in Go
• Interface best practices

• Small interfaces principle
• Accept interfaces, return structs
• Interface segregation
• Dependency injection with interfaces
• Mocking with interfaces for testing
• Sort interface implementation
• Custom sorting with sort.Interface
• Error interface and custom errors
• Wrapping errors
• Interface values: dynamic type and value

Topics Covered

• Packages: organizing Go code
• Creating packages
• Package naming conventions
• Exported vs unexported identifiers
• Package initialization with init()
• Import statements and aliases
• Blank imports with _
• Internal packages
• Vendoring and dependency management
• Go modules in detail

• go.mod and go.sum files
• Module versioning
• Error handling philosophy in Go
• Error as values
• Creating errors with errors.New() and fmt.Errorf()
• Error wrapping with %w verb
• errors.Is() and errors.As()
• Panic and recover mechanism
• When to panic
• Defer statement for cleanup

Topics Covered

• Concurrency vs parallelism
• Go's concurrency philosophy
• Goroutines: lightweight threads
• Starting goroutines with go keyword
• Goroutine scheduling and GOMAXPROCS
• Channels: communication between goroutines
• Creating channels with make()
• Sending and receiving on channels
• Channel directions: send-only, receive-only
• Buffered channels

• Channel closing and range loops
• Select statement for multiple channels
• Default case in select
• Channel patterns: fan-in, fan-out
• Worker pools with goroutines
• Pipeline pattern
• Timeout handling with channels
• Context package for cancellation
• sync.WaitGroup for goroutine coordination
• Race conditions and data races

Topics Covered

• Mutex and RWMutex for synchronization
• Atomic operations with sync/atomic
• sync.Once for one-time initialization
• sync.Map for concurrent map access
• sync.Pool for object reuse
• Condition variables with sync.Cond
• Semaphores implementation
• Context package deep dive
• Context cancellation and timeouts
• Context values and best practices

• Errgroup for error handling in goroutines
• Advanced channel patterns
• Pub-sub pattern with channels
• Circuit breaker pattern
• Retry with exponential backoff
• Rate limiting algorithms
• Lock-free programming basics
• Memory model and happens-before
• Detecting race conditions
• Benchmarking concurrent code

Topics Covered

• Reflection in Go with reflect package
• Type and Value in reflection
• Inspecting types at runtime
• Modifying values through reflection
• Struct tag parsing with reflection
• Method invocation via reflection
• Creating generic functions with reflection
• Reflection performance considerations
• When to use reflection
• Generics in Go (Go 1.18+)

• Type parameters and constraints
• Generic functions
• Generic types and structs
• Type inference with generics
• Type sets and interface constraints
• Comparable constraint
• Generic slice operations
• Generic data structures
• Generics best practices
• Migrating from interface{} to generics

Topics Covered

• Testing in Go philosophy
• Writing tests with testing package
• Test file naming conventions
• Test function signatures
• Running tests with go test
• Table-driven tests
• Subtests with t.Run()
• Test helpers and cleanup
• Testing packages and examples
• Benchmark functions

• Running and interpreting benchmarks
• Benchmark comparisons
• Coverage analysis with go test -cover
• Coverage reports and visualization
• Mocking and test doubles
• Dependency injection for testing
• Integration testing
• End-to-end testing
• Fuzzing with go test
• Property-based testing
• Test fixtures and golden files
• Testing concurrent code
• Race detection in tests

Topics Covered

• Performance optimization principles
• Profiling with pprof
• CPU profiling
• Memory profiling and allocation
• Goroutine profiling
• Block profiling
• Mutex profiling
• Trace collection and analysis
• Benchmark-driven optimization
• Memory management in Go

• Garbage collection tuning
• Escape analysis
• Stack vs heap allocation
• Reducing allocations
• String optimization techniques
• Slice performance tips
• Map optimization
• Compiler optimizations
• Assembly in Go
• CGO and performance implications
• Performance monitoring in production

Topics Covered

• Command-line argument parsing with flag package
• Positional arguments and subcommands
• Cobra framework for complex CLIs
• Viper for configuration management
• Environment variables handling
• Configuration file formats: JSON, YAML, TOML
• Interactive CLIs with prompts
• Terminal colors and formatting
• Progress bars and spinners
• Table output formatting

• Shell completion scripts
• Cross-platform considerations
• Signal handling
• Daemon processes
• CLI testing strategies
• Distribution and installation
• Self-updating CLIs
• CLI documentation generation
• Man pages creation
• CLI best practices

Topics Covered

• File operations with os package
• Reading files: various techniques
• Writing files efficiently
• File permissions and metadata
• Directory operations
• Path manipulation with filepath
• Temporary files and directories
• File watching and monitoring
• Memory-mapped files
• Buffered I/O with bufio

• CSV and JSON file processing
• Binary file handling
• Archive formats: tar, zip
• Compression: gzip, zlib
• Process execution with os/exec
• Pipes and inter-process communication
• System calls and syscall package
• Platform-specific code with build tags
• CGO for C integration
• Unsafe package usage

Topics Covered

• TCP/IP programming with net package
• TCP server and client
• UDP programming
• Unix domain sockets
• Network protocols implementation
• HTTP client customization
• WebSocket implementation
• TLS/SSL configuration
• Certificate handling
• DNS operations

• Port scanning
• Network interfaces information
• Raw sockets (with x/net)
• Packet capture basics
• Network monitoring
• Load balancing algorithms
• Proxy server implementation
• Tunneling and VPN basics
• Network security basics
• Rate limiting at network level

Topics Covered

• JSON encoding/decoding with encoding/json
• Custom JSON marshaling
• JSON streaming
• XML processing
• Protocol Buffers with protobuf
• MessagePack encoding
• YAML handling
• TOML configuration
• CSV processing
• Binary encoding with encoding/binary

• Base64 encoding
• Hex encoding
• Custom encoders and decoders
• Schema validation
• Data transformation pipelines
• ETL processes in Go
• Data compression techniques
• Encryption and decryption
• Hashing and checksums
• Digital signatures

Topics Covered

• Go modules deep dive
• Module versioning strategies
• Semantic versioning
• Module proxies and private modules
• Vendoring dependencies
• go.work for multi-module repos
• Build flags and tags
• Cross-compilation
• Static vs dynamic linking
• Build optimization flags

• Makefile for Go projects
• Task automation with Mage
• CI/CD for Go projects
• GitHub Actions for Go
• GitLab CI for Go
• Release management
• Semantic release
• Containerizing Go applications
• Multi-stage Docker builds
• Minimal Docker images with scratch

Topics Covered

• Go code style and conventions
• Effective Go guidelines
• go fmt and goimports
• Linting with golangci-lint
• Static analysis tools
• Code review practices
• Design patterns in Go
• SOLID principles in Go
• Domain-Driven Design with Go
• Clean Architecture in Go

• Hexagonal architecture
• Documentation with godoc
• README best practices
• API documentation
• Code comments guidelines
• Error handling patterns
• Logging best practices
• Configuration management patterns
• Security best practices
• Code metrics and complexity

Topics Covered

• Debugging with Delve
• Remote debugging
• Debugging goroutines
• Core dumps analysis
• Stack traces interpretation
• Panic recovery strategies
• Memory leaks detection
• Goroutine leaks
• Deadlock detection
• Race condition debugging

• Performance bottleneck identification
• Distributed tracing
• Logging strategies
• Structured logging
• Log aggregation
• Metrics collection
• Error tracking services
• Debugging production issues
• Post-mortem analysis
• Debugging tools and techniques

Topics Covered

• HTTP protocol deep dive
• HTTP/1.1 vs HTTP/2 vs HTTP/3
• net/http package fundamentals
• HTTP handlers and HandlerFunc
• ServeMux and routing
• Middleware pattern in Go
• Request context and cancellation
• Request parsing and validation
• Response writing techniques
• Cookie handling

• Session management
• File uploads and downloads
• Streaming responses
• Server-Sent Events (SSE)
• WebSocket upgrade
• HTTP/2 Server Push
• TLS/HTTPS configuration
• HTTP client best practices
• Connection pooling
• Timeouts and deadlines

Topics Covered

• Gin framework introduction
• Gin routing and parameters
• Gin middleware
• Request binding and validation
• Echo framework
• Fiber framework overview
• Chi router
• Gorilla toolkit
• REST API design principles
• RESTful routing conventions

• API versioning strategies
• Request/response formatting
• Content negotiation
• CORS handling
• Authentication methods: Basic, Token, OAuth
• JWT implementation
• Rate limiting
• API documentation with Swagger
• OpenAPI specification
• Postman collections

Topics Covered

• database/sql package
• Database drivers for MySQL, PostgreSQL
• Connection pooling configuration
• Prepared statements
• Transactions handling
• Batch operations
• SQL injection prevention
• Query builders
• GORM introduction and setup
• GORM models and migrations

• GORM associations
• GORM hooks and callbacks
• SQLX for enhanced database operations
• SQLBoiler for type-safe ORM
• Ent framework overview
• Database migrations with golang-migrate
• Connection management best practices
• Read replicas and write masters
• Database testing strategies
• Fixtures and seed data

Topics Covered

• MongoDB driver for Go
• MongoDB CRUD operations
• Aggregation pipelines
• MongoDB transactions
• Redis with Go
• Redis data structures
• Redis pub/sub
• Redis Streams
• Caching strategies
• Cache-aside pattern

• Write-through caching
• Cache invalidation
• Distributed caching
• Memcached integration
• ElasticSearch with Go
• Full-text search implementation
• Time-series databases: InfluxDB
• Graph databases: Neo4j
• Key-value stores
• Document stores

Topics Covered

• GraphQL introduction and concepts
• GraphQL vs REST comparison
• GraphQL schema definition
• Types and resolvers
• Queries and mutations
• Subscriptions for real-time
• gqlgen framework
• Graph-gophers library
• Schema-first vs code-first
• DataLoader pattern

• N+1 query problem solutions
• GraphQL federation
• Error handling in GraphQL
• Authentication and authorization
• Rate limiting GraphQL
• GraphQL testing
• Apollo integration
• GraphQL documentation
• Performance optimization
• Caching strategies

Topics Covered

• gRPC introduction and architecture
• Protocol Buffers (protobuf) syntax
• Defining services and messages
• protoc compiler usage
• Code generation for Go
• Unary RPC
• Server streaming RPC
• Client streaming RPC
• Bidirectional streaming
• gRPC error handling

• Status codes and details
• Metadata and headers
• Interceptors (middleware)
• Authentication in gRPC
• TLS/mTLS configuration
• Load balancing gRPC
• Service discovery
• gRPC-Gateway for REST
• gRPC reflection
• Testing gRPC services

Topics Covered

• Message queue patterns
• RabbitMQ with Go
• AMQP protocol
• Exchanges, queues, bindings
• Apache Kafka with Go
• Producers and consumers
• Kafka Streams equivalent
• NATS messaging system
• NATS Streaming/JetStream
• AWS SQS integration

• Google Pub/Sub
• Event sourcing pattern
• CQRS implementation
• Saga pattern
• Outbox pattern
• Event-driven architecture
• Eventual consistency
• Idempotency handling
• Dead letter queues
• Message ordering

Topics Covered

• Authentication strategies
• Password hashing with bcrypt
• Session-based authentication
• Token-based authentication
• JWT implementation and validation
• OAuth 2.0 implementation
• OpenID Connect
• Social login integration
• Multi-factor authentication
• API key management

• Role-based access control (RBAC)
• Attribute-based access control (ABAC)
• Security middleware
• CSRF protection
• XSS prevention
• SQL injection prevention
• Rate limiting implementation
• DDoS protection
• Secrets management
• Vault integration

Topics Covered

• Observability principles
• Structured logging with zap/zerolog
• Log levels and formatting
• Distributed tracing with OpenTelemetry
• Jaeger integration
• Zipkin integration
• Metrics with Prometheus
• Custom metrics and labels
• Grafana dashboards
• Application Performance Monitoring (APM)

• Health checks implementation
• Readiness and liveness probes
• Error tracking with Sentry
• Distributed logging with ELK
• CloudWatch integration
• DataDog integration
• Alerts and notifications
• SLA monitoring
• Performance monitoring
• Cost monitoring

Topics Covered

• Docker deep dive for Go
• Multi-stage builds optimization
• Minimal images with distroless
• Docker Compose for development
• Container networking
• Volume management
• Docker registry
• Kubernetes concepts
• Pods, Services, Deployments
• ConfigMaps and Secrets

• Ingress controllers
• StatefulSets for databases
• Jobs and CronJobs
• Helm charts creation
• Operators in Go
• kubebuilder framework
• operator-sdk
• Custom Resource Definitions (CRDs)
• Admission webhooks
• Service mesh with Istio

Topics Covered

• CI/CD principles
• GitHub Actions for Go
• GitLab CI configuration
• Jenkins pipelines
• CircleCI setup
• Build automation
• Test automation
• Code quality gates
• Security scanning
• Dependency scanning

• Container scanning
• Artifact management
• Semantic versioning
• Release automation
• GitOps with ArgoCD
• Flux CD
• Infrastructure as Code with Terraform
• Ansible for configuration
• Monitoring CI/CD
• Rollback strategies

Topics Covered

• Production readiness checklist
• High availability design
• Disaster recovery planning
• Backup strategies
• Data retention policies
• Compliance requirements
• GDPR considerations
• Security hardening
• Performance tuning
• Capacity planning

• Cost optimization
• Documentation standards
• Runbooks creation
• On-call procedures
• Incident management
• Post-mortem process
• Change management
• Feature flags
• A/B testing
• Production debugging

Topics Covered

• Choosing the capstone: a production-shaped API service, a concurrent data pipeline, or a CLI tool people would actually use
• A one-page spec: scope, milestones, stack
• Repository and project skeleton ready on day one
• Instructor sign-off before the build begins

Topics Covered

• Two focused weeks of building in vertical slices
• Instructor checkpoints and honest scope cuts
• Using the whole course: the language, concurrency where it earns it, the standard library, and tests throughout
• Daily commits and an always-working build

Topics Covered

• The finishing pass: edge cases, errors, documentation
• Production-shape pass: config, logging, graceful shutdown, and a load test that predicts
• A README worth reading and a demo worth watching
• A full-course spiral review before the exam

Topics Covered

• Presenting the capstone: live demo plus the hardest bug story
• The honest map of next roads: cloud-native infrastructure, platform engineering, and distributed systems
• Where our other courses continue the journey