Golang Tutorial Videos

0:54:38

Building a Bank with Go

Large banking systems are incredibly dated, often as a result of a series of mergers between banks, leading to a patchwork of different systems & technologies. As a result, the...

Large banking systems are incredibly dated, often as a result of a series of mergers between banks, leading to a patchwork of different systems & technologies. As a result, the pace of innovation in the banking industry has slowed to a crawl. At Mondo we are building a new kind of bank, a smart bank that belongs in the 21st century, and we’re building it almost entirely in Go. This talk will cover how we are developing new core banking systems from scratch backed by a microservice based platform written in Go, running across multiple data centres using tools including Docker and Mesos. We also look at why Go is perfectly suited to this, our architectural decisions, common pitfalls to avoid, and lessons learnt when developing high volume, low latency, distributed Go applications.

0:52:10

Building APIs

Go is great for quickly putting together APIs addressing all kinds of problems, from simple data persistence or composing external services, to exposing complicated business logic that makes up you...

Go is great for quickly putting together APIs addressing all kinds of problems, from simple data persistence or composing external services, to exposing complicated business logic that makes up you the heart of your product or service. What’s different about Go is that these “knocked-up” services are, if built correctly, ready to deploy, scale, and live out in the wild. This talk would deep dive on the simple http.Handler and http.HandlerFunc types and how they can be used along with some cool techniques to solve a myriad of real world problems.

0:52:08

CockroachDB

CockroachDB aims to bring the best aspects of Google’s next generation database, Spanner, to the rest of the world via open source. Databases should scale horizontally with minimum fuss, survive...

CockroachDB aims to bring the best aspects of Google’s next generation database, Spanner, to the rest of the world via open source. Databases should scale horizontally with minimum fuss, survive disasters of all sorts including datacenter outages, and provide the right primitives so that developers can build applications, not workarounds. Learn about the design of CockroachDB and how you can use it to easily build scalable, resilient applications in Go that can be deployed to any cloud infrastructure seamlessly. Category

0:53:45

Complex Concurrency

There is a lot of power available through Go’s concurrency primitives, but they are still just that: primitives. Typical examples of channel and goroutine usage show pipelines and worker pools,...

There is a lot of power available through Go’s concurrency primitives, but they are still just that: primitives. Typical examples of channel and goroutine usage show pipelines and worker pools, but real applications are rarely that simple. Production systems can easily end up with hundreds of goroutines running dozens of interdependent functions; reasoning about the resulting interactions is not easy. Shopify’s Sarama library is an open-source fat client for LinkedIn’s Kafka project. It is heavily concurrent, making use of Go’s concurrency primitives to build several complex patterns, including fanout-and-shuffle among others. This talk will cover some of the patterns used in Sarama, including the challenges faced, problems overcome, and trade-offs made. Sarama has been running in production for nearly a year and a half across Shopify’s infrastructure, processing hundreds of millions of messages per day.

0:24:32

Crossing the Language Chasm

What makes millions of developers choose a particular programming language? Is it the community? Is it the features? Is it the platform compatibilities? Maybe it’s just all the hype, or...

What makes millions of developers choose a particular programming language? Is it the community? Is it the features? Is it the platform compatibilities? Maybe it’s just all the hype, or it might be because we really believe it’s the best language that ever existed? Every technology follows a well defined adoption life cycle. Where is Go in that adoption curve? Let’s talk about what we can do as a community to help Go cross the language chasm, how the community can help define and adopt Go’s future tools to attract and inspire the next generation of Gophers.

0:51:10

Dependency Management

The “go get” tool is brilliant but the tool is also its own worse enemy. It is a major reason for the problems we have with dependency management. There is...

The “go get” tool is brilliant but the tool is also its own worse enemy. It is a major reason for the problems we have with dependency management. There is no clean way to fix the dependency problem and keep “go get”. I believe solutions that wish to add or track a commit id or tag for the import url would actually create an even worse situation than we already have today. It is error prone and does not fix the inherent problem, a project needs to own and control its own consistent version of each dependency. Many agree that vendoring is the right solution, but how to vendor is the question. In this talk, I will show how vendoring is simplified and a consistent reproducible build is possible once you abandon “go get”.

1:00:34

Go Kit A Toolkit for Microservices

Go is the language of the server, but it’s not yet reached a critical mass in the modern enterprise. This talk describes Go kit, a toolkit for microservices in larger...

Go is the language of the server, but it’s not yet reached a critical mass in the modern enterprise. This talk describes Go kit, a toolkit for microservices in larger tech organizations. Learn about the motivation for its existence, how it’s progressed so far, its architectural philosophy of declarative composition, and the ways in which it’s opinionated. In the end, we’ll build an example service, utilizing each of the Go kit components.

0:49:41

Program Analysis

Go is a simple language with a very small grammar, which makes building tools for the language quite enjoyable. This talk covers different techniques that you can use to analyze...

Go is a simple language with a very small grammar, which makes building tools for the language quite enjoyable. This talk covers different techniques that you can use to analyze a given program without having to read a single line of code. From tools to measure the quality and complexity of a program to ones that pinpoint bugs and performance issues. We will discuss the limits of what static analysis can understand and how dynamic analysis techniques can help us breach the gap between theory and usability.

0:53:10

Stupid Gopher Tricks

They say you can’t teach an old dog new tricks, but what about a gopher? In this talk we’ll investigate a bunch of odd corners of the language, libraries, and...

They say you can’t teach an old dog new tricks, but what about a gopher? In this talk we’ll investigate a bunch of odd corners of the language, libraries, and tools that even seasoned Go programmers might not know.

0:27:15

The Go Community

We often think of “The Go Community” as a single entity. But different species of Gopher interact in different ways: Email, IRC, Twitter, in person, or perhaps not at all....

We often think of “The Go Community” as a single entity. But different species of Gopher interact in different ways: Email, IRC, Twitter, in person, or perhaps not at all. How do we maintain the underlying “gopherness” (if any) as these communities grow? How do we keep these groups communities that we (and others) want to be a part of going forward? And why bother worrying about community anyway? This talk will present my view of these communities, how my own involvement has changed and grown over time, reflect on some of the growing pains I’ve seen, and present ideas for encouraging a positive Gopher environment.

0:37:45

Understanding Memory Allocation in Go

Go’s clean syntax and built in garbage collection make it a breeze to write programs quickly. But as you go further down the rabbit hole, understanding your program’s memory consumption...

Go’s clean syntax and built in garbage collection make it a breeze to write programs quickly. But as you go further down the rabbit hole, understanding your program’s memory consumption and behaviours becomes important. In this talk I will explain the difference between using values and references (pointers) and explain the usage of make and built-in datatypes (like slices and maps). Along the way, I will present a few common mistakes, and give a few tips on how to avoid them.

1:03:54

Whispered Secrets

A fun mashup of networking, file IO and cryptography using Go’s standard package library. There’ll be cipher streams for files and TCP connections, hybrid encryption between web services using AES...

A fun mashup of networking, file IO and cryptography using Go’s standard package library. There’ll be cipher streams for files and TCP connections, hybrid encryption between web services using AES and RSA, and HMAC signatures for tamper-proofing. All backed up with working code. Aside from the technical content we’ll explore the benefits of putting security at the heart of application design, knowing as little as necessary about our users to service their needs without compromising their privacy.

0:25:26

A Beginners Guide to Context

The context package offers some great features that any go programmer can take advantage of to build great apps. However, it can be a little tricky when you first pick...

The context package offers some great features that any go programmer can take advantage of to build great apps. However, it can be a little tricky when you first pick it up to understand the ins and outs of how to use it and when to use it.

This talk was one simple goal, to show how the to use the context package in your programs. We’ll walk through the context package and how we can use it to make our go programs simpler and easier to manage.

We’ll look at examples and real code using context to demonstrate the everyday use cases that we may encounter and how to support them.

0:27:01

A Go IDE - Because Semantics Matter

With Go, developers use many different setups, one of the most common being editors in combination with command line tools. So one might question how using this setup differs from...

With Go, developers use many different setups, one of the most common being editors in combination with command line tools. So one might question how using this setup differs from an IDE. What benefits does the latter provide?

