Programming in Go

Content

– Introduction to Go

• Why Go? Performance, simplicity, and cloud-native development
• Go vs. other languages: C++, Java, Python, Rust
• Use cases: Microservices, CLI tools, systems programming
• Go philosophy: Less is more, explicit over implicit

– Language Fundamentals and Syntax

• Variables, constants, and typing
• Basic data types and type inference
• Pointers and memory management
• Control structures: if, for, switch
• Functions: Definition, parameters, return values, multiple returns

– Data Structures and Algorithms

• Arrays and slices: Creation, manipulation, slicing
• Maps: Key-value stores and efficient lookups
• Structs: User-defined data types
• Interfaces: Duck typing and polymorphism
• Generics: Type-safe generic programming

– Object-Oriented Programming in Go

• Embedding instead of inheritance
• Methods and receivers
• Interface composition
• Type assertions and type switches

– Concurrency and Parallelism

• Goroutines: Lightweight threads and goroutine scheduling
• Channels: Safe communication between goroutines
• Select statements: Non-blocking operations
• Context package: Request cancellation and timeouts
• Sync package: Mutexes, wait groups, atomic operations

– Error Handling and Robustness

• The Error interface and error handling
• Custom error types and error wrapping
• Panic and recover: Exception-like mechanisms
• Defer statements: Resource cleanup
• Best practices for robust error handling

– Testing and Quality Assurance

• Unit tests: Table-driven tests, subtests
• Benchmarking: Performance measurements
• Integration tests and test coverage
• Mocking and test doubles
• Fuzzing and property-based testing

– REST API Development

• HTTP server with net/http
• Routing: gorilla/mux, chi, gin
• JSON handling: encoding/json, serialization
• Middleware: Logging, CORS, authentication
• RESTful design principles

– Databases and Persistence

• SQL databases: database/sql, prepared statements
• ORM libraries: GORM, sqlx
• NoSQL: MongoDB driver, Redis client
• Connection pooling and transactions
• Migrations and schema management

– Security and Best Practices

• Input validation and sanitization
• SQL injection prevention
• Cross-site scripting (XSS) protection
• Authentication and authorization
• Secure coding guidelines for Go

– Build System and Tooling

• Go modules: Dependency management
• Build constraints and cross-compilation
• Go tools: fmt, vet, lint, mod
• Profiling and performance analysis
• Debugging with Delve

– Containerization and Deployment

• Docker images for Go applications
• Multi-stage builds and image optimization
• Kubernetes deployments
• Configuration management: Environment variables, config files
• Health checks and graceful shutdown

– Advanced Topics

• Reflection and code generation
• CGO: Integration with C libraries
• WebAssembly and web development
• Plugin system and dynamic loading
• Performance optimization and memory profiling

– CLI Applications and Tools

• cobra: Framework for CLI applications
• flag package: Command-line arguments
• viper: Configuration management
• Logging: log, zap, logrus
• Distribution and packaging

You will not only get to know these concepts but also apply them practically. From the first “Hello World” to production-ready applications, we continuously build working programs and learn Go the way it’s used in practice.

The actual course content may differ from the above depending on the trainer, delivery, duration and the composition of participants.