book

Practical Systems Programming in Go

Name: Practical Systems Programming in Go
Author: Mihalis Tsoukalos
ISBN: 9781806112197

by Mihalis Tsoukalos

March 2026

Intermediate

588 pages

14h 46m

English

Packt Publishing

Read now

Unlock full access

Preface
Free benefits with your book
Part 1: A quick introduction to Go
Chapter 1: Essential Go
Why use Go?Go versus Rust versus Zig versus CHow to run Go codeFundamental data typesVariables and constantsPublic and private (exported and unexported)Printing valuesNumeric data typesStrings and runesLearning about strings.BuilderError handlingArrays and slicesArraysSlicesSlicingFunctionsIterator functionsLearning how to use regular expressionsWorking with command-line argumentsThe viper and cobra packagesThe viper packageThe cobra packageImplementing which(1)Implementing basename(1)SummaryExercisesAdditional resources
Chapter 2: Data Collections and Functions
Understanding and using mapsUnderstanding the versatility of structuresPointersSummaryExercisesAdditional resources
Chapter 3: Go Concurrency
Learning about goroutinesCreating goroutinesWaiting for goroutines to finish their jobsWaitGroup.Go – new in Go 1.25Learning about channelsLearning about the select statementHandling multiple channels with selectExchanging data with channelsBuffered and unbuffered channelsTiming out goroutines with channelsImplementing worker poolsSignal channelsMonitor goroutinesCatching deadlocks and race conditionsRace conditionsConcurrent matrix multiplication in GoDeadlocksSummaryExercisesAdditional resources
Chapter 4: Advanced Go
The Go program execution processCommon misconceptions about GoGo is slow because it has garbage collectionChannels are the best way to do all concurrency in GoGo does not need profiling as it is already fastThe Go compiler does not optimize muchGoroutines are just like threadsGo does not support fine-grained control over memoryGo is just another general-purpose languageThe Go garbage collectorLearning about the GOGC environment variableMemory leaksPointers and references creating memory leaksGoroutines creating memory leaksThe Go schedulerLearning about the effects of GOMAXPROCSProfile-Guided Optimization (PGO)make and newWorkspacesInterfacesThe empty interfaceThe uses of the empty interfaceReflectionInspecting structures with reflectionGenericsPackages and modulesTesting Go codeTesting ch01/basename.goThe synctest packageUnderstanding how dates and times workBenchmarking Go codeBenchmarking ch04/jsonReflection.goBenchmarking PGO gainsProfiling applicationsSummaryExercisesAdditional resources
Part 2: Systems Programming Essentials
Chapter 5: Working with File I/O
When learning, implement what you need or likestdin, stdout, and stderrChecking whether a file path existsReading filesFile seekingUnbuffered readingBuffered readingBenchmarking buffered and unbuffered readingProfiling buffered and unbuffered readingReading a file line by lineReading a file word by wordReading a file character by characterWriting filesCreating new filesCreating a file if it does not existAppending to filesSystem logging and logging to filesUnbuffered writingBuffered writingBenchmarking buffered and unbuffered writingBenchmarking buffer size in buffered writingBenchmarking file copyingConverting tabs to spaces and vice versaDeveloping wc(1)SummaryExercisesAdditional resources
Chapter 6: UNIX Signals and File Systems
A storyHandling UNIX signalsDifferentiating between file typesFinding more information about filesThe io/fs packageTraversing directory treesEmbedding static assets in Go binariesA utility for finding empty directoriesCreating the tree(1) utility in GoCopying a single file into multiple directoriesCreating the dd(1) utility in GoSummaryExercisesAdditional resources
Chapter 7: Working with Structured Data and Databases
Working with JSON dataWorking with a stream of JSON recordsJSON benchmarkingConverting from JSON to XMLJSON's evolution: json/v2Solving the traveling salesman problemCreating sample graphsImplementing the traveling salesman algorithmImplementing the Dijkstra algorithmWorking with SQLite3The use of external Go modulesDemonstrating SQLite3 interactionsStoring JSON data in a SQLite3 databaseWorking with PostgreSQLUsing a Docker image for PostgreSQLCreating database reportsSummaryExercisesAdditional resources