We’re going to share the journey of us having written a Go IDE based on IntelliJ Platform. We’ll see how IntelliJ provides the infrastructure for building static analysis engines. Inspections, with their quick fixes, “Find Usages” of symbols, refactorings and navigation are made possible when the code being analysed.

We’ll see some of these benefits and the challenges confronted in the process.

0:18:51

Advanced Patterns with io.ReadWriter

io.Reader, io.Writer, and io.ReadWriter are some of the most powerful, yet surprisingly subtle, tools in the Go standard library. In this talk, we’ll explore two concrete examples leveraging these building...

io.Reader, io.Writer, and io.ReadWriter are some of the most powerful, yet surprisingly subtle, tools in the Go standard library. In this talk, we’ll explore two concrete examples leveraging these building blocks to construct expressive and performant abstractions. We’ll also cover details of package bufio, the LimitReader, and other techniques to rain kittens on our code and dial it up to 11.

0:24:37

Advanced testing concepts for Go 1.7

Go 1.7 introduces the Run method to tests and benchmarks in the testing package. These innocently looking methods enable a wide range of functionality as often seen in other testing...

Go 1.7 introduces the Run method to tests and benchmarks in the testing package. These innocently looking methods enable a wide range of functionality as often seen in other testing frameworks, but staying true to Go’s design principles. This talk will cover how to use the Run methods for setup and teardown, dynamic tests, exerting fine control over parallelism, programmatically creating benchmarks, and selecting subtests and subbenchmarks on the command line, among other things.

0:31:38

An Actor Model in Go

The actor model makes it easier to reason about the behaviour of concurrent systems. Languages such as Erlang and Scala provide actor support as standard, but it can be added...

The actor model makes it easier to reason about the behaviour of concurrent systems. Languages such as Erlang and Scala provide actor support as standard, but it can be added to your Go programs with just a little care.

This talk will cover: A basic description of the actor model, different styles of implementation of actors in Go, limitations of Go compared to an ideal actor model, experience from actors as used in Weave Net, the Open Source container network written in Go

0:31:17

Applied Go kit

Ladies and gentlemen, don’t miss this public bludgeoning of the microservices horse for its sweet hypeglue! We will survey the complex and often contradictory landscape of microservices, explain the numerous...

Ladies and gentlemen, don’t miss this public bludgeoning of the microservices horse for its sweet hypeglue! We will survey the complex and often contradictory landscape of microservices, explain the numerous and byzantine ways that they will ruin your day, and propose partial and underspecified solutions with Go kit, a toolkit for microservices in Go. Attendees will observe the practical application of SOLID software engineering principles, and may become sufficiently jaded to seriously consider a career change. I hear carpentry is meditative.

0:30:16

Developing Apps for Developing Countries with go-mobile

What is the connection between go-mobile, GOMAXPROCS and app development for developing countries? App development for developing countries introduces a a different mindset and a slew of new challenges: smartphones...

What is the connection between go-mobile, GOMAXPROCS and app development for developing countries? App development for developing countries introduces a a different mindset and a slew of new challenges: smartphones function as a user’s main point of connection, local demand for use of mobile apps and web is different and infrastructure places strict limits on users’ internet data volume. Combining the processing power of the average multi-core smartphone with go-mobile can reduce the data consumption of apps.

In this talk we’ll discuss how the mobile world looks like in developing countries: what apps are like, what are the common devices and and what are the current initiatives to increase internet connectivity. We’ll then see how efficiently can data be compress in the device and how this may make apps more practical and accessible for the developing world.

0:22:17

Let’s build a CI/CD pipeline

Continuous integration/deployment is a methodology for making small, iterative changes that get deployed frequently. Many companies have reservations about adopting this strategy, from small startups with important deadlines to large...

Continuous integration/deployment is a methodology for making small, iterative changes that get deployed frequently. Many companies have reservations about adopting this strategy, from small startups with important deadlines to large enterprises with lengthy release cycles. We’ll explore the cost and value of the CI/CD methodology and how it fits into your organization, then set up a CI/CD pipeline using a simple Go app, Cloudfoundry, and a CI/CD server to see it in action.

0:25:32

Building an enterprise service in Go

Go has been widely successful for creating tools and infrastructure, but the simplicity of the language also makes for an excellent fit for implementing core business applications. We will look...

Go has been widely successful for creating tools and infrastructure, but the simplicity of the language also makes for an excellent fit for implementing core business applications. We will look at a few patterns for domain objects and code organization and hopefully we’ll take some additional steps towards Go in the modern enterprise. During this talk we will look at a sample application that demonstrates how a core domain could be implemented in Go. Hopefully, it will serve as leverage and inspiration for developers that want to write their next enterprise service in Go rather than using the traditional Java stack.

0:30:06

Building Cloud Native applications with Go

Seems that everywhere you look now large scale, bleeding edge cloud technology projects are being written in the Go Programming Language including many of the the current wave of ‘Cloud...

Seems that everywhere you look now large scale, bleeding edge cloud technology projects are being written in the Go Programming Language including many of the the current wave of ‘Cloud Native’ applications and services such as Kubernetes (Container management and orchestration) and Prometheus (systems and service monitoring). In this talk we’ll look into why Go is fast becoming the “Cloud Programming Language” and show you how you can apply the lessons learned on these Open Source projects to building your own Cloud Native apps including deep dives and demos around containerization, deployment and scalability.

0:24:23

Building Mobile SDKs for iOS and Android - Ain’t nobody got time for that!

You have built your shiny backend API for your Kitten as a Service platform and whilst you’ve tried to keep the API contract small and succinct the the uptake has...

You have built your shiny backend API for your Kitten as a Service platform and whilst you’ve tried to keep the API contract small and succinct the the uptake has been no where near as fast as you wanted, mobile developers are not integrating your API into their apps.

The key problem is that pretty much everyone is lazy, I am and so are you, admit it. We want to concentrate our time writing application features not writing scaffold and integration code, as an API provider this is why you need an easy to use SDK for others to consume.

In this talk I will run through such an example and will show you step by step just how easy it is to leverage the power of Go to create native performing SDKs for both iOS and Android. Of course this is but a small part of what you can achieve with GoMobile but the techniques you will learn in this session will equip you to take things to the next level.

0:24:14

Building your own log-based message queue in Go

As applications become more data-intensive and with the rise of event based architectures, terms like stream processing, ETL and data integration, become normal vocabulary for many organizations. At the center...

As applications become more data-intensive and with the rise of event based architectures, terms like stream processing, ETL and data integration, become normal vocabulary for many organizations. At the center of many of these systems we find Apache Kafka, the state of the art when it comes to storing and moving around large amounts of data.

Kafka, together with Zookeeper, forms a large and complex system. But some of its unique properties like strong ordering and constant time read/write derive from its simple core data structure, the log. We’ll briefly define what’s really a “log”, and how logs are at the core of many data stores.

We’ll see how a fully functional log-based queue can be rather simple to implement, you can build it yourself, and in this talk I’ll show how I’ve been building my own.

We’ll walk through the basic building blocks required to implement a pub/sub queue around a log. Segments, data indexes, offset management, etc. While I demo NetLog (netlog.io), my attempt to create a lightweight and easy-to-use log-based message queue in Go. And BigLog, its building blocks library that you can use to create your own queue.

0:28:15

Cloud in your Cloud

How is the cloud built? We will go into detail how we write microservices that run the cloud at scale. With tens of the thousands of customers, and 10+ datacenters....

How is the cloud built? We will go into detail how we write microservices that run the cloud at scale. With tens of the thousands of customers, and 10+ datacenters. We will talk about how we write, monitor and deploy the microservices that run the cloud you use.

Digital ocean is one of the largest cloud providers on the planet with 10 different datacenters and tens of the thousands of customers. We will talk about how we use microservices to power our cloud. First we will talk about how we using GO to build microservices. The trade offs of different rpcs protocols such as GRPC and http/JSON. Second we will dive into how we manage service discovery with Consul on thousands of nodes. Third we will talk about how we monitor health and performance of the cloud. We will go into how you should build metrics into your microservices. How we use structured logging into kibana. Last we will talk about different deployment strategies we have used, including some on bare metal for hypervisors. Some at virtual machines. Lastly our more modern pieces that run on Docker and Mesos. We will go through how we tried all this different techniques to find the right one for each service.

