Efficient Go Data-Driven Performance Optimization (Bartlomiej Plotka) (Z-Library)

📄 File Format: PDF

💾 File Size: 8.8 MB

📖 Read Online ⬇️ Download

Registered users can read the full content for free

Register as a Gaohf Library member to read the complete e-book online for free and enjoy a better reading experience.

📄 Page 1

Bartłomiej Płotka Efficient Go Data-Driven Performance Optimization

📄 Page 2

GO “Efficient Go is a marvelous and insightful book that changes your outlook on software efficiency with Go. You learn how to make data-driven assessments while optimizing your code base and identifying optimizable patterns. It simply makes it easy for you and makes you want to care about the efficiency of your code as soon as you type it!” —Saswata Mukherjee Engineer at Red Hat Efficient Go US $59.99 CAN $74.99 ISBN: 978-1-098-10571-6 Twitter: @oreillymedia linkedin.com/company/oreilly-media youtube.com/oreillymedia With technological advancements, fast markets, and higher complexity of systems, software engineers tend to skip the uncomfortable topic of software efficiency. However, tactical, observability-driven performance optimizations are vital for every product to save money and ensure business success. With this book, any engineer can learn how to approach software efficiency effectively, professionally, and without stress. Author Bartłomiej Płotka provides the tools and knowledge required to make your systems faster and less resource-hungry. Efficient Go guides you in achieving better day-to-day efficiency using Go. In addition, most content is language-agnostic, allowing you to bring small but effective habits to your programming or product management cycles. This book shows you how to: • Clarify and negotiate efficiency goals • Optimize efficiency on various levels • Use common resources like CPU and memory effectively • Assess efficiency using observability signals like metrics, logging, tracing, and (continuous) profiling via open source projects like Prometheus, Jaeger, and Parca • Apply tools like go test, pprof, benchstat, and k6 to create reliable micro and macro benchmarks • Efficiently use Go and its features like slices, generics, goroutines, allocation semantics, garbage collection, and more! Bartłomiej Płotka is a principal software engineer at Red Hat with a background in observability and SRE. He’s a CNCF Ambassador, TAG Observability tech lead, and cofounder of the Thanos project. He’s also a core maintainer of other open-source projects written in Go, including Prometheus and bingo.

📄 Page 3

Bartłomiej Płotka Efficient Go Data-Driven Performance Optimizations Boston Farnham Sebastopol TokyoBeijing

📄 Page 4

