Book Image

Go Programming Cookbook - Second Edition

By : Aaron Torres

Book Image

Go Programming Cookbook - Second Edition

By: Aaron Torres

Overview of this book

Go (or Golang) is a statically typed programming language developed at Google. Known for its vast standard library, it also provides features such as garbage collection, type safety, dynamic-typing capabilities, and additional built-in types. This book will serve as a reference while implementing Go features to build your own applications. This Go cookbook helps you put into practice the advanced concepts and libraries that Golang offers. The recipes in the book follow best practices such as documentation, testing, and vendoring with Go modules, as well as performing clean abstractions using interfaces. You'll learn how code works and the common pitfalls to watch out for. The book covers basic type and error handling, and then moves on to explore applications, such as websites, command-line tools, and filesystems, that interact with users. You'll even get to grips with parallelism, distributed systems, and performance tuning. By the end of the book, you'll be able to use open source code and concepts in Go programming to build enterprise-class applications without any hassle.

Preface

Who this book is for

What this book covers

To get the most out of this book

Free Chapter

I/O and Filesystems

I/O and Filesystems

Technical requirements

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/template

Command-Line Tools

Command-Line Tools

Technical requirements

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

Data Conversion and Composition

Data Conversion and Composition

Technical requirements

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

Structure tags and basic reflection in Go

Implementing collections via closures

Error Handling in Go

Error Handling in Go

Technical requirements

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

Network Programming

Network Programming

Technical requirements

Writing a TCP/IP echo server and client

Writing a UDP server and client

Working with domain name resolution

Working with WebSockets

Working with net/rpc for calling remote methods

Using net/mail for parsing emails

All about Databases and Storage

All about Databases and Storage

Using 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

Creating storage interfaces for data portability

Web Clients and APIs

Web Clients and APIs

Technical requirements

Initializing, storing, and passing http.Client structures

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

Using twitchtv/twirp for RPC

Microservices for Applications in Go

Microservices for Applications in Go

Technical requirements

Working with web handlers, requests, and ResponseWriter instances

Using structures and closures for stateful handlers

Validating input for Go structures and user inputs

Rendering and content negotiation

Implementing and using middleware

Building a reverse proxy application

Exporting GRPC as a JSON API

Testing Go Code

Testing Go Code

Technical requirements

Mocking using the standard library

Using the Mockgen package to mock interfaces

Using table-driven tests to improve coverage

Using third-party testing tools

Behavior testing using Go

Parallelism and Concurrency

Parallelism and Concurrency

Technical requirements

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

Distributed Systems

Distributed Systems

Technical requirements

Using service discovery with Consul

Implementing basic consensus using Raft

Using containerization with Docker

Orchestration and deployment strategies

Monitoring applications

Collecting metrics

Reactive Programming and Data Streams

Reactive Programming and Data Streams

Technical requirements

Using Goflow for data flow programming

Using Kafka with Sarama

Using async producers with Kafka

Connecting Kafka to Goflow

Writing a GraphQL server in Go

Serverless Programming

Serverless Programming

Go programming on Lambda with Apex

Apex serverless logging and metrics

Google App Engine with Go

Working with Firebase using firebase.google.com/go

Performance Improvements, Tips, and Tricks

Performance Improvements, Tips, and Tricks

Technical requirements

Using the pprof tool

Benchmarking and finding bottlenecks

Memory allocation and heap management

Using fasthttprouter and fasthttp

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

Currency conversions and float64 considerations

Working with currency is always a tricky process. It can be tempting to represent money as a float64, but this can result in some pretty tricky (and wrong) rounding errors when doing calculations. For this reason, it's preferable to think of money in terms of cents and store the figure as an int64 instance.

When collecting user input from forms, the command line, or other sources, money is usually represented in dollar form. For this reason, it's best to treat it as a string and convert that string directly to cents without floating-point conversions. This recipe will present ways to convert a string representation of currency into an int64(cents) instance and back again.

How to do it...

The following steps cover how to write and run your application:

From your Terminal/console application,createa new directory called~/projects/go-programming-cookbook/chapter3/currency.