Book Image

Go Cookbook

By : Aaron Torres
Book Image

Go Cookbook

By: Aaron Torres

Overview of this book

Go (a.k.a. Golang) is a statically-typed programming language first developed at Google. It is derived from C with additional features such as garbage collection, type safety, dynamic-typing capabilities, additional built-in types, and a large standard library. This book takes off where basic tutorials on the language leave off. You can immediately put into practice some of the more advanced concepts and libraries offered by the language while avoiding some of the common mistakes for new Go developers. The book covers basic type and error handling. It explores applications that interact with users, such as websites, command-line tools, or via the file system. It demonstrates how to handle advanced topics such as parallelism, distributed systems, and performance tuning. Lastly, it finishes with reactive and serverless programming in Go.

Related Content you might be interested in

Current Title:

Small book image
Go Cookbook
Aaron Torres
Jun, 2017 | 400 pages
Small book image
Go Standard Library Cookbook
Radomír Sohlich
Feb, 2018 | 340 pages
Small book image
Hands-On System Programming with Go
Alex Guerrieri
Jul, 2019 | 458 pages
Small book image
Building RESTful Web services with Go
Naren Yellavula
Dec, 2017 | 316 pages
Table of Contents (14 chapters)
Preface
Preface
What this book covers
What you need for this book
Who this book is for
Sections
Conventions
Reader feedback
Customer support
Free Chapter
1
I/O and File Systems
I/O and File Systems
Introduction
Using the common I/O interfaces
Using the bytes and strings packages
Working with directories and files
Working with the CSV format
Working with temporary files
Working with text/template and HTML/templates
2
Command-Line Tools
Command-Line Tools
Introduction
Using command-line flags
Using command-line arguments
Reading and setting environment variables
Configuration using TOML, YAML, and JSON
Working with Unix pipes
Catching and handling signals
An ANSI coloring application
3
Data Conversion and Composition
Data Conversion and Composition
Introduction
Converting data types and interface casting
Working with numeric data types using math and math/big
Currency conversions and float64 considerations
Using pointers and SQL NullTypes for encoding and decoding
Encoding and decoding Go data
Struct tags and basic reflection in Go
Implementing collections via closures
4
Error Handling in Go
Error Handling in Go
Introduction
Handling errors and the Error interface
Using the pkg/errors package and wrapping errors
Using the log package and understanding when to log errors
Structured logging with the apex and logrus packages
Logging with the context package
Using package-level global variables
Catching panics for long running processes
5
All about Databases and Storage
All about Databases and Storage
Introduction
The database/sql package with MySQL
Executing a database transaction interface
Connection pooling, rate limiting, and timeouts for SQL
Working with Redis
Using NoSQL with MongoDB and mgo
Creating storage interfaces for data portability
6
Web Clients and APIs
Web Clients and APIs
Introduction
Initializing, storing, and passing http.Client structs
Writing a client for a REST API
Executing parallel and async client requests
Making use of OAuth2 clients
Implementing an OAuth2 token storage interface
Wrapping a client in added functionality and function composition
Understanding GRPC clients
7
Microservices for Applications in Go
Microservices for Applications in Go
Introduction
Working with web handlers, requests, and ResponseWriters
Using structs and closures for stateful handlers
Validating input for Go structs and user inputs
Rendering and content negotiation
Implementing and using middleware
Building a reverse proxy application
Exporting GRPC as a JSON API
8
Testing
Testing
Introduction
Mocking using the standard library
Using the Mockgen package
Using table-driven tests to improve coverage
Using third-party testing tools
Practical fuzzing
Behavior testing using Go
9
Parallelism and Concurrency
Parallelism and Concurrency
Introduction
Using channels and the select statement
Performing async operations with sync.WaitGroup
Using atomic operations and mutex
Using the context package
Executing state management for channels
Using the worker pool design pattern
Using workers to create pipelines
10
Distributed Systems
Distributed Systems
Introduction
Using service discovery with Consul
Implementing basic consensus using Raft
Using containerization with Docker
Orchestration and deployment strategies
Monitoring applications
Collecting metrics
11
Reactive Programming and Data Streams
Reactive Programming and Data Streams
Introduction
Goflow for dataflow programming
Reactive programming with RxGo
Using Kafka with Sarama
Using async producers with Kafka
Connecting Kafka to Goflow
Writing a GraphQL server in Go
12
Serverless Programming
Serverless Programming
Introduction
Go programming on Lambda with Apex
Apex serverless logging and metrics
Google App Engine with Go
Working with Firebase using zabawaba99/firego
13
Performance Improvements, Tips, and Tricks
Performance Improvements, Tips, and Tricks
Introduction
Speeding up compilation and testing cycles
Using the pprof tool
Benchmarking and finding bottlenecks
Memory allocation and heap management
Vendoring and project layout
Using fasthttprouter and fasthttp

Introduction

Go applications frequently need to make use of long-term storage. This is usually in the form of relational and non-relational databases, as well as key-value stores and more. When working with these storage applications, it helps to wrap your operations in an interface. The recipes in this chapter will examine various storage interfaces, considering parallel access with things such as connection pools, and look at general tips for integrating a new library, which is often the case when using a new storage technology.

Previous Section
End of Section 2
Next Section