book

Mastering Go - Third Edition

Name: Mastering Go - Third Edition
Author: Mihalis Tsoukalos
ISBN: 9781801079310

by Mihalis Tsoukalos

August 2021

Beginner to intermediate

682 pages

13h 37m

English

Packt Publishing

Read now

Unlock full access

Preface
Who this book is forWhat this book coversTo get the most out of this bookGet in touch
A Quick Introduction to Go
Introducing GoThe history of GoWhy UNIX and not Windows?The advantages of GoThe go doc and godoc utilitiesHello World!Introducing functionsIntroducing packagesRunning Go codeCompiling Go codeUsing Go like a scripting languageImportant formatting and coding rulesImportant characteristics of GoDefining and using variablesPrinting variablesControlling program flowIterating with for loops and rangeGetting user inputReading from standard inputWorking with command-line argumentsUsing error variables to differentiate between input typesUnderstanding the Go concurrency modelDeveloping the which(1) utility in GoLogging informationlog.Fatal() and log.Panic()Writing to a custom log filePrinting line numbers in log entriesOverview of Go genericsDeveloping a basic phone book applicationExercisesSummaryAdditional resources
Basic Go Data Types
The error data typeNumeric data typesNon-numeric data typesStrings, Characters, and RunesConverting from int to stringThe unicode packageThe strings packageTimes and datesA utility for parsing dates and timesWorking with different time zonesGo constantsThe constant generator iotaGrouping similar dataArraysSlicesAbout slice length and capacitySelecting a part of a sliceByte slicesDeleting an element from a sliceHow slices are connected to arraysThe copy() functionSorting slicesPointersGenerating random numbersGenerating random stringsGenerating secure random numbersUpdating the phone book applicationExercisesSummaryAdditional resources
Composite Data Types
MapsStoring to a nil mapIterating over mapsStructuresDefining new structuresUsing the new keywordSlices of structuresRegular expressions and pattern matchingAbout Go regular expressionsMatching names and surnamesMatching integersMatching the fields of a recordImproving the phone book applicationWorking with CSV filesAdding an indexThe improved version of the phone book applicationExercisesSummaryAdditional resources
Reflection and Interfaces
ReflectionLearning the internal structure of a Go structureChanging structure values using reflectionThe three disadvantages of reflectionType methodsCreating type methodsUsing type methodsInterfacesThe sort.Interface interfaceThe empty interfaceType assertions and type switchesThe map[string]interface{} mapThe error data typeWriting your own interfacesUsing a Go interfaceImplementing sort.Interface for 3D shapesWorking with two different CSV file formatsObject-oriented programming in GoUpdating the phone book applicationSetting up the value of the CSV fileUsing the sort packageExercisesSummaryAdditional resources
Go Packages and Functions
Go packagesDownloading Go packagesFunctionsAnonymous functionsFunctions that return multiple valuesThe return values of a function can be namedFunctions that accept other functions as parametersFunctions can return other functionsVariadic functionsThe defer keywordDeveloping your own packagesThe init() functionOrder of executionUsing GitHub to store Go packagesA package for working with a databaseGetting to know your databaseStoring the Go packageThe design of the Go packageThe implementation of the Go packageTesting the Go packageModulesCreating better packagesGenerating documentationGitLab Runners and GoThe initial version of the configuration fileThe final version of the configuration fileGitHub Actions and GoStoring secrets in GitHubThe final version of the configuration fileVersioning utilitiesExercisesSummaryAdditional resources
Telling a UNIX System What to Do
stdin, stdout, and stderrUNIX processesHandling UNIX signalsHandling two signalsFile I/OThe io.Reader and io.Writer interfacesUsing and misusing io.Reader and io.WriterBuffered and unbuffered file I/OReading text filesReading a text file line by lineReading a text file word by wordReading a text file character by characterReading from /dev/randomReading a specific amount of data from a fileWriting to a fileWorking with JSONUsing Marshal() and Unmarshal()Structures and JSONReading and writing JSON data as streamsPretty printing JSON recordsWorking with XMLConverting JSON to XML and vice versaWorking with YAMLThe viper packageUsing command-line flagsReading JSON configuration filesThe cobra packageA utility with three commandsAdding command-line flagsCreating command aliasesCreating subcommandsFinding cycles in a UNIX file systemNew to Go 1.16Embedding filesReadDir and DirEntryThe io/fs packageUpdating the phone book applicationUsing cobraStoring and loading JSON dataImplementing the delete commandImplementing the insert commandImplementing the list commandImplementing the search commandExercisesSummaryAdditional resources
Go Concurrency
Processes, threads, and goroutinesThe Go schedulerThe GOMAXPROCS environment variableConcurrency and parallelismGoroutinesCreating a goroutineCreating multiple goroutinesWaiting for your goroutines to finishWhat if the number of Add() and Done() calls differ?Creating multiple files with goroutinesChannelsWriting to and reading from a channelReceiving from a closed channelChannels as function parametersRace conditionsThe Go race detectorThe select keywordTiming out a goroutineTiming out a goroutine – inside main()Timing out a goroutine – outside main()Go channels revisitedBuffered channelsnil channelsWorker poolsSignal channelsSpecifying the order of execution for your goroutinesShared memory and shared variablesThe sync.Mutex typeWhat happens if you forget to unlock a mutex?The sync.RWMutex typeThe atomic packageSharing memory using goroutinesClosured variables and the go statementThe context packageUsing context as a key/value storeThe semaphore packageExercisesSummaryAdditional resources
Building Web Services
The net/http packageThe http.Response typeThe http.Request typeThe http.Transport typeCreating a web serverUpdating the phone book applicationDefining the APIImplementing the handlersExposing metrics to PrometheusThe runtime/metrics packageExposing metricsCreating a Docker image for a Go serverExposing the desired metricsReading metricsPutting the metrics in PrometheusVisualizing Prometheus metrics in GrafanaDeveloping web clientsUsing http.NewRequest() to improve the clientCreating a client for the phone book serviceCreating file serversDownloading the contents of the phone book applicationTiming out HTTP connectionsUsing SetDeadline()Setting the timeout period on the client sideSetting the timeout period on the server sideExercisesSummaryAdditional resources
Working with TCP/IP and WebSocket
TCP/IPThe nc(1) command-line utilityThe net packageDeveloping a TCP client Developing a TCP client with net.Dial()Developing a TCP client that uses net.DialTCP()Developing a TCP serverDeveloping a TCP server with net.Listen()Developing a TCP server that uses net.ListenTCP()Developing a UDP clientDeveloping a UDP serverDeveloping concurrent TCP serversWorking with UNIX domain socketsA UNIX domain socket serverA UNIX domain socket clientCreating a WebSocket serverThe implementation of the serverUsing websocatUsing JavaScriptCreating a WebSocket clientExercisesSummaryAdditional resources

