Schedule

This class teaches how to build production-level services in Go with a focus on macro-level engineering decisions. From the beginning you will program along with the instructor, walking through the design philosophies and guidelines used to engineer the code. With each new feature, you will learn more about the transition from programming to engineering and the points of refactoring required to write production-level applications. Throughout the class, Go modules and Kubernetes will be a focus. Everyone will be making better engineering decisions after this class.

NOTE: according to the instructor, there will be two coffee breaks; one in the morning (about 11:00) and one in the afternoon(about 16:30) plus the lunch break (13:00).

This class teaches how to build distributed applications in Go with Service Weaver. At the beginning of the class, the instructor will walk you through the motivation behind Service Weaver and introduce you to the core abstractions that you need to know in order to develop a Service Weaver application. In the second part of the class, we will develop, instrument, test, and debug an emoji search engine application that will run in the cloud. 

NOTE: according to the instructor, there will be a coffee break in the morning (about 11:00).

Not enough people practice TDD so here's a chance to practice it and learn why it's such a powerful tool while being guided by software developers experienced in testing.

NOTE: according to the instructor, there will be a coffee break in the afternoon (about 16:30).

Go has come a long way in recent years, with a more productive, coherent experience than ever before.

In this talk, we'll review the latest advancements in the Go language and toolchain, and how the Go Team leverages its portfolio of projects to create complete, developer-centric solutions.

Where does your Go run? How do you tell it what to do?
Configuration is a huge part of modern development but while we benefit from Go's static type system to catch programming errors early, we don't have the same for configuration data. This talk explains how the new CUE language integrates with Go, "shifting left" your Go types to earlier stages of deployment, reducing risk while bringing joy.

Building apps is tough and involves lots of languages to reach multiple platforms - unless you build them with Go and let the tools do the hard work!
This talk covers the joy I experienced when starting to build graphical apps using Go and how any developer can feel the same with the Fyne toolkit.

Code security analysis, dependencies vulnerability scanning and supply chain security should be incorporated in the development process of any Go project.
In this talk, we will show how open source Go tools such as gosec, govulncheck and cosign make it easy to implement these security checks.

Thanks to its system interface (WASI), webassembly (WASM) is out loose and hitting the server side, the cloud native applications, the container world. And what's in common? All domains where Go runs strong.
Let's explore what we can do today and what's ahead, of course, using Go!

In this talk, we will delve into the recent advancements made towards supporting the BTF (BPF Type Format) debug format within Aya and bpf-linker. We are going to explain how BTF is generated, what’s the role of LLVM there and what we had to do in order to generate appropriate BTF information for Rust programs.

Do you have a quick and exciting idea or topic you'd like to share with the GoLab + RustLab 2023 community through a Lightning Talk, or do you know someone who might have something to share? We encourage you to submit your proposals or sponsor a proposal using the form below: Link to Lightning Talks Submission.

Do you enjoy testing? Some say yes, some say no, but for most I believe the most ‘senior’ answer is ‘it depends’.

So, what are the variables that determine this? Culture? Code? Something else beginning with C?  This is what I’ve spent the past few months investigating, so come join me and find out!

What are two of the most desired characteristics when you develop software? Storage and Speed!
In this talk I will cover both of those topics and how they mix up! I will explain a simple Redis usage pattern and compare 2 of the most popular Redis modules in Go: GoRedis and Redigo.

As more and more applications rely on personalised user experiences, recommendation engines have become an integral component of modern systems. But how do these systems work on a database level? And why does it make sense to build them in Go?

Good enough test coverage enables truly continuous deployment. Unit tests get one so far, but integration tests with actual counterparties make more sense for some features. Measuring and monitoring the code coverage for the integration tests helps to achieve the ideal deployment pipeline.

Encourage good patterns, and improve developers experience through code generation. Telemetry, decorators, ORMs, schema-first approach - automate these chores, without increasing complexity, without runtime errors, without developer having to remember about them.

Are you tired of updating the changelog file for each release of your project? Introducing git-cliff, the command-line tool written in Rust that aims to automate the process of generating your changelog based on conventional commits, saving you time and effort. Let's see how it works!

The Go runtime is an essential part of every single Go compiled binary. Understanding what it does for us and the price we pay for it can be interesting.

This talk will explore what the runtime does internally and what it provides to us.

Learn how to apply DDD to Go applications without compromising its unique idioms and language features. 
This talk covers tactical and strategic patterns with real-world examples and best practices, making it ideal for DDD beginners and those who previously struggled to use it in Go.

Experience the quirky journey of building lychee, an async Rust link checker. From weekend project to a 2-year saga, it explores software development's underestimated complexities, open-source struggles, and funding nuances. Dive into the reality of creating robust tools. How hard could it be?

