November 11th, 2024
Registration
Fyne apps from start to store - SOLD OUT!
For folk looking to get a hands-on intro to graphical app development with Go and Fyne this session is for you.
Everything from getting started, through building an app onto your computer and on to customising the toolkit and building your own widgets. You'll learn everything you need to build the app of your dreams. :)
LEVEL: Introductory or Overview
A simple approach to secure code - SOLD OUT!
In this journey through secure software development, you'll learn and practise defensive coding approaches that will enable you and your team to write safe code without even thinking about security.
We will walk through classes of issues and see how to prevent vulnerabilities from seeping into code.
LEVEL: Intermediate
Go design principles for better Go development - SOLD OUT!
Learn how to design robust Go applications that are simple to maintain. In this hands-on workshop we will cover (and appreciate) the different philosophies that went into the Go programming language, and how to make the best Go design choices. This workshop is ideal for anyone looking to expand their design skills, or struggling to expand their Go codebases (we will understand why that happens), as well as for people new to Go who are looking to get an idea of how to work with it.
LEVEL: Intermediate
Coffee break
Lunch
Go testing boot camp - SOLD OUT!
This hands-on workshop will take a simple legacy cloud native application with no coverage and will show the common techniques and tools to gradually introduce coverage, to make the application behavior deterministic and without regressions.
LEVEL: Intermediate
Exercises in performance optimizations - SOLD OUT!
The 1 Billion Row Challenge is a simple, data-intensive task, that nonetheless allows to explore many optimization ideas and techniques in Go.
In this workshop, we start with a baseline implementation and interactively improve on the solution, learning about benchmarking, different performance characteristics of standard library types, concurrency patterns, fast data structures, useful operating system facilities and more.
Coffee break
November 12th, 2024
Registration
Conference Presentation
Welcome coffee
Instrumenting Go Apps With OpenTelemetry
This talk will introduce you to the magic world of OpenTelemetry, an open source and vendor neutral initiative from CNCF. It will give you an idea of how to instrument your Go applications with OTel, and why you should do it.
Spoiler: it saves your time and your company money. You will see how OpenTelemetry magically can handle your traces, logs, and metrics and send them to anywhere you want with its own protocol.
LEVEL: Introductory and Overview
Watermill: the missing standard library for event-driven applications
A couple of years ago, I worked on a project with high scalability and resiliency requirements. Event-driven architecture would be the perfect fit there. Unfortunately, nobody else on the team felt comfortable using event-driven architecture. I asked myself: "What can I do to make building event-driven applications as simple as an HTTP server?". This was the moment when Watermill was born.
A couple of years later, Watermill became the most popular Go library for building Event-Driven applications, used by numerous companies, more than 50 contributors, and over 6k stars on GitHub.
LEVEL: Advanced
Test-driven Hardening: Crafting Seccomp Profiles within Test Pipeline
This talk introduces a method to enhancing the security of software projects by seamlessly integrating Seccomp profile generation into the test pipeline. This methodology emphasizes comprehensive test coverage of the application, encompassing both integration and unit tests.
LEVEL: Intermediate
Let's Go asynchronous
During this talk I would summarize the cases where the synchronous communication is the right choice and on contrary where it is causing problems and it is better to pick the asynchronous one. Throughout the presentation I will combine the slides with actual code comparing the two principles on real simple examples to let the listener to better imagine the impacts. I will show how it is easy to implement load balancing/throttling/rate limiting to prevent Go apps from overwhelming just by switching to asynchronous communication. Also the implementation of retries mechanism will be shown as one example where asynchronous communication may be used. For the examples I will use regular Http server written in Go as a example of synchronous code and consumers using RabbitMQ and PGQ to cover the asynchronicity. The summary of the talk will be, that before designing some feature, you should think twice, whether it is not better to do design it in asynchronous way. And if you decide it is better to make it asynchronous, that it is not a big deal to actually implement it in Go using already existing tools and libraries.
LEVEL: Intermediate
Lunch
Accepting complex inputs with simple code
On the boundaries of our programs lives the realm of raw bites. This talk presents a collection of nuance-increasing strategies to keep the chaos at bay.
LEVEL: Intermediate
How to write a programming language and shell in Go with 92% test coverage and instant CI/CD
Have you wondered how terminal shells work? Do you want to create your own programming language? This talk is for you! We will look at Elvish, a shell and built in Go with a full-fledged programming language. We will dive into how its implementation as well as testing and CI/CD strategy.
LEVEL: Intermediate
Test-Driving HTML templates
After a decade or more where Single-Page-Applications generated by JavaScript frameworks have become the norm, we see that server-side rendered HTML is becoming popular again, also thanks to the emergence of libraries such as HTMX or Turbo. Writing a rich web UI in a traditionally server-side language like Go is now not only possible, but a very attractive proposition.
LEVEL: Intermediate
From Bland to Spiky: How Generics Made My Service Super Robust
Get ready to witness a code transformation that's more exciting than watching a hedgehog unfurl! Generics in Go were introduced in March '22, but aside from scratching the surface, there haven't been many presentations about using them on a larger scale. In my talk, I will explore the challenges we faced, how we used clever generic design patterns to overcome them, and the benefits we gained.
LEVEL: Advanced
Empowering Go's Capabilities with the WebAssembly System Interface (WASI)
This session will provide a detailed introduction to WASI and its integration in Go, using live coding examples. It will also explore how Go applications can utilize WASI and networking extensions for creating robust WebAssembly applications. Attendees will gain a thorough insight into developing and deploying Go applications with WASI.
LEVEL: Intermediate
Go’s Strategic Advantage in the Era of EU Cyber Resilience and Liability
How the EU will once again force the global IT industry to improve, and why Go is perfectly suited to meet the challenges ahead. An introduction to cyber resilience, product liability and the software supply chain in the Go ecosystem.
Coffee break
Go Birthday Party
Artistic-tech Showcase with DJ-set to celebrate 15 years of Go.
November 13th, 2024
TinyGo for Pet Automation
This session will demonstrate how to automate a dog's daily routine using Arduino and TinyGo, with a real-life example of opening a kennel door and releasing dog food. Attendees will learn the benefits of using TinyGo, and how it makes development more approachable compared to traditional Arduino programming. By the end of the talk, attendees will have a solid understanding of how to use Arduino and TinyGo in their own automation projects (for pets and beyond).
LEVEL: Intermediate
Using Nix to create reproducible Go development environments
Nix the package manager has gained a lot of popularity in the last 18 months or so. I would love to be able to show other Gophers, how they can leverage Nix and its ecosystem to improve their development environments.
Including how we can use it to create more consistent development environments, between different devices and other engineers. So we get the same development environment and tooling as each other. Then how can we use it in CI, Go have essentially the same local development environment and CI development environment. Avoiding the dreaded “it works on my machine” meme.
Go is the perfect language to pair with Nix because of how simple it is to set up with Nix. Due to it having some great tooling already. We will see, we can replace some of our existing tooling to manage developer environments with Nix.
LEVEL: Intermediate
Building Ultra-Resilient Systems in Go
In the past 6 months, my team encountered two critical incidents stemming from the same root cause - complete power loss in one of our primary data centers. The incidents occurred 5 months apart, and although the root cause was the same, our services responded very differently the second time around. Drawing from lessons learnt from this, this talk dives deep into the strategies and techniques implemented to build ultra-resilient systems in Go.
LEVEL: Introductory and Overview
Coffee break
Beyond table tests
Unlike other languages, the tools Go offers out of the box for unit testing our applications are pretty comprehensive.
The audience will walk away with a set of new techniques to write more coherent and understandable tests that fit well in a Go project.
LEVEL: Introductory and Overview
Exploring Go's Prowess in Immersive Database Development: immudb as a Case Study
Regardless of your interest in database development, this talk guarantees valuable insights into leveraging the capabilities of Go for crafting scalable and performance-critical applications.
LEVEL: Intermediate
Graphs and games: can Go take a Ticket to Ride?
The outline of the talk should go this way
- Introduce myself and my passion for board games
- Explain the game Ticket to Ride and why I decided to implement it in Go
- Show the creation of a Ticket to Ride board in Go
- Explore some Graph algorithms that can give us some insights on
- If time permits also show some gameplay examples
LEVEL: Introductory and Overview
To CGo or not: Cross compiling a SQLite driver
The talk will be about the CGo-free database/sql driver for SQLite
(modernc.org/sqlite) and the related technologies it relies upon.
Namely the C to Go compiler/transpiler (modernc.org/ccgo/v4) and the runtime
support emulating the C libc (modernc.org/libc).
LEVEL: Intermediate
Collaborate on architecture, and express it in Go
We will discuss which behaviors we should avoid, how to initiate and lead architectural discussions, and how to express these intentions in Go. We will start with issues with large pull requests, being too excited with solutions, and ivory tower architects. Next, we will move on to keeping decision records and diagrams, confronting our biases, and approaching the problem differently. In the end, we will do a live coding session to continue the discussion with future developers reading our code: using type aliases, interfaces, internal folders, and project structure.
LEVEL: Advanced
Lunch
Swiss knife for Go debugging with VSCode
Being able to debug your code in the IDE should be an easy process. If you ever struggled with debugging Go code in Visual Studio Code, this session is definitely for you. We'll take a look at how to debug several kinds of projects by only tweaking settings in the dreaded "launch.json" file. You'll discover how many options and customizations you can apply to this file to leverage your debugging experience. Finally, we briefly touch on the key features of the Delve debugger.
LEVEL: Introductory and Overview
Deep dive into a Go binary
Whenever you compile a program in Go, it generates a binary that contains your program, but... what is there?
Of course there the compiled version of your code, but what else?
Come with me to explore the inside of the go binary, the elf sections, and how they are used by our executable.
LEVEL: Advanced
From Source to Binary: Cross-Compiling in Go Explained
Attendees will learn about Go's toolchain, particularly the `go build` command, and how environment variables such as `GOOS` and `GOARCH` are used to specify the desired target operating system and architecture. We will explore practical examples of cross-compiling Go applications for various platforms, including Linux, Windows, macOS, and ARM-based systems.
The talk will also address common challenges and best practices in cross-compiling, such as handling platform-specific dependencies, managing external libraries, and optimizing binary size and performance. We will showcase tools and techniques to streamline the cross-compilation process, including the use of Docker for creating reproducible build environments.
By the end of this session, participants will have a comprehensive understanding of how to effectively cross-compile Go programs, enabling them to deliver consistent and reliable binaries across diverse platforms with ease.
LEVEL: Intermediate
How to Punch Holes in Network Infrastructure using Go
I had a dream last year about a fully decentralized peer-to-peer network leveraging an architecture that could enhance application performance, save bandwidth, and save money. In this dream, I was using my favorite programming language Go, leveraging Goroutines, Garbage Collection, Channels, and more. It was beautiful. Then suddenly I woke up and was left wondering if this was something I could actually build. What happened next was an adventure of learning about peer-to-peer networking, hole punching through network devices, discovering the go-libp2p module, and realizing my dream of a Go application that could establish peer-to-peer connections over the internet.
In this talk, I am going to share with you what I learned and how you can use Go and the go-libp2p module to punch holes through your networking devices to establish peer-to-peer connections over the internet.
LEVEL: Intermediate
Resizing Animated GIFs Without CGO or Third-Party Libraries
GIF animation icons enable users to express themselves much better. Resizing animated GIFs is necessary to support them.
What would you use when implementing GIF resizing in your Go web application? ImageMagick as we did? Another CLI? Or a C library wrapper?
There is little knowledge of GIF resizing in pure Go. There are articles about basic image resizing, but they don't cover animated GIF-specific processing. Therefore, popular methods to implement it are using CLIs or C library wrappers.
However, those invoke several unignorable issues. Calling CLIs directly from the code causes security concerns. Image-processing CLIs and C libraries are typically large files that don't fit into a container environment. Also, they cause performance overheads that affect app latency.
Stop using them by implementing GIF resizing with pure Go! It requires some specific knowledge, but it's so simple that we can implement it with only standard libraries and sub-repositories (golang.org/x libraries)!
Learn how to implement GIF resizing with pure Go step by step and the cautionary points you may face during the implementation.
LEVEL: Advanced
Coffee break
Keynote: Go ten years ago, Go ten years from now
Go was already a stable language ten years ago, yet it would be unrecognizable to most now.
Forget modules, the LSP, contexts, and even generics - all taken for granted today.
Where will Go be ten years from now?