Book Image

Mastering Go - Second Edition

By : Mihalis Tsoukalos
Book Image

Mastering Go - Second Edition

By: Mihalis Tsoukalos

Overview of this book

Often referred to (incorrectly) as Golang, Go is the high-performance systems language of the future. Mastering Go, Second Edition helps you become a productive expert Go programmer, building and improving on the groundbreaking first edition. Mastering Go, Second Edition shows how to put Go to work on real production systems. For programmers who already know the Go language basics, this book provides examples, patterns, and clear explanations to help you deeply understand Go’s capabilities and apply them in your programming work. The book covers the nuances of Go, with in-depth guides on types and structures, packages, concurrency, network programming, compiler design, optimization, and more. Each chapter ends with exercises and resources to fully embed your new knowledge. This second edition includes a completely new chapter on machine learning in Go, guiding you from the foundation statistics techniques through simple regression and clustering to classification, neural networks, and anomaly detection. Other chapters are expanded to cover using Go with Docker and Kubernetes, Git, WebAssembly, JSON, and more. If you take the Go programming language seriously, the second edition of this book is an essential guide on expert techniques.

Related Content you might be interested in

Current Title:

Small book image
Mastering Go - Second Edition
Mihalis Tsoukalos
Aug, 2019 | 798 pages
Small book image
Go Systems Programming
Mihalis Tsoukalos
Sep, 2017 | 466 pages
Small book image
Mastering Go – Third Edition
Mihalis Tsoukalos
Aug, 2021 | 682 pages
Small book image
Hands-On System Programming with Go
Alex Guerrieri
Jul, 2019 | 458 pages
Table of Contents (20 chapters)
Title Page
Title Page
Copyright and Credits
Copyright and Credits
Mastering Go Second Edition
About Packt
About Packt
Why subscribe?
Contributors
Contributors
About the author
About the reviewer
Preface
Preface
Who this book is for
What this book covers
To get the most out of this book
Get in touch
Free Chapter
1
Go and the Operating System
Go and the Operating System
The history of Go
Where is Go going?
The advantages of Go
Compiling Go code
Executing Go code
Two Go rules
Downloading Go packages
UNIX stdin, stdout, and stderr
About printing output
Using standard output
Getting user input
About error output
Writing to log files
Error handling in Go
Using Docker
Exercises and links
Summary
2
Understanding Go Internals
Understanding Go Internals
The Go compiler
Garbage collection
Calling C code from Go
Calling Go functions from C code
The defer keyword
Panic and recover
Two handy UNIX utilities
Your Go environment
The go env command
The Go assembler
Node trees
Finding out more about go build
Creating WebAssembly code
General Go coding advice
Exercises and links
Summary
3
Working with Basic Go Data Types
Working with Basic Go Data Types
Numeric data types
Go loops
Go arrays
Go slices
Go maps
Go constants
Go pointers
Times and dates
Measuring execution time
Web links and exercises
Summary
4
The Uses of Composite Types
The Uses of Composite Types
About composite types
Structures
Tuples
Regular expressions and pattern matching
Strings
The switch statement
Calculating Pi with high accuracy
Developing a key-value store in Go
Go and the JSON format
Go and the YAML format
Additional resources
Exercises and web links
Summary
5
How to Enhance Go Code with Data Structures
How to Enhance Go Code with Data Structures
About graphs and nodes
Algorithm complexity
Binary trees in Go
Hash tables in Go
Linked lists in Go
Doubly linked lists in Go
Queues in Go
Stacks in Go
The container package
Generating random numbers
Generating secure random numbers
Performing matrix calculations
Solving Sudoku puzzles
Additional resources
Exercises
Summary
6
What You Might Not Know About Go Packages and Functions
What You Might Not Know About Go Packages and Functions
About Go packages
About Go functions
Developing your own Go packages
Go modules
Creating good Go packages
The syscall package
The go/scanner, go/parser, and go/token packages
Text and HTML templates
Additional resources
Exercises
Summary
7
Reflection and Interfaces for All Seasons
Reflection and Interfaces for All Seasons
Type methods
Go interfaces
Writing your own interfaces
Reflection
Object-oriented programming in Go
An introduction to git and GitHub
Debugging with Delve
Additional resources
Exercises
Summary
8
Telling a UNIX System What to Do
Telling a UNIX System What to Do
About UNIX processes
The flag package
The viper package
The cobra package
The io.Reader and io.Writer Interfaces
The bufio package
Reading text files
Reading a specific amount of data
The advantages of binary formats
Reading CSV files
Writing to a file
Loading and saving data on disk
The strings package revisited
About the bytes package
File permissions
Handling UNIX signals
Programming UNIX pipes in Go
About syscall.PtraceRegs
Tracing system calls
User ID and group ID
The Docker API and Go
Additional resources
Exercises
Summary
9
Concurrency in Go – Goroutines, Channels, and Pipelines
Concurrency in Go – Goroutines, Channels, and Pipelines
About processes, threads, and goroutines
Goroutines
Waiting for your goroutines to finish
Channels
Pipelines
Race conditions
Comparing Go and Rust concurrency models
Comparing Go and Erlang concurrency models
Additional resources
Exercises
Summary
10
Concurrency in Go – Advanced Topics
Concurrency in Go – Advanced Topics
The Go scheduler revisited
The select keyword
Timing out a goroutine
Go channels revisited
Shared memory and shared variables
Revisiting the go statement
Catching race conditions
The context package
Additional resources
Exercises
Summary
11
Code Testing, Optimization, and Profiling
Code Testing, Optimization, and Profiling
About optimization
Optimizing Go code
Profiling Go code
The go tool trace utility
Testing Go code
Testing an HTTP server with a database backend
Benchmarking Go code
A simple benchmarking example
Benchmarking buffered writing
Finding unreachable Go code
Cross-compilation
Creating example functions
From Go code to machine code
Generating documentation
Using Docker images
Additional resources
Exercises
Summary
12
The Foundations of Network Programming in Go
The Foundations of Network Programming in Go
About net/http, net, and http.RoundTripper
About TCP/IP
About IPv4 and IPv6
The nc(1) command-line utility
Reading the configuration of network interfaces
Performing DNS lookups
Creating a web server in Go
HTTP tracing
Creating a web client in Go
Timing out HTTP connections
The Wireshark and tshark tools
gRPC and Go
Additional resources
Exercises
Summary
13
Network Programming – Building Your Own Servers and Clients
Network Programming – Building Your Own Servers and Clients
Working with HTTPS traffic
The net standard Go package
A TCP client
A TCP server
A UDP client
Developing a UDP server
A concurrent TCP server
Creating a Docker image for a Go TCP/IP server
Remote Procedure Call (RPC)
Doing low-level network programming
Additional resources
Exercises
Summary
14
Machine Learning in Go
Machine Learning in Go
Calculating simple statistical properties
Regression
Classification
Clustering
Anomaly detection
Neural networks
Outlier analysis
Working with TensorFlow
Talking to Kafka
Additional resources
Exercises
Summary
Where to go next?
Other Books You May Enjoy
Other Books You May Enjoy
Leave a review - let other readers know what you think

The Go assembler

This section will briefly talk about the assembly language and the Go assembler, which is a Go tool that allows you to see the assembly language used by the Go compiler.

As an example, you can see the assembly language of the goEnv.go program you saw in the previous section of this chapter by executing the next command:

$ GOOS=darwin GOARCH=amd64 go tool compile -S goEnv.go

The value of the GOOS variable defines the name of the target operating system whereas the value of the GOARCH variable defines the compilation architecture. The preceding command was executed on a macOS Mojave machine, hence the use of the darwin value for the GOOS variable.

The output of the previous command is pretty large even for a small program such as goEnv.go. Some of its output is next:

"".main STEXT size=859 args=0x0 locals=0x118
   0x0000 00000 (goEnv.go:8)       TEXT...
Previous Section
End of Section 11
Next Section