Take part in innovation

Attend the most revolutionary event of the year

GoLab

GoLab is the first Italian conference on Go. GoLab was created and yearly organized by Develer, the company who launched events like PyCon, EuroPython, LinuxLab, Better Software, Better Embedded, QtDay.

Theory and practice. Together.

We of Golab think that the best way to learn a technology is putting together theory and practice, that's why you will find both kinds of talks.

Qualified speakers.

All our speakers have several years of professional and personal experience with Go. Technical talks and case studies will clarify all your doubts about the language and will help you with everyday projects.

Italian gophers and international friends

GoLab is a unique occasion to meet all the sector protagonists. The event offers you the opportunity to build the right network.

Monday, October 22nd

Pick your badge up at the registration desk


30min

Welcome to the attendees and main information about the conference


15mins

Embedded and Patterns rooms

TBA


45min

Embedded and Patterns rooms

30min

Common area

Edo Scalafiotti

Fuchsia is the new OS from Google based on a new non Linux kernel that could replace Android. Few Programming Languages will be supported and Go is of course one of them. This talk will highlight how to write an application in Go for Fuchsia and will also serve as an introduction to the new OS.

Google has started working on the Fuchsia OS back in 2016 with a possible release window of 2019, early 2020. This OS is meant to run on every device: be a laptop, smartphone, IoT or embedded and could potentially replace Android and Chrome OS. It will heavily use the Google Feed and have different programming paradigms, especially around the new concepts of Stories and Modules, coupled with the cloud User Ledger.

This talk will highligt how to develop a Go application in Fuchsia, how to make the best use of Stories and Modules and how to prepare for the possible convergence of mobile and desktop. A particular focus will be given on performance seen that it will no longer be safe to assume on what type of hardware the app will be running.

Although still relevant to Go, this talk will also highlitght how Fuchsia works, how to install a developer version and how Go can interact with front-end libraries like Flutter.


45min

Embedded

Intermediate

Giovanni Bajo

TBA

45min

Embedded

TBA

What happens if you take reconfigurable hardware (like FPGA) and mix it with a modern language like Go?
What if the processor became a modular object?
This talk is about the BondMachine Project, a reconfigurable computing system, which completely rethinks the stack.

In this talk I will introduce the BondMachine (BM) project. The project’s aim is to implement a full reconfigurable computing system by creating a heterogeneous and flexible architecture and to use Go as source language for the its applications. The central part of the project is its compiler, Bondgo, that starting from an high level language, in this case Go, produces not only the assembly code for the architecture but, unlike other compilers, can even create a specific device optimized to run the code (in the form of HDL code). The architecture became thus part of the compilation process. The Go code is mapped this way very closely to the hardware in ways that will be shown in the presentation thought several examples. For several Go constructs, channels to name one, an hardware counterpart have been created. Finally thanks to a custom network protocol many BondMachines can be interconnected together, therefore building heterogeneous multicore systems or even cluster of multi-cores. The flexibility of the BM makes possible the implementation of any computing system ranging from networks of small agents, like IoT (Internet of Things), to high performance devices for ML (Machine Learning) or real time data analysis, and even systems that mix all this different characteristics together. The BM can interact with standard Linux workstations both as a special purpose hardware accelerator or as part of a computer/BM hybrid clusters.


45min

Embedded

Intermediate

90min

Hotel Restaurant