Working with REST APIs
An introduction to RESTDeveloping RESTful servers and clientsA RESTful serverA RESTful clientCreating a functional RESTful serverThe REST APIUsing gorilla/muxThe use of subroutersWorking with the databaseTesting the restdb packageImplementing the RESTful serverTesting the RESTful serverTesting GET handlersTesting POST handlersTesting the PUT handlerTesting the DELETE handlerCreating a RESTful clientCreating the structure of the command-line clientImplementing the RESTful client commandsUsing the RESTful clientWorking with multiple REST API versionsUploading and downloading binary filesUsing Swagger for REST API documentationDocumenting the REST APIGenerating the documentation fileServing the documentation fileExercisesSummaryAdditional resources
Code Testing and Profiling
Optimizing codeBenchmarking codeRewriting the main() function for better testingBenchmarking buffered writing and readingThe benchstat utilityWrongly defined benchmark functionsProfiling codeProfiling a command-line applicationProfiling an HTTP serverThe web interface of the Go profilerThe go tool trace utilityTracing a web server from a clientVisiting all routes of a web serverTesting Go codeWriting tests for ./ch03/intRE.goThe TempDir functionThe Cleanup() functionThe testing/quick packageTiming out testsTesting code coverageFinding unreachable Go codeTesting an HTTP server with a database backendFuzzingCross-compilationUsing go:generateCreating example functionsExercisesSummaryAdditional resources
Working with gRPC
Introduction to gRPCProtocol buffersDefining an interface definition language fileDeveloping a gRPC serverDeveloping a gRPC clientTesting the gRPC server with the clientExercisesSummaryAdditional resources
Go Generics
Introducing genericsConstraintsCreating constraintsDefining new data types with genericsUsing generics in Go structuresInterfaces versus genericsReflection versus genericsExercisesSummaryAdditional resources
Appendix A – Go Garbage Collector
Heap and stackGarbage collectionThe tricolor algorithmMore about the operation of the Go garbage collectorMaps, slices, and the Go garbage collectorUsing a sliceUsing a map with pointersUsing a map without pointersSplitting the mapComparing the performance of the presented techniquesAdditional resources
Other Books You May Enjoy
Index

Content preview from Mastering Go - Third Edition

7 Go Concurrency

The key component of the Go concurrency model is the goroutine, which is the minimum executable entity in Go. Everything in Go is executed as a goroutine, either transparently or consciously. Each executable Go program has at least one goroutine, which is used for running the main() function of the main package. Each goroutine is executed on a single OS thread according to the instructions of the Go scheduler, which is responsible for the execution of goroutines. The OS scheduler does not dictate how many threads the Go runtime is going to create because the Go runtime will spawn enough threads to ensure that GOMAXPROCS threads are available to run Go code.

However, goroutines cannot directly communicate with each other. Data ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781801079310

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Mastering Go - Third Edition

by Mihalis Tsoukalos

7

Go Concurrency

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.