Go Programming - From Beginner to Professional - Second Edition: Learn everything you need to build modern software using Go

Cover
Title Page
Copyright and Credits
Contributors
Table of Contents
Preface
Part 1: Scripts
Chapter 1: Variables and Operators
	Technical requirements
	Introduction to Go
	What does Go look like?
		Exercise 1.01 – using variables, packages, and functions to print stars
		Activity 1.01 – defining and printing
	Declaring variables
		Declaring a variable using var
		Exercise 1.02 – declaring a variable using var
		Declaring multiple variables at once with var
		Exercise 1.03 – declaring multiple variables at once with var
		Skipping the type or value when declaring variables
		Exercise 1.04 – skipping the type or value when declaring variables
		Type inference gone wrong
		Short variable declaration
		Exercise 1.05 – implementing a short variable declaration
		Declaring multiple variables with a short variable declaration
		Exercise 1.06 – declaring multiple variables from a function
		Using var to declare multiple variables in one line
		Non-English variable names
	Changing the value of a variable
		Exercise 1.07 – changing the value of a variable
		Changing multiple values at once
		Exercise 1.08 – changing multiple values at once
	Operators
		Exercise 1.09 – using operators with numbers
		Shorthand operators
		Exercise 1.10 – implementing shorthand operators
		Comparing values
		Exercise 1.11 – comparing values
		Zero values
		Exercise 1.12 – zero values
	Value versus pointer
		Getting a pointer
		Exercise 1.13 – getting a pointer
		Getting a value from a pointer
		Exercise 1.14 – getting a value from a pointer
		Function design with pointers
		Exercise 1.15 – function design with pointers
		Activity 1.02 – pointer value swap
	Constants
		Exercise 1.16 – constants
	Enums
		Activity 1.03 – message bug
		Activity 1.04 – bad count bug
	Summary
Chapter 2: Command and Control
	Technical requirements
	Introduction
	if statements
		Exercise 2.01 – a simple if statement
		if else statements
		Exercise 2.02 – using an if else statement
		else if statements
		Exercise 2.03 – using an else if statement
		initial if statements
		Exercise 2.04 – implementing initial if statements
	Expression switch statements
		Exercise 2.05 – using a switch statement
		Exercise 2.06 – switch statements and multiple case values
		Exercise 2.07 – expressionless switch statements
	Loops
		Exercise 2.08 – using a for i loop
		Exercise 2.09 – looping over arrays and slices
		range loop
		Exercise 2.10 – looping over a map
		Activity 2.01 – looping over map data using range
		Activity 2.02 – implementing FizzBuzz
	break and continue
		Exercise 2.11 – using break and continue to control loops
		Activity 2.03 – bubble sort
	goto statements
		Exercise 2.12 – using goto statements
	Summary
Chapter 3: Core Types
	Technical requirements
	Introduction
	True and false
		Exercise 3.01 – Program to measure password complexity
	Numbers
		Integers
		Floating-point numbers
		Exercise 3.02 – Floating-point number accuracy
		Overflow and wraparound
		Exercise 3.03 – Triggering number wraparound
		Big numbers
		Exercise 3.04 – Big numbers
	byte
	Text
		Rune
		Exercise 3.05 – Safely looping over a string
	The nil value
		Activity 3.01 – Sales tax calculator
		Activity 3.02 – Loan calculator
	Summary