978-1-098-10571-6 [LSI] Efficient Go by Bartłomiej Płotka Copyright © 2023 Alloc Limited. All rights reserved. Printed in the United States of America. Published by O’Reilly Media, Inc., 1005 Gravenstein Highway North, Sebastopol, CA 95472. O’Reilly books may be purchased for educational, business, or sales promotional use. Online editions are also available for most titles (http://oreilly.com). For more information, contact our corporate/institu‐ tional sales department: 800-998-9938 or corporate@oreilly.com. Acquisitions Editors: Brian Guerin and Zan McQuade Indexer: WordCo Indexing Services, Inc. Development Editor: Melissa Potter Interior Designer: David Futato Production Editor: Clare Laylock Cover Designer: Karen Montgomery Copyeditor: Sonia Saruba Illustrator: Kate Dullea Proofreader: Piper Editorial Consulting, LLC November 2022: First Edition Revision History for the First Edition 2022-11-08: First Release See http://oreilly.com/catalog/errata.csp?isbn=9781098105716 for release details. The O’Reilly logo is a registered trademark of O’Reilly Media, Inc. Efficient Go, the cover image, and related trade dress are trademarks of O’Reilly Media, Inc. The views expressed in this work are those of the author, and do not represent the publisher’s views. While the publisher and the author have used good faith efforts to ensure that the information and instructions contained in this work are accurate, the publisher and the author disclaim all responsibility for errors or omissions, including without limitation responsibility for damages resulting from the use of or reliance on this work. Use of the information and instructions contained in this work is at your own risk. If any code samples or other technology this work contains or describes is subject to open source licenses or the intellectual property rights of others, it is your responsibility to ensure that your use thereof complies with such licenses and/or rights.

📄 Page 5

Table of Contents Preface. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ix 1. Software Efficiency Matters. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 Behind Performance 3 Common Efficiency Misconceptions 7 Optimized Code Is Not Readable 7 You Aren’t Going to Need It 14 Hardware Is Getting Faster and Cheaper 17 We Can Scale Horizontally Instead 25 Time to Market Is More Important 29 The Key to Pragmatic Code Performance 32 Summary 34 2. Efficient Introduction to Go. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35 Basics You Should Know About Go 36 Imperative, Compiled, and Statically Typed Language 37 Designed to Improve Serious Codebases 37 Governed by Google, Yet Open Source 39 Simplicity, Safety, and Readability Are Paramount 40 Packaging and Modules 41 Dependencies Transparency by Default 43 Consistent Tooling 45 Single Way of Handling Errors 47 Strong Ecosystem 51 Unused Import or Variable Causes Build Error 52 Unit Testing and Table Tests 53 Advanced Language Elements 55 Code Documentation as a First Citizen 55 iii

📄 Page 6

Backward Compatibility and Portability 58 Go Runtime 58 Object-Oriented Programming 59 Generics 63 Is Go “Fast”? 67 Summary 69 3. Conquering Efficiency. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71 Beyond Waste, Optimization Is a Zero-Sum Game 73 Reasonable Optimizations 74 Deliberate Optimizations 77 Optimization Challenges 79 Understand Your Goals 80 Efficiency Requirements Should Be Formalized 83 Resource-Aware Efficiency Requirements 86 Acquiring and Assessing Efficiency Goals 89 Example of Defining RAER 90 Got an Efficiency Problem? Keep Calm! 94 Optimization Design Levels 98 Efficiency-Aware Development Flow 102 Functionality Phase 104 Efficiency Phase 106 Summary 109 4. How Go Uses the CPU Resource (or Two). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111 CPU in a Modern Computer Architecture 113 Assembly 115 Understanding Go Compiler 118 CPU and Memory Wall Problem 126 Hierachical Cache System 127 Pipelining and Out-of-Order Execution 129 Hyper-Threading 132 Schedulers 133 Operating System Scheduler 134 Go Runtime Scheduler 138 When to Use Concurrency 145 Summary 146 5. How Go Uses Memory Resource. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149 Memory Relevance 150 Do We Have a Memory Problem? 152 Physical Memory 153 iv | Table of Contents

📄 Page 7

OS Memory Management 156 Virtual Memory 158 mmap Syscall 162 OS Memory Mapping 168 Go Memory Management 172 Values, Pointers, and Memory Blocks 176 Go Allocator 181 Garbage Collection 185 Summary 191 6. Efficiency Observability. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193 Observability 194 Example: Instrumenting for Latency 199 Logging 199 Tracing 205 Metrics 211 Efficiency Metrics Semantics 220 Latency 221 CPU Usage 229 Memory Usage 234 Summary 238 7. Data-Driven Efficiency Assessment. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239 Complexity Analysis 240 “Estimated” Efficiency Complexity 241 Asymptotic Complexity with Big O Notation 243 Practical Applications 246 The Art of Benchmarking 250 Comparison to Functional Testing 252 Benchmarks Lie 254 Reliability of Experiments 256 Human Errors 256 Reproducing Production 258 Performance Nondeterminism 260 Benchmarking Levels 266 Benchmarking in Production 268 Macrobenchmarks 269 Microbenchmarks 270 What Level Should You Use? 271 Summary 273 Table of Contents | v

📄 Page 8

8. Benchmarking. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275 Microbenchmarks 275 Go Benchmarks 277 Understanding the Results 284 Tips and Tricks for Microbenchmarking 288 Too-High Variance 288 Find Your Workflow 289 Test Your Benchmark for Correctness! 290 Sharing Benchmarks with the Team (and Your Future Self) 294 Running Benchmarks for Different Inputs 297 Microbenchmarks Versus Memory Management 299 Compiler Optimizations Versus Benchmark 301 Macrobenchmarks 306 Basics 307 Go e2e Framework 310 Understanding Results and Observations 316 Common Macrobenchmarking Workflows 325 Summary 327 9. Data-Driven Bottleneck Analysis. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 329 Root Cause Analysis, but for Efficiency 330 Profiling in Go 331 pprof Format 332 go tool pprof Reports 340 Capturing the Profiling Signal 355 Common Profile Instrumentation 360 Heap 360 Goroutine 365 CPU 367 Off-CPU Time 369 Tips and Tricks 373 Sharing Profiles 373 Continuous Profiling 373 Comparing and Aggregating Profiles 378 Summary 379 10. Optimization Examples. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 381 Sum Examples 382 Optimizing Latency 383 Optimizing bytes.Split 387 Optimizing runtime.slicebytetostring 389 Optimizing strconv.Parse 391 vi | Table of Contents

📄 Page 9

Optimizing Memory Usage 395 Moving to Streaming Algorithm 395 Optimizing bufio.Scanner 397 Optimizing Latency Using Concurrency 402 A Naive Concurrency 402 A Worker Approach with Distribution 404 A Worker Approach Without Coordination (Sharding) 406 A Streamed, Sharded Worker Approach 408 Bonus: Thinking Out of the Box 411 Summary 413 11. Optimization Patterns. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 415 Common Patterns 416 Do Less Work 416 Trading Functionality for Efficiency 419 Trading Space for Time 419 Trading Time for Space 420 The Three Rs Optimization Method 421 Reduce Allocations 421 Reuse Memory 422 Recycle 423 Don’t Leak Resources 426 Control the Lifecycle of Your Goroutines 427 Reliably Close Things 435 Exhaust Things 438 Pre-Allocate If You Can 440 Overusing Memory with Arrays 445 Memory Reuse and Pooling 449 Summary 459 Next Steps 461 A. Latencies for Napkin Math Calculations. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 465 Index. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 467 Table of Contents | vii

📄 Page 10

(This page has no text content)

📄 Page 11

Preface Welcome to the pragmatic software development world, where engineers are not afraid of ambitious performance goals. Where the change in requirements or unex‐ pected efficiency issues is handled without stress, where code is optimized tactically and effectively, based on data, yet the codebase is kept simple and easy to read, main‐ tain, and extend. Wait, is this even possible? Yes, and I will show you how! The good news is that if you bought this book, you are already halfway there—it means you acknowledge the problem and are open to learn‐ ing more! The bad news is that, while I tried to distill the knowledge to only what’s necessary, there are still 11 chapters to go through. I think Efficient Go is unique in this regard as it is not a quick tutorial. Instead, it is a complete guide to writing effi‐ cient yet pragmatic software that goes through all aspects I wish I had known when I started my career. In this book, you will undoubtedly learn a lot about my favorite programming lan‐ guage, Go, and how to optimize it. But don’t let the title of this book fool you. While I use Go as the example language to show the optimization mindset and observability patterns, 8 out of 11 chapters of this book are language agnostic. You can use the same techniques to improve software written in any other language like Java, C#, Scala, Python, C++, Rust, or Haskell. Finally, if you expected a full list of low-level optimization tricks, this is not the right book. Firstly, optimizations do not generalize well. The fact that someone unrolled the loop or used a pointer in their struct field and achieved better efficiency does not mean it will be helpful if we do the same! We will go through some optimization tricks, but I emphasize complete knowledge about efficiency in pragmatic software development instead. Secondly, “low-level” dangerous tricks are often not needed. In most cases, an aware‐ ness of simple points where your program wastes time and resources is enough to fulfill your efficiency and scalability goals cheaply and effectively. Furthermore, you ix

📄 Page 12

will learn that in most cases, there is no need to rewrite your program to C++, Rust, or Assembly to have an efficient solution! Before we start, let’s go through the main goals behind this book and why I found it necessary to focus my time on the subject of efficiency. You will also learn how to get the most out of this book and effectively use it in your software development tasks. Why I Wrote This Book I spent around 1,200 hours writing Efficient Go, so the choice to deliver such a book was not spur-of-the-moment. In the era of social media, YouTube, and TikTok, book writing and reading might feel outdated, but in my experience, modern media tend to oversimplify topics. You have to condense those to an absolute minimum not to lose viewers and monetization. It leads to the wrong incentives, which generally collide with what I wanted to achieve with this book. My mission here is straightforward: I want the software I use or depend on to be bet‐ ter! I want software project contributors and maintainers to understand their code’s efficiency and how to assess it. I want them to reliably review my or others’ pull requests with efficiency improvements. I want people around me to know how to handle performance issues professionally instead of building a stressful atmosphere. I want users and stakeholders to be cautious with the benchmarks and cheap market‐ ing we see in the industry. Finally, I want leaders, directors, and product managers to approach software efficiency topics maturely with the awareness of how to form pragmatic efficiency requirements that help engineers to deliver excellent products. I also consider this book a small contribution toward more sustainable software. Every wasted CPU time and memory wastes a significant amount of your business’s money. However, it also wastes energy and hardware, which has a serious environ‐ mental effect. So saving money and the planet at the same time while enabling better value for your business is not a bad outcome of the skills you will learn here. I figured out that writing a book is the best way to achieve this goal. It’s easier than continuously explaining the same nuances, tooling, and techniques in my daily work, open source, and conferences! How I Gathered This Knowledge I built my experience toward efficiency topics and high-quality software development through a lot of practice, mistakes, experiments, implicit mentors, and research. I was 29 years old when I started writing this book. That might not feel like much experience, but I started a full-time, professional software development career when I was 19. I did full-time computer science studies in parallel to work at Intel around software-defined infrastructure (SDI). I initially coded in Python around the x | Preface

📄 Page 13

1 If you are new to software development or open source, talk to us, start contributing, and apply for two months paid mentorship. Let me know if you would like to have fun while mentoring others! We need good mentors too—it’s important to teach another generation of open source maintainers. OpenStack project, then in C++ including contributions to the popular-back-then Mesos project under the supervision of amazing engineers from Mesosphere and Twitter. Finally, I moved to develop Go around Kubernetes and fell in love with this language. I spent a nontrivial amount of time at Intel on node oversubscription feature with noisy neighbor mitigations. Generally, oversubscription allows running more pro‐ grams on a single machine than would be otherwise possible. This can work since statistically, all programs rarely use all of their reserved resources simultaneously. Looking at this now from a later perspective, it is usually easier and more effective to save money by starting with software optimization than by using complex algorithms like this. In 2016, I moved to London to work for a gaming start-up. I worked with past employees of Google, Amazon, Microsoft, and Facebook to develop and operate a global gaming platform. We were developing microservices, mostly in Go running on dozens of Kubernetes clusters worldwide. This is where I learned a lot about dis‐ tributed systems, site reliability engineering, and monitoring. Perhaps this was when I got addicted to amazing tooling around observability, which is key to achieving pragmatic efficiency and explained in Chapter 6. My passion for good visibility of the running software translated to becoming an expert in using and developing a popular, open source, time-series database for mon‐ itoring purposes called Prometheus. Eventually, I became an official maintainer and started multiple other Go open source projects and libraries. Finally, I had an oppor‐ tunity to cocreate with Fabian Reinartz a large distributed time-series database in the open source called Thanos. I would not be surprised if some of my code runs in your company infrastructure! In 2019, I moved to Red Hat, where I work full-time on observability systems in open source. This is when I also dived more into continuous profiling solutions, which you will learn in this book too. I am also active in the Cloud Native Computing Foundation (CNCF) as the ambassa‐ dor and observability Technical Advisory Group (TAG) tech lead. In addition, I co- organize conferences and meetups. Finally, with the Prometheus and Thanos projects, with the team, we mentor multiple engineers every year via the CNCF men‐ toring initiatives.1 Preface | xi

📄 Page 14

I wrote or reviewed thousands of code lines for various software that had to run on production, be reliable, and scale. I have taught and mentored over two dozen engi‐ neers so far. However, perhaps the most insightful was the open source work. You interact with diverse people, from different companies and places worldwide, with different backgrounds, goals, and needs. Overall, I believe we achieved amazing things with the fantastic people I had a chance to work with. I was lucky to work in environments where high-quality code was more important than decreasing code review delays or reducing time spent addressing style issues. We thrived on good system design, code maintainability, and readability. We tried to bring those values to open source, and I think we did a good job there. How‐ ever, there is one important thing I would improve if I had a chance to write, for instance, the Thanos project again: I would try to focus more on the pragmatic effi‐ ciency of my code and the algorithms we chose. I would focus on having clearer effi‐ ciency requirements from the start and invest more in benchmarking and profiling. And don’t get me wrong, the Thanos system nowadays is faster and uses much fewer resources than some competitors, but it took a lot of time, and there is still a massive amount of hardware resources we could use less. We still have many bottlenecks that await community attention. However, if I applied the knowledge, techniques, and suggestions that you will learn in this book, I believe we could have cut the develop‐ ment cost in half, if not more, to have Thanos in the state we have today (I hope my ex-boss who paid for this work won’t read that!). My journey showed me how much a book like this was needed. With more people programming overall, often without a computer science background, there are plenty of mistakes and misconceptions, especially regarding software efficiency. Not much literature was available to give us practical answers to our efficiency or scaling ques‐ tions, especially for Go. Hopefully, this book fills that literature gap. Who This Book Is For Efficient Go focuses on giving the tools and knowledge necessary to answer when and how to apply efficiency optimization, depending strongly on circumstances and your organization’s goals. As a result, the primary audience for this book is software devel‐ opers designing, creating, or changing programs written in Go and any other modern language. It should be a software engineer’s job to be an expert on ensuring the soft‐ ware they create works within both functional and efficiency requirements. Ideally, you have some basic programming skills when starting this book. xii | Preface

📄 Page 15

2 I’ve already gotten feedback from some experienced people that they did not know you could use metrics to work on efficiency and performance improvements! It’s possible, and you will learn how here. I believe this book is also useful to those who primarily operate software somebody else writes, e.g., DevOps engineers, SRE, sysadmins, and platform teams. There are many optimization design levels (as discussed in “Optimization Design Levels” on page 98). Sometimes it makes sense to invest in software optimizations, and some‐ times we might need to address it on other levels! Moreover, to achieve reliable effi‐ ciency, software engineers have to benchmark and experiment a lot with production- like environments (as explained in Chapter 6), which usually means close collaboration with platform teams. Finally, the observability practices explained in Chapter 6 are state-of-the-art tools recommended for modern platform engineering. I am a strong proponent of avoiding differentiating between application performance monitoring (APM) and observability for SRE. If you hear that differentiation, it’s mostly coming from vendors who want you to pay more or feel like they have more features. As I will explain, we can reuse the same tools, instrumentations, and signals across all software observations.2 Generally, we are on the same team—we want to build better products! Finally, I would like to recommend this book to managers, product managers, and leaders who want to stay technical and understand how to ensure you are not wasting millions of dollars on easy-to-fix efficiency issues within your team! How This Book Is Organized This book is organized into 11 chapters. In Chapter 1, we discuss efficiency and why it matters. Then, in Chapter 2, I briefly introduce Go with efficiency in mind. Then, in Chapter 3, we will talk about optimizations and how to think about them and approach those. Efficiency improvements can take enormous amounts of your time, but systematic approaches help you save a lot of time and effort. In Chapters 4 and 5, I will explain all you need to know about latency, CPU, and memory resources, as well as how OS and Go abstract them. Then we will move on to what it means to perform data-driven decisions around software efficiency. We will start with Chapter 6. Then we will discuss the reliability of experiments and complexity analysis in Chapter 7. Finally, I will explain bench‐ marking and profiling techniques in Chapters 8 and 9. Last but not least, I will show you various examples of different optimization situa‐ tions in Chapter 10. Finally, in Chapter 11, we will take a few learnings and summa‐ rize various efficiency patterns and tricks we see in the Go community. Preface | xiii

📄 Page 16

Conventions Used in This Book The following typographical conventions are used in this book: Italic Indicates new terms, URLs, email addresses, filenames, and file extensions. Constant width Used for program listings, as well as within paragraphs to refer to program ele‐ ments such as variable or function names, databases, data types, environment variables, statements, and keywords. Constant width bold Shows commands or other text that should be typed literally by the user. Constant width italic Shows text that should be replaced with user-supplied values or by values deter‐ mined by context. This element signifies a tip or suggestion. This element signifies a general note. This element indicates a warning or caution. Using Code Examples This book contains code examples that should help you understand the tools, techni‐ ques, and good practices. All of them are in the Go programming language and work with Go version 1.18 and above. You can find all the examples from this book in the executable and tested open source GitHub repository efficientgo/examples. You are welcome to fork it, use it, and play with the examples I share in this book. Everybody learns differently. For some people, it is helpful to import some examples into their favorite IDE and play xiv | Preface

📄 Page 17

with it by modifying it, running, testing, or debugging. Find the way that works for you and feel free to ask questions or propose improvements through GitHub issues or pull requests! Note that the code examples in this book are simplified for a clear view and smaller size. Particularly, the following rules apply: • If the Go package is not specified, assume package main. • If the filename or extension of the example is not specified, assume the file has a .go extension. If it’s a functional test or microbenchmark, the file name has to end with _test.go. • import statements are not always provided. In such cases, assume standard library or previously introduced packages are imported. • Sometimes, I don’t provide imports in the import statement but in a comment (// import <URL>). This is when I want to explain a single nontrivial import out of many needed in this code example. • A comment with three dots (// ...) specifies that some unrelated content was removed. This highlights that some logic is there for a function to make sense. • A comment with the handle error statement (// handle error) indicates that error handling was removed for readability. Always handle errors in your code! This book is here to help you get your job done. In general, if this book offers an example code, you may use it in your programs and documentation. You do not need to contact us for permission unless you’re reproducing a significant portion of the code. For example, writing a program that uses several chunks of code from this book does not require permission. Selling or distributing examples from O’Reilly books does require permission. Answering a question by citing this book and quoting example code does not require permission. However, incorporating a significant amount of example code from this book into your product’s documentation does require permission. We appreciate but generally do not require attribution. An attribution usually includes the title, author, publisher, and ISBN. For example, "Efficient Go by Bartło‐ miej Płotka (O’Reilly). Copyright 2023 Alloc Limited, 978-1-098-10571-6.” If you feel your use of code examples falls outside fair use or the permission given above, feel free to contact us at permissions@oreilly.com. Preface | xv

📄 Page 18

Acknowledgments As they say, “the greatness is in the agency of others”. This book is no different. Numerous people helped me directly or indirectly in my Efficient Go book-writing journey and my career. First of all, I would love to thank my wife, Kasia—without her support, this wouldn’t be possible. Thanks to my main tech reviewers, Michael Bang and Saswata Mukherjee, for relent‐ lessly checking all the content in detail. Thanks to others who looked at some parts of the early content and gave amazing feedback: Matej Gera, Felix Geisendörfer, Giedrius Statkevičius, Björn Rabenstein, Lili Cosic, Johan Brandhorst-Satzkorn, Michael Hausenblas, Juraj Michalak, Kemal Akkoyun, Rick Rackow, Goutham Veer‐ amachaneni, and more! Furthermore, thanks to the many talented people from the open source community who share enormous knowledge in their public content! They might not realize it, but they help with such work, including my writing of this book. You will see quotes from some of them in this book: Chandler Carruth, Brendan Gregg, Damian Gryski, Frederic Branczyk, Felix Geisendörfer, Dave Cheney, Bartosz Adamczewski, Domi‐ nik Honnef, William (Bill) Kennedy, Bryan Boreham, Halvar Flake, Cindy Sridharan, Tom Wilkie, Martin Kleppmann, Rob Pike, Russ Cox, Scott Mayers, and more. Finally, thanks to the O’Reilly team, especially Melissa Potter, Zan McQuade, and Clare Jensen, for amazing help and understanding of delays, moving deadlines, and sneaking more content into this book than planned! :) Feedback Is Welcome! If you are interested in following my work or the groups I work with or want to learn even more in this area, follow me on Twitter or check my blog. Do not hesitate to reach out to me if you have feedback on my work or the content I have produced. I am always open to learning more! O’Reilly Online Learning For more than 40 years, O’Reilly Media has provided technol‐ ogy and business training, knowledge, and insight to help companies succeed. Our unique network of experts and innovators share their knowledge and expertise through books, articles, and our online learning platform. O’Reilly’s online learning xvi | Preface

📄 Page 19

platform gives you on-demand access to live training courses, in-depth learning paths, interactive coding environments, and a vast collection of text and video from O’Reilly and 200+ other publishers. For more information, visit https://oreilly.com. How to Contact Us Please address comments and questions concerning this book to the publisher: O’Reilly Media, Inc. 1005 Gravenstein Highway North Sebastopol, CA 95472 800-998-9938 (in the United States or Canada) 707-829-0515 (international or local) 707-829-0104 (fax) We have a web page for this book, where we list errata, examples, and any additional information. You can access this page at https://oreil.ly/efficient-go. Email bookquestions@oreilly.com to comment or ask technical questions about this book. For news and information about our books and courses, visit https://oreilly.com. Find us on LinkedIn: https://linkedin.com/company/oreilly-media. Follow us on Twitter: https://twitter.com/oreillymedia. Watch us on YouTube: https://www.youtube.com/oreillymedia. Preface | xvii

📄 Page 20

(This page has no text content)