Chapter 8: Programming TCP/IP Services
A storyDeveloping a TCP serverTesting the TCP serverMaking the TCP server concurrentDeveloping a TCP clientDeveloping a UDP serverDeveloping a UDP clientCollecting TCP/IP metricsContainerizing the serverStoring TCP/IP metricsRunning Prometheus and the Go server as Docker imagesSummaryExercisesAdditional resourcesSubscribe to Deep Engineering
Chapter 9: Creating Web Services
The net/http packageCreating a simple HTTP server with middlewareCreating an HTTP clientProfiling HTTP applicationsTesting HTTP applicationsThe context packageCreating a proxy serverDeveloping a web serviceDeveloping a client for the web serviceImplementing the commandsReading data from PrometheusCreating sample data for PrometheusImplementing the utilitySummaryExercisesAdditional resources
Part 3: Applications
Chapter 10: Writing a Programming Language
Why create a new programming language?Defining the syntax of SMALLThe components of a programming languageThe lexerReading code from external filesThe parserThe evaluatorUsing SMALLSummaryExercisesAdditional resources
Chapter 11: Adding New Features to SMALL
Why do we need to extend a programming languageNew features in SMALLImplementing the updated version of SMALLThe lexerThe parserThe evaluatorUsing the languageWriting tests for SMALLSummaryExercisesAdditional resources
Chapter 12: Time Series Distances
If you only work for money, you will become miserableIntroduction to time seriesReading time seriesGetting information about a time seriesTime series distancesAbout the Euclidean distanceAbout the Chebyshev distanceAbout the Manhattan distanceAbout LCSSAbout DTWAbout MPdistCreating a summary of a time seriesCreating a Go packageWorking with workspacesDocumenting the packageHow to see the documentationPublishing the Go package on GitHubBenchmarking the distancesFinding the nearest neighbor of a time seriesUsing TigerBeetle for financial accountingConnecting to TigerBeetleWriting data to TigerBeetleReading the data backSummaryExercisesAdditional resources
Chapter 13: Time Series Data Mining
ClassificationClassification implementationClusteringClustering methodologyClustering implementationOutlier analysisTrying the Green Tea garbage collectorNew in Go 1.26: Goroutine metricsNew in Go 1.26: Goroutine leak profileSummaryExercisesAdditional resources
Chapter 14: Creating an Index for Unix Files
Understanding Binary TreesA sweet improvement to new()Understanding Radix TreesCreating a filesystem index serviceThe server codeUsing the serviceCreating a command-line clientAbout fsnotifyNew in Go 1.26: log to multiple targetsSummaryExercisesAdditional resources
Chapter 15: Unlock Your Exclusive Benefits
Unlock this Book's Free Benefits in 3 Easy Steps
Other Books You May Enjoy
Subscribe to Deep Engineering
Index

Content preview from Practical Systems Programming in Go

Part 1 A quick introduction to Go

In this first part of the book, you will develop a solid understanding of the Go programming language through the lens of a systems engineer. We begin by establishing the core syntax and philosophy, moving quickly into the data collections and patterns that underpin efficient software. The logic behind this section is to treat concurrency not as an advanced add-on but as a fundamental building block of the language, introduced early to ensure you can think in terms of parallel execution from the outset. By the end of this part, you will have mastered the advanced Go features necessary to build robust abstractions that remain performant under the pressures of a modern operating system.

This part of the book includes ...

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

Hands-On Software Engineering with Golang

Publisher Resources

ISBN: 9781806112197

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Practical Systems Programming in Go

by Mihalis Tsoukalos

Part 1

A quick introduction to Go

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.