Chapter 4: Complex Types
	Technical requirements
	Introduction
	Collection types
	Arrays
		Exercise 4.01 – Defining an array
		Comparing arrays
		Exercise 4.02 – Comparing arrays
		Initializing arrays using keys
		Exercise 4.03 – Initializing an array using keys
		Reading from an array
		Exercise 4.04 – Reading a single item from an array
		Writing to an array
		Exercise 4.05 – Writing to an array
		Looping over an array
		Exercise 4.06 – Looping over an array using a “for i” loop
		Modifying the contents of an array in a loop
		Exercise 4.07 – Modifying the contents of an array in a loop
		Activity 4.01 – Filling an array
	Slices
		Exercise 4.08 – Working with slices
		Appending multiple items to a slice
		Exercise 4.09 – Appending multiple items to a slice
		Creating slices from slices and arrays
		Exercise 4.10 – Creating slices from a slice
		Understanding slice internals
		Exercise 4.11 – Using make to control the capacity of a slice
		Background behavior of slices
		Exercise 4.12 – Controlling internal slice behavior
		Map fundamentals
		Exercise 4.13 – Creating, reading, and writing a map
		Reading from maps
		Exercise 4.14 – Reading from a map
		Activity 4.02 – Printing a user’s name based on user input
		Activity 4.03 – Slicing the week
		Deleting elements from a map
		Exercise 4.15 – Deleting an element from a map
		Activity 4.04 – Removing an element from a slice
	Simple custom types
		Exercise 4.16 – Creating a simple custom type
	Structs
		Exercise 4.17 – Creating struct types and values
		Comparing structs to each other
		Exercise 4.18 – Comparing structs to each other
		Struct composition using embedding
		Exercise 4.19 – Struct embedding and initialization
		Activity 4.05 – Creating a locale checker
		Type conversions
		Exercise 4.20 – Numeric type conversions
		Type assertions and interface{}
		Exercise 4.21 – Type assertions
		Type switch
		Exercise 4.22 – Type switch
		Activity 4.06 – Type checker
	Summary
Part 2: Components
Chapter 5: Functions – Reduce, Reuse, and Recycle
	Technical requirements
	Introduction
	Functions
		Parts of a function
	The checkNumbers function
		Exercise 5.01 – creating a function to print salesperson expectation ratings from the number of items sold
	Parameters
		The difference between an argument and a parameter
		Exercise 5.02 – mapping index values to column headers
		Function variable scope
		Return values
		Exercise 5.03 – creating a checkNumbers function with return values
		Activity 5.01 – calculating the working hours of employees
	Naked returns
		Exercise 5.04 – mapping a CSV index to a column header with return values
		Variadic functions
		Exercise 5.05 – summing numbers
		Anonymous functions
		Exercise 5.06 – creating an anonymous function to calculate the square root of a number
	Closures
		Exercise 5.07 – creating a closure function to decrement a counter
		Function types
		Exercise 5.08 – creating various functions to calculate salary
	defer
		Activity 5.02 – calculating the payable amount for employees based on working hours
	Separating similar code
	Summary
Chapter 6: Don’t Panic! Handle Your Errors
	Technical requirements
	Introduction
	What are errors?
		Syntax errors
		Runtime errors
		Exercise 6.01 – runtime errors while adding numbers
		Semantic errors
		Exercise 6.02 – a semantic error with walking distance
		Error handling using other programming languages
	Error interface type
		Creating error values
		Exercise 6.03 – creating an application to calculate pay for the week
	Panic
		Exercise 6.04 – Crashing the program on errors using a panic
	Recover
		Exercise 6.05 – recovering from a panic
		Guidelines when working with errors and panics
		Error wrapping
		Activity 6.01 – creating a custom error message for a banking application
		Activity 6.02 – validating a bank customer’s direct deposit submission
		Activity 6.03 – panic on invalid data submission
		Activity 6.04 – preventing a panic from crashing the app
	Summary
Chapter 7: Interfaces
	Technical requirements
	Introduction
	Interface
		Defining an interface
		Implementing an interface
		Advantages of implementing interfaces implicitly
		Exercise 7.01 – implementing an interface
	Duck typing
	Polymorphism
		Empty interface
		Type assertion and switches
		Exercise 7.03 – analyzing empty interface{} data
		Activity 7.01 – calculating pay and performance review
		any
	Summary
Chapter 8: Generic Algorithm Superpowers
	Technical requirements
	Introduction
	When to use generics?
	Type parameters
		Activity 8.01 – a minimum value
	Type constraints
		Exercise 8.01 – calculate the maximum value using interfaces
		Exercise 8.02 – calculate the largest stock of items on a ranch
	Type inference
	When to use generics versus interfaces
	What are some best practices?
	Summary
