Sign In Start Free Trial

Book Overview & Buying
Table Of Contents
Feedback & Rating

Hands-On High Performance with Go

By : Strecansky

3.6 (5)

Hands-On High Performance with Go

3.6 (5)

By: 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

Preface

Who this book is for

What this book covers

To get the most out of this book

Get in touch

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

Summary

Data Structures and Algorithms

Data Structures and Algorithms

Understanding benchmarking

Introducing Big O notation

Understanding sort algorithms

Understanding search algorithms

Exploring trees

Exploring queues

Summary

Understanding Concurrency

Understanding Concurrency

Understanding closures

Exploring goroutines

Introducing channels

Introducing semaphores

Understanding WaitGroups

Iterators and the process of iteration

Briefing on generators

Summary

STL Algorithm Equivalents in Go

STL Algorithm Equivalents in Go

Understanding algorithms in the STL

Understanding containers

Understanding function objects

Summary

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

Summary

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

Summary

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

Summary

Memory Management in Go

Memory Management in Go

Understanding Modern Computer Memory - A Primer

Allocating memory

Understanding memory utilization

Briefing on limited memory situations

Summary

GPU Parallelization in Go

GPU Parallelization in Go

Cgo – writing C in Go

GPU-accelerated computing – utilizing the hardware

CUDA on GCP

CUDA – powering the program

Summary

Compile Time Evaluations in Go

Compile Time Evaluations in Go

Exploring the Go runtime

Understanding functions

Summary

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 list

Go run – executing your packages

Go install – installing your binaries

Building Go binaries with Docker

Summary

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

Summary

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

Summary

Clusters and Job Queues

Clusters and Job Queues

Clustering in Go

Exploring job queues in Go

Summary

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

Summary

Other Books You May Enjoy

Other Books You May Enjoy

Leave a review - let other readers know what you think

Customer Reviews

3.6 (5)

5 star

40%

4 star

20%

3 star

20%

2 star

0

1 star

20%

Understanding closures

One of the most important parts of Go is that it is a language that supports first-class functions. First-class functions are functions that have the ability to be passed to other functions as variables. They can also be returned from other functions. This is important to note because we can use them as closures.

Closures are helpful because they are a great way to keep your code DRY as well as helping to isolate your data. Keeping datasets small has been a core tenet of this book thus far, and that doesn't change in this chapter (nor any subsequent chapter). Being able to isolate the data that you wish to manipulate can help you to continue to write performant code.

Closures keep a local scope and have access to the outer function's scope and parameters, as well as global variables. Closures are functions that reference variables outside of their...

Search

Your notes and bookmarks