Copy pasting boilerplate about HTTP handlers is exciting and funny for the first 3 webservices you code in Go. After that, it gets pretty annoying.

Generics provide a way to abstract that while keeping a strong type system.
RIP is an attempt to make REST in Go even simpler.

What if you could make Rust, TinyGo, JavaScript, ... plugins for your Go applications?
And why not take advantage of recognized Frameworks such as Fiber or Gin to create microservices based on WebAssembly? It is already possible thanks to the Extism project.

What does it mean to be a full-time maintainer? Last year, I left the Go Team at Google to become an independent professional open source maintainer. We'll talk about this experiment to establish a new more sustainable funding model for open source maintainers and how we can make it more accessible.

Can you feel the speed of your code? How do you optimize things that seem impossible to optimize? What are the acceptable tradeoffs for a speed increase?
There are a ton of questions when dealing with optimizing code. Let's try to structure our approach to writing fast code to get answers!

We used Go to build a new cloud programming framework at Google. The way people use microservices to build distributed systems slowdown innovation and hinders application’s performance. Instead, the developer should split the code at logical boundaries and delegate execution challenges to a runtime.

Let's see how the heart of a Gameboy works by analysing the 8-bit microprocessor: Sharp LR35902. We will look at the behaviour of one of the CPU registers, memory and graphics processing of a Gameboy, consolidating this knowledge into writing an emulator for the Web.

The Go programming language appears simple because the compiler handles the complexities of running them. This talk will examine the steps of compilation, divided into the front-end (Parsing, Tokenizing, AST Generation) and the back-end (AST to SSA conversion, Optimizations, Assembly).

How would you build a cloud platform to support global deployments?
After building a cloud provider in Python, we picked Go and the main open-source techs we're using are in… Go. Let's talk about building an engine to enable worldwide deployments of Go apps using BareMetal, Nomad, Kuma, gRPC & more.

An introduction to a very robust approach to coding that allows programmers to write secure code without even thinking about security.

Go programs are often benchmarked, profiled, and optimized by looking at a particular workload. For CLIs and short-lived processes, getting to your “main” function as fast as possible is just as important - how do we measure and improve that?

Join me in this experiment, we'll make some Go programs visually without writing a single line of Go code. I'll show some real life examples, talk about what could be done and what next!

EBPF is getting popular and popular. In this talk I will reintroduce it, and will describe what is the state of the art and how we can leverage it to solve problems related to performance, security and networking.

Do you have a quick and exciting idea or topic you'd like to share with the GoLab + RustLab 2023 community through a Lightning Talk, or do you know someone who might have something to share? We encourage you to submit your proposals or sponsor a proposal using the form below: Link to Lightning Talks Submission.

As we as humans must stay in the queues for bananas, the Gophers should sometimes stay organised too. You may use various technologies for simple queueing, but you can also easily use Postgres too. Write the reliable consumers in Go on top of Postgres tables and keep your architecture simple...

Developing with a database can be difficult, especially when dealing with typing issues, setting up a new database instance for testing, handling migrations, and other related tasks. By combining dbmate, sqlc, and test containers, we can effortlessly improve our database within our Go code.

This is a story about how I reverse engineered Quicktime screen recording, Xcode test execution, built reverse engineering tools myself, created a small community for my 2 open source projects, stayed motivated for over 5 years and why Go was a great choice for all of this.

Hello! Are you interested in software security? Ever wondered how to implement the best security practices in Go? If so, you don't want to miss my upcoming talk. During this talk, we will demystify the complex world of software vulnerabilities by applying the latest tools for Go applications.

A step by step guide for introducing concurrency into an application by using goroutines and spinning out multiple deployments. Shown through the lens of how a coffee shop goes from tiny one person operation to a huge conglomerate. Friendly for all levels of programming and Go experience.

Research is an integral part of every software career, but it’s an activity that’s rarely discussed. In this session we’ll use examples drawn from a real world project to see how research shapes and guides it. There’ll be code in Go, Ruby, JavaScript, and Bash.

The Go linker optimizes the size of your binaries by removing functions that are never called, a process called "deadcode elimination". Some uses of reflection can, however, partially disable it. Learn how you can determine if your program is suffering from this problem and how you can solve it.

Go 1.21's standard library features a new structured logging package,  "log/slog". slog aims to be easy to use, flexible and fast. In this talk, I’ll describe the motivation for adding structured logging to the standard library, and I’ll cover the design and API of the package.

I haven't run my backend locally for the past 5 years, and still never ship a broken API. How? Join me at GoLab and learn how to upgrade your test suite with Cucumber feature tests. Make changes, run the tests, and confidently push directly to production. Bonus: you get documentation for free.

In this fast-paced interactive keynote, we will Go from the incredibly small to as far as our imaginations can take us.
By the end you will have shared a true "out of the box" experience.