Learn Go with Pocket-Sized Projects (Final) (Aliénor Latour, Donia Chaiehloudj etc.) (z-library.sk, 1lib.sk, z-lib.sk)

Learn Go with Pocket-Sized Projects Aliénor Latour, Donia Chaiehloudj, and Pascal Bertrand To comment go to livebook. Manning Shelter Island For more information on this and other Manning titles go to manning.com.

copyright For online information and ordering of this and other Manning books, please visit www.manning.com. The publisher offers discounts on this book when ordered in quantity. For more information, please contact Special Sales Department Manning Publications Co. 20 Baldwin Road PO Box 761 Shelter Island, NY 11964 Email: orders@manning.com © 2025 Manning Publications Co. All rights reserved. No part of this publication may be reproduced, stored in a retrieval system, or transmitted, in any form or by means electronic, mechanical, photocopying, or otherwise, without prior written permission of the publisher. Many of the designations used by manufacturers and sellers to distinguish their products are claimed as trademarks. Where those designations appear in the book, and Manning Publications was aware of a trademark claim, the designations have been printed in initial caps or all caps.

Recognizing the importance of preserving what has been written, it is Manning’s policy to have the books we publish printed on acid- free paper, and we exert our best efforts to that end. Recognizing also our responsibility to conserve the resources of our planet, Manning books are printed on paper that is at least 15 percent recycled and processed without the use of elemental chlorine. Manning Publications Co. 20 Baldwin Road PO Box 761 Shelter Island, NY 11964 The author and publisher have made every effort to ensure that the information in this book was correct at press time. The author and publisher do not assume and hereby disclaim any liability to any party for any loss, damage, or disruption caused by errors or omissions, whether such errors or omissions result from negligence, accident, or any other cause, or from any usage of the information herein. ISBN 9781633438804 Printed in the United States of America Development editor: Doug Rudder Technical editor: Egon Elbre Review editors: Dunja Nikitović and Aleksandar Dragosavljević Production editor: Keri Hales Copy editor: Julie McNamee

Proofreader: Katie Tennant Technical proofreader: Mike Haller Typesetter: Tamara Švelić Sabljić Cover designer: Marija Tudor

dedication To Pulsar, that brought us together, and tea time, that keeps us together —Aliénor To Didier, Lila, my mum, and all the gophers —Donia To my parents, who nurtured in me a love for books —Pascal

contents foreword preface acknowledgments about this book about the authors about the cover illustration 1 Meet Go 1.1 What is Go? 1.2 Why you should learn Go 1.2.1 How and where Go can help you 1.2.2 Where can Go cannot help you 1.2.3 Comparison with commonly used languages 1.3 Why pocket-sized projects? 1.3.1 What you’ll know after reading the book (and writing the code) 2 Hello, earth! Extend your hello, world 2.1 Any travel begins at home 2.1.1 Our first program: main.go 2.1.2 Let’s test with the Example function 2.1.3 Calling the greet function 2.1.4 Testing a specific function with the testing package 2.2 Are you a polyglot?

2.2.1 Parlez-vous français? The switch angle 2.2.2 Adapt the test with Test functions 2.3 Supporting more languages with a phrasebook 2.3.1 Introducing the Go map hash table 2.3.2 Writing a table-driven test 2.4 Using the flag package to read the user’s language 2.4.1 Add a flag 2.4.2 Test the command-line interface 2.5 Side quests 3 A bookworm’s digest: Playing with loops and maps 3.1 Loading the JSON data 3.1.1 Defining a JSON example 3.1.2 Opening a file 3.1.3 Parse the JSON 3.1.4 Test it 3.2 Finding books that bookworms have in common 3.2.1 Count the books 3.2.2 Keeping higher occurrences 3.2.3 Determinism 3.3 Print 3.4 Improvements 3.4.1 Implement sort.Interface 3.4.2 Exercise: Reading recommendations 3.4.3 Using bufio to open a file 4 A log story: Creating a library 4.1 Defining the API

4.1.1 Package summary 4.1.2 Exporting the supported levels 4.1.3 Object-oriented Go: “GoOOP”? 4.1.4 The New() function 4.1.5 What about testing? 4.1.6 Documenting code 4.2 Implementing the exported methods 4.2.1 Default implementation 4.2.2 Interfacing 4.2.3 Refactoring 4.3 The functional options pattern 4.3.1 Creating configurations 4.3.2 Testing our example 4.4 Additional functionalities 4.4.1 Logging the log level 4.4.2 Exposing the generic logging function 4.5 Logging: Best practices 5 Gordle: Play a word game in your terminal 5.1 Basic main version 5.1.1 Mini main 5.1.2 Read player’s input 5.1.3 Isolate the check 5.1.4 Check for victory 5.2 Providing feedback 5.2.1 Define character status 5.2.2 Checking a guess against the solution