Introducing GoCV (https://gocv.io) a new package for letting Go programmers create computer vision applications using OpenCV.

In this talk I will show how to use GoCV to build the next generation of computer vision applications, with live code demonstrations including a Tensorflow enabled drone.

It is easier to see what comes next for the Internet of Things (IoT) when you have eyes on the world. Computer Vision (CV) software, in particular the open source OpenCV (http://opencv.org) has made big leaps in power and usability, and is ready to come into its own as a key part of an advanced IoT solution.

At the same time the Go programming language aka Golang has won over fans with clean code, high-performance, and portability. But there has not been any way to unlock the most state-of-the-art CV libraries using the most state-of-the-art programming language… until now.


45min

Embedded

Intermediate

Nic Jackson

TBA


45mins

Embedded

TBA

30min

Common area

  • Documenting Go Code with Beatiful Tests - Paweł Słomka
  • Turn data into Go structs - Martin Czygan
  • Interfaces Best Practices - Anuj Agrawal
  • Small is more - Andrea Masi
  • Go Italia Association: the state of the art - TBA

30min

Embedded and Patterns rooms

All levels

Luca Cipriani

What happens when you have half a million users, 11 millions of their files, and you have to change completely the underlying technology with no downtime, no conflicts, over several weeks of a rolling update?

Arduino Create is a web application that handles half a million users, 11 millions of files totaling 100GB. Files were saved in AWS S3 but we decided that using a NFS shared between instances was easier and better performing. But how to migrate data without stopping the service for several hours? How to do a rolling update, in order to minimize issues ?

In this talk we examine the various solutions considered and focus on the final one, that involves using interfaces and a synchronization mechanism.


45min

Embedded

Intermediate

45mins

Embedded and Patterns rooms

All levels

45mins

Embedded and Patterns rooms

All levels

180min

Location TBA

A fast-paced dive into the rudiments of virtual machine and emulator implementation.

If you’ve played games or worked in any one of a number of popular programming languages you’re likely to have relied on a software machine written by a small but dedicated team of virtual machine enthusiasts. And unless you’ve taken a course in programming language implementation you probably have only a loose idea of what software machines are, how they work, or how easy it is to write your own.

My interest in this field was sparked during the era of home micros when I chanced upon an article in a programming magazine on how to implement Forth in Basic. That article with its inscrutable magic became an obsession that lead to a career in coding and much else beyond.

In this fast-paced introduction I’ll use code written in C and Go to explain the basic building-blocks with which we can model computing machines in software, covering as many of the main architectural features as possible in the time: stacks; heaps; dispatchers; clocks; registers; instruction sets.

This talk contains a lot of code (including some mildly gnarly C) but regardless of you current skill level it will reveal a little of the magic underneath many of the tools you probably use daily. The examples should also be sufficient to kickstart your own adventures in this fascinating field.


45min

Patterns

Intermediate

Have you ever wondered what really lies behind the “go” statement? Did you ever stop and think about differences between goroutines and standard operative system threads? Is there something you should know to avoid bugs or weird, unintended behaviours?

What really happens when you spawn a goroutine? How are variables closured in it? How does the scheduler interrupt execution of a goroutine to switch context or perform a garbage collection? Why should you know the answers to all these questions?

Goroutines are one of Go’s core features. They are by far more efficient than standard OS threads, but they have to pay a price for that. This talk is about go’s runtime internals and their most unexpected behaviors you should know about.


45min

Patterns

Advanced

How many times did you try to decode a string and couldn’t because it was malformed? With state machines, we can dynamically decode malformed or incomplete strings. This talk will discuss how to implement such state machines and the problems you might encounter.

Applying university computer science to real projects is not always a straightforward process. This talk is an example of how to implement a finite state machine (FSM) from a paper design to a Go project. It all started with a bunch of malformed b64 strings that couldn’t be decoded by standard tools only because they had some invalid characters in the middle. After stripping a couple of them manually, it was time to solve this problem more definitively. Our use case was the decoding package of an open source suite to test web applications, Wapty (https://github.com/empijei/wapty). The decode package uses a finite state machine to parse strings and intelligently decode them. If an invalid sequence is encountered, the tool will replace it with a default character and then try to recover the decoding process. This is possible thanks to a FSM that peeks the next characters and, if they are valid, proceeds to decode them, otherwise ignoring them and moving on.


45min

Patterns

All levels

90min

Hotel Restaurant

You completed the tour, learned the language, got your pet project on Github. Time to start a new project, a big one: how do you organize code, tests, docs? During the talk I’ll try to save you some trial and error by sharing the lessons learned during a year spent coding a non trivial Go project.

There’s no silver bullet to organize a non trivial Go project, only good practices and experience. You can try different things but when the project gets traction, with a lot of people involved, it might be difficult to change strategy. You may look at what others do in bigger, well known projects but size matters and you can’t just do “what they do at Kubernetes”. During the talk I’ll show some lessons learned while building from the ground up a Go project that now has more than 600 source files, dozens of packages and the tooling needed to build binaries, packages and Docker images.

Outline

  • Project layout
  • Keep your tooling sharp: task orchestration without Make
  • How to use tooling to tame CGO
  • Keep your software modular and portable with build flags
  • Organize and run different types of tests
  • Make docs a first class citizen
  • Docker integration
  • Provide system packages with Omnibus installer

45min

Patterns

Beginner

45min

Patterns

TBA

30min

Common area

30min

Embedded and Patterns rooms

Go code generation was traditionally still a difficult topic. Armed with Gomacro REPL, we will see how creating and manipulating abstract syntax trees (go/ast.Node) becomes as easy as adding few keystrokes to a statement or declaration. And you can do it interactively: much more fun and productive.

Go code generation, while easier than in many other languages, is still mostly considered an advanced topic.

Borrowing ideas from code generation languages, we propose an alternative approach that is easy, interactive and fun.

Using Go interactive interpreter Gomacro, we show how creating and manipulating abstract syntax trees of go/ast.Node becomes a matter of adding few keystrokes to an expression, statement or declaration.

A quick example: x + y is a Go expression that could be saved, compiled and executed. ~"{x + y} is another Go expression that, when typed at Gomacro prompt, gets executed immediately and returns an ast.Node containing the parsed abstract syntax tree &ast.BinaryExpr{X: &ast.Ident{Name: "x"}, Op: token.ADD, Y: &ast.Ident{Name: "y"}} which can be inspected and manipulated directly at the prompt.

Compare it to the traditional approach to generate such ast.BinaryExpr: save the string "x + y" somewhere (in a file, or as a string in source code…), write code that invokes one of the functions go/parser.Parse*, compile and execute it.

By combining two additional Lisp code generation techniques supported by Gomacro, namely quasiquoting and macros, a full code-generating program often consists of the skeleton code to generate, wrapped inside ~"{}, intermixed with normal Go code that loops and sets the non-constant parts.

For reference, more than 75% of Gomacro ‘fast’ interpreter source code is generated with this mechanism. In the author’s opinion, using a traditional approach to generate the same code would have been simply too onerous.

And much less fun.


45min

Patterns

Intermediate

Vincenzo Di Somma

In this workshop we’ll go from your first Go program to concurrent programming strategies, presenting examples and use real world cases, including testing, benchmarking and debugging.

135min

Trainings

TBA

90mins

Hotel Restaurant

Mark Bates

In this workshop we cover all you need to know about working with relational databases, like Postgres or MySQL, in Go.


150min

Trainings

TBA

30min

Common area

Mark Bates

In this workshop we cover all you need to know about working with relational databases, like Postgres or MySQL, in Go.


75min

Trainings

TBA

Bill Kennedy

This class will not focus on syntax but learning how to read and understand the Go code you are writing. With a big understanding of “if performance matters” then these things matter. We will talk about semantics, guidelines, mechanical sympathy and data oriented design. We are going to talk about writing concurrent code and how to effectively use channels. Then we will dig into benchmarking and profile tooling.

135min

Premium Training

TBA

90mins

Hotel Restaurant

Bill Kennedy

This class will not focus on syntax but learning how to read and understand the Go code you are writing. With a big understanding of “if performance matters” then these things matter. We will talk about semantics, guidelines, mechanical sympathy and data oriented design. We are going to talk about writing concurrent code and how to effectively use channels. Then we will dig into benchmarking and profile tooling.

150min

Premium Training

TBA

30min

Common area

Bill Kennedy

This class will not focus on syntax but learning how to read and understand the Go code you are writing. With a big understanding of “if performance matters” then these things matter. We will talk about semantics, guidelines, mechanical sympathy and data oriented design. We are going to talk about writing concurrent code and how to effectively use channels. Then we will dig into benchmarking and profile tooling.

75min

Premium Training

TBA

Tuesday, October 23rd

Pick your badge up at the registration desk


30min

Welcome to the attendees and main information about the conference


15mins

Web and Developer Experience rooms

Bill Kennedy

TBA


45min

Web and Developer Experience rooms

30min

Common area

Mark Bates

Come one, come all! Come see the fool who’s trying to rewrite Rails in Go! No part of the Rails eco-system is safe from the mad fool who tries to rebuild it all again with a compiled, statically typed language. Can he do it? See for yourself!

I spent 12 years writing Ruby on Rails applications. I wrote a lot of them. I was great at it. I could knock an application out in a weekend.

A few years back I found Go. I feel in love. I won’t bore you with the details of why, they’re un-important. What is important is I wanted to build web apps in Go, but I couldn’t. It was painful. I struggled. I tried every “framework”, every 3rd party package I could find, but none of them brought me the developer speed I had with Rails. I cried. I drank. I cried and drank.

Finally, I thought, why not take all of the experience I’ve had with Rails and all the of the experience I’ve had with all the Go frameworks and packages I’ve played with and try to smoosh it all together and see what happens. Enter Buffalo.

This talk isn’t about trying to convert anyone to using Buffalo over Rails, or Go over Ruby. Instead it’s a look at the challenges, the ups and downs, the high and lows, of trying to re-build a framework that is known for it’s harrowing use of dynamic meta-programming in a language that knows not of those things.

I’ll discuss rebuilding Rake as Grift. Look at the challenges of trying to build an ActiveRecord like system (including migrations) with Pop, and much more.

This talk will hopefully provide light on why you should never want to build your own web framework, and why you should shower those who do with lots of pretty, shiny trinkets.


45min

Web

All levels

A successful story of reimplementing a safe-browsing proxy for Telefónica, moving from C++ and socket handling, to Go and packet management, and how Go can help you to be productive and efficient, and to achieve a high-quality product.

In the last years, several projects in Telefónica were based on Awanode. Awanode is a C++ proxy, on top of libev, that managed socket connections in 2 different network interfaces (ingress and egress). Awanode receives HTTP(S) requests in ingress interface, apply several policies (customizable by each project), and forward the requests to the egress interface to reach any Internet service.

Although projects using Awanode were successful, working with it introduces several challenges:

  • Development in C++ is not very productive. Developers must be very careful during the development because introducing a bug during the implementation becomes very difficult to track afterwards. Most of the times, memory leaks or invalid memory access were fixed after several days reading hundreds of lines of code.
  • As a result of the previous point, a custom SDL was developed to customize the platform. But it introduced other problems out of the scope.
  • Handling sockets, as nginx or other well-known proxies, is simple to develop. However, tuning it to reach the maximum performance is a time consuming task. A lot of issues appeared due to handling connections (IP and port spoofing, exhausting the available ports in the host, conflicting with other network infrastructure deployed in the platform, …).


45min

Web

All levels

It generally takes lots of time and decisions to create an HTTP API, but when you want to get productive fast, you want to skip as many steps as possible. I’ve been working with gRPC for almost a year and I can guide you from first lines of the code up to request tracking or exposing it via HTTP.

When you want to build a usable API these days, you immediately think about creating an HTTP server and you start from there. You may want to use a standard library or a handful of popular libraries that help you with that. What if I told you that there is an alternative? With gRPC you can build fast, elegant and reliable solutions which, in the end, could also be exposed via standard HTTP server. I would like to guide you from the first steps, through various levels of compexity, to request tracking while mainaining an elegant, readable and testable codebase.


45min

Web

Intermediate

90min

Hotel Restaurant

In this talk we will go through whole “serverless” thing: from decomposing app and its logic to microservices and further to smaller bits, i.e. functions to defining data flow through functions and building their fault-tolerant pipeline.

Serverless architectures refer to applications that significantly depend on “cloud” services (knows as Backend as a Service) or on custom code that’s run in ephemeral runtime (Function as a Service or “FaaS”).

To application developers, “serverless” mean app where some certain logic of it is still written by the developer but unlike traditional architectures or microservices is run in stateless compute runtime that is event-triggered, may only last for one invocation, and fully managed by a cloud. Serverless helps developers to transfer responsibility of keeping their apps up and running as well as scaling out their workload capacity without involving DevOps/Ops as we got used to.

Moreover, we will go through the demo that highlights key takeaways:

  • how to design scalable architecture without getting into troubles by hitting concrete bottlenecks
  • how to combine multiple programming languages into a single app
  • why Go and Python are the ones of the best programming languages designed exactly for serverless


45min

Web

Intermediate

Microservices, DDD, distributed systems, serverless. All trends decompose to the max, which moves the complexity to the collaboration of these pieces. I want to tell some war stories around that in this talk and give people some guidance.

How can you implement complex end-to-end use cases (e.g. a customer order) when you have a bunch of nicely decoupled (micro-)services (e.g. checkout, payment & shipping)? How do the services collaborate? Synchronous or asynchronous? Choreographed using event-chains? Orchestration using frameworks like Netflix Conductor? In this talk, I discuss different alternatives and show how to handle long running processes and requirements around state, error handling, timeouts, distributed transactions or compensation. I discuss how you can ensure visibility and provide status and error monitoring. Expect live hacking leveraging lightweight open source frameworks like Zeebe.io. I will share our experiences from real-life projects.


45min

Web

All levels

30min

Common area

TBA

30min

Web and Developer Experience rooms

All levels

Andrea Tosatto

Looking at the most popular (container) orchestration projects available in the Community (Docker, Kubernetes, Nomad, etc) most of them are written in Go.

What is making Go so much effective for writing such systems?

In this presentation we walk through the architecture of a generic orchestration system and see how each of the different components can be effectively implemented in Go.


45min

Web

TBA

This will be a step-by-step talk on building a FaaS platform for executing Go functions from packages exposed via Git and a REST API to trigger function execution. The system will utilize the Go build system internally, text templates, GOPATH, and the Go standard library atop FreeBSD Jails and ZFS.

Function as a service (FaaS) is a type of cloud computing that allows a consumer of the service the ability to run discrete, specific pieces of code rather than building a full application or integrating that functionality into a larger application. This approach allows for potentially less code, cheaper computing costs, and faster development. These systems are quickly becoming integral components of modern architectures. Most of the major cloud providers have incorporated some form of FaaS into their service offering. One of the biggest benefits to using one of these services is that you have access to the catalog of other services they offer which allows for building powerful applications quickly with less code.

This talk will go through the steps necessary to build your own FaaS system that will be able to execute Go functions in packages accessible via Git. We’ll begin with a high level review of what FreeBSD Jails are, how they’re used traditionally and how they’ll be used by our system. Then a high level review of ZFS, more from the perspective of our use case which will include zpools, datasets, snapshots, and clones and how they’ll provide us with our filesystems. Once the base system components are understood, we’ll take a look at why Go is a great choice to build this system. At the heart of what binds these components together is Go’s text template system, the compiler, GOPATH, and the standard library.

The talk will also cover building an extremely simple DHCP server embedded into the application as well as a REST API for triggering function execution and a means of administration.

The goal, by the end, is to have the audience understand how Go makes building a FaaS platform easy with real world, practical examples, and a reference implementation to use for inspiration or to build from.


45min

Web

Beginner

Farewell and final networking


90min

Web and Developer Experience rooms

Go fit perfectly inside containers, you can ship apps as tiny images on k8s, distributing them across the globe. Gianluca will show how InfluxData debugs containers running on Kubernetes to allow sysadmins and developers to troubleshoot and replicate issues using core dump, debuggers, and logs.

Go applications are perfect to be run inside a container. You can build a single binary, a tiny Docker image and you can ship them on your Kubernetes cluster. A successful production environment requires stability and simplicity, it needs to be easy to troubleshoot and operators need to be able to get all the information developers will need to fix a bug. During this talk, Gianluca will share what influxData is doing to allow developers and system administrator to work together, understanding problems running live at scale on Kubernetes and how to escalate them down to Software Engineer using logs, delve, gdb, core dumps, and traces to replicate and fix issues.


45min

Developer Experience

Intermediate

Unit testing using mocks is a common technique in Go and other languages. However, some dependencies are harder to mock than others; standard library packages such os can be particularly tricky. This talk covers strategies for effectively testing code that depends on such hard-to-mock packages.

Mocking dependencies is a common unit testing technique. Mocks are code that can be injected in place of real dependencies, allowing a developer to control the behavior of these dependencies from a test. Mocks may be generated by a tool or written by hand, but either way they make it easy to exercise error conditions and isolate tests from external software and systems.

In Go, it’s easiest to use mocks for dependencies that export interfaces. A mock object conforming to some interface can be built or generated and injected for tests, while a real object conforming to the same interface is used in production. However, not all packages provide nice mockable interfaces. In particular, low-level packages such as the os package in the Go standard library tend to export functions (as opposed to structs with methods) and structs with data members (as opposed to accessor functions). These properties make it difficult to build mocks for testing code that depends on such packages.

This talk will provide a brief introduction to testing with mocks, discuss what makes some dependencies harder to mock than others, then describe strategies for testing code with hard-to-mock dependencies. Strategies include:

  • Isolating code that depends on hard-to-mock packages.
  • Wrapping hard-to-mock dependencies and using mocks.
  • Using function variables to mock exported functions without building unnecessary interfaces.
  • Composing wrapping, function variables, and mocks to simulate complex dependencies.

Attendees will learn about these strategies through a series of practical examples based on common Go use-cases. The examples will use programmable mocks generated with mockery and mockpkg, but the strategies are equally applicable to hand-built mocks or those generated by other tools.



45min

Developer Experience

Intermediate

Do you like Go so much and use it in every software project? Do you think Go is a truly universal language? How about taking it to the next level and trying Go as a scripting language for your favourite Linux distribution?

Why use Go as a scripting language? Short answer: why not? Go is relatively easy to learn, not too verbose and there is a huge ecosystem of libraries which can be reused to avoid writing all the code from scratch. Some other potential advantages it might bring:

  • build your complex Go project with Go-based build system: no Makefiles, bash or Python - all pure Go!
  • easy non-privileged package management out of the box: if you want to use a third-party library in your script, you can simply go get it to your GOPATH
  • quick code prototyping on early project stages: short-circuit the “edit->compile->check” cycle, instead immediately execute your source file
  • fail early with strongly-typed scripting language: if you have a typo in your 2k line script, it will fail to start instead of executing first 1800 lines and leave your system in an inconsistent state

There were previous attempts to make Go scriptable using a shebang line, however (mostly because lines starting with # are not valid in Go) the solution is not perfect: you end up with .go files either to be used as scripts only or as real compilable Go programs, but not both. This talk describes a way how one can use some advanced features of binary execution on Linux to overcome previous problems and make Go truly native scripting language.



45min

Developer Experience

All levels

90mins

Hotel Restaurant

In late 2016 a small team of engineers set out to completely rewrite the core of the NYTimes Crossword in Go and migrate it to GCP. In mid-2017, we achieved 100% traffic cutover with zero downtime for our 300K paying subscribers. We’ve cut our costs in half despite doubling our traffic in that time.

The Games backend supports several mobile clients, including iOS, Android, Kindle, Windows and web. It was obvious the LAMP stack it was running on was could not keep pace with demand and a new architecture was needed. AppEngine and Go were chosen due to their demonstrated performance in scalable web applications and SOAs. The multi-phase migration was planned and executed by a team of 3 developers. The new system can now handle 10pm traffic spikes when the new daily crossword is released and regularly performs beyond a six-sigma error rate. Beyond AppEngine, we utilize PubSub, TaskQueue, BigQuery, Kubernetes and several other GCP tools.


45min

Developer Experience

Intermediate

TBA


45min

Developer Experience

TBA

30min

Common area

TBA

30min

Web and Developer Experience rooms

All levels

Plot twist: sometimes Go gets in our way. While exploring the container world, we can find surprising limits if the implementation of the Go runtime, and the solutions needed to overcome those limits may be even more surprising. In this talk we will see some of those limits, and their solutions.

The advantages given by Go are well known, and benefits of using channels and goroutine are evidents. However, sometimes the language -or its runtime- gets in the way, leading to subtle bugs, which require sometimes very surprising solutions to over come them. In this talk we will see some of those cases with their solutions, directly from the container ecosystem.


45min

Developer Experience

Intermediate

Famous last words: “CGo will allow me to write code in Go once and invoke it from other languages easily”. I demonstrate that this approach is mostly more trouble than it’s worth; by doing a live end-to-end exercise of invoking go built shared library from other higher level languages.


45min

Developer Experience

All levels

A workshop with performance evaluation hands-on using profiling tools popular in Go community to find and debug performance issues. Attendees will work on a pre-defined non-performant code to find and fix performance issues in the code as we discuss various tools including pprof and flamegraphs.

Most new developers writing code in Go do not really understand how they can evaluate the performance of their code. The first tryst with performance is usually benchmarking tools which is usually used to detect degradation of performance. Most developers would not look for performance issues as they develop their application and, hence, do not develop an understanding of various profiling tools that are available for Go. In this workshop, attendees will begin with a pre-defined non-performant code and will identify and debug performance issues like high latency due to burning of CPU cycles, cases with larger memory footprint than required, goroutine leaks, etc. In the process, attendees will get a change to go hands-on using tools like pprof and flamegraphs.


135min

Trainings

Beginner

90mins

Hotel Restaurant

A workshop with performance evaluation hands-on using profiling tools popular in Go community to find and debug performance issues. Attendees will work on a pre-defined non-performant code to find and fix performance issues in the code as we discuss various tools including pprof and flamegraphs.

Most new developers writing code in Go do not really understand how they can evaluate the performance of their code. The first tryst with performance is usually benchmarking tools which is usually used to detect degradation of performance. Most developers would not look for performance issues as they develop their application and, hence, do not develop an understanding of various profiling tools that are available for Go. In this workshop, attendees will begin with a pre-defined non-performant code and will identify and debug performance issues like high latency due to burning of CPU cycles, cases with larger memory footprint than required, goroutine leaks, etc. In the process, attendees will get a change to go hands-on using tools like pprof and flamegraphs.


45min

Trainings

Beginner

Martin Czygan

Machine Learning allows to tackle hard tasks like image analysis or natural language translation. While Go is not the most prominent tool for research, it is loved for its simplicity, stability and easy of deployment. In this workshop, we explore, how Go and machine learning can fit together.

Machine Learning allows to tackle hard tasks like image analysis or natural language translation. While Go is not the most prominent tool for research, it is loved for its simplicity, stability and easy of deployment. In this workshop, we explore, how Go can be used for machine learning: what libraries are available and how they compare to other options in other languages. We also explore how to write applications, that embed (e.g. neural network) models, that have been created in other languages.

During the workshop, the participants will develop or extend a couple of examples. A number of pre-trained models will be available for use in own Go programs and for experimentation.


45min

Trainings

Intermediate

30min

Common area

Martin Czygan

Machine Learning allows to tackle hard tasks like image analysis or natural language translation. While Go is not the most prominent tool for research, it is loved for its simplicity, stability and easy of deployment. In this workshop, we explore, how Go and machine learning can fit together.

Machine Learning allows to tackle hard tasks like image analysis or natural language translation. While Go is not the most prominent tool for research, it is loved for its simplicity, stability and easy of deployment. In this workshop, we explore, how Go can be used for machine learning: what libraries are available and how they compare to other options in other languages. We also explore how to write applications, that embed (e.g. neural network) models, that have been created in other languages.

During the workshop, the participants will develop or extend a couple of examples. A number of pre-trained models will be available for use in own Go programs and for experimentation.


120min

Trainings

Intermediate

Giovanni Bajo

TBA

135min

Trainings 2

TBA

90mins

Hotel Restaurant

Giovanni Bajo

TBA

150min

Trainings 2

TBA

location

GoLab will be held in Florence,
at Grand Hotel Mediterraneo.

Grand Hotel Mediterraneo

Lungarno del Tempio, 44
50121 Firenze (FI)

go to the website

OUR CONFERENCES IN NUMBERS

Registration

All the tickets are valid for the two days of conference.

sponsors

GoLab is always possible thanks to our sponsors. We are available to find a custom solution for your company, become a sponsor.



partners

Last editions of GoLab were possible thanks to our partners. Contact us and become our partner.