Part 3: Modules
Chapter 9: Using Go Modules to Define a Project
	Technical requirements
	Introduction
	What is a module?
		Key components when working with Go modules
		The go.mod file
		The go.sum file
	How are modules helpful?
		Precise and simplified dependency management
		Versioning and reproducibility
		Improved collaboration
		Dependency safety
		Ease of use while promoting isolation and modularity
	Exercise 09.01 – creating and using your first module
	When should you use external modules, and why?
	Exercise 09.02 – using an external module within our module
	Consuming multiple modules within a project
		Activity 9.01 – consuming multiple modules
	Defining multiple modules within a project
	Go workspaces
		Exercise 09.03 – working with workspaces
	Summary
Chapter 10: Packages Keep Projects Manageable
	Technical requirements
	Introduction
		Maintainable
		Reusable
		Modular
	What is a package?
		Package structure
		Package naming
		Package declarations
	Exported and unexported code
		Package alias
		Main package
		Exercise 10.01 – Creating a package to calculate areas of various shapes
	The init() function
		Exercise 10.02 – Loading budget categories
		Executing multiple init() functions
		Exercise 10.03 – Assigning payees to budget categories
		Activity 10.01 – Creating a function to calculate payroll and performance review
	Summary
Chapter 11: Bug-Busting Debugging Skills
	Technical requirements
	Introduction
	Methods for bug-free code
		Coding incrementally and testing often
		Writing unit tests
		Handling all errors
		Performing logging
		Formatting using fmt
		Exercise 11.01 – Working with fmt.Println
		Formatting using fmt.Printf()
		Additional options for formatting
		Exercise 11.02 – Printing decimal, binary, and hex values
	Basic debugging
		Printing Go variable types
		Exercise 11.03 – Printing the Go representation of a variable
	Logging
	Logging fatal errors
		Activity 11.01 – Building a program to validate Social Security Numbers
	Debugging in live or restricted environments
	Summary
Chapter 12: About Time
	Technical requirements
	Introduction
	Making time
		Exercise 12.01 – Creating a function to return a timestamp
	Comparing time
	Duration calculation
	Managing time
		Exercise 12.02 – Duration of execution
	Formatting time
		Exercise 12.03 – What is the time in your zone?
		Activity 12.01 – Formatting a date according to user requirements
		Activity 12.02 – Enforcing a specific format of date and time
		Activity 12.03 – Measuring elapsed time
		Activity 12.04 – Calculating the future date and time
		Activity 12.05 – Printing the local time in different time zones
	Summary
Part 4: Applications
Chapter 13: Programming from the Command Line
	Technical requirements
	Introduction
	Reading arguments
		Exercise 13.01 – saying hello using a name passed as an argument
	Using flags to control behavior
		Exercise 13.02 – using flags to say hello conditionally
	Streaming large amounts of data in and out of your application
		Exercise 13.03 – using pipes, stdin, and stdout to apply a Rot13 encoding to a file
	Exit codes and command line best practices
	Knowing when to stop by watching for interrupts
	Starting other commands from your application
		Exercise 13.04 – creating a stopwatch with a time limit
	Terminal UIs
		Exercise 13.05 – creating a wrapper for our Rot13 pipeline
	go install
	Summary
Chapter 14: File and Systems
	Technical requirements
	Introduction
	Filesystem
		File permissions
	Flags and arguments
		Signals
		Exercise 14.01 – simulating a cleanup
	Create and write to files
		Reading the whole file at once
		Exercise 14.02 – backing up files
	CSV
	Embedding
	Summary
Chapter 15: SQL and Databases
	Technical requirements
	Introduction
	Understanding the database
		Installing and configuring Postgres SQL
	Database API and drivers
	Connecting to databases
		Creating a new project
	Creating tables
	Inserting data
		Exercise 15.01 – creating a table that holds a series of numbers
	Retrieving data
	Updating existing data
	Deleting data
		Exercise 15.02 – holding prime numbers in a database
	Truncating and deleting table
		Activity 15.01 – holding user data in a table
		Activity 15.02 – finding the messages of specific users
	Adding users with GORM
		Finding Users with GORM
	Summary
