Schedule

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

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.

• repo: https://github.com/empijei/def-prog-exercises

LEVEL: Intermediate

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

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.

LEVEL: Intermediate

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

TBA

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

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

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

This talk explores how to use Go and NATS JetStream to implement scalable micro-services based on event-driven architectures.

We'll start with a foundational overview of event-driven architectures, highlighting their benefits for system design, such as improved responsiveness and component decoupling.

LEVEL: Introductory and Overview

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

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

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

Gopls is Go’s implementation of the Language Server Protocol, which turns any text editor into an IDE. In this talk, Alan of the Go team at Google will present the results of his year-long effort to rearchitect Gopls to enable it to work efficiently in the largest of Go projects. By exploiting the dependency structure of Go programs at various levels of scale (identifiers, imports, types, modules) and using techniques from compilers and build systems, the new design enables Gopls to start more quickly and to serve much larger codebases, while consuming dramatically less memory. It also fixes a number of longstanding bugs and unlocks some new features, such as modular static analysis.

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.

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

Lightning talks on 12/11/2024.

To add a lightning talk proposal, please click here: https://survey.typeform.com/to/dau3dqBr

• Dario Castañé: Orchestrion: Automatic compile-time instrumentation of Go code (lighting demo)
• Jorropo: Why go does not have Tail-Call-Optimization (TCO)
• Tanguy Herrmann: Prototype a CRUD API in less than 50 LOC

Let’s travel together from the dawn of Go into the far-flung future of programming, with a few stops along the way for some live demos of moving objects.

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: Introductory or Overview

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

Domain-Driven Design (DDD) is complex, especially for Go developers. This talk will guide you through DDD basics—like domain modeling, bounded contexts, and ubiquitous language—showing why they're valuable tools for aligning code with business needs. We'll then explore hexagonal architecture to structure DDD within a Go codebase, making it adaptable and scalable.

Through real-world scenarios and common challenges, you'll learn best practices for effectively implementing DDD in Go, empowering your Gopher to navigate this intricate domain confidently.

LEVEL: Intermediate

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

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

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

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

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

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

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

Lightning talks on 13/11/2024.

To add a lightning talk proposal, please click here: https://survey.typeform.com/to/dau3dqBr

You'll also have a chance to talk and connect with all the others attendees of the conference. Go make some new connections!

• Enrico Candino: gocollect: collecting test coverage of running applications
• Ralph Kühnert: Get started with ebitengine!
• Damien Neil: os.Root: A traversal resistant file API

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

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

Lightning talks on 13/11/2024.

To add a lightning talk proposal, please click here: https://survey.typeform.com/to/dau3dqBr

• Jan Zombik: Timestone 🗿 Deterministic concurrency in Go tests
• Damien Neil: gate: a robust, context-friendly alternative to sync.Cond
• Martin Munilla: The quest for a go frontend framework
• Guillermo Mariscal: Kubernetes Esteroids with custom go controllers
• Andrew Williams: Coding graphical apps with Go and without

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?