Schedule

Wednesday 17th August 2016

  • 09.00
    • Workshop - Level I Introductory Ultimate Go Workshop Cory LaNou

      If you are new to Go or have only been coding for less than a year, then this class is for you. Take a 7 hour tour of Go learning the specification, implementation and idioms to help make you a better Go developer. The class is going to be dense and fast paced. If you love the Go In Action book, this class makes it come to life.

      This session covers language syntax, arrays, slices and maps, methods, interfaces and embedding, concurrency, channels, and http.

      More details or Buy tickets

  • 09.00
    • Workshop - Level II Advanced Advanced Go Workshop William Kennedy

      If you are a seasoned Go developer and have even worked on a project or two, then this class is for you. In the first part of the class you will take a deep dive into mechanical sympathy and data oriented design within Go. In the second part of the class, we will show all of the Go profiling tooling and help you better understand and debug your programs.

      This session covers mechanical sympathy and data oriented design, profiling , benchmarking and performance, memory tracing and comparing, GODEBUG, go-fuzz, and Go execution tracer.

      More details or Buy tickets

  • 18.00
    • Pre-Conference Social

      The pre-conference social is a traditional style pubcon, open to anyone, where conference attendees and locals can meet up before the conference to network and socialise.
      More details »

Thursday 18th August 2016

  • 09.00
    • The Brewery Foyer Registration and Refreshments

      Please bring a copy of your ticket either printed or on a mobile device.

  • 10.00
    • Opening address Welcome to The Golang UK Conference

      The conference team welcome all our delegates, speakers, and sponsors to the conference and provide an overview of the day's events to come.

  • 10.10
  • 10.40
    • Room change

  • 10.50
    • Sainsbury's Track Idiomatic Go Tricks Level: Advanced/Niche/Technical Mat Ryer

      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.

      Video »
    • Side Track Applied Go kit Level: Intermediate Peter Bourgon

      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.

      Video »
  • 11.20
    • Refreshment break

      Light refreshments will be served in the exhibition hall where you will also be able to network with fellow delegates and our sponsors.

  • 11.40
    • Sainsbury's Track When Idioms Become Bottlenecks Level: Intermediate Travis Bischel

      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.

      Video »
    • Side Track Cloud in your Cloud Level: Intermediate Matthew Campbell

      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.

      Video »
  • 12.10
    • Room change

  • 12.20
    • Sainsbury's Track Advanced testing concepts for Go 1.7 Level: Advanced/Niche/Technical Marcel van Lohuizen

      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.

      Video »
    • Side Track Developing Apps for Developing Countries with go-mobile Level: Beginner/Introductory Natalie Pistunovich

      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.

      Video »
  • 12.50
    • Lunch

      A buffet lunch will be served in the exhibition hall where you will also be able to network with fellow delegates and our sponsors.

  • 13.50
    • Sainsbury's Track A Beginners Guide to Context Level: Beginner/Introductory Paul Crawford

      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.

      Video »
    • Side Track Go from Dev to Prod Level: Beginner/Introductory Florin Pățan

      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

      Video »
  • 14.20
    • Room change

  • 14.30
    • Sainsbury's Track Design patterns in Microservices architectures and Gilmour Level: Intermediate Piyush Verma

      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.

      Video »
    • Side Track Dropping down: Go functions in assembly Level: Advanced/Niche/Technical Michael Munday

      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.

      Video »
  • 15.00
    • Room change

  • 15.10
    • Sainsbury's Track What every developer should know about logging Level: Intermediate Slawosz Slawinski

      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.

      Video »
    • Side Track Static Deadlock Detection for Go Level: Advanced/Niche/Technical Nicholas Ng

      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.

      Video »
  • 15.40
    • Refreshment break

      Light refreshments will be served in the exhibition hall where you will also be able to network with fellow delegates and our sponsors.

  • 16.00
    • Sainsbury's Track Building an enterprise service in Go Level: Intermediate Marcus Olsson

      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.

      Video »
    • Side Track Advanced Patterns with io.ReadWriter Level: Advanced/Niche/Technical Paul Bellamy

      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.

      Video »
  • 16.30
    • Room change

  • 16.40
    • Sainsbury's Track Grand Treatise of Modern Instrumentation and Orchestration Level: Intermediate Björn Rabenstein

      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.

      Video »
    • Side Track Implementing Software Machines in Go (and C) Level: Intermediate Eleanor McHugh

      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.

      Video »
  • 17.00
    • Main Conference Social

      The conference social is open to all conference attendees and gives you a chance to relax and meet other delegates after a big day of learning.More details »

