Go-Lang Development Fundamentals

CONTENT

Section 1: Software Engineering and the Software Development Life Cycle
1. Chapter 1: A Bird’s-Eye View of Software Engineering
1.1. What is software engineering? 9
1.2. Types of software engineering roles 10
1.3. A list of software development models that all engineers should know

Section 2: Best Practices for Maintainable and Testable Go Code
2. Chapter 2: Best Practices for Writing Clean and Maintainable Go Code 36
2.1. The SOLID principles of object-oriented design 37
2.2. Organizing code into packages 49
2.3. Tips and tools for writing lean and easy-to-maintain Go code 55

3. Chapter 3: Dependency Management 77
3.1. What’s all the fuss about software versioning? 78
3.2. Vendoring – the good, the bad, and the ugly 89
3.3. Strategies and tools for vendoring dependencies 91

4. Chapter 4: The Art of Testing 103
4.1. Technical requirements 103
4.2. Unit testing 104
4.3. Integration versus functional testing 135
4.4. Smoke tests 138
4.5. Chaos testing – breaking your systems in fun and interesting ways! 140
4.6. Tips and tricks for writing tests 142

Section 3: Section 3: Designing and Building a Multi-Tier System from Scratch
5. Chapter 5: The Links ‘R’; Us Project 157
5.1. System overview – what are we going to be building? 158
5.2. Selecting an SDLC model for our project 159
5.3. Requirements analysis 161
5.4. System component modeling 169
5.5. Monolith or microservices? The ultimate question 176

6. Chapter 6: Building a Persistence Layer 180
6.1. Technical requirements 180
6.2. Exploring a taxonomy of database systems 182
6.3. Understanding the need for a data layer abstraction 189
6.4. Designing the data layer for the link graph component 190
6.5. Designing the data layer for the text indexer component 215

7. Chapter 7: Data-Processing Pipelines 239
7.1. Technical requirements 239
7.2. Building a generic data-processing pipeline in Go 240
7.3. Building a crawler pipeline for the Links ‘R’ Us project 267

8. Chapter 8: Graph-Based Data Processing 291
8.1. Technical requirements 292
8.2. Exploring the Bulk Synchronous Parallel model 292
8.3. Building a graph processing system in Go 295
8.4. Solving interesting graph problems 3215

9. Chapter 9: Communicating with the Outside World 347
9.1. Technical requirements 348
9.2. Designing robust, secure, and backward-compatible REST APIs 348
9.3. Building RPC-based APIs with the help of gRPC 370
9.4. Decoupling Links ‘R’ Us components from the underlying data stores 389

10. Chapter 10: Building, Packaging, and Deploying Software 398
10.1. Technical requirements 399
10.2. Building and packaging Go services using Docker 400
10.3. A gentle introduction to Kubernetes 404
10.4. Building and deploying a monolithic version of Links ‘R’ Us 411

Section 4: Scaling Out to Handle a Growing Number of Users
11. Chapter 11: Splitting Monoliths into Microservices 441
11.1. Technical requirements 442
11.2. Monoliths versus service-oriented architectures 443
11.3. Monitoring the state of your microservices 445
11.4. Building a microservice-based version of Links ‘R’ Us 469

12. Chapter 12: Building Distributed Graph-Processing Systems 480
12.1. Technical requirements 481
12.2. Introducing the master/worker model 481
12.3. Out-of-core distributed graph processing 484
12.4. Deploying a distributed version of the Links ‘R’ Us PageRank calculator 537

13. Chapter 13: Metrics Collection and Visualization 548
13.1. Technical requirements 549
13.2. Monitoring from the perspective of a site reliability engineer 549
13.3. Exploring options for collecting and aggregating metrics 551
13.4. Visualizing collected metrics using Grafana 562
13.5. Using Prometheus as an end-to-end solution for alerting 564