5.3 Corpus 5.3.1 Create a list of words 5.3.2 Read the corpus 5.3.3 Pick a word 5.3.4 Let’s play! 5.4 The limit of runes 5.5 Conclusion 6 Money converter: CLI around an HTTP call 6.1 Business definitions 6.1.1 Converting money 6.2 Representing money 6.2.1 Floating-point numbers 6.2.2 Back to money 6.2.3 Floating-point number operations 6.2.4 Implementing decimals 6.2.5 Currency value object 6.2.6 NewAmount 6.3 Applying conversion logic 6.3.1 Applying an exchange rate 6.3.2 Validating the result 6.4 Writing the CLI 6.4.1 Flags and arguments 6.4.2 Parse into business types 6.4.3 Stringer 6.4.4 Convert 6.5 Calling the bank

6.5.1 Dependency injection: Theory 6.5.2 ECB package 6.5.3 HTTP call: Easy version 6.5.4 Parse the response 6.5.5 Integration in the money package 6.5.6 Dependency injection in main 6.5.7 Sharing the executable 6.6 Making improvements 6.6.1 Caching 6.6.2 Timeout 6.6.3 Alternative tree 7 Caching with generics 7.1 A naive cache 7.1.1 Introduction to generics 7.1.2 Project initialization 7.1.3 Implementation 7.2 Introducing goroutines 7.2.1 What’s a goroutine? 7.2.2 How to launch a goroutine 7.2.3 Using channels to communicate that a goroutine has ended 7.2.4 Running goroutines and having a synchronization point 7.3 A more thread-safe cache 7.3.1 Using goroutines 7.3.2 Using t.Parallel() 7.3.3 Using go test -race . 7.3.4 Add a mutex

7.4 Possible improvements 7.4.1 Adding time to live 7.4.2 Add a maximum number of items in the cache 7.5 Common mistakes 7.5.1 When to use channels in a concurrency situation 7.5.2 Concurrency effect of a workload type 7.5.3 Finish your goroutines 8 Gordle as a service 8.1 Empty shell for the new service 8.1.1 Server, service, web service, endpoints, and HTTP handlers 8.1.2 Let’s code 8.2 Adding endpoints 8.2.1 Create a new game 8.2.2 Get the game status 8.2.3 Guess 8.3 Domain objects 8.3.1 Domain types 8.3.2 API adapters 8.4 Repository 8.4.1 In-memory database 8.4.2 Simplest repository 8.4.3 Service-level dependency 8.4.4 Add a mutex to the repository 8.5 Adapting the Gordle library 8.5.1 API of the library 8.5.2 Usage in the endpoints

8.6 Security notions and improvements 8.6.1 Limiting the number of requests served at a time 8.6.2 User authentication 8.6.3 Logging 8.6.4 Error formatting 8.6.5 Decode query parameters 9 Concurrent maze solver 9.1 Maze generation 9.1.1 What is an image? 9.1.2 Maze constraints 9.2 Maze solver 9.2.1 Setup 9.2.2 Loading the maze image 9.2.3 Add the solver 9.3 Let’s go exploring! 9.3.1 Finding the entrance 9.3.2 Communicating new possible paths 9.3.3 Recording the explored path 9.3.4 Waiting for unexplored paths and starting a goroutine 9.3.5 Stop listening, we found it: Short version 9.3.6 Testing one goroutine’s logic 9.4 Show the result 9.5 Notify when the treasure is found 9.5.1 Keep track of all the goroutines 9.5.2 Send a quit signal 9.6 Visualization

9.6.1 Overcome the loop constraint 9.6.2 Animate the exploration 10 Habits tracker using gRPC 10.1 API definition 10.1.1 Protobuf declaration 10.1.2 Code generation 10.2 Empty service 10.2.1 Creating a small logger 10.2.2 Server structure 10.2.3 Creating and running the server 10.3 First endpoint: Create 10.3.1 Business layer 10.3.2 API layer 10.3.3 Data retention 10.4 Unit testing with generated mocks 10.4.1 Generate mocks 10.4.2 Use the mocks 10.5 Integration testing 10.5.1 List habits 10.5.2 Integration with go test 10.6 Getting the best out of the context 10.6.1 What is a context? 10.6.2 Create a context 10.6.3 Using a context 10.7 Track your habits 10.7.1 Tick a habit

