Firenze
November 11th, 2024
November 13th, 2024

Schedule

We've been working tirelessly for months to bring the best and brightest minds in the industry to GoLab.

This version is not definitive: from now to November there will be some minor changes or some additions (we are still working on the social events) but these are going to be the main features of the conference.

See you there!

November 11th, 2024

Day 1
Grand Hotel Mediterraneo
08:30
Registration desk
Networking time

Registration

09:30
GoLab Workshops I
180
min
workshop

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

GoLab Workshops II
180
min
workshop

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

GoLab Workshops III
360
min
workshop

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

11:00
Coffee break room (GHM)
Networking time

Coffee break

13:00
Lunch room
Networking time

Lunch

15:00
GoLab Workshops I
180
min
workshop

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

GoLab Workshops II
180
min
workshop

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.

16:00
Coffee break room (GHM)
Networking time

Coffee break

November 12th, 2024

Day 2
Grand Hotel Mediterraneo
09:00
Registration desk
Networking time

Registration

10:00
Main Hall
Networking time

Conference Presentation

10:15
Main Hall
45
min
11:00
Coffee break room (GHM)
Networking time

Welcome coffee

11:30
GoLab Discovery
25
min
talk

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

GoLab Deep
40
min
talk

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

12:00
GoLab Discovery
25
min
talk

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

12:30
GoLab Deep
40
min
talk

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

GoLab Discovery
min
talk

TBA1

TBA

13:00
Lunch room
Networking time

Lunch

15:00
GoLab Discovery
25
min
talk

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

GoLab Deep
40
min
talk

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

15:30
GoLab Discovery
25
min
talk

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

16:00
GoLab Discovery
25
min
talk

TBA2

TBA

GoLab Deep
40
min
talk

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

16:30
GoLab Discovery
25
min
talk

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

17:00
GoLab Discovery
25
min
talk

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.

GoLab Deep
25
min
talk

Lightning Talks (12/11/24)

TBA

17:30
Coffee break room (GHM)
Networking time

Coffee break

18:00
Main Hall
60
min
talk

Closing Keynote: TBA Evans

TBA

19:30
Main Hall
Networking time

Go Birthday Party

Artistic-tech Showcase with DJ-set to celebrate 15 years of Go.

November 13th, 2024

Day 3
Grand Hotel Mediterraneo
10:00
GoLab Discovery
25
min
talk

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

GoLab Deep
40
min
talk

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

10:30
GoLab Discovery
25
min
talk

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

11:00
Coffee break room (GHM)
Networking time

Coffee break

11:30
GoLab Discovery
25
min
talk

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

GoLab Deep
40
min
talk

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

12:00
GoLab Discovery
25
min
talk

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

12:30
GoLab Discovery
25
min
talk

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

12:30
GoLab Deep
40
min
talk

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

13:00
Lunch room
Networking time

Lunch

14:00
GoLab Discovery
25
min
talk

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

GoLab Deep
40
min
talk

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

14:30
GoLab Discovery
25
min
talk

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

15:00
GoLab Discovery
25
min
talk

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

GoLab Deep
40
min
talk

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

15:30
GoLab Discovery
25
min
talk

TBA

TBA

16:00
Coffee break room (GHM)
Networking time

Coffee break

16:30
Main Hall
30
min
talk

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?

17:00
Main Hall
Networking time

Goodbye Gophers!

GoLab is a conference made by Develer.
Develer is a company based in Campi Bisenzio, near Florence. Our motto is : "Technology to give life to your products". We produce hardware and software to create exceptional products and to improve industrial processes and people's well being.
In Develer we have passion for the new technologies and we offer our clients effective solutions that are also efficient, simple and safe for the end users. We also believe in a friendly and welcoming environment where anybody can give their contribution. This passion and this vision are what we've been driven to organize our conference "made by developers for developers".


Subscribe to our newsletter

We hate spam just as much as you do, which is why we promise to only send you relevant communications. We respect your privacy and will never share your information with third parties.
©2024 GoLab | The international conference on Go in Florence-Design & devCantiere Creativo-Made withDatoCMS