Practical Software Development in Golang

Introduction

The book «Hands-On Software Engineering with Golang» (2020, 554 pp.) by Achilles Anagnostopoulos is not another introduction to Go syntax, but a deep practical guide to building complex, scalable, and maintainable software systems in Go. Unlike many books that focus on the basics, this work is dedicated specifically to engineering practices: architecture, design, testing, deployment, and monitoring. It is ideal for those already familiar with Go who want to advance to the level of a senior developer or architect.

What the book is about

The book is built around the development of a real application — a link graph analysis system. Throughout the chapters, the author consistently applies the principles of Domain-Driven Design (DDD), builds a microservice architecture, uses gRPC for inter-service communication, implements containerization (Docker, Kubernetes), and sets up CI/CD pipelines. Each chapter is a complete stage that can be immediately applied in practice.

Main topics:

• Architectural patterns: DDD, CQRS, Event Sourcing, hexagonal architecture.
• Microservices: design, communication (gRPC, RabbitMQ), orchestration.
• Testing: unit, integration, end-to-end, property-based testing.
• CI/CD: pipeline setup, automated testing and deployment.
• Monitoring and observability: logging, metrics, tracing (OpenTelemetry).
• Performance: profiling, benchmarking, optimization.

Who this book is for

The book is intended for experienced Go developers (at least 1-2 years) who want to delve into designing complex systems. It will also be useful for architects, team leads, and anyone transitioning from writing simple utilities to building production-grade applications. Beginners in Go may find the book challenging, as the author does not explain basic syntax and assumes knowledge of the language.

What the reader will learn

• How to apply DDD to identify bounded contexts and aggregates.
• How to build microservices using gRPC and asynchronous queues.
• How to implement CQRS and Event Sourcing in Go.
• How to write tests at different levels and use property-based testing.
• How to containerize applications and deploy them in Kubernetes.
• How to set up CI/CD with GitHub Actions or GitLab CI.
• How to profile and optimize the performance of Go applications.
• How to implement observability: logging, metrics (Prometheus), and tracing (Jaeger).

Strengths

The main advantage of the book is its practical focus. Each concept is immediately backed by code that can be run and modified. The author does not just retell theory but shows how to make architectural decisions and what trade-offs they involve. The code on GitHub is accompanied by detailed comments. Another plus is its relevance: the book was published in 2020, and most approaches (gRPC, Kubernetes, OpenTelemetry) remain industry standards.

The chapters on testing and CI/CD deserve special mention — they provide ready-made recipes that can be immediately implemented in any project. The book teaches not just to write code, but to think about the system as a whole: from requirements to operations.

Who it is recommended for

I recommend this book to anyone who wants to move from writing "scripts" in Go to creating industrial systems. It will be useful both for individual developers and for teams adopting Go in production. If you have already read «The Go Programming Language» or «Concurrency in Go» and want to move further — this book will be an excellent next step.

On the PythonLib website, the book is available for review