10.7.2 Store ticks per week 10.7.3 Handle corner cases 10.7.4 Get habit status 10.7.5 Add a timestamp 10.7.6 Habit tracker in action 11 HTML templating with a gRPC client 11.1 Your basic HTTP server 11.1.1 Hello plain text 11.1.2 Templates: Display a variable 11.1.3 Add a gRPC client 11.2 Basic template operations 11.2.1 Iterate through a slice 11.2.2 Accessing fields 11.2.3 Conditional formatting 11.3 Send a tick to the server 11.3.1 What page should we display? 11.3.2 Send tick to the backend 11.3.3 Adding colors 11.4 Use a form to create a habit 11.4.1 HTML form 11.4.2 Read a form’s values 11.5 More template niceties 11.5.1 Passing more than one object to the template 11.5.2 Calling functions 11.5.3 Using define to declare functions 12 Go for other architectures

12.1 Getting started with Wasm 12.1.1 Some practice with Hello Wasm 12.1.2 Write a file server 12.2 Multiplication quiz project 12.2.1 Displaying random numbers on the HTML page 12.2.2 Registering functions in Go 12.2.3 Reading an input from the page 12.3 TinyGo 12.3.1 Building a simple TinyGo application 12.3.2 Differences with Go 12.3.3 Debugging and deploying with TinyGo appendix A Installation steps A.1 Install A.2 Check A.3 Go’s environment variables A.3.1 The go env command A.3.2 The GOBIN variable A.3.3 The GOPATH variable A.3.4 The GOROOT variable A.4 Hello! A.5 Installing new dependencies A.5.1 go install A.5.2 go get A.6 Code editors appendix B Formatting cheat sheet appendix C Zero values

C.1 What is a zero value? C.2 The zero values of any types C.3 Slices and maps specificities C.4 Benefiting from zero values appendix D Benchmarking appendix E Passing by value or by reference E.1 Go passes everything by value E.1.1 Copying parameters on the stack E.1.2 Using pointers E.1.3 Shallow copies E.1.4 Functions vs. methods E.2 Special types of parameters: slices, maps, and channels E.2.1 Passing a slice as a parameter E.2.2 maps, channels, and more E.3 A few recommendations E.3.1 Passing by value should be the default E.3.2 Passing by pointer is a minor optimization E.3.3 Passing by pointer when mutating E.3.4 Using slices and maps E.3.5 Passing a pointer to a slice or to a map E.3.6 Writing your own Copy function appendix F Fuzzing F.1 A new testing method F.2 How it works F.3 Writing a first test F.3.1 Function under test

F.3.2 Fuzz test F.4 Running and interpreting fuzz tests F.5 Fixing the breach F.6 Best practices and common pitfalls appendix G Connecting to a database G.1 Setup G.1.1 Starting a PostgreSQL database locally G.1.2 Seed the schema G.2 Repository package G.2.1 Injecting a connection G.2.2 Querying the database G.3 Libraries index

foreword Programming is for everyone. This dream of making computers available and easier to use has been one of the guiding principles for so many pioneers in this still evolving field. We are the inheritors of this fantastic legacy. And by we, of course, I mean you and I, the generations of people who have been able to follow some of the many paths to computer use that have already been prepared for us, in particular, that collection of tools for thought known as programming languages. A few of those very smart yet practical people created the Go programming language. Go can be quite expressive, despite having a small number of keywords compared to many other popular programming languages. This makes it a lot easier to remember, but certainly doesn’t always make it obvious how to make Go do what you want, at least not without some guidance. The real trick is to make it easier for people to make some relatively quick progress toward whatever they want to achieve, while at the same time preparing them with the deeper knowledge they will need to go further. And one of the best ways to accomplish this is by way of a well-thought-out book, such as the one you’re looking at right now. Learn Go with Pocket-Sized Projects gives you practical projects that are neither too big to wrap your head around quickly, nor too small to actually show you something useful. Along the way, the book is seasoned with a number of important techniques that you’ll surely need, shared with a wry humor that keeps you smiling. Regardless if you’re a student, hobbyist, or professional practitioner, there’s something for you to grab ahold of and run with for a bit. And that is a great way to learn. The book introduces you to some among the wide spectrum of possibilities that Go can be used for. From an elaborated hello, world, to making LEDs

blink on an Arduino, it contains a nice collection of different small applications to help you feel full but not overstuffed. Most importantly, the book does so with a sense of fun and playfulness. Learning doesn’t happen when you’re bored out of your mind; it happens when you are fully engaged. Grasping this simple truth and using it to write a book about Go programming just seems like a good idea, and I’m glad to see that my friends have done exactly that. —Ron Evans, Open Source Contributor, TinyGo, and Technologist for Hire, The Hybrid Group