Part 5: Building For The Web
Chapter 16: Web Servers
	Technical requirements
	Introduction
	How to build a basic server
	HTTP handler
		Exercise 16.01 – creating a Hello World server
	Simple routing
		Exercise 16.02 – routing our server
	Handler versus handler function
		Activity 16.01 – adding a page counter to an HTML page
	Adding middleware
	Dynamic content
		Exercise 16.03 – personalized welcome
	Templating
		Exercise 16.04 – templating our pages
	Static resources
		Exercise 16.05 – creating a Hello World server using a static file
	Getting some style
		Exercise 16.06 – a stylish welcome
	Getting dynamic
		Activity 16.02 – external template
	Embedding external files
	Summary
Chapter 17: Using the Go HTTP Client
	Technical requirements
	Introduction
	The Go HTTP Client and its uses
	Sending a request to a server
		Exercise 17.01 – sending a GET request to a web server using the Go HTTP Client
	Structured data
		Exercise 17.02 – using the HTTP Client with structured data
		Activity 17.01 – requesting data from a web server and processing the response
	Sending data to a server
		Exercise 17.03 – sending a POST request to a web server using the Go HTTP Client
		Uploading files in a POST request
		Exercise 17.04 – uploading a file to a web server via a POST request
		Custom request headers
		Exercise 17.05 – using custom headers and options with the Go HTTP Client
		Activity 17.02 – sending data to a web server and checking whether the data was received using POST and GET
	Summary
Part 6: Professional
Chapter 18: Concurrent Work
	Technical requirements
	Introduction
	Goroutines
		Exercise 18.01 – using concurrent Goroutines
	WaitGroup
		Exercise 18.02 – experimenting with WaitGroup
	Race conditions
	Atomic operations
		Exercise 18.03 – an atomic change
	Invisible concurrency
	Channels
		Exercise 18.04 – exchanging greeting messages via channels
		Exercise 18.05 – two-way message exchange with channels
		Exercise 18.06 – summing numbers from everywhere
		Exercise 18.07 – request to Goroutines
	The importance of concurrency
		Exercise 18.08 – equally splitting work between Goroutines
	Concurrency patterns
	Buffers
		Exercise 18.09 – notifying when the computation has finished
		Some more common practices
	HTTP servers
	Methods as Goroutines
		Exercise 18.10 – a structured work
	Go context package
		Exercise 18.11 – managing Goroutines with a context
	Concurrent work with sync.Cond
		Exercise 18.12 – creating a WIP limited queue
	The thread-safe map
		Exercise 18.13 – counting how many times random numbers are between 0 and 9 using sync.Map
	Summary
Chapter 19: Testing
	Technical requirements
	Introduction
	Unit tests
		Exercise 19.01 – table-driven tests
	Integration tests
		Exercise 19.02 – integration test with a database
	E2E tests
	HTTP testing
		Exercise 19.03 – authentication integration with a test server
	Fuzz testing
	Benchmarks
	Test suites
		Exercise 19.04 – using TestMain to execute several test functions
	Test report
	Code coverage
	Summary
Chapter 20: Using Go Tools
	Technical requirements
	Introduction
	The go build tool
		Exercise 20.01 – using the go build tool
	The go run tool
		Exercise 20.02 – using the go run tool
	The gofmt tool
		Exercise 20.03 – using the gofmt tool
	The goimports tool
		Exercise 20.04 – using the goimports tool
	The go vet tool
		Exercise 20.05 – using the go vet tool
	The Go race detector
		Exercise 20.06 – using the Go race detector
	The go doc tool
		Exercise 20.07 – implementing the go doc tool
	The go get tool
		Exercise 20.08 – implementing the go get tool
		Activity 20.01 – using gofmt, goimport, go vet, and go get to correct a file
	Summary
Chapter 21: Go in the Cloud
	Technical requirements
	Introduction
	Making your app monitorable by systems such as Prometheus
		Exercise 21.01 – Creating an app with a /healthz endpoint
	Enabling deep insights through OpenTelemetry
		Exercise 21.02 – Using OpenTelemetry for queryable logs and tracing
	Best practices for putting your Go application in a container
		Exercise 21.03 – Creating a Dockerfile for a Go application
	Making your app ready to work with orchestrators such as Kubernetes
	Summary
Index
Other Books You May Enjoy