Book Image

Hands-On High Performance with Go

By : Bob Strecansky

Book Image

Hands-On High Performance with Go

By: Bob Strecansky

Overview of this book

Go is an easy-to-write language that is popular among developers thanks to its features such as concurrency, portability, and ability to reduce complexity. This Golang book will teach you how to construct idiomatic Go code that is reusable and highly performant. Starting with an introduction to performance concepts, you’ll understand the ideology behind Go’s performance. You’ll then learn how to effectively implement Go data structures and algorithms along with exploring data manipulation and organization to write programs for scalable software. This book covers channels and goroutines for parallelism and concurrency to write high-performance code for distributed systems. As you advance, you’ll learn how to manage memory effectively. You’ll explore the compute unified device architecture (CUDA) application programming interface (API), use containers to build Go code, and work with the Go build cache for quicker compilation. You’ll also get to grips with profiling and tracing Go code for detecting bottlenecks in your system. Finally, you’ll evaluate clusters and job queues for performance optimization and monitor the application for performance regression. By the end of this Go programming book, you’ll be able to improve existing code and fulfill customer requirements by writing efficient programs.

Preface

Who this book is for

What this book covers

To get the most out of this book

Section 1: Learning about Performance in Go

Section 1: Learning about Performance in Go

Free Chapter

Introduction to Performance in Go

Introduction to Performance in Go

Technical requirements

Understanding performance in computer science

A brief history of Go

The ideology behind Go performance

Data Structures and Algorithms

Data Structures and Algorithms

Understanding benchmarking

Introducing Big O notation

Understanding sort algorithms

Understanding search algorithms

Exploring trees

Exploring queues

Understanding Concurrency

Understanding Concurrency

Understanding closures

Exploring goroutines

Introducing channels

Introducing semaphores

Understanding WaitGroups

Iterators and the process of iteration

Briefing on generators

STL Algorithm Equivalents in Go

STL Algorithm Equivalents in Go

Understanding algorithms in the STL

Understanding containers

Understanding function objects

Matrix and Vector Computation in Go

Matrix and Vector Computation in Go

Introducing Gonum and the Sparse library

Introducing BLAS

Introducing vectors

Introducing matrices

Matrix operations

Understanding matrix structures

Section 2: Applying Performance Concepts in Go

Section 2: Applying Performance Concepts in Go

Composing Readable Go Code

Composing Readable Go Code

Maintaining simplicity in Go

Maintaining readability in Go

Exploring packaging in Go

Understanding naming in Go

Understanding formatting in Go

Briefing on interfaces in Go

Comprehending methods in Go

Comprehending inheritance in Go

Exploring reflection in Go

Template Programming in Go

Template Programming in Go

Understanding Go generate

The link toolchain

Introducing Cobra and Viper for configuration programming

Text templating

HTML templating

Exploring Sprig

Memory Management in Go

Memory Management in Go

Understanding Modern Computer Memory - A Primer

Allocating memory

Understanding memory utilization

Briefing on limited memory situations

GPU Parallelization in Go

GPU Parallelization in Go

Cgo – writing C in Go

GPU-accelerated computing – utilizing the hardware

CUDA – powering the program

Compile Time Evaluations in Go

Compile Time Evaluations in Go

Exploring the Go runtime

Understanding functions

Section 3: Deploying, Monitoring, and Iterating on Go Programs with Performance in Mind

Section 3: Deploying, Monitoring, and Iterating on Go Programs with Performance in Mind

Building and Deploying Go Code

Building and Deploying Go Code

Building Go binaries

Go build – building your Go code

Go clean – cleaning your build directory

Retrieving package dependencies with go get and go mod

Go run – executing your packages

Go install – installing your binaries

Building Go binaries with Docker

Profiling Go Code

Profiling Go Code

Understanding profiling

Exploring instrumentation methodologies

Briefing on CPU profiling

Briefing on memory profiling

Extended capabilities with upstream pprof

Comparing multiple profiles

Interpreting flame graphs within pprof

Detecting memory leaks in Go

Tracing Go Code

Tracing Go Code

Implementing tracing instrumentation

Understanding the tracing format

Understanding trace collection

Exploring pprof-like traces

Go distributed tracing

Implementing OpenCensus for your application

Clusters and Job Queues

Clusters and Job Queues

Clustering in Go

Exploring job queues in Go

Comparing Code Quality Across Versions

Comparing Code Quality Across Versions

Go Prometheus exporter – exporting data from your Go application

APM – watching your distributed system performance

SLIs and SLOs – setting goals

Logging – keeping track of your data

Other Books You May Enjoy

Other Books You May Enjoy

Leave a review - let other readers know what you think

Customer Reviews

5 star

0

4 star

0

3 star

0

2 star

0

1 star

0

Summary

In this chapter, we learned the core concepts of performance in computer science. We also learned some of the history of the Go computer programming language and how its inception ties in directly with performance work. Lastly, we learned that Go is used in a myriad of different cases because of the utility, flexibility, and extensibility of the language. This chapter has introduced concepts that will continually be built upon in this book, allowing you to rethink the way you are writing your Go code.

In Chapter 2, Data Structures and Algorithms, we'll dive into data structures and algorithms. We'll learn about different algorithms, their Big O notation, and how these algorithms are constructed in Go. We'll also learn about how these theoretical algorithms relate to real-world problems and write performant Go to serve large amounts of requests quickly and efficiently. Learning more about these algorithms will help you to become more efficient in the second layer of the optimizations triangle that was laid out earlier in this chapter.