0:29:10

Design patterns in Microservices architectures and Gilmour

Microservices is a talk of the town. Newer protocols like GRPC and frameworks like Gokit make us the armchair architects who have seen it all. But let’s take a step...

Microservices is a talk of the town. Newer protocols like GRPC and frameworks like Gokit make us the armchair architects who have seen it all. But let’s take a step back into thinking what are the common design patterns in building a microservices architectures. Varying from Request Response, Signal Slots, Service Discovery, Load Balancing, Error handling   Monitoring. Then through code samples and demos we address these using Gilmour, a microservices Library over non-HTTP transports.

0:28:18

Dropping down: Go functions in assembly

Writing functions using Go’s assembler can be tricky. Used judiciously however a little sprinkling of assembly can seriously improve the performance of your program on modern hardware. This tutorial will...

Writing functions using Go’s assembler can be tricky. Used judiciously however a little sprinkling of assembly can seriously improve the performance of your program on modern hardware. This tutorial will show you how to write Go functions in assembly: covering the basics such as syntax, function arguments and stack management. We will also touch on the effects of adding assembly on portability and testing.

0:30:56

Go from Dev to Prod

You finished working on your new Go project and now you’d like to share it with the world. Now what?

This talk aims to highlight what are the...

You finished working on your new Go project and now you’d like to share it with the world. Now what?

This talk aims to highlight what are the choices and points to look after when you plan to run your app in production.

• logging
• monitoring
• deployment
• versions
• and many more

0:31:32

GoBridge and the Go Community: Initiatives and Opportunities

The Go community is fairly homogeneous and missing out on what a more diverse community can accomplish. More diversity can have a greater impact on our community’s ability to be...

The Go community is fairly homogeneous and missing out on what a more diverse community can accomplish. More diversity can have a greater impact on our community’s ability to be more innovative and creative, and to find solutions to problems we don’t even know we have yet. With this in mind, GoBridge was created to focus on initiatives that provide safe and accessible environments for a variety of people to learn from each other. In this talk I will share the different initiatives GoBridge volunteers are working on to increase adoption of Go and diversity in our community, and suggest super simple ways to contribute.

0:26:57

Grand Treatise of Modern Instrumentation and Orchestration

Go plays a major role in modern distributed systems. It is a great choice to implement microservices, as exemplified by the popular Go kit. Even more convincing is the...

Go plays a major role in modern distributed systems. It is a great choice to implement microservices, as exemplified by the popular Go kit. Even more convincing is the dominance of Go in the orchestration layer: Kubernetes, etcd, and Weave’s Flux are just a few well-known examples.

Monitoring large-scale distributed systems including the underlying infrastructure poses an entirely new challenge. Prometheus was designed to meet that challenge. Unsurprisingly, it is written in Go, and it is not by coincidence that all examples given above feature some kind of Prometheus integration.

How can you, as a Go developer, integrate your own software? This talk will show you how to use the Prometheus client library for instrumenting your own code to expose Prometheus metrics and for writing small adapter applications to export metrics from 3rd-party systems. You will learn to identify and implement the metrics that are needed to enable meaningful service monitoring and alerting.

0:21:22

How to Raise a Gopher in Record Time

As an electrical engineer, both in college and at Intel, my exposure to software development was limited. I have been interested in software development, began learning on my own and...

As an electrical engineer, both in college and at Intel, my exposure to software development was limited. I have been interested in software development, began learning on my own and then I got an opportunity to shift inside Intel. The team I joined was writing code in Go and I had a lot to learn quite quickly. For those who are new to Go and learning the language, having the right resources, especially early on, can make all the difference. Without knowing where to find them, a lot of time can be spent searching. I want to share what helped me accelerate my learning, which is not over, by the way, and never will be.

0:27:57

Idiomatic Go Tricks

Using only the Go language, you can do some pretty powerful things. In my five years experience, I have picked up a selection of powerful, elegant, simple, and cool tips...

Using only the Go language, you can do some pretty powerful things. In my five years experience, I have picked up a selection of powerful, elegant, simple, and cool tips and tricks that make coding in Go even more fun. Go deliberately has no magic built into the language, but magic things happen when it is used correctly. This talk will cover some of my favourites.

0:43:57

Implementing Software Machines in Go (and C)

I’ve been interested in the design and implementation of virtual machines since encountering the source code for a simple Forth interpreter written in Basic when I was 15. It was...

I’ve been interested in the design and implementation of virtual machines since encountering the source code for a simple Forth interpreter written in Basic when I was 15. It was a fascinating, inscrutable piece of magic which played a key role in my becoming a professional programmer.

Most of us who’ve played games or worked in any one of a number of popular programming languages will have used virtual machines but unless we’ve taken a course in programming language design we probably have only a loose idea of what these are and how they work.

In this workshop we’ll look at the various parts necessary to model a computer-like machine in code, borrowing ideas as we go from real-world hardware design. We’ll use a mixture of C and Go as our modelling languages: C is the lingua franca of the VM world whilst Go has excellent tooling and concurrency.

We’ll also examine some of the benefits of phrasing software development problems in mechanistic terms. These include ease of composition, automation, security, testing, repeatability and reasoning about performance.

You’ll need a laptop with Go and a recent version of Clang or GCC installed and a basic grasp of Go.

0:26:56

Inception, Go programs that generate Go code

Go is amazing, but sometimes we need to code lots of boiler plate. Fortunately, there are different ways you can reduce boilerplate by having programs generate all the boring code...

Go is amazing, but sometimes we need to code lots of boiler plate. Fortunately, there are different ways you can reduce boilerplate by having programs generate all the boring code you would traditionally write by hand.

In this talk we will look into different ways you can build programs that generate source code for other programs.

0:28:13

Managing and Scaling Real-Time Data Pipelines using Go

Go’s concurrency model lends itself nicely to building real-time data pipelines, but how does this work out at scale? At Riot, we handle millions of player events, metrics and logs...

Go’s concurrency model lends itself nicely to building real-time data pipelines, but how does this work out at scale? At Riot, we handle millions of player events, metrics and logs daily through a series of Go-based microservices – this tutorial will help attendees get comfortable with Go concurrency in practice, and walk through some of the best practices for architecting and operating real-time distributed systems with Go at their heart, including lessons learned along the way.

0:45:38

Real-Time Go

Garbage-collected languages like Go usually don’t have the reputation of being particularly well-suited for real-time applications. As an online advertising company with a focus on the travel industry, we extensively...

Garbage-collected languages like Go usually don’t have the reputation of being particularly well-suited for real-time applications. As an online advertising company with a focus on the travel industry, we extensively use real-time bidding (RTB) to programmatically buy ad impression through automated auctions. In order to effectively take part in these auctions we have developed our own in-house bidder using Go.

Building a bidder to accommodate both the specific requirements of our business and the constraints of a soft real-time application while quickly iterating on new features was a big challenge. Over the course of more than two years, we have learned a number of lessons and techniques on designing, instrumenting and tuning Go applications and their underlying data stores for efficiency under real time conditions. We would like to share these in this talk.

0:28:29

Real-time machine learning in Go for smart energy applications

The smart energy sector is poised to deliver huge savings through efficiency improvements and ancillary services such as Open Energi’s Dynamic Demand.

This talk, aimed at Go programmers...

The smart energy sector is poised to deliver huge savings through efficiency improvements and ancillary services such as Open Energi’s Dynamic Demand.

This talk, aimed at Go programmers who do not have much experience with Machine Learning (ML), will start by introducing common idioms used by well known machine learning frameworks like scikit-learn and Matlab’s ML Toolbox, and how they are mirrored in Go packages like Goml and Go Learn. I’ll also briefly explain how one can use Storm multilang or os/exec to assemble a polyglot ML solution without requiring a data scientist to make (many) changes to their model code.

