Book Image

Mastering Go – Third Edition - Third Edition

By : Mihalis Tsoukalos
5 (2)
Book Image

Mastering Go – Third Edition - Third Edition

5 (2)
By: Mihalis Tsoukalos

Overview of this book

Mastering Go is the essential guide to putting Go to work on real production systems. This freshly updated third edition includes topics like creating RESTful servers and clients, understanding Go generics, and developing gRPC servers and clients. Mastering Go was written for programmers who want to explore the capabilities of Go in practice. As you work your way through the chapters, you’ll gain confidence and a deep understanding of advanced Go concepts, including concurrency and the operation of the Go Garbage Collector, using Go with Docker, writing powerful command-line utilities, working with JavaScript Object Notation (JSON) data, and interacting with databases. You’ll also improve your understanding of Go internals to optimize Go code and use data types and data structures in new and unexpected ways. This essential Go programming book will also take you through the nuances and idioms of Go with exercises and resources to fully embed your newly acquired knowledge. With the help of Mastering Go, you’ll become an expert Go programmer by building Go systems and implementing advanced Go techniques in your projects.

Related Content you might be interested in

Current Title:

Small book image
Mastering Go – Third Edition - Third Edition
Mihalis Tsoukalos
Aug, 2021 | 682 pages
Small book image
Mastering Go.
Mihalis Tsoukalos
Aug, 2019 | 798 pages
Small book image
Mastering Go
Mihalis Tsoukalos
Apr, 2018 | 606 pages
Small book image
Go Systems Programming
Mihalis Tsoukalos
Sep, 2017 | 466 pages
Table of Contents (17 chapters)
Preface
Preface
Who this book is for
What this book covers
To get the most out of this book
Get in touch
1
A Quick Introduction to Go
A Quick Introduction to Go
Introducing Go
Hello World!
Running Go code
Important characteristics of Go
Developing the which(1) utility in Go
Logging information
Overview of Go generics
Developing a basic phone book application
Exercises
Summary
Additional resources
Free Chapter
2
Basic Go Data Types
Basic Go Data Types
The error data type
Numeric data types
Non-numeric data types
Go constants
Grouping similar data
Pointers
Generating random numbers
Updating the phone book application
Exercises
Summary
Additional resources
3
Composite Data Types
Composite Data Types
Maps
Structures
Regular expressions and pattern matching
Improving the phone book application
Exercises
Summary
Additional resources
4
Reflection and Interfaces
Reflection and Interfaces
Reflection
Type methods
Interfaces
Working with two different CSV file formats
Object-oriented programming in Go
Updating the phone book application
Exercises
Summary
Additional resources
5
Go Packages and Functions
Go Packages and Functions
Go packages
Functions
Developing your own packages
Using GitHub to store Go packages
A package for working with a database
Modules
Creating better packages
Generating documentation
GitLab Runners and Go
GitHub Actions and Go
Versioning utilities
Exercises
Summary
Additional resources
6
Telling a UNIX System What to Do
Telling a UNIX System What to Do
stdin, stdout, and stderr
UNIX processes
Handling UNIX signals
File I/O
Reading text files
Writing to a file
Working with JSON
Working with XML
Working with YAML
The viper package
The cobra package
Finding cycles in a UNIX file system
New to Go 1.16
Updating the phone book application
Exercises
Summary
Additional resources
7
Go Concurrency
Go Concurrency
Processes, threads, and goroutines
The Go scheduler
Goroutines
Channels
Race conditions
The select keyword
Timing out a goroutine
Go channels revisited
Shared memory and shared variables
Closured variables and the go statement
The context package
The semaphore package
Exercises
Summary
Additional resources
8
Building Web Services
Building Web Services
The net/http package
Creating a web server
Updating the phone book application
Exposing metrics to Prometheus
Developing web clients
Creating file servers
Timing out HTTP connections
Exercises
Summary
Additional resources
9
Working with TCP/IP and WebSocket
Working with TCP/IP and WebSocket
TCP/IP
The net package
Developing a TCP client
Developing a TCP server
Developing a UDP client
Developing a UDP server
Developing concurrent TCP servers
Working with UNIX domain sockets
Creating a WebSocket server
Creating a WebSocket client
Exercises
Summary
Additional resources
10
Working with REST APIs
Working with REST APIs
An introduction to REST
Developing RESTful servers and clients
Creating a functional RESTful server
Creating a RESTful client
Uploading and downloading binary files
Using Swagger for REST API documentation
Exercises
Summary
Additional resources
11
Code Testing and Profiling
Code Testing and Profiling
Optimizing code
Benchmarking code
Profiling code
The go tool trace utility
Testing Go code
Testing an HTTP server with a database backend
Fuzzing
Cross-compilation
Using go:generate
Creating example functions
Exercises
Summary
Additional resources
12
Working with gRPC
Working with gRPC
Introduction to gRPC
Defining an interface definition language file
Developing a gRPC server
Developing a gRPC client
Exercises
Summary
Additional resources
13
Go Generics
Go Generics
Introducing generics
Constraints
Defining new data types with generics
Interfaces versus generics
Reflection versus generics
Exercises
Summary
Additional resources
14
Other Books You May Enjoy
Other Books You May Enjoy
15
Index
Index
Appendix A – Go Garbage Collector
Appendix A – Go Garbage Collector
Heap and stack
Garbage collection
Additional resources

Cross-compilation

Cross-compilation is the process of generating a binary executable file for a different architecture than the one on which we are working without having access to other machines. The main benefit that we receive from cross-compilation is that we do not need a second or third machine to create and distribute executable files for different architectures. This means that we basically need just a single machine for our development. Fortunately, Go has built-in support for cross-compilation.

To cross-compile a Go source file, we need to set the GOOS and GOARCH environment variables to the target operating system and architecture, respectively, which is not as difficult as it sounds.

You can find a list of available values for the GOOS and GOARCH environment variables at https://golang.org/doc/install/source. Keep in mind, however, that not all GOOS and GOARCH combinations are valid.

The code of crossCompile.go is the following:

package main...
Previous Section
End of Section 9
Next Section