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
-
Workshop - Level I Introductory
Ultimate Go Workshop
Cory LaNou
-
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
-
Workshop - Level II Advanced
Advanced Go Workshop
William Kennedy
-
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 »
-
Pre-Conference Social
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.
-
The Brewery Foyer
Registration and Refreshments
-
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.
-
Opening address
Welcome to The Golang UK Conference
-
10.10
- Keynote SOLID Go design Dave Cheney Video »
-
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 »
-
Sainsbury's Track
Idiomatic Go Tricks
Level: Advanced/Niche/Technical
Mat Ryer
-
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.
-
Refreshment break
-
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.
Video »
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. -
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.
Video »
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.
-
Sainsbury's Track
When Idioms Become Bottlenecks
Level: Intermediate
Travis Bischel
-
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.
Video »
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.
-
Sainsbury's Track
Advanced testing concepts for Go 1.7
Level: Advanced/Niche/Technical
Marcel van Lohuizen
-
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.
-
Lunch
-
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.
Video »
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. -
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
-
Sainsbury's Track
A Beginners Guide to Context
Level: Beginner/Introductory
Paul Crawford
-
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 »
-
Sainsbury's Track
Design patterns in Microservices architectures and Gilmour
Level: Intermediate
Piyush Verma
-
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.
Video »
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. -
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.
Video »
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.
-
Sainsbury's Track
What every developer should know about logging
Level: Intermediate
Slawosz Slawinski
-
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.
-
Refreshment break
-
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 »
-
Sainsbury's Track
Building an enterprise service in Go
Level: Intermediate
Marcus Olsson
-
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.
Video »
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. -
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.
Video »
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.
-
Sainsbury's Track
Grand Treatise of Modern Instrumentation and Orchestration
Level: Intermediate
Björn Rabenstein
-
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 »
-
Main Conference Social
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.
-
The Brewery Foyer
Registration and Refreshments
-
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.
-
Opening address
Welcome and Prize Raffle
-
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 »
-
Keynote
GoBridge and the Go Community: Initiatives and Opportunities
Carlisia Campos
-
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 »
-
Sainsbury's Track
Managing and Scaling Real-Time Data Pipelines using Go
Level: Intermediate
Jennie Lees
-
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.
-
Refreshment break
-
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.
Video »
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.
-
Sainsbury's Track
Building Cloud Native applications with Go
Level: Intermediate
Mandy Waite
-
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.
Video »
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. -
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 »
-
Sainsbury's Track
Seven ways to profile Go applications
Level: Intermediate
Dave Cheney
-
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.
-
Lunch
-
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.
Video »
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? -
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?
Video »
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.
-
Sainsbury's Track
The dark side of microservices
Level: Beginner/Introductory
Jelmer Snoeck
-
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.
Video »
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. -
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 »
-
Sainsbury's Track
Building your own log-based message queue in Go
Level: Intermediate
Víctor Ruiz
-
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.
Video »
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.
-
Sainsbury's Track
Simplifying building and managing microservices with Micro
Level: Intermediate
Asim Aslam
-
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.
-
Refreshment break
-
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.
Video »
In this talk we will look into different ways you can build programs that generate source code for other programs. -
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
-
Sainsbury's Track
Inception, Go programs that generate Go code
Level: Intermediate
Ernesto Jimenez
-
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.
Video »
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. -
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.
Video »
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.
-
Sainsbury's Track
Real-time machine learning in Go for smart energy applications
Level: Intermediate
Michael Bironneau