-
GoLabOctober 22-23, 2018
Attend the most revolutionary event of the year
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.
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.
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.
GoLab is a unique occasion to meet all the sector protagonists. The event offers you the opportunity to build the right network.
08.45
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
10.15
30min
Common area
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
11.30
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
13.00
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
15.15
TBA
45mins
Embedded
TBA
16.00
30min
Common area
16.30
30min
Embedded and Patterns rooms
All levels
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
17.45
45mins
Embedded and Patterns rooms
All levels
18.30
45mins
Embedded and Patterns rooms
All levels
20.00
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
13.00
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
45min
Patterns
Beginner
15.15
45min
Patterns
TBA
16.00
30min
Common area
16.30
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
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
13.00
90mins
Hotel Restaurant
In this workshop we cover all you need to know about working with relational databases, like Postgres or MySQL, in Go.
In the first part of the workshop we will look at database/sql package found in the Go standard library. While covering this package we’ll learn about how database drivers are registered and used, how to insert and retrieve records from the database, and finally cover how to deal with null records in the database.
Once we understand the basics of working with databases in Go, we’ll move to the github.com/jmoiron/sqlx package. The sqlx sits on top of the standard library and provides a slightly higher abstraction, including support for common tasks such as mapping a struct to a SQL result row.
Finally, we’ll look at the github.com/markbates/pop package that sits on top of sqlx. Pop aims to make common CRUD tasks simpler in Go. Pop also supports migrations, CLI tools, and more.
150min
Trainings
TBA
16.00
30min
Common area
In this workshop we cover all you need to know about working with relational databases, like Postgres or MySQL, in Go.
In the first part of the workshop we will look at database/sql package found in the Go standard library. While covering this package we’ll learn about how database drivers are registered and used, how to insert and retrieve records from the database, and finally cover how to deal with null records in the database.
Once we understand the basics of working with databases in Go, we’ll move to the github.com/jmoiron/sqlx package. The sqlx sits on top of the standard library and provides a slightly higher abstraction, including support for common tasks such as mapping a struct to a SQL result row.
Finally, we’ll look at the github.com/markbates/pop package that sits on top of sqlx. Pop aims to make common CRUD tasks simpler in Go. Pop also supports migrations, CLI tools, and more.
75min
Trainings
TBA
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
13.00
90mins
Hotel Restaurant
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
16.00
30min
Common area
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
08.45
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
09.30
TBA
45min
Web and Developer Experience rooms
10.15
30min
Common area
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:
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
13.00
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:
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
16.00
30min
Common area
16.30
30min
Web and Developer Experience rooms
All levels
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
18.00
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:
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:
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
13.00
90mins
Hotel Restaurant
We always hear how Go is a simple language, how it can enable developers to be productive. In this talk, we'll start from scratch and develop a production-ready service in Go, using the standard library, a few popular libraries, instrument it, and deploy it using Docker.
45min
Developer Experience
Beginner
15.15
TBA
45min
Developer Experience
TBA
16.00
30min
Common area
16.30
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
13.00
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
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
16.00
30min
Common area
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
GoLab will be held in Florence,at Grand Hotel Mediterraneo.
45
countries
350
speakers
20
conferences
5000
attendees
All the tickets are valid for the two days of conference.
€10
€79
€119
€55
€124
€164
GoLab is always possible thanks to our sponsors. We are available to find a custom solution for your company, become a sponsor.
Last editions of GoLab were possible thanks to our partners. Contact us and become our partner.
