GoLab 2019

This talk is a fundamental exploration of Go app basics: best practices to building internal services, meaningful return types, error handling, isolation of external dependencies and unit testing design. It will give Go beginners a good starting point to building testable and well designed apps.

Develop, Build, Release and? That's all? No the work of a developer is not yet quite over.

Every coder thinks they know functions. Neat little packages of code for hiding away all that ugly implementation detail we only want to write once and would prefer no one else ever saw. In fact we take them so much for granted that when academics wax lyrical about their amazing potential we tend to assume they’re talking about the very same thing and wonder what all the fuss is about. Especially when presented with languages like Haskell which read more like a maths textbook and come with that knowing smile our parents had when telling us to eat our green vegetables: this is better for you.

With the growing popularity of Go many people are asking how to build a solid GUI. It’s design for concurrency and portability makes it a great match for cross-platform development. This talk shows how the Fyne toolkit is designed to help make beautiful and idiomatic native apps simply, using pure Go.

The io package offers efficient primitives and utilities to work with data and data streams. This talk highlights the core I/O interfaces and additional helpers from the standard library. We will see, when and how to implement these interfaces yourself and look at some existing implementations.

How a truly cloud-OS could provide the same outcomes that Moore’s Law had promised — but cannot deliver anymore. Now that miniaturisation has almost reached its limits, optimisation will become the key for innovation, so PLs like Go and a new kind of developer would need to emerge to support it.

Users don’t want to waste time looking at loading spinners. When creating a user-facing service it’s extremely important to ensure it can perform adequately well, especially under heavy load.

Description: This class has been designed over the past 4 years and goes beyond just being a language class. There will be very little teaching of syntax and a big focus on learning how to read and understand the code you are writing. With a big understanding of "if performance matters" then these things matter.

Let’s spy all our Go programs!

Go is all about parallelism and concurrency, but they don’t come for free. This talk is about measuring their contention price, and being able to reduce it.

Grpc is known as an “Rpc framework”. What is less known is how it internally works and the fact that a lot of “advanced features” such as service discovery, retries, tracing are really easy to enable in the Go implementation. In this talk I will describe this less known features of Grpc.

Gdlv is a GUI frontend for Delve that supports Windows, Linux and macOS. I will perform a live demonstration of its main features, including conditional breakpoints, expression evaluation, stepping through code and reversible debugging.

Go 1.11 introduced modules, the new standard package management system for Go. It’s a massive step forward for the community, especially because we can build proxy servers instead of just using Github to fetch code. Athens is leading the way to solve some painful problems we’ve had for years.

TinyGo takes the Go programming language to the “final frontier” where we could not go before running directly on microcontrollers like Arduino and more! TinyGo (http://tinygo.org) is a new miniature version of the Go language that can run directly even on the smallest of computing devices.

In this talk, we’ll have a look at how to use the popular Raspberry Pi 3 development platform with Go and add some smartness to it to automate our lives.

Gio is a new Go library for creating portable GUI programs in pure Go that runs on all the major desktops (macOS, Windows, Linux), mobile platforms (iOS, Android) as well as in the browser.

Garbage collection is an important part of Go memory management.

GitLab is a ruby on rails application, but this didn’t prevent us from having fun with Go. Learn how we decomposed our monolith by writing a smart reverse proxy in Go that handles I/O intensive operations. A technique that every web app can use, regardless of the company stack.

It’s Okay to Dream and Fail Plenty is the story of Delphine Nyaboke from Kenya, "a daughter of the Earth who understands that the world owes her nothing, neither does she it".

"It starts with a problem": let's follow Roberto Clapis' closing talk to see also how it ends!

You want to build a production grade web service in Go, but what's important to get right from the very beginning so you can have success. In this talk, we will live code the beginnings of a web service and talk about the Macro level engineering decisions you need answers for. Along the way, I will impart my design philosophies, guidelines and priorities for you to consider and think about.

In the world of High Energy Physics (HEP), software at large is usually written in a mixture of C++ and Python (with dwindling amounts FORTRAN).
This is the result of 2 somewhat conflicting constraints:
- software has to run fast to quickly analyze petabytes of data
- software has to be relatively easy to write (and tweaked) by people with a wide variety of programming skills
What could Go bring to the table?

Microservices have become very popular to break complex systems into loosely coupled services communicated with APIs. This talk covers well-known design patterns and go frameworks to build up microservices architecture successfully, and deploy your application on any cloud provider.

This talk will dive into how we rewrote one of our production services in Go, leveraging Golang’s natives proxy implementation and routines alongside its async capabilities for improved scale & throughput of web services, enabling exponentially improved performance.

In this workshop, Elias will take you all the way from an empty "func main" to a functional
GUI program that runs on your desktop, mobile and even in a browser. Along the way, you will
be introduced to the core concepts of Gio, in particular immediate mode GUIs and how common
tasks such as drawing, layout and input look like."

We encrypt our web connections. We encrypt our files. Why the heck don’t we encrypted our database tables? It may sound a bit mad encrypting something we’ll need to be able to search whilst it’s still encrypted but that’s what you’re going to learn in a single session.

The Analysis API is used to write analyses (like those in go vet and go lint) that can help surface bugs and show code improvements to users. I’ll show how to use and write analyses, and see their results, so you can help improve your code quality.

When using the right patterns, testing in Go is more powerful than any other language. In this talk I present those patterns and show how they can save massive amounts of time, energy and cognitive effort for everyday Go programmers.

Failure has been neglected for quite some time in our industry, but how can we design for failure? And especially, how Gocan help us be prepared for the unexpected?

In this talk we have a look at the new Go Modules functionality and explore everything that a user needs to understand to use them, from creating a project, using dependencies, running tests and more.

Mutexes can be a central part of creating highly concurrent systems, but designing a system that utilise them can be very complex.

Based on a real case, we will look at design considerations for a performant and scalable service.

We introduce and describe the backend event system used in production by the Cacoo team, with a focus on its architecture, main design choices and development challenges.

At the HackLab at GoLab you will get to program robots, drones, and sensors, all using our favorite programming language Go!

In this workshop participants can familiarize themselves with the support for concurrency and parallel programming in the language and the standard library. We’ll explore channels and goroutines, the sync and context package, and a few general patterns for writing robust concurrent programs.

The Go team has built a module mirror and checksum database, which adds reliability and security to the Go ecosystem. This talk discusses the technical details of authenticated module proxies, following the journey of a request through the go command, proxy, and checksum database.

Serveless gained some good traction lately, and at GitLab we decided that we want to build a serverless platform too.
This talk will allow you to understand Serverless better and will guide you through myriad of complexities of building software that builds and deploys your functions to a serverless backend.

Maintaining an open-source API client takes some effort. Not only do you have to reflect the API, you also want to provide the best developer experience possible. This talk is about best practices you should use when writing Go API clients while maintaining flexibility & stability in the long term.

Ever wanted to ask arbitrary questions about your program while it is running with minimal impact on performance? In this talk, we go beyond static instrumentation and look at specific techniques for gathering information about your programs so that you can understand what your gophers are up to!

We have developed a complete Go interpreter for production use. We built this to bring you executable Go scripts, embedded dynamic Go plugins, interactive Go shells, and instant prototyping on top of the Go runtime.

KubeVirt extends Kubernetes by allowing users to run virtual machines side to side to containers in their Kubernetes clusters. We will have a whirlwind tour of the architecture, the challenges, the technologies, the components that make this possible.

Closing Talk: The Legacy of Go