Golang

Overview

Go is the programming language of the cloud era: Simple, fast, and reliable. In this intensive course, you will learn to develop high-performance microservices, REST APIs, and CLI tools. From fundamentals through advanced concepts like concurrency to production-ready deployments - you will continuously build practical applications and learn Go the way it's used in industry. Whether you're new to Go or want to deepen your knowledge, this course optimally prepares you for developing modern, scalable software solutions.

What you will achieve

The goal of the course is to provide participants with a comprehensive understanding of the Go programming language and enable them to independently develop modern, scalable, and performant applications. Participants will learn to use Go effectively in practice - from developing microservices and REST APIs through implementing concurrency patterns to production-ready deployments. After the course, they will be able to develop Go applications that meet the requirements of modern cloud-native systems and have a solid foundation for the continuous development of their Go knowledge.

Who it is for

This course is designed for developers looking to expand their skills and learn the Go programming language. It is suitable for beginners with basic programming knowledge as well as experienced developers aiming to build powerful, scalable, and modern applications.

Course format

The course is hands-on and combines theoretical foundations with focused exercises to reinforce the learned concepts.

Requirements

Participants should have basic programming knowledge in a C-related programming language. A fundamental understanding of web services (e.g. REST) is required.

Course 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.