What does the future of code execution look like on the web? 2017 will be the year for native implementations of ES modules and WebAssembly, representing a huge shift from the execution model we have in place today. Guy looks at the native adoption path for web modules based on the current specifications and upcoming proposals, imagining how this might affect the web runtime and tooling.
Go's tools can help you diagnose problems with your applications—if you can wield them effectively. The Execution Tracer provides great visibility into the scheduler, to help solve timing dependent bugs and track down latency problems. Rhys argues you should learn how to use the tools before you have a time-critical need.
Go is a great general purpose programming language and it is thus no surprise it can be a great fit for science work. But Go could be an even better fit for all kind of exploratory work, such as data analysis, if it had an interactive interpreter, also known as a Read-Eval-Print Loop (a REPL). Sébastien introduces pygo, a very first step in that direction.
We learn new stuff when we work on our projects. Let us use linters together with version control to enforce the changes we want to see in our code base. However, at times it might be too much work to change the configuration of our linters. Rolf Erik proposes a way to make that easier so that we can make sure we utilise what we learn.
Prototyping remains an underappreciated technique in software design. In this talk, Robert develops a functioning prototype for a specific Go language extension, multi-dimensional index expressions. He explains how implementing and playing with the prototype informs the existing design, which ultimately may lead to a better final design.
The past decade has seen an explosion of new programming languages, many of them bringing exciting ideas from the research community into the world of mainstream programming. And then there is Go. John looks at why Go is so frequently criticised by the programming languages community, why that might not matter, and how we can all learn from this.
The tried-and-true approach to sharing memory in Go is via communication. Yet there are scenarios where the amount of data is prohibitively expensive to pass around. Instead of falling back to locks, immutable data structures provide an alternative way, where we can achieve concurrent access to shared memory while at the same time make reasoning about complexity much easier.
First class functions, sometimes known as anonymous functions or closures, are a powerful concept that let Go programmers pass around behaviour to be executed, rather than data to be interpreted. In this presentation Dave explains what first class functions are, shows how to use them, and concludes with an observation that first class functions are something that all Go programmers can become comfortable using with just a little practice.
Erlang is a programming language dedicated to building robust and scalable services. It has matured for many years and finally reached a point where it is one of the secret weapons used by many prominent companies to build large-scale systems. Mickaël walks you through computing history to understand the concepts behind Erlang and explains how they influenced the design of modern languages.
Computing isn't physics. But as we add scale to computing systems, we can begin to reason from simple principles to detailed understanding of how our systems must work. These constraints, in turn, shape our entire industry in predictable ways. Ted gives two examples: the deep reason big data is big right now and how messaging systems must work.
Scaling up machine learning techniques to keep pace with "big data" is its own interesting engineering problem. Recently, Apache Spark has become a popular framework for large-scale ML. Sean introduces the intuition behind modern large-scale recommenders and highlights four ways ML algorithms are engineered to scale.
Developers usually come to Go for the concurrency patterns and the simplicity, but not everybody out there is looking tools for distributed and concurrent systems, at least in the beginning. Yet, they still use Go for their specific problems, which is a key for adoption worldwide. Veronica presents two such interesting use cases.
100% uptime is impossible. Modern architectures are designed around failure but what does that mean for the human aspect of incident management? David's talk considers how to prepare for outages, how to structure the response, and how those experiences and techniques differ for small and large companies.
As developers we tend to neglect the importance of the academic research on distributed systems. Sam reminds us to spend some time into diving into the details and the formal theory behind many of our distributed data stores, grasp the trade-offs they make, and avoid getting fooled by their marketing.
Paul delves into some of the challenges involved in building a distributed database specifically for time series data. High write throughput, even higher read throughput, large range scans of data to answer queries, and large range deletes all conspire to make time series data both the worst and best use case to build for in distributed databases.
Convergent Replicated Data Types offer a principled approach to eventually consistent data modelling, with defined data types always converging to single correct values. CRDTs are one of the key building blocks of a distributed system, enabling strong eventual consistency and highly available, low latency applications.