The second half of the talk will explain how we’ve leveraged Go primitives and cloud-based services to deliver scalable real-time machine learning services written entirely in Go with low cognitive overhead for both data scientists and developers.

0:22:02

Revolutionising Retail with Go

In a competitive market, Sainsbury’s is on a technology transformation process which involves the adoption of Go and a journey to cloud based distributed systems at scale.

The...

In a competitive market, Sainsbury’s is on a technology transformation process which involves the adoption of Go and a journey to cloud based distributed systems at scale.

The talk covers why we are increasingly choosing Go to solve these problems, architectural decisions, common mistakes, technology stack and how this delivers highly available, distributed systems that need to interact with legacy systems.

0:30:04

Seven ways to profile Go applications

Microbenchmarks are all fine and good, but the first step from benchmarking one function and understanding the performance of a complex application in production is a doozie.

This talk...

Microbenchmarks are all fine and good, but the first step from benchmarking one function and understanding the performance of a complex application in production is a doozie.

This talk will cover seven different ways to profile a running Go application. We’ll discuss the strengths and weaknesses of various approaches, and highlight some new options available in Go 1.7.

0:27:08

Simplifying building and managing microservices with Micro

We’re moving towards a world of infinite compute with the public cloud but leveraging it still proves to be difficult. Containers are naturally guiding us towards developing distributed systems but...

We’re moving towards a world of infinite compute with the public cloud but leveraging it still proves to be difficult. Containers are naturally guiding us towards developing distributed systems but the tools to help build them are still formulating. Micro looks to solve these problems by providing the fundamental building blocks for building and managing microservices.

0:27:30

SOLID Go Design

David is a software engineer, author, blogger, and speaker from Sydney, Australia as well as a long time contributor to the Go project, focussing on performance and the application of...

David is a software engineer, author, blogger, and speaker from Sydney, Australia as well as a long time contributor to the Go project, focussing on performance and the application of Go to small computers. David also runs the Sydney Go Users’ group.

0:23:55

Static Deadlock Detection for Go

Go’s concurrency features differ from mainstream programming languages in that they are based on the high-level and formal model of CSP (or process calculi) by Tony Hoare in 1978. Over...

Go’s concurrency features differ from mainstream programming languages in that they are based on the high-level and formal model of CSP (or process calculi) by Tony Hoare in 1978. Over the years, a large body of research work was developed for understanding concurrency based on process calculi, but rarely applied directly in programming langauges. I will talk about a static analyser we developed for detecting deadlocks in Go, inspired by a research area which gives “types” to process calculi. In a nutshell, the tool infers “types” for communication between goroutines from Go source code, then construct a bird’s eye view of all communication (also called choreography or global graph) possible at runtime, through which deadlocks and communication problems are discovered.

This talk will focus on the work-in-progress aspects of the tool. No knowledge of CSP/process calculi are needed but some understanding of concurrency in Go and static analysis concepts are expected.

0:26:42

The dark side of microservices

The term “microservices” has been around for a while now. We’ve seen a lot of information on why you should adopt this type of architecture, but no one tells you...

The term “microservices” has been around for a while now. We’ve seen a lot of information on why you should adopt this type of architecture, but no one tells you why you shouldn’t. This talk won’t do that either, but we’ll go over some of the issues and traps that microservices bring with it.

We’ll look at what kind of tools you need to get a system like this up and running. What kind of decisions do you have to take to roll out a system like this?

How do you communicate between services? REST or RPC? XML or JSON? What framework do we use? micro or go-kit? Where do we store our metrics? How do we create new services? How do we develop these newly created services and communicate with existing services?

These are all decisions a team can get hung up on and spend a lot of time on. This talk aims to help in the decision making and give some insights in our decisions.

Besides the tools and decisions, we’ll also look at the extra complexity this system brings with it. How do you debug multiple services? How do you keep track of all these services?

0:26:14

What every developer should know about logging

Go is one of the most popular languages to write applications structured into (micro)services, which gives developers lot of freedom, fun and possibilities to explore new solutions. Such applications are...

Go is one of the most popular languages to write applications structured into (micro)services, which gives developers lot of freedom, fun and possibilities to explore new solutions. Such applications are harder to debug on production than normal, monolithic applications, due to many services involved during single operation (eg. http request). Proper logging is a good way to overcome this problem.

First, I will answer why we need logs - to understand what application is doing on production and how is used. This information are crucial for debugging and continuous improvements.

Then, I will cover popular golang logs libraries: standard library log package and glog. After such introduction I will cover implementations of more advanced logging implemented in open source microservices library go-kit.

I want to cover also more topics: log sampling in high traffic deployments, log tricks like switching log level in production systems, log infrastructure elements such as log forwarders, log readers and log storage. I also will cover security risks when logs are not properly anonymized.

I am convinced that this presentation will help developers to write logs that makes theirs job more enjoyable and less stressful.

0:23:00

What is a container, really? Let's write one in Go from scratch

Everyone has heard of Docker, but what is a container? Is it really “a lightweight VM”? In this talk we’ll dispel the magic by writing a container in about 100...

Everyone has heard of Docker, but what is a container? Is it really “a lightweight VM”? In this talk we’ll dispel the magic by writing a container in about 100 lines of Go.

0:23:35

When Idioms Become Bottlenecks

Idiomatic Go code is composable and easy to understand, greatly improving the experience of writing new code and contributing to unfamiliar code bases. This allows Go to compete as a...

Idiomatic Go code is composable and easy to understand, greatly improving the experience of writing new code and contributing to unfamiliar code bases. This allows Go to compete as a language suitable for myriad tasks. When using Go as a low-level systems language, occasionally idioms come back to bite you.

Idioms are generally great: they provide portability guarantees as well as a common baseline for programmers. However, these idioms sometimes break down when applied to scalable systems code. For example, we’re told not to use the “unsafe” package, instead, avoid performing “unsafe” memory operations. Similarly, don’t use “atomic, use “sync” instead. In essence, “Don’t be clever.” In some cases, following these idioms to the letter becomes a real bottleneck.

In this talk, we’ll explore how eschewing some of these idioms leads us to predictable latency and in some cases drastically improved throughput. We can use low level, “unsafe” primitives correctly through careful coding. We’ll look at how to do this without sacrificing too much in terms of composability, comparing several concurrent communication patterns in Go to non-idiomatic counterparts in the context of a messaging platform.

36:05

Betting on Go

This talk discusses HashiCorp’s journey with Go from its infancy to the mature, production-ready language it has become today. We will discuss the decision-making process which ultimately landed on Go,...

This talk discusses HashiCorp’s journey with Go from its infancy to the mature, production-ready language it has become today. We will discuss the decision-making process which ultimately landed on Go, the benefits we’ve gotten out of the standard library, the limitations we’ve hit along the way.

43:29

Bringing Go to the Enterprise

In this talk I’ll share my unique experiences as a trainer and author bringing Go to enterprise companies. We’ll talk about what works well, what needs improvement, and what we...

In this talk I’ll share my unique experiences as a trainer and author bringing Go to enterprise companies. We’ll talk about what works well, what needs improvement, and what we can do as a community to foster Go adoption in more companies. In 2016 I quit my job and set out to train the world on how to use Go and Kubernetes. Over the course of the last 18 months I’ve learned a lot of things about Go, and I want to share them with you in this talk.

45:02

Buffalo: Rapid Web Development in Go

Put the fun back in writing Go web applications using the Buffalo framework. A Ruby on Rails inspired, idiomatic, web framework written in Go. Fun, Fast, and easy!

Put the fun back in writing Go web applications using the Buffalo framework. A Ruby on Rails inspired, idiomatic, web framework written in Go. Fun, Fast, and easy!

33:33

Building a RESTful API using go-swagger

Learn how to define a RESTful API by writing a Swagger specification and using go-swagger to generate a go server skeleton and client package. This talk focuses on developer productivity...

Learn how to define a RESTful API by writing a Swagger specification and using go-swagger to generate a go server skeleton and client package. This talk focuses on developer productivity from inception to production, detailing the journey from the first line of code through to the production of a fully tested Docker image ready for deployment.

