GoLab 2022

Have you ever thought about writing a logger instead of using the one in the std library?
Let’s code an idiomatic logger that supports tracing and other custom behaviors out of the box maintaining blazing fast and simple APIs by using benchmarks and profiling as the foundation for our decisions.

How to write functions with the flexible APIs offered by languages such as Ruby without sacrificing more type safety than strictly necessary. Then how to test them without excess code bloat.
Lots of fun will be had with Interfaces, Type Switches, Generics, and go test.

After years of working on, with and reviewing Go I collected a series of real-world examples of surprising behaviors that Go might have. I put them together in a comedic interactive talk so that we can all share some knowledge that will probably spare us some headaches in future debugging sessions and code reviews.

Go has amazing built-in support for cross-compilation, but only as long as you don’t depend on C/C++ code. In this talk I’ll explain why some projects might want to depend on C/C++, and how you can use the Zig toolchain to make cross-compilation as seamless as it is for projects written in pure Go.

Learn how you can improve your work with dependencies by using the Driver Pattern! This extremely powerful design pattern allows you to encapsulate functionality shared between dependencies and elevates the classic interface and implementation pattern to the next level.

This talk is dedicated to API and communication design, the glue that holds together microservice architectures. We will build a demo app to discuss the pros and cons of common solutions: REST APIs, gRPC, event busses and automated networking. Join us to talk about microservices talking together!

Everyone wants Generators in Go. To be able to yield a value from a function and then keep it running.
Some people turn to goroutines and channels, but that comes with significant overhead.
In this talk, we’ll use static analysis & code generation to roll our own generators.

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? We will talk about testing, fuzzing, static analysis, formal proofs, code generation, safe interfaces, complexity, and readability, with examples from across the standard library, x/crypto, and the age codebase.

As of Go 1.15, the Go compiler supports compiling your code to WebAssembly. Unfortunately there has been very little documentation of how it works. This talk will cover how it all works at a low level and how it all is built up into making your work shine!

During the past year as maintainer, I found a set of common patterns people new to Go keep missing. In this talk I put them together as a set of actionable items that will dramatically help Go developers in their clean code journey.

Defensive programming aims to make your code more resilient against unforeseen bugs or unexpected inputs. The practice is well understood for languages like C – this talk will explore how one might write Defensive Go.

This talk gets you started with setting up proper tests using the tools already built-in to the language!

Everyone loves Go, but integrating it with complex C++ codebases is not easy. This recently was our mission in Falco, the Cloud-Native Runtime Security tool. In this session, we share how we adopted CGO for our performance-critical use case and how we overcame the engineering challenges involved.

Go with v1.18 release now has built-in support for fuzzing-based testing. It is a big step for the community, especially for those working on projects in the security domain. Fuzz testing your code at the early stage of development mitigates the risk of having security vulnerabilities in production.