GopherCon 2019: Mobile Game Development in Go - Hajime Hoshi Gopher Academy 2026-09-23 | GopherCon 2019: Mobile Game Development in Go - Hajime Hoshi
GopherCon 2023: Filippo Valsorda - High-Assurance Go Cryptography Gopher Academy 2024-04-21 | The cryptography standard library is arguably some of the most critical code written in Go. How do we ensure it’s safe and bug-free? In this presentation, we will talk about testing, fuzzing, static analysis, formal proofs, code generation, safe interfaces, complexity, and readability.
GopherCon 2023: Andy Haskell - Terminal UI Apps From the Ground Up with Bubble Tea Gopher Academy 2024-04-21 | Bubble Tea is a Go framework that enables building apps in the terminal (TUIs) with convenient features like arrow-key and even mouse event handling, adding “wow factor” with animations and managing multiple pages, and an ecosystem of Go packages that might make development in Bubble Tea feel familiar if you’ve done frontend web development before. The best part, though, is that because Bubble Tea’s core interface is made for representing the frontend-famous Elm Architecture, it’s conducive to managing as much or as little complexity as your TUI needs to have.In this talk, we will look at how to build a plant-watering app from the ground up in Bubble Tea and its ecosystem, including doing I/O to save and load data, using imported UI components, giving the app CSS-like styling, and navigating between pages.
GopherCon 2023: Jon Bodner - Automatically Instrument Your Go Source Code with Orchestrion Gopher Academy 2024-04-21 | This talk presents Orchestrion, a tool that we are developing at Datadog for the automatic instrumentation of Go source code. There are other tools (some open source) that add tracing information to Go programs. What makes Orchestrion’s design interesting is that it’s meant to be extensible, both in how it can find what should be instrumented and in where it can output its instrumentation information.We will cover why a tool like this is necessary, how it was built, and what makes it different from other similar tools that are available. What’s more important than the actual tool is the set of techniques that are used to produce it. Several important software engineering concepts will be discussed, including how to parse a programming language, how to build a tool that analyzes source code, what distributed tracing is and why it’s important, and the power of annotations to represent cross-cutting concerns.
GopherCon 2023: Brynette Stewart - Golang Testing for All at Scale Gopher Academy 2024-04-20 | In this Lightning Talk, let’s learn the importance of test-driven development when writing for applications of unclear boundaries and scale, using the core libraries and minimal code. With the use of well-written interfaces and configurations, we can create services that align with the product vision and make it easy to understand for multiple audiences.
GopherCon 2023: Henrique Vicente - Integration Tests: Writing Good Automated Tests Gopher Academy 2024-04-20 | Writing automated tests is essential to ensure high quality and efficiency in software development. One of the most effective ways to achieve these goals is to write fast integration tests whenever possible (such as an entire test suite in single-digit seconds). In this Lightning Talk, let's see some strategies on how to do it, and when to use mocking or unit tests instead.
GopherCon 2023: Michael Richman - Can ChatGPT Do My Job? Gopher Academy 2024-04-20 | I asked both ChatGPT and Bard to do a coding task that no one on my team had time to work on. It was a fairly straightforward conversion utility that I wanted written in Go. Let’s see how they did. (Spoiler Alert: Neither fully succeeded.)
GopherCon 2023: Ron Evans - A Small Update About TinyGo - GopherCon 2023 Edition Gopher Academy 2024-04-20 | A small update about some of the recent activity in the wide, wonderful world of TinyGo.
GopherCon 2023: Thomas Eckert - ‘Tis But a Scratch: Shrinking Container Images using FROM scratch Gopher Academy 2024-04-20 | Smaller container images improve security, speed up deployment, and lower container registry costs. Because Go compiles to a static binary, it can run in containers based on the `scratch` image. This eliminates the need to ship Linux as a dependency for your container. This Lightning Talk covers what the `scratch` image is and how to use it in multi-stage builds to ship leaner and more secure images.
GopherCon 2023: Thomas Miller - Teaching and Learning with Go: The Northwestern Experience Gopher Academy 2024-04-20 | At GopherCon 2021, we presented a Lightning Talk about the need for Go in data science and the planned introduction of Go into Northwestern’s data science program. In this Lightning Talk, we report on the success of this effort, well documented in the website Learning Go for Data Science. We encourage Gophers to join us in contributing to public GitHub repositories for data science, providing case studies and data sets, along with Go, Python, and R programs for analysis and modeling. We also argue that Go should be the first language taught to students of computer science and data science.
GopherCon 2023: Yolan Romailler - A Supply Chain Issue Lurking in Your API Gopher Academy 2024-04-20 | In recent years, we’ve heard more and more about supply chain issues and attacks, and the Go team has been actively working on these problems within the Go ecosystem. In this Lightning Talk, we’ll see what kind of supply chain attacks can be performed against Go code, as well as an actual example lurking at the API level in the Go standard library itself (along with a workaround to prevent it). We’ll also discuss good security practices to avoid these.
GopherCon 2023: Yucong Sun - Winning the Latency Arms Race in the Coinbase Golang Trading Engine Gopher Academy 2024-04-20 | This Lightning Talk will show how we improved the throughput/latency of Coinbase’s main trading engine with a program written in Go. Ultimately we were able to increase from 3Kqps (p99 in less than 10ms) to 20Kqps with (p99 in less than 5ms), even while changing to a smaller machine. As added context, we will also briefly cover the Golang runtime tracing tools, the widely used GRPC library and Hashicorp Raft library, as well as the Golang scheduler.
GopherCon 2023: Samantha Coyle - Go Microservices for ML at the Edge Gopher Academy 2024-03-25 | AI/ML open-source solutions are becoming more prevalent with the increased availability of data along with faster and low-cost processing computing. Our team developed an AI/ML Data pipeline processing infrastructure to enable healthcare use cases with open source (and Go-based) EdgeX Foundries microservices that automatically detect, manage, and process images received from OEM equipment. So basically, we enabled AI/ML pipelines for image processing and automating image comparisons - all while leveraging a Go containerized microservice-based architecture and various communication APIs and MQTT message bus.In developing this healthcare solution, we encountered several interesting challenges and Go packages to include:* A distributed deployment at the edge scenario with some Go microservices running on Windows-based OEM equipment and others running on a Linux edge box.* The need for services to wait for their dependent services to be up and ready before accepting TCP connections.* Backend status internationalization capabilities.* Classic idempotency issues in integration tests due to timing issues on various developers’ machines.This unique project introduced the ability to consume some interesting Go packages. There were challenges and learnings along the way, that I look forward to sharing with you!
GopherCon 2023: James Heller - Halloween Spooktacular: Fog Machine Madness Gopher Academy 2024-03-25 | In the shadowy realm of engineering lies an eerie tale of a haunted fog machine. Brave souls reverse-engineered the machine's remote, crafting a circuit that binds it to a raspberry-pi. Using GoBot, Nats, and k3s, they summon the fog with motion sensors, a chilling testament to the dangers of over-engineering!
GopherCon 2023: Patricio Whittingslow - Cognitive Load and Go Gopher Academy 2024-03-25 | Go is easy to read, but why? It's not just simple language spec but rather deliberate language design choices such as where types are found in source code. In this Lightning Talk, join me as we dive into the world of cognitive psychology and how Go leverages its syntax to reduce the cognitive load of readers to a minimum!
GopherCon 2023: Johan Brandhorst-Satzkorn - Go Support for WASI/Wasm Gopher Academy 2024-03-25 | WebAssembly (Wasm) was built for the browser but has recently found a footing in the backend deployment space due to its focus on sandboxing, security, and performance. The WASI specification allows programming languages to support OS-level features like interacting with files and standard I/O, but this is only the beginning. In this Lightning Talk, we will look at Go 1.21’s WASI support and take a view towards the future of WASI.
GopherCon 2023: Hari Bhaskaran - Freeze: A TinyGo-Powered Meeting Muter with a Twist Gopher Academy 2024-03-25 | Freeze is a fun and useful TinyGo-powered meeting muter taking on the world of work-from-home. It is designed for family members seeking to temporarily mute the participant's audio during virtual meetings. The system restores a sense of autonomy to those not engaged in remote work within the household. My Lightning Talk will include a demo showcasing TinyGo on Arduino, Go on Mac, and Bluetooth low-energy basics.
GopherCon 2023: Benjamin Bryant - The Blueprints to Building Your Own Badass Community Gopher Academy 2024-03-25 | Want to build a Go Community, but unsure where to begin? "It's too scary!", "What if no one shows?”, "Way too much work!"True, True, and True, but don’t be deterred! There are strategies Gophers use worldwide to create hack nights, meetups, and parties. In this talk, I’ll show you how!
GopherCon 2023: Jonathan Amsterdam - Structured Logging for the Standard Library Gopher Academy 2024-03-25 | Go 1.21 has a new structured logging package called slog. In this talk, I’ll describe the motivation for adding structured logging to the standard library, and I’ll cover the design and API of the package. Along the way, I’ll explain how the design achieves high performance.
GopherCon 2023: Julie Qiu - Vulnerability Management for Go Gopher Academy 2024-03-25 | Developers depend on software written by others more than ever, yet we often download code from strangers off the internet, without investigating the risks that may come with pulling in dependencies. To enable Go developers to find vulnerabilities in their dependencies, the Go Team built Go's support for vulnerability management. We'll discuss what tools are available to Go developers, and how you can leverage them to build more secure and reliable software with Go.
GopherCon 2023: Bryan Boreham - Blazing Fast Merge with Loser Trees Gopher Academy 2024-03-25 | Both sorting and merging efficiently can be hard problems. Merging ordered sequences is a little bit easier, but still hard. Thankfully many hard problems in computer science have been well-studied. A good strategy for k-way merging is called Tournament Tree, or Loser Tree. Go didn’t have an implementation of that, so I made one.In this talk, we will look at:Fundamentals and problems of k-way mergesWhy Loser Tree is a good theoretical solutionHow Go generics enable an efficient implementationHow profiling and benchmarks were used to tune the implementation and interfaceHow to apply this in practice, exemplified through Prometheus, Pyroscope, and Grafana LokiAttendees of this talk will gain awareness of a new Open-Source package they could use and insight into the design of an interface using generics.
GopherCon 2023: Dr. Rebecca Bilbro - A Witch’s Guide to Go: 3 Charms to Enchant Your Software Gopher Academy 2024-03-24 | Renowned computer scientist and distributed systems researcher John Ousterhout has called software design a “black art” — practiced by many, understood by few, and talked about openly by almost no one.At Stanford, Ousterhout attempts to educate undergraduates in these dark arts. Students in his CS 190: Software Design Studio course must implement the Raft consensus protocol, receive feedback, re-architect, and refactor as a means of learning how to decompose complex problems through code. For veteran Golang programmers, the alchemy required to design such systems may seem unremarkable, and we can forget how magic Go’s concurrency and memory management felt at first blush. However, by voicing our favorite programming techniques (aka “spells”) aloud we can sharpen our gifts, empower new apprentices, and better defend our codebases from wickedness and misfortune.With the goal of transforming these dark arts into everyday practical magic, come along and explore the lessons of Ousterhout’s course (and subsequent book) through the lens of Go, and set against a backdrop of choices made in the design of a distributed system.
GopherCon 2023: Madhav Jivrajani - Reliably Absorbing a Go Release Gopher Academy 2024-03-24 | The Go project releases two minor versions a year, but challenges exist in keeping up with them. Let’s explore how the Kubernetes project hopes to rely on Go 1.21’s extended backwards compatibility to arrive at a solution for reliably absorbing Go releases, and how you can benefit from our learnings!
GopherCon 2024: Celebrating International Women’s Day in the Go Community Gopher Academy 2024-03-08 | Today we celebrate and honor the invaluable contributions of women in technology! 💻 From developers to engineers, leaders to learners, women play a vital role in shaping the future of tech and the vibrant spirit of the Go community. 💜 #InternationalWomensDay #RoadToGopherCon #golang
GopherCon 2023: Yifei Zhang - Balanced GC: A Copying Garbage Collector for Golang Gopher Academy 2024-02-26 | In this talk, we introduce balanced GC, which allows bump allocation for small pointerless objects in per-goroutine allocation buffers and uses a copying GC to manage that memory. Balanced GC can significantly accelerate object allocation and improve the performance of large-scale online microservices.
GopherCon 2023: Robert Griesemer - Everything You Always Wanted to Know About Type Inference Gopher Academy 2024-02-26 | Type inference is a powerful Go feature that simplifies the use of generic functions by allowing a user to omit explicit type arguments. Instead, the compiler looks at the uses of the generic functions and deduces what the type arguments must be. The result is less boilerplate and clutter and ultimately cleaner code.If you are curious about how type inference does its magic, are wondering about how much more we can infer, or simply want to learn a bit more about one of Go's generic features, this talk is for you.
GopherCon 2023: Jeremy Fleitz - Special When Lit: Using Go to Bring a Pinball Machine Back to Life! Gopher Academy 2024-02-26 | In this talk, I will demonstrate how concurrency and WaitGroups were used to build an event-driven package called GoFlip to implement the game rules for a pinball machine controlled by a Raspberry Pi. Arduinos provide the peripheral interfaces, while TinyGo is evaluated to further improve the overall design of this now fully functional pinball machine powered by Go.
GopherCon 2023: Akshay Shah - Leveraging Protobuf Schemas in Kafka with Go Gopher Academy 2024-02-26 | Kafka is arguably the most popular data streaming platform valued for its performance, scalability, and flexibility. This adaptability, however, comes at a price: no built-in contracts between producers and consumers often lead to data loss when breaking changes are made to the shape of the data. We’re going to demonstrate how to use Protocol Buffers to efficiently provide structure to our data and utilize registries to share these schemas between producers and consumers in Go.
GopherCon 2023: Branden Brown - StAtE OF tHe arT In RAnDomneSS Gopher Academy 2024-02-25 | Package math/rand has seen extra discussion in the past few months thanks to Russ Cox's revised API proposal. Aside from its technical importance as a first v2 in the standard library, the redesign holds exciting changes for people who love doing cool things with math in Go. Let's take a tour of pseudorandom number generators to understand the improvements and implications of math/rand/v2.
GopherCon 2023: Ellery Addington-White - From Zero to Hero: Launch Your Own Game in 45 Minutes Gopher Academy 2024-02-25 | Have you ever wanted to build your own game but are not sure where to start? Come learn how to build an interactive game in Golang with an in-game player chat room. Then, deploy your game to AWS and scale it on a Serverless stack so you can share it with your friends afterward!
GopherCon 2023: Kaylyn Gibilterra - Idiomatic Go Tells a Story Gopher Academy 2024-02-25 | It can be hard to put a finger on what makes some Go code idiomatic and some code functional, but not quite right. This talk will share a practice I have formed to consistently translate satisfactory Go code into delightful packages and type definitions worth bragging about.This practice applies principles from storytelling to idiomatic Go code. We will cover how the Hero's Journey can be applied to rethinking your Go packages - complete with world design, character development, and plot points that will turn a potential drudgery of code refactoring into the creative world of story development.
GopherCon 2023: Konrad Reiche - Building a Highly Concurrent Cache in Go: A Hitchhikers Guide Gopher Academy 2024-02-25 | Why doesn’t the Go standard library provide a concurrent cache? Because Go emphasizes building custom data structures that fit your needs. In this talk, you will learn how to design, implement, and optimize a concurrent cache in Go, combing LRU & LFU eviction policy, and advanced concurrency patterns beyond sync.Mutex.
GopherCon 2023: Joe Tsai - The Future of JSON in Go Gopher Academy 2024-02-25 | The widely-used “encoding/json” package is over a decade old and has served the Go community well. Over time, we’ve learned much about what works but also identified several flaws and shortcomings. What does the future hold for “json”? What will it take to update “json” to the next version?
GopherCon 2023: Jess McClintock - Understanding Supply Chain Threats with Static Analysis Gopher Academy 2024-02-24 | With increasing rates of supply chain attacks and vulnerabilities, there is a need for greater visibility into what behaviors are present in a package’s dependencies. Each Go package has an implicit set of expected capabilities - for example, it would be unexpected for a numerical analysis package to require network access. I will present a CLI tool for Go that highlights privileged permissions in your package’s dependencies to prevent supply chain attacks and motivate secure coding practices within the ecosystem.
GopherCon 2023: Kate Pond - Go Proverbs to Overcome Imposter Syndrome Gopher Academy 2024-02-24 | The Go Proverbs presented to us by Rob Pike in 2015 were initially intended to help us understand the Go programming language a bit better. However, over time, I’ve found that some of those proverbs provide more than just understanding things like “Cgo is not Go.” Not only do the proverbs offer a way to think about how to be a better Go engineer, but they can also help folks overcome the ever-prevalent imposter syndrome. Let me tell you how!
GopherCon 2024: A Look Back at 10 Years of GopherCon with Johnny Boursiquot Gopher Academy 2024-02-20 | Big shoutout to the incredible Johnny Boursiquot! His testimonial says it all... our community is the place for Go enthusiasts to thrive. 🚀💻 Thank you, Johnny, for being a rockstar supporter of #GopherCon since day one! 🌟
GopherCon 2022: Yolan Romailler - Randomness 101: From the Secret to the Public One Gopher Academy 2023-12-27 | Randomness is tricky: even a slight bias can lead to disasters - from rigged lotteries to faulty signatures leaking your private keys, or losing millions in BTC.RNGs, as we say, are far too important to be left to chance! In this talk, we’ll learn why, as well as how to create and consume all kinds of randomness in Go.
GopherCon 2022: Nathanial Murphy - Real-time Adaptive Controls for Increased Resiliency Gopher Academy 2023-12-27 | Modern distributed systems are equipped with hundreds of tunables such as worker pool sizes, autoscaling policies, throttlers, and circuit breakers that directly affect the service resilience. Finding ideal initial values for these tunables requires deep technical expertise. Additionally, these workloads change over time, requiring regular effort to re-tune stale parameters. As a consequence, configuration errors have become a source of operational toil and one of the major causes of overload, cascading service, and system failures across the industry. Container workloads should aim to expose a minimal configuration surface by dynamically adjusting parameters based on observations. In this talk, Nathanial provides a deep dive into how CrowdStrike is using real-time Adaptive Controls (inspired by TCP congestion control) to dynamically tune these parameters for improved resiliency using real-time sampling of errors and latencies, removing the need for periodic adjustment. He also discusses lessons learned by deploying the feature to CrowdStrike’s massive production systems that handle multiple trillions of events per day without causing any incidents.
GopherCon 2022: De Sheng Chuan & Yang Ang - How We Achieved 100x Scale Gopher Academy 2023-12-27 | At Abnormal Security, we redesigned an existing production system to use Golang and Kafka in two months with two engineers while having to roll out new product features. The new system can support a greater than 100x scale than its predecessor at 10% of its cost, thanks to Golang’s concurrency paradigms and compatibility with low-level C-based Kafka library to create a high concurrency and high throughput system to handle millions of requests with ease.Check out this Lightning Talk to learn more!
GopherCon 2022: Kalan Chan - Making the Leap from NodeJS to Go Gopher Academy 2023-12-27 | This Lightning Talk will be focused on my experiences going from NodeJS backends to Golang. I will be covering some of the weird pain points of Go and how different the language is compared to non-strongly typed languages. Afterward, I will explain why I think switching to Go was a good move, talk about all the positives, and tell how Go has made me a better developer.
GopherCon 2022: Adam Berkan - How Should We Access Global Resources? Gopher Academy 2023-12-27 | How should we access global & semi-global resources like the database, the logger, or request headers? Global variables suck. Passing every resource as a parameter is excessive. Stuffing them in a context is not type-safe. Hiding them in a `server` object hides which ones are actually used.At Khan Academy, we've been creating an interface object that provides access to all these resources but allows the function to declare which parts of the interface it requires.Based on my blog post: blog.khanacademy.org/statically-typed-context-in-go, check out this Lightning Talk to learn more!
GopherCon 2022: Ron Evans - A Small Update on TinyGo Gopher Academy 2023-12-27 | This Lightning Talk is a whirlwind tour of the awesome things going on in the world using TinyGo. Yes, I will wear the helmet!
GopherCon 2022: Adam Bernot - 7 Jobs 1 Year: Using Go in Different Workplaces Gopher Academy 2023-12-27 | Last year, I wrote Go code for seven very different companies. I was engineering hire #1 at one of these companies and one of many thousands of engineers at another. This Lightning Talk is a short story about how jobs that look similar on paper can result in very different day-to-day work.
GopherCon 2022: Michael Richman - Go Templates Gopher Academy 2023-12-27 | Go text & html templates are great, but using them is a bit non-obvious out of the standard lib box. At Bitly, we wrote a fairly simple wrapper package that make them a lot more intuitive and straightforward to use in our web apps. Learn more about in this Lightning Talk!
GopherCon 2022: Jin Lin - Profile-Guided Optimization in the Go Compiler Gopher Academy 2023-12-27 | Inefficiencies in Go programs can be isolated via profiling tools such as pprof and linux profiler perf. Such tools can pinpoint source code regions where most of the execution time is spent. Unlike other optimizing compilers such as LLVM, the Go compiler does not yet perform Profile-Guided Optimization(PGO). PGO uses information about the code’s runtime behavior to guide compiler optimizations such as inlining, code layout, etc. PGO can improve application performance in the range of 15-30% [LLVM]. In this Lightning Talk, we extend the Go compiler with PGO. Specifically, we incorporate the profiles into the compiler frontend, backend, and linker to perform profile-guided inlining, code specialization, basic block layout, and function reordering optimizations. The format of the profile file consumed by our PGO is identical to the protobuf format produced by the pprof tool. This format is rich enough to carry additional hardware performance counter information. The first version of the code that performs profile-guided inlining is being upstreamed to Go at go-review.googlesource.com/c/go/+/429863 and the proposal is at go-review.googlesource.com/c/proposal/+/430398/2/design/55025-pgo-design.md
GopherCon 2022: Tom Lyons: How I Write HTTP Clients After (almost) 7 Years Gopher Academy 2023-12-27 | HTTP Servers have middleware.HTTP Clients have… nothing?Inspired by the well-known article and previous GopherCon talk “How I Write HTTP Services After 7/8 Years” by Mat Ryer, Tom aims to provide a rival paradigm for HTTP clients. This talk introduces and describes using client decorators for building better HTTP clients with easier testing and greater maintainability.
GopherCon 2022: Steve Francia - Go: Our Journey from Early Adopter to Mainstream and Beyond Gopher Academy 2023-12-26 | In 2015, Go reached a critical juncture. Go’s success with early adopters from cloud infrastructure, such as Kubernetes and Docker, had plateaued. Go was stuck in the early adopter phase with no clear strategy of how to bring Go to the enterprise/mainstream. Enterprises remained skeptical; Go was used more on hobbies, than at work, and was not considered enterprise. In this keynote, I'll share the strategy we used to bring Go to the mainstream/enterprise. Through this, I’ll share the journey the Go community took to get there - the milestones we reached, the decisions we made and why, and the surprises along the way. Lastly, I’ll share insights into how we see the future of Go unraveling.
Coming Soon to GopherCon 2023... Capture the Flag, One Byte at a Time! Gopher Academy 2023-08-16 | Fall out Gophers and venture into the wasteland of GopherCon's newest conference challenge, a Capture the Flag competition inspired by the video game, Fallout! Set against the backdrop of a world in flux, lay down your arms and battle your fellow Gophers with brainpower. Navigate security challenges in Go such as reverse engineering IoT devices and deciphering machine code byte by byte. Join us on this journey, September 25th - 28th in San Diego at the 9th Annual GopherCon! Will you emerge as the victor in this dance of codes and enigmas?gophercon.comSUBSCRIBE to this Channel------------------------------------------------------------------------------youtube.com/@GopherAcademyFollow us on Socials Media!!**************************************************facebook.com/gopherconinstagram.com/gophercontwitter.com/gopherconlinkedin.com/company/gopherconHosted by @codeprosorg Gopher created by Clint Kadera, which was inspired by the original Gopher artist Renee French#RoadToGopherCon #golang #cybersecurity #ctf #GopherConCTF #EpochsEdge #DigitalDuel #infosec #security #hacker #hackers #go #googlego #fallout #wasteland #mutants #gophers #monsters #capturetheflag #software #softwareengineer #codingchallenge #codingchallenges #adventure #puzzles #puzzle
GopherCon 2022: Neha Agarwal - Test Infrastructure as a Service Gopher Academy 2023-08-04 | For Go module-based microservices at CrowdStrike, we have migrated to a new way of testing: creating test microservices as macro modules. These macro modules sit close to the service module and make it easier to write tests. They integrate well with the existing CI/CD infrastructure. With microservice patterns and tests running in dedicated goroutines, the consumers and producers of any data service can remain connected.It also reduces the necessity for separate test framework jobs that must disconnect from all networks before exiting.
GopherCon 2022: Konrad Reiche - Errors: to Log, or Not to Log? Gopher Academy 2023-08-02 | Most of the time, errors are returned to the calling code. What happens at the end though? Log the error? Logging every error results in a monitoring system that is noisy and easy to ignore.What if we let errors define whether they should be logged or not? This wayerrors can be categorized, tracked as metrics, and communicated to the calling code what to do with the error.