26:22

Building Go with Bazel

Tired of Makefile hacks? Bazel offers fast, reproducible builds for software of any size. Why is it better than go build? Bazel makes polyglot projects easy, has remote build workers,...

Tired of Makefile hacks? Bazel offers fast, reproducible builds for software of any size. Why is it better than go build? Bazel makes polyglot projects easy, has remote build workers, and shared caching. Get started building Go projects, learn key concepts, and get ready to turbocharge your build.

42:29

Can you write an OS Kernel in Go?

Go is a great language for building server applications but can you use it to write an OS kernel? Let’s talk about the challenges involved in writing, compiling and linking...

Go is a great language for building server applications but can you use it to write an OS kernel? Let’s talk about the challenges involved in writing, compiling and linking Go code that runs in Ring-0 and code a simple “Hello World” demo in Go that runs inside QEMU.

43:54

Command Line Scripting with Templates

Go’s template language is often used to enable scripting in command line tools. In practice, however, it can be difficult to take advantage of these scripting capabilities. This talk will...

Go’s template language is often used to enable scripting in command line tools. In practice, however, it can be difficult to take advantage of these scripting capabilities. This talk will explore why this is, propose some best practices and describe a new package designed to make scripting easier.

31:52

Concurrency Patterns in Go

We all know that go comes with great concurrency tools like go routines and channels. But is this really everything? This session starts with an overview of common concurrency patterns...

We all know that go comes with great concurrency tools like go routines and channels. But is this really everything? This session starts with an overview of common concurrency patterns and ends with best practices on lockless programming that won’t let your head explode.

46:40

Creating interactive frontend apps with GopherJS and React

Fed up of Javascript? Do you pine for Go’s simplicity and fantastic tooling? Learn how to painlessly create interactive UIs in your favourite language… and never write a line of...

Fed up of Javascript? Do you pine for Go’s simplicity and fantastic tooling? Learn how to painlessly create interactive UIs in your favourite language… and never write a line of Javascript again!

49:54

Deep Learning with Go

You’ve heard about self-driving cars, self-organizing drone swarms, conversational interfaces, and emotion recognition. That’s all ‘deep learning’ - a powerful AI taking the world by storm! In my talk, I’ll...

You’ve heard about self-driving cars, self-organizing drone swarms, conversational interfaces, and emotion recognition. That’s all ‘deep learning’ - a powerful AI taking the world by storm! In my talk, I’ll show you how to build ‘deep learning’ models with Go to solve complex real-world challenges.

45:21

Embedding

Embedding. It sure is weird, isn’t it? it’s unlike traditional inheritance, and it can be uncomfortable at first. But it does have a lot of positives to it that might...

Embedding. It sure is weird, isn’t it? it’s unlike traditional inheritance, and it can be uncomfortable at first. But it does have a lot of positives to it that might not be obvious at first. In this talk, we’ll go over highlights and pitfalls of embedding, and some interesting ways to use it.

38:29

Fighting latency: the CPU profiler is not your ally

When we talk about a ‘fast’ service we often don’t mean one that can process 500MB/s per core, but one that can respond in less than 5ms. However, many causes...

When we talk about a ‘fast’ service we often don’t mean one that can process 500MB/s per core, but one that can respond in less than 5ms. However, many causes of latency are invisible to network operations, disk reads, locks, channels, scheduling. Let’s see how to use the new tracer to profile them.

42:49

Go routines optimization

Go routines can become the star or the bottleneck of your application. Learn how to select the best approach for reaching efficient concurrency by analyzing bottlenecks related to go-routines, comparing...

Go routines can become the star or the bottleneck of your application. Learn how to select the best approach for reaching efficient concurrency by analyzing bottlenecks related to go-routines, comparing resource utilization, locks, queuing and sequential processing.

27:29

Going on the Road Less Bumpy

In this presentation Vlad Galu, VP of Engineering at GlobalSign, describes the experience of basing a greenfield project on Go, the build-up and the evolution of the team and GlobalSign’s...

In this presentation Vlad Galu, VP of Engineering at GlobalSign, describes the experience of basing a greenfield project on Go, the build-up and the evolution of the team and GlobalSign’s next generation PKI platforms along with the wider ecosystem.

35:50

Golang's Realtime GC in Theory and Practice

Go’s GC is optimized for low latency applications. In this talk we’ll see how it works (the tricolor algorithm), why it works (achieving such short GC pauses), and most importantly,...

Go’s GC is optimized for low latency applications. In this talk we’ll see how it works (the tricolor algorithm), why it works (achieving such short GC pauses), and most importantly, whether it works (bench-marking these GC pauses, and comparing them with other languages).

33:06

How to build an SDK in Go

Dropbox offers a well documented API with SDKs in 7 different languages including Python and Java, but not Go (which is used heavily within Dropbox). In this talk, I’ll share...

Dropbox offers a well documented API with SDKs in 7 different languages including Python and Java, but not Go (which is used heavily within Dropbox). In this talk, I’ll share my experiences developing a Go SDK for Dropbox: lessons and best practices for building SDKs in Go.

32:21

How to correctly use package context

Go 1.7 introduced package context to the standard library. Using context is a very powerful way to orchestrate go routine cancellation and debugging information during a request. This talk lays...

Go 1.7 introduced package context to the standard library. Using context is a very powerful way to orchestrate go routine cancellation and debugging information during a request. This talk lays the foundation of best practice around how to use this package.

16:55

How we built and launched Gopherize.me

37:40

It doesn't have to be REST: Websockets in Go

The speed of Go should make us reconsider well estabilshed paradigms. When developing APIs it is practically impossible not to mention REST yet many applications would benefit from real-time interactivity....

The speed of Go should make us reconsider well estabilshed paradigms. When developing APIs it is practically impossible not to mention REST yet many applications would benefit from real-time interactivity. There are different WebSocket and WebSocket emulation implementations in the Go ecosystem. This talk will give you headspace to consider WebSockets as an alternative communication protocol for your application by giving an overview of the current state of the art of WebSockets in Go.

40:38

Making My First Go Contribution

Want to contribute to Go but don’t know how? Neither did I when I hacked a solution for the Go Presenter Tool. Learn about my motivations, how I approached the...

Want to contribute to Go but don’t know how? Neither did I when I hacked a solution for the Go Presenter Tool. Learn about my motivations, how I approached the problem with a beginner’s mind, figured out Gerrit, how it’s like having my code reviewed by the Go team, and how I finally got it merged.

34:48

Production-ready Go

When you’re new to Go, it’s easy to build and deploy production systems quickly - and learn the hard way what ‘production ready’ means. This is a rundown of the...

When you’re new to Go, it’s easy to build and deploy production systems quickly - and learn the hard way what ‘production ready’ means. This is a rundown of the things you really need to care about.

17:55

Ruby to Go - What to expect when you switch

An overview of the differences between the two languages from a seasoned Rubyist and a complete Go newbie perspective. What to expect from your everyday coding when you switch to...

An overview of the differences between the two languages from a seasoned Rubyist and a complete Go newbie perspective. What to expect from your everyday coding when you switch to Go.

35:04

State of the Gopher Nation

39:58

Static Analysis in Go

Tools like go package provide static analysis. This session shows step by step how to use it. This session makes you that you can start to use static...

Tools like go package provide static analysis. This session shows step by step how to use it. This session makes you that you can start to use static analysis for creating tools which are useful for your daily development, such as a linter and a refactoring tool which can be customized for your project.

38:34

The Beginner's Guide to Linux Syscalls

Don’t think you’ve ever made a syscall? Trust me, you have! In this talk we’ll explore what syscalls are, how they work and what you can do with them, with...

Don’t think you’ve ever made a syscall? Trust me, you have! In this talk we’ll explore what syscalls are, how they work and what you can do with them, with a good measure of live-coding demos to keep things real.

43:45

Translating Go to Other (Human) Languages

Like most programming languages, Go uses English keywords. But Go’s unique approach to byte and string handling makes it the ideal candidate for a universal programming language that can be...