Friday 19th August 2016

  • 09.00
    • The Brewery Foyer Registration and Refreshments

      Please bring a copy of your ticket either printed or on a mobile device.

  • 10.00
    • Opening address Welcome and Prize Raffle

      The conference team welcome all our delegates, speakers, and sponsors to the conference and provide an overview of the day's events to come. Prizes from our sponsors will be raffled off.

  • 10.10
    • Keynote GoBridge and the Go Community: Initiatives and Opportunities Carlisia Campos

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

      Video »
  • 10.40
    • Room change

  • 10.50
    • Sainsbury's Track Managing and Scaling Real-Time Data Pipelines using Go Level: Intermediate Jennie Lees

      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.

      Video »
    • Side Track How to Raise a Gopher in Record Time Level: Beginner/Introductory Tiffany Jernigan

      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.

      Video »
  • 11.20
    • Refreshment break

      Light refreshments will be served in the exhibition hall where you will also be able to network with fellow delegates and our sponsors.

  • 11.40
    • Sainsbury's Track Building Cloud Native applications with Go Level: Intermediate Mandy Waite

      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.

      Video »
    • Side Track Building Mobile SDKs for iOS and Android Ain’t nobody got time for that! Level: Intermediate Nic Jackson

      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.

      Video »
  • 12.10
    • Room change

  • 12.20
    • Sainsbury's Track Seven ways to profile Go applications Level: Intermediate Dave Cheney

      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.

      Video »
    • Side Track Let’s build a CI/CD pipeline Level: Beginner/Introductory Jean de Klerk

      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.

      Video »
  • 12.50
    • Lunch

      A buffet lunch will be served in the exhibition hall where you will also be able to network with fellow delegates and our sponsors.

  • 13.50
    • Sainsbury's Track The dark side of microservices Level: Beginner/Introductory Jelmer Snoeck

      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?

      Video »
    • Side Track A Go IDE - Because Semantics Matter Level: Beginner/Introductory Alexander Zolotov

      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.

      Video »
  • 14.20
    • Room change

  • 14.30
    • Sainsbury's Track Building your own log-based message queue in Go Level: Intermediate Víctor Ruiz

      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.

      Video »
    • Side Track What is a container, really? Let's write one in Go from scratch Level: Advanced/Niche/Technical Liz Rice

      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.

      Video »
  • 15.00
    • Room change

  • 15.10
    • Sainsbury's Track Simplifying building and managing microservices with Micro Level: Intermediate Asim Aslam

      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.

      Video »
    • Side Track Real-Time Go Level: Advanced/Niche/Technical Andreas Krennmair

      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.

      Video »
  • 15.40
    • Refreshment break

      Light refreshments will be served in the exhibition hall where you will also be able to network with fellow delegates and our sponsors.

  • 16.00
    • Sainsbury's Track Inception, Go programs that generate Go code Level: Intermediate Ernesto Jimenez

      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.

      Video »
    • Side Track An Actor Model in Go Level: Intermediate Bryan Boreham

      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

      Video »
  • 16.30
    • Room change

  • 16.40
    • Sainsbury's Track Real-time machine learning in Go for smart energy applications Level: Intermediate Michael Bironneau

      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.

      Video »
    • Side Track Revolutionising Retail with Go Charlie Smith

      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.

      Video »