Hands-On Software Architecture with Golang

▶Book Description
Building software requires careful planning and architectural considerations; Golang was developed with a fresh perspective on building next-generation applications on the cloud with distributed and concurrent computing concerns.

Hands-On Software Architecture with Golang starts with a brief introduction to architectural elements, Go, and a case study to demonstrate architectural principles. You'll then move on to look at code-level aspects such as modularity, class design, and constructs specific to Golang and implementation of design patterns. As you make your way through the chapters, you'll explore the core objectives of architecture such as effectively managing complexity, scalability, and reliability of software systems. You'll also work through creating distributed systems and their communication before moving on to modeling and scaling of data. In the concluding chapters, you'll learn to deploy architectures and plan the migration of applications from other languages.

By the end of this book, you will have gained insight into various design and architectural patterns, which will enable you to create robust, scalable architecture using Golang.

▶What You Will Learn
⦁ Understand architectural paradigms and deep dive into Microservices
⦁ Design parallelism/concurrency patterns and learn object-oriented design patterns in Go
⦁ Explore API-driven systems architecture with introduction to REST and GraphQL standards
⦁ Build event-driven architectures and make your architectures anti-fragile
⦁ Engineer scalability and learn how to migrate to Go from other languages
⦁ Get to grips with deployment considerations with CICD pipeline, cloud deployments, and so on
⦁ Build an end-to-end e-commerce (travel) application backend in Go

▶Key Features
⦁ Gain knowledge of architectural approaches on SOA and microservices for architectural decisions
⦁ Explore different architectural patterns for building distributed applications
⦁ Migrate applications written in Java or Python to the Go language

▶Who This Book Is For
Today, the majority of backend software is still in languages such as Java, C++, and C#. Companies have invested a lot in these technologies and they are sometimes apprehensive about newer tech, including Go. This book is for software developers, architects, and CTOs, in similar situations, looking to use Go in their software architecture to build productiongrade applications and migrating from other platforms.

▶What this book covers
⦁ Chapter 1, Building Big with Go, takes a broad view of what considerations are needed when setting out to build mission-critical software. It gives an overview of microservices and how Go is a good fit for this architectural paradigm. We end the chapter with a quick tour of Go, for the sake of those who are new to the language.

⦁ Chapter 2, Packaging Code, delves into ways of organizing code at various levels in Go. It looks at project organization, packages, object orientation, and structuring tests. Many first timers get the encapsulation wrong, leading to unmanageable code or cyclic dependencies later on. This chapter provides pointers on how to avoid these and structure code for feature velocity.

⦁ Chapter 3, Design Patterns, takes us through various design patterns, such as the creational, structural, and behavioral design patterns, looking at descriptions of each pattern and examining the Go code for each implementation. We also look at the general principles of class (struct/interface) design.

⦁ Chapter 4, Scaling Applications, explores what scalability means, and how to quantify systems in terms of scalability. We describe how to scale algorithms and data structures, and how to identify bottlenecks and alleviate them. Then we'll look at ways of running multiple application instances and what mechanisms work best for different use cases.

⦁ Chapter 5, Going Distributed, looks at building distributed systems in Go, as your application is not going to run on a single machine. The chapter starts by listing common fallacies when it comes to distributed systems. It goes into detail on the common problems, such as consensus and consistency, and the patterns and protocols for solving them. We then go deep into various distributed architectures.

⦁ Chapter 6, Messaging, covers some messaging theory and then dives into Apache Kafka and NSQ—a brokerless messaging platform. Messaging systems are described in detail, and illustrated with code. This chapter also describes various messaging patterns, such as request-reply, fan-out, and pipes-and-filters.

⦁ Chapter 7, Building APIs, shows how to build REST and GraphQL services in Go. APIs are the lingua franca of the microservices world. At the end, the chapter takes a deep dive into Go-Kit, a collection of packages that together give a slightly opinionated framework for quickly building a service-oriented architecture.

⦁ Chapter 8, Modeling Data, starts off by introducing the entity-relationship way of modeling data. It then describes various persistence stores (such as relational databases, key-value stores, and column-oriented stores). This chapter takes a deep dive into MySQL, Redis, and Cassandra, the most commonly used storage technologies. This chapter outlines the architecture of the stores and showcases the Go code for interacting with them.

⦁ Chapter 9, Anti-Fragile Systems, explores various facets of building resilient systems, from ruggedizing individual services to achieving high availability. Each of these facets need to work together to enable systems that thrive under stress. We describe common patterns such as Hystrix and explain how to implement them in Go. The chapter also briefly covers disaster recovery and business continuity.

⦁ Chapter 10, Case Study – Travel Website, details some high-level architecture, low-level design, and key code constructs. Having a sense of the various building blocks, we will build an e-commerce app – a travel website, to be exact. Essentially, we will use everything we will have learned so far to build a non-trivial system.

⦁ Chapter 11, Planning for Deployment, discusses deployment considerations for Go programs. These includes things such as Continuous Integration and Continuous Deployment (CICD) pipelines, as well as application monitoring using tools such as New Relic. We build a robust CICD pipeline for a sample program using Jenkins and tools such as fmt and lint to ensure code quality before the push to production.

⦁ Chapter 12, Migrating Applications, describes a migration strategy that systematically moves relevant/critical parts of your applications to Go and showcases the business value of doing so at every stage. In this final chapter of the book, I also describe my experience with hiring and staffing a team for Go development—a common concern for many companies.