Like most programming languages, Go uses English keywords. But Go’s unique approach to byte and string handling makes it the ideal candidate for a universal programming language that can be localized to allow English-speaking and non-English speaking developers to collaborate on the same projects.

48:01

Understanding concurrency with behavioural types

Concurrent programming is difficult. This talk is about applying programming languages & concurrency research, specifically behavioural types as an abstraction, to verify concurrent Go programs. The talk covers what behavioural...

Concurrent programming is difficult. This talk is about applying programming languages & concurrency research, specifically behavioural types as an abstraction, to verify concurrent Go programs. The talk covers what behavioural types are and how they can be used to reason in Go’s concurrency model.

38:47

Writing Beautiful Packages in Go

Whether for internal use, or destined for open-source stardom, writing good packages with clean and clear APIs will greatly increase the chance that the code is used and reused. Explore...

Whether for internal use, or destined for open-source stardom, writing good packages with clean and clear APIs will greatly increase the chance that the code is used and reused. Explore best practices, goals, and idioms that help make beautiful packages.

22:55

Athens: The Center of Knowledge

In the classical period of Greece, Athens was the center of knowledge, learning, and arts. The ideas that were born during that time are often considered as the birth of...

In the classical period of Greece, Athens was the center of knowledge, learning, and arts. The ideas that were born during that time are often considered as the birth of democracy and Western civilization. In this talk you’ll learn about the Athens project, bringing global package management to Go. You’ll learn about Zeus, the globally distributed system of proxy servers, and Olympus, the federated source of truth for package versions.

26:47

Black Box Monitoring in Go

You’ve set up your favorite monitoring agent on all of your services and you have incredible visibility into the internals of your infrastructure. All seems good in the world, but...

You’ve set up your favorite monitoring agent on all of your services and you have incredible visibility into the internals of your infrastructure. All seems good in the world, but can your end user actually use your service? In this talk we’ll write a simple app that simulates end user activity.

42:18

Blockchain Apps in Go

Ever wonder how blockchains work? Why is it that many popular blockchains are using Go? In this talk we will explore how blockchains work at a protocol level, what Go...

Ever wonder how blockchains work? Why is it that many popular blockchains are using Go? In this talk we will explore how blockchains work at a protocol level, what Go libraries you can use to interact with them. By the end of the talk you will be able to build your first Blockchain App.

46:38

Broadcasting Channels

Channels - they sure are fun. You can do a lot with channels, but by default, only in a one-to-one manner. In this talk, I’ll show you how to enable...

Channels - they sure are fun. You can do a lot with channels, but by default, only in a one-to-one manner. In this talk, I’ll show you how to enable one to many broadcast semantics in a thread-safe way, that can even gracefully handle shutdowns, failures, and panics

21:43

Building Resilient Data Pipelines in Go

The modern world runs on Data. In this talk we will cover how Gophers of any level can easily build Data Pipelines in Go with Kafka and Cassandra. At the...

The modern world runs on Data. In this talk we will cover how Gophers of any level can easily build Data Pipelines in Go with Kafka and Cassandra. At the end, we will look at how GE has written a Data Pipeline in Go that can handle over 800,000 writes per second of industrial time series data.

25:45

Code, Content, & Crafting Your Voice

Hi, my name is Amy! By day, I’m a systems software engineer and work in the fabulous world of distributed systems. However, outside of writing code, I also care a...

Hi, my name is Amy! By day, I’m a systems software engineer and work in the fabulous world of distributed systems. However, outside of writing code, I also care a lot about making YouTube videos on my channel Amy Codes! The channel enables me to carve out a space online and craft my voice into a personal brand. What inspired to make YouTube videos? What is entailed in crafting a distinctive personal brand? Why should software engineers care? How has building a personal brand been effective in empowering other people? I hope to provide you actionable advice to apply into your own career.

29:38

Component & Integration Tests for Micro-services

Having a microservices architecture, the challenge comes with setting up a testing framework. Sometimes the structure of the project allows only unit tests and end-to-end and acceptance tests. This talk...

Having a microservices architecture, the challenge comes with setting up a testing framework. Sometimes the structure of the project allows only unit tests and end-to-end and acceptance tests. This talk will explore different options that would allow accommodating different types of tests; unit, component, integration and end-to-end tests.

37:49

Debuggers From Scratch

At some stage in your programming life you may well have used a debugger, but did you wonder how it was able to step into and control your executable? In...

At some stage in your programming life you may well have used a debugger, but did you wonder how it was able to step into and control your executable? In this talk we’ll see how debuggers work by building one from scratch in a few lines of Go.

33:19

Deep Learning, Ready? Go!

Imagine that you need to develop an Optical Character Recognition system using neural networks. Why is not Go your first choice for this kind of project? In this talk I’m...

Imagine that you need to develop an Optical Character Recognition system using neural networks. Why is not Go your first choice for this kind of project? In this talk I’m going to show you a traditional solution using tensorflow and python, and also, how we can achieve a similar result using Go.

36:24

Documenting Go Code with Beautiful Tests

Whether you believe in TDD or not, you must agree that it’s unwise to build production code with no tests. They verify your application, but also act as a perfect...

Whether you believe in TDD or not, you must agree that it’s unwise to build production code with no tests. They verify your application, but also act as a perfect documentation for the development team. I would like to show a couple of tips and tricks of how you can write pretty and effective tests.

45:20

Experimental Refactoring with Go

Refactoring is essential to the software lifecycle. Can we make it safe enough to be a part of every company’s CD workflow? In this talk attendees will learn how to:...

Refactoring is essential to the software lifecycle. Can we make it safe enough to be a part of every company’s CD workflow? In this talk attendees will learn how to: utilise multi-step deploys; tame feature flags; run multiple code paths concurrently in production without influencing users.

37:47

From source code to Kubernetes, a Continuous Deployment tale

This talk will cover the basics of creating good Docker images for your Go projects using multi-stage builds. Once we have that image ready we will need to run it...

This talk will cover the basics of creating good Docker images for your Go projects using multi-stage builds. Once we have that image ready we will need to run it somewhere, I think that a Kubernetes cluster could be a nice place to start. Of course, we don’t want to repeat those steps by hand everytime we want to do a new deployment so we will probably need to learn how to use a CI/CD tool to automate all the steps. And finally, the icing on the cake would be make this automagically run everytime we push code to our repository.

48:25

Go Test: Under the Hood

This talk will cover a brief introduction to go test, before diving into the more interesting parts of using the tool and the library itself. Covering topics like enabling testing...

This talk will cover a brief introduction to go test, before diving into the more interesting parts of using the tool and the library itself. Covering topics like enabling testing of un-exported objects in separate testing packages, interesting or unconventional flags, and the newly added caching mechanisms, the talk will aim to raise folks understanding and capabilities with go test beyond just the basics, to help gophers become better testers by simply introducing them to more of the test tool and library itself.

39:21

Going GraphQL

REST is the current leader in client-server interactions. Our services have better tooling like grpc and better formats like protocol buffers and avro. Being well typed, GraphQL can bring these...

REST is the current leader in client-server interactions. Our services have better tooling like grpc and better formats like protocol buffers and avro. Being well typed, GraphQL can bring these together to become the next step in client/server interaction.

43:56

GoPro: More Concurrent than Parallel!

Complex systems call for better controllability over various design parameters (data and control widths, on-/off- chip memory, topology etc.). Unlike software based simulations, rapid FPGA-accelerated prototyping (using GoPro) will allow...

Complex systems call for better controllability over various design parameters (data and control widths, on-/off- chip memory, topology etc.). Unlike software based simulations, rapid FPGA-accelerated prototyping (using GoPro) will allow faster simulation and exploration of large scale systems.

37:42

Goroutines: The Dark Side of the Runtime

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...

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?

33:13

Go's role in publishing data at the Office for National Statistics

ONS needed to take obtuse datasets and publish them in a searchable way - so citizens can start to make sense of statistics the affect them. Using Go we’ve rebuilt...

ONS needed to take obtuse datasets and publish them in a searchable way - so citizens can start to make sense of statistics the affect them. Using Go we’ve rebuilt how data gets prepared, a pipeline for custom queries and extended our go-ns library - learning more about the practical sides of Go.

27:53

Growing a Community of Gophers

What it the true impact of community? In this talk we will go over what is important for community health, and what makes a healthy open source project. We will...

What it the true impact of community? In this talk we will go over what is important for community health, and what makes a healthy open source project. We will discuss how community has affected Gophers all over the world, and how individuals become leaders in their regions. Last, we will dig into how to get involved in the community in meaningful, tangible ways.

44:42

How do you structure your Go apps?

“How should I structure my Go app?” is one of the most common questions asked by new and experienced developers alike. It certainly was one of my first questions, and...

“How should I structure my Go app?” is one of the most common questions asked by new and experienced developers alike. It certainly was one of my first questions, and is something I keep coming back to. Let’s discuss a few patterns and trends used in the industry these days.

44:42

Orchestration of Microservices

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...

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.

44:38

Production Ready Go Service in 30 Minutes

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...

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.

52:11

Scorch! a New Index for Bleve

Bleve, an open-source full-text search library for Go, has moved beyond the general-purpose key/value store and now implements its own custom binary index format named Scorch. Learn about the data-structures...

Bleve, an open-source full-text search library for Go, has moved beyond the general-purpose key/value store and now implements its own custom binary index format named Scorch. Learn about the data-structures and Go libraries we’ve chosen to build this solution.

40:33

Secrets about using Machine Learning and Go

After a year doing Machine Learning at Machine Box and with Go being my favorite language, I’d like to share my experiences. Covering best practices for training models and serving...

After a year doing Machine Learning at Machine Box and with Go being my favorite language, I’d like to share my experiences. Covering best practices for training models and serving them in production, as well as little tips and tools that we use with Go to make your life a little bit easier.

34:44

The Best Feature of Go

The Go community is definitely the best feature of the language, but how may we engage with it and become more than just a bystander on the crowd? How do...

The Go community is definitely the best feature of the language, but how may we engage with it and become more than just a bystander on the crowd? How do we contribute to the Go language OSS? Too much for you? What about a community built library? Contributing with code is too scary? What about building samples and documenting? Maybe you are a local leader and you can start a meetup, or join an active one… Do you like to write? Record videos? Literally the options are endless, so I want to explore some of those while sharing my personal experiences with the hopes of inspiring other people to engage with the community as well.

43:47

Three Billy GOats Gruff: A Dev's Tale from VMs to Serverless

47:15

Understanding Go's Memory Allocator

Ever wondered how does Go manage memory allocation? In this talk we are going to explore Go’s memory allocator and understand how its algorithm interacts with the operating system to...

Ever wondered how does Go manage memory allocation? In this talk we are going to explore Go’s memory allocator and understand how its algorithm interacts with the operating system to manage memory!

37:39

Using Go for Healthcare

DeepMind is a British artificial intelligence research company, dedicated to using that research to help address the toughest social challenges. In this talk, we’ll cover our working in healthcare, and...

DeepMind is a British artificial intelligence research company, dedicated to using that research to help address the toughest social challenges. In this talk, we’ll cover our working in healthcare, and how we use Go to power Streams, our mobile application used by NHS clinicians.

38:45

When to Choose a Monolith: Reducing Fragmentation in System Architectures

Telling the true story of moving from a very fragmented architecture to a monolith built entirely in Go. This tale conveys many foundational building blocks of Go in a way...

Telling the true story of moving from a very fragmented architecture to a monolith built entirely in Go. This tale conveys many foundational building blocks of Go in a way that is accessible and informative. Based on real experience it will help any team looking at their architectural choices.

41:17

You Might Be a Go Contributor Already and Not Know It

Contributing to Go is more than just writing code for the compiler and standard library. Between other official Go projects, third-party projects, articles, workshops, and conference talks, you can even...

Contributing to Go is more than just writing code for the compiler and standard library. Between other official Go projects, third-party projects, articles, workshops, and conference talks, you can even be a contributor to Go without ever even signing up for a Gerrit account.

34:55

A Go Security Journey

As we approach the tenth anniversary of Go 1.0, Bryan Boreham looks at how Go is being used to build larger and larger systems. What works well at scale, how...

As we approach the tenth anniversary of Go 1.0, Bryan Boreham looks at how Go is being used to build larger and larger systems. What works well at scale, how do we learn those approaches, and how do we lay the foundations for the next ten years?

28:01

Advanced Testing Techniques

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...

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.

20:53

Building APIs in Go The Stack Without a Framework

While there are many frameworks to build APIs in Go, each of them has extra overload in terms of the features available and the packages that are going to be...

While there are many frameworks to build APIs in Go, each of them has extra overload in terms of the features available and the packages that are going to be installed. In this talk the speaker talks about her experience in using different frameworks and walks you through a stack that could implement a DIY API solution for Go apps.

23:27

Building a net Conn Type From the Ground Up

Package net is a one-stop shop for Go networking with TCP or UDP, but there are many other interesting and unusual socket types in the wild. This talk will demonstrate...

Package net is a one-stop shop for Go networking with TCP or UDP, but there are many other interesting and unusual socket types in the wild. This talk will demonstrate how to build a net.Conn type using the Linux system call interface, and show how that type can be used to serve SSH, HTTP, and more!

31:28

Dr Jekyll and Mr Hyde, Embracing the Dual Nature of State

You are halfway through processing some business logic in one of your micro services then boom! something fails. This may be due to network issues, or a 3rd party API...

You are halfway through processing some business logic in one of your micro services then boom! something fails. This may be due to network issues, or a 3rd party API being down or a deploy of your service. How do you consistently recover from that failure?

31:44

Energy Implications of Your Go code

Data movement accounts for almost 65% of energy usage in edge devices. It is important for every programmer to be aware of the energy aspect of their code, particularly when...

Data movement accounts for almost 65% of energy usage in edge devices. It is important for every programmer to be aware of the energy aspect of their code, particularly when it comes to devices with limited energy budget.

28:48

Experimenting with Golang and Webassembly

Ever wanted to know what WASM means? Do you wonder why we need WASM when we have Javascript? Do you dream of your Golang code running in the browser? This...

Ever wanted to know what WASM means? Do you wonder why we need WASM when we have Javascript? Do you dream of your Golang code running in the browser? This talk is an introduction to WebAssembly and Golang WebAssembly support. We will embark on a quest to run our favorite Golang programs in the browser to make the web a better place.

25:32

Finding Dependable Go Packages

At some point, we all find ourselves wanting to use a third-party Go package in our Go code. This talk discusses strategies for discovering, evaluating and maintaining Go packages and...

At some point, we all find ourselves wanting to use a third-party Go package in our Go code. This talk discusses strategies for discovering, evaluating and maintaining Go packages and modules. It also introduces a site that the Go team is building to streamline the process for finding dependable Go packages.

32:33

Fun With Pointers

In this talk you will learn how to use pointers effectively in Go. We’ll cover from the basics of pointer declaration and usage, to the implications of allocating memory on...

In this talk you will learn how to use pointers effectively in Go. We’ll cover from the basics of pointer declaration and usage, to the implications of allocating memory on the stack versus the heap. We’ll also see some practical use cases and interesting behaviours when using pointers, including when to use pointer receivers vs value receivers, unsafe package tricks and when a nil pointer is not exactly nil (hint: interfaces!).

37:25

Gio Cross Platform GUI Programming for Mobile, Desktop, WebAssembly

Gio is a new open source Go library for writing immediate mode GUI programs that run on all the major platforms: Android, iOS/tvOS, macOS, Linux, Windows and WebAssembly. The talk...

Gio is a new open source Go library for writing immediate mode GUI programs that run on all the major platforms: Android, iOS/tvOS, macOS, Linux, Windows and WebAssembly. The talk will cover Gio’s unusual design and how it achieves simplicity, portability and performance.

23:11

Go as a Scripting Language in Linux

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...

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?

29:19

Going Infinite: Handling 1 Million Websocket Connections in Go

Go HTTP server provides great scalability, allocating a goroutine per connection, and reusing the efficient multiplexing and scheduling of the Go runtime. While this technique is almost ideal for most...

Go HTTP server provides great scalability, allocating a goroutine per connection, and reusing the efficient multiplexing and scheduling of the Go runtime. While this technique is almost ideal for most scenarios, it comes with limited scale for websockets apps due to high memory consumption. In this talk, we will show how we’ve implemented our own event loop mechanism to overcome those limitations and efficiently manage millions of concurrent connections while minimizing resource utilization.

31:17

Going Serverless For Fun and Profit

This talk looks at what are the options available for a Go developer to work in such environments and showcase going from scratch to a full project in less than...

This talk looks at what are the options available for a Go developer to work in such environments and showcase going from scratch to a full project in less than 30 minutes. I will quickly explain the serverless concepts, the pros and cons for using it, and show examples of when serverless can be used to make a difference. After that, I will show various platforms for running serverless workloads, such as AWS Lambda or GCP Cloud Functions. With that knowledge, I will then show users how to build such serverless apps so that they can be ready to migrate from a platform to another with little code overhead. One last use-case I’ll present is a possible way to architect their apps for the future, where one could move pieces of logic from standard web servers to serverless infrastructure and vice-versa. If Internet is available (and working), and the Demo Gods are not acting up, this talk will feature live demos, otherwise material will be prepared for off-line scenarios.

25:52

Implementing a Search Index

Current production search solutions are not taking advantage of the latest research on NLP (Natural language processing) and Machine Learning. We are going to explore how you can apply ML...

Current production search solutions are not taking advantage of the latest research on NLP (Natural language processing) and Machine Learning. We are going to explore how you can apply ML and NLP to build a search index using Go, and see how they can be applied to problems like finding the best answer to a question, or discovering similar documents.

44:04

Impossible Go!

You know how to code in Go, don’t you? Let’s see! This talk shows Go snippets that seem easy, difficult, wrong or impossible. Through these different obfuscated Go constructs and...

You know how to code in Go, don’t you? Let’s see! This talk shows Go snippets that seem easy, difficult, wrong or impossible. Through these different obfuscated Go constructs and code, we not only have fun but also learn about various nuances of Go to improve our Go coding skills and practices!

32:11

Improving Dependencies for Everyone

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...

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.

27:11

Lock-free Observations for Prometheus Histograms

Implementing metrics in a client library for Prometheus comes with an interesting challenge: Those metrics are typically updated a lot (like a counter that gets incremented each time a service...

Implementing metrics in a client library for Prometheus comes with an interesting challenge: Those metrics are typically updated a lot (like a counter that gets incremented each time a service processes a request) while reading their current value is relatively rare (each time the Prometheus server scrapes the instance, which happens a few times per minute). All those mutations and reads have to be concurrency-safe, but the otherwise quite handy RWMutex is only good for the opposite case: Many reads, few writes. Perhaps lock-free programming can help? A simple counter only needs updates of a single variable, and that’s perfectly handled by the atomic package . But alas! There are beasts like histograms, where you have to update the buckets, a total count of observations, and the sum of observations – all at the same time! It makes the Prometheus server very unhappy if the scrape delivers some of those values prior to and some after an observation. Let’s dive a bit deeper into atomic operations, the Go memory model, layout of structs in memory, and more, to finally come up with a sane (or rather insane) way to atomically change multiple values in an efficient way. Warning: This talks includes looking at code that probably runs in binaries near you!

31:28

Lost in Transaction?

Consistency gets incredibly hard in today’s architectures as ACID transactions are not available in distributed systems. Most techies are not really aware of the complexity they face. I want to...

Consistency gets incredibly hard in today’s architectures as ACID transactions are not available in distributed systems. Most techies are not really aware of the complexity they face. I want to make this transparent but also discuss solution strategies/patterns to survive.

30:51

Monolith Decomposition

At Deliveroo, we had a scaling problem, which had some serious business implications. Luckily, Go came to the rescue! We picked Go up quickly and created a super-scalable service. I...

At Deliveroo, we had a scaling problem, which had some serious business implications. Luckily, Go came to the rescue! We picked Go up quickly and created a super-scalable service. I want to explain why & how we created this service, what we learnt & why everything we build next will be using Go.

26:34

Productionise any Application in Kubernetes Using Sidecar Containers

The sidecar pattern in Kubernetes allows you to add other functionality alongside an application for things like monitoring, TLS termination, circuit breaking etc. This talk will demonstrate how to easily...

The sidecar pattern in Kubernetes allows you to add other functionality alongside an application for things like monitoring, TLS termination, circuit breaking etc. This talk will demonstrate how to easily improve the security and reliability of a service that you don’t have access to the code base.

42:00

Robotics with Go is a Breeze

Ever wanted to control a drone with Go? Of course, who wouldn’t want to do that?! With gobot that’s as easy as goblin pie. Here, let me show you how...

Ever wanted to control a drone with Go? Of course, who wouldn’t want to do that?! With gobot that’s as easy as goblin pie. Here, let me show you how you can build your own face tracking drone.

25.35

Tackling Contention: The Monsters Inside the 'sync.Locker

25:37

Using and Writing Go Analyses

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...

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.

30:20

Write Less (Code), Generate More

Want to write less code and let the machine do the work? In this talk, Paul will give an introduction to code generation in Go, show you how to write...

Want to write less code and let the machine do the work? In this talk, Paul will give an introduction to code generation in Go, show you how to write a simple code generator, and share some tips on how to integrate code generation into your development workflow.

31:13

Writing REST Services for the gRPC curious

Ever wished you could use gRPC for your new service instead of tired old JSON/REST? I will introduce and demo the gRPC-Gateway, which makes it possible to expose a JSON/REST...

Ever wished you could use gRPC for your new service instead of tired old JSON/REST? I will introduce and demo the gRPC-Gateway, which makes it possible to expose a JSON/REST interface while maintaining many of the benefits of using gRPC. It can even be used with browser clients!

26:54

Go Large!

As software engineers, if we ask users to trust us with their data, it’s our responsibility to make sure that their privacy is maintained. We know our apps will be...

As software engineers, if we ask users to trust us with their data, it’s our responsibility to make sure that their privacy is maintained. We know our apps will be attacked continuously from multiple directions. What should we do to protect this data?

26:54

Engineering Innovation

Constraints are by definition limiting. So why is it that time and time again we see that constraints unlock innovation? In this talk André digs into how constraints and innovation...

Constraints are by definition limiting. So why is it that time and time again we see that constraints unlock innovation? In this talk André digs into how constraints and innovation go hand in hand, with concrete examples that take a philosophical concept and show how it applies to software engineering and the Go language itself.

28:30

Generics Unconstrained

This talk explores some ways that Go’s previous generic functionality (interfaces, closures) can make life easier in the brave new world of type parameters. By the end of the talk,...

This talk explores some ways that Go’s previous generic functionality (interfaces, closures) can make life easier in the brave new world of type parameters. By the end of the talk, you should come away with a better understanding of how type parameters can work together with other Go language features and some rules of thumb about when to use constraints.

29:53

Zero to Hero: How we make great Golang engineers at Luno

At Luno they hire engineers that collaborate well, are keen problem solvers, and take their work seriously without taking themselves too seriously. This means they hire engineers with no Golang...

At Luno they hire engineers that collaborate well, are keen problem solvers, and take their work seriously without taking themselves too seriously. This means they hire engineers with no Golang experience and through a well crafted onboarding process they teach them how to contribute idiomatic Go code and well thought out system designs. This talk is how they do that and some of what they teach.

38:41

eBPF Superpowers for Go programmers

eBPF has been called “Superpowers for Linux”, and in this talk Liz discusses why it’s a foundational technology for a new generation of networking, security and observability tools, answering questions...

eBPF has been called “Superpowers for Linux”, and in this talk Liz discusses why it’s a foundational technology for a new generation of networking, security and observability tools, answering questions such as:

• What is eBPF?
• How is it unleashing a new wave of innovation in the Linux kernel?
• Can I write eBPF applications in Go?
• How can I use eBPF tools to help me write better Go applications? Even if you’re not a Linux kernel aficionado you’ll leave this talk understanding how eBPF enables high-performance infrastructure tooling.