book

Mastering Go - Fourth Edition

Name: Mastering Go - Fourth Edition
Author: Mihalis Tsoukalos
ISBN: 9781805127147

by Mihalis Tsoukalos

March 2024

Intermediate to advanced

740 pages

14h 57m

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
Getting the most out of this book – get to know your free benefits Introducing GoThe history of GoThe advantages of GoWhen to use GoMy personal Go journeyThe go doc and godoc utilitiesHello World!Introducing functionsIntroducing packagesRunning Go codeCompiling Go codeUsing Go like a scripting languageImportant formatting and coding rulesWhat you should know about GoDefining and using variablesConstantsGlobal 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 entriesWriting to multiple log filesDeveloping a statistics applicationSummaryExercisesAdditional resources
Basic Go Data Types
The error data typeNumeric data typesAvoiding overflowsNon-numeric data typesStrings, characters, and runesConverting int to stringThe unicode packageThe strings packageTimes and datesWorking with different time zonesConstantsThe constant generator iotaTyped and untyped constantsGrouping similar dataArraysSlicesAbout slice length and capacitySelecting a part of a sliceByte slicesDeleting an element from a sliceHow slices are connected to arraysCatching out of bounds errorsThe copy() functionSorting slicesPointersConverting a slice to an array or an array pointerData types and the unsafe packageGenerating random numbersGenerating random stringsGenerating secure random numbersUpdating the statistics applicationSummaryExercisesAdditional resources
Composite Data Types
MapsHow to tell whether a key exists on a mapStoring to a nil mapIterating over mapsStructuresThe type keywordDefining new structuresUsing the new keywordSlices of structuresRegular expressions and pattern matchingAbout regexp.Compile and regexp.MustCompileGo regular expressionsAbout raw string and interpreted string literalsMatching names and surnamesMatching integersImproving the statistics applicationWorking with CSV filesThe updated version of the statistics applicationSummaryExercisesAdditional resources
Go Generics
An introduction to genericsHello, generics!ConstraintsCreating constraintsSupporting underlying data typesSupporting slices of any typeDefining new data types with genericsUsing generics in Go structuresThe cmp packageThe slices packageShallow and deep copiesThe maps packageWhen to use genericsSummaryExercisesAdditional resources
Reflection and Interfaces
ReflectionUnderstanding the internal structure of a Go structureChanging structure values using reflectionThe three disadvantages of reflectionType methodsCreating type methodsValue and point receiversUsing type methodsInterfacesThe sort.Interface interfaceThe empty interfaceType assertions and type switchesThe map[string]interface{} mapThe error data typeWriting your own interfacesUsing a Go interfaceObject-oriented programming in GoInterfaces versus genericsReflection versus genericsUpdating the statistics applicationSummaryExercisesAdditional resources
Go Packages and Functions
Go packagesAbout go get and go installFunctionsAnonymous 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 keywordBig O complexityDeveloping your own packagesThe init() functionOrder of executionUsing GitHub to store Go packagesA package for working with SQLiteWorking with SQLite3 and GoStoring the Go packageThe design of the Go packageThe implementation of the Go packageTesting the Go packageModulesCreating better packagesGenerating documentationWorkspacesVersioning utilitiesSummaryExercisesAdditional resources
Telling a UNIX System What to Do
stdin, stdout, and stderrUNIX processesFile 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 recordsThe viper packageUsing command line flagsReading JSON configuration filesThe cobra packageA utility with three commandsAdding command line flagsCreating command aliasesCreating subcommandsImportant Go featuresEmbedding filesReadDir and DirEntryThe io/fs packageUpdating the statistics applicationThe slog packageSending logs to io.DiscardUsing cobraStoring and loading JSON dataImplementing the list commandImplementing the insert commandSummaryExercisesAdditional resources
Go Concurrency
Processes, threads, and goroutinesThe Go schedulerThe GOMAXPROCS environment variableConcurrency and parallelismGoroutinesCreating a goroutineCreating multiple goroutinesWaiting for all 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 conditions are badThe 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 goroutinesHandling UNIX signalsHandling two signalsShared 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 packageAbout context.WithCancelCauseThe semaphore packageMaking the statistics application concurrentSummaryExercisesAdditional resources
Building Web Services
The net/http packageThe http.Response typeThe http.Request typeThe http.Transport typeCreating a web serverUpdating the statistics applicationDefining the APIImplementing the handlersCreating a Docker imageDeveloping web clientsUsing http.NewRequest() to improve the clientUsing errGroupCreating a client for the statistics serviceTiming out HTTP connectionsUsing SetDeadline()Setting the timeout period on the client sideSetting the timeout period on the server sideSummaryExercisesAdditional resources

Working with TCP/IP and WebSocket
TCP/IPThe nc(1) command line utilityThe net packageDeveloping a TCP clientDeveloping 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 serversCreating a WebSocket serverThe implementation of the serverUsing websocatCreating a WebSocket clientWorking with RabbitMQRunning RabbitMQWriting to RabbitMQReading from RabbitMQHow to remove a moduleSummaryExercisesAdditional 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 subroutersThe Gin HTTP frameworkGin versus GorillaWorking with the databaseImplementing 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 versionsSummaryExercisesAdditional resources
Code Testing and Profiling
Optimizing codeRewriting the main() function for better testingProfiling 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.goTesting UNIX signalsDisabling test cachingThe testing.TempDir() functionThe Cleanup() functionThe testing/quick packageTiming out testsTesting using testing.T.Fatal() and testing.T.Fatalf()Table-driven testsTesting code coverageFinding unreachable Go codeTesting an HTTP server with a database backendThe govulncheck toolInstalling the toolCross-compilationUsing go:generateCreating example functionsSummaryExercisesAdditional resources
Fuzz Testing and Observability
Fuzz testingA simple fuzz testing exampleAn advanced fuzz testing exampleCorrecting the bugObservabilityThe runtime/metrics packageMeasuring the execution time of a functionThe expvar packageLearning about CPU characteristicsExposing metrics to PrometheusExposing metricsCreating a Docker image for a Go serverSpecifying the metrics to exposeGetting the metricsPutting the metrics in PrometheusVisualizing Prometheus metrics in GrafanaSummaryExercisesAdditional resources
Efficiency and Performance
Benchmarking codeA simple benchmark scenarioBenchmarking the number of memory allocationsInitial versionImproving the number of memory allocationsBuffered versus unbuffered file I/OThe benchstat utilityWrongly defined benchmark functionsGo memory managementHeap and stackThe main elements of the Go memory modelMemory leaksSlices and memory leaksMaps and memory leaksMemory pre-allocationWorking with eBPFWhat is eBPF?About observability and eBPFCreating an eBPF tool in GoSummaryExercisesAdditional resources
Changes in Recent Go Versions
About rand.Seed()What is new in Go 1.21?The sync.OnceFunc() functionThe clear functionWhat is new in Go 1.22?Changes in slicesChanges in for loopsThe math/rand/v2 packageSummaryExercisesAdditional resources
Unlock Your Book’s Exclusive Benefits
How to unlock these benefits in three easy stepsStep 3Need help?
Appendix
The Go Garbage CollectorGarbage collectionThe key characteristics of the Go GCLearning more about the Go GCThe tri-color algorithmMore about the operation of the Go GCMaps, slices, and the Go GCUsing slicesUsing maps with pointersUsing maps without pointersSplitting a mapComparing the performance of the presented techniquesAdditional resources
Other Books You May Enjoy
Index

Content preview from Mastering Go - Fourth Edition

4 Go Generics

This chapter is about generics and how to use the new syntax to write generic functions and define generic data types. Generic programming is a programming paradigm that allows the developer to implement a function using one or more data types that are going to be provided at a later time.

The Go generics support came with Go 1.18, which was officially released in February 2022. As a result, Go generics is now old news! Nevertheless, the Go community is still trying to make sense and good use of generics. In fact, most Go developers are already doing their job without the help of generics.

If you feel that this chapter does not interest you at this point of your learning journey, feel free to skip it and come back at a later stage. ...

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: 9781805127147

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Mastering Go - Fourth Edition

by Mihalis Tsoukalos

4

Go Generics

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.