Sunday 2nd October (Workshops)*


12:45 Registration

13:00 – Tea Hall – Workshop: Writing a Go logger

  • SPEAKER: Damiano Petrungaro
  • LENGTH: 3h
    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.
    Writing a logger can be tricky and performance issues are hidden and tricky to find.
    Since I wrote a logger in Go (, I want to share the knowledge I gained out of that by coding a session (inspired by the open-source one I wrote) to show bottlenecks from a performance and design perspective.
    The deep dive will be in writing benchmarks for encoding the log entry and profiling the whole logger design to determine where it could be improved.

16:00 – Smart Room – Coffee break

16:30 – Tea Hall – Workshop: Writing flexible Functions and Methods in Go using Generics

  • SPEAKER: Eleanor McHugh
  • LENGTH: 3h
    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.
    I love Go but have always found the way it handles collection types somewhat frustrating. In languages such as Ruby the collection classes are fleshed out with lots of functionality (batteries included) that in Go we have to roll for ourselves. It’s not that the same things can’t be done, it’s that there’s no clear template for how to go about doing so consistently. As a consequence of this I’ve been working on various packages for collection handling in Go for more than a decade now, some of them more practical than others.
    Another of my interests is the use of Higher-Order Functions and Interfaces in API design. This topic doesn’t seem to get a lot of coverage despite Go having First-Class Function Closures. We’ll look at how to leverage Closures to write flexible functions and methods with strong type safety guarantees, as well as how to loosen those restrictions at runtime using Type Switches and Interfaces.
    There was one very frustrating problem with these techniques prior to the introduction of Generics – the amount of code repetition necessary to support even the relatively small set of base types. This could be tackled using Reflection but that essentially abandons the speed of compiled code in favour of runtime interpretation as well as further degrading type safety. I don’t have a big problem with this on my personal projects but I feel bad doing it in production code.
    Generics aren’t currently a perfect solution but they are very helpful so I’ll use them extensively throughout my examples and contrast them with alternative approaches.
    Testing also benefits from both Closures and Generics so I’ll include examples of test code using both to write declarative tests and then to reduce the amount of code repetition involved.
    If time allows I’ll include a Reflection example to highlight how much more legible Generic Functions are, and apply the testing techniques to benchmarking.
    By the end of the session I’ll have covered these topics in sufficient depth that anyone with a basic knowledge of Go will be able to have fun exploring further.

20:00 – Acero Rosso – Gopher’s and Rustacean’s Dinner

Monday 3rd October

8:30 – Registration

9:30 – Smart Room – Welcome Coffee

10:15 – Introduction to the conference

10:30 – Main Hall – Keynote: Things you didn’t know about Go and how to become an expert

  • SPEAKER: Roberto Clapis
  • LENGTH: 1h
    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.

11:30 – Main Hall – Zig Makes CGo Cross-compilation Just Work

  • SPEAKER: Loris Cro
  • LENGTH: 1h
    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.

12:30 – Main Hall – Beyond database/sql: The Driver Pattern

  • SPEAKER: Boston Cartwright
  • LENGTH: 1h
    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.

13:30 – Acero Rosso – Lunch

15:00 – Main Hall – Call me maybe – communication between microservices

  • SPEAKERS: Adelina Simion, Artur Kondas
  • LENGTH: 1h
    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!

16:00 – Main Hall – Generating Generators

  • SPEAKER: Tamir Bahar
  • LENGTH: 1h
    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.

17:00 – Smart Room – Welcome Coffee

17:30 – Main Hall – High-assurance Go cryptography

  • SPEAKER: Filippo Valsorda
  • LENGTH: 1h
    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.

Tuesday 4th October

9:00 – Registration

9:30 – Smart Room – Welcome Coffee

10:00 – Main Hall – The Go WebAssembly ABI at a Low Level

  • SPEAKER: Xe Iaso
  • LENGTH: 1h
    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!

11:00 – Main Hall – Recipes for reducing cognitive load – yet another idiomatic Go talk

  • SPEAKER: Federico Paolinelli
  • LENGTH: 1h
    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.

12:00 – Main HallDefensive programming techniques in Go

  • SPEAKER: Daniel Martí
  • LENGTH: 1h
  • ABSTRACT: 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..

13:00 – Acero Rosso – Lunch

14:30 – Main Hall – Built-In Testing in Go is More Than Just Passable

  • SPEAKER: Scott McAllister
  • LENGTH: 1h
    This talk gets you started with setting up proper tests using the tools already built-in to the language!

15:30 – Main Hall – Modernizing Falco with Go: a Story of Love and Betrayal

  • SPEAKER: Jason Dellaluce, Leonardo Grasso
  • LENGTH: 1h
    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.

16:30 – Smart Room – Coffee Break

17:00 – Main Hall – Uncover Unknown Bugs With Fuzzing in Go

  • SPEAKER: Sagar Sonwane
  • LENGTH: 1h
    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.

18:00 – Bye, Gophers!

DISCLAIMER: this schedule is not definitely confirmed. Sessions and time sessions may change.

Follow us