You are viewing content from a past/completed QCon -

Track: Modern Compilation Targets

Location: Windsor, 5th flr.

Day of week:

For many years, we just compiled our languages either for x86 chips, or for a few platforms like the JVM that then compiled for that. But recently this has all started changing. First we have new computer platforms, such as GPUs and FPGAs. GPUs, in particular, are a really important compute platform now, and we want to be able to target these with our programming languages. So far this has not been very easy, but this is starting to change. In addition, there are new software compilation targets, such as Web Assembly, that is letting us program the web from any language. This track explores what is changing now and where we are going with languages and their compiler targets.

Track Host: Justin Cormack

Developer @Docker

Justin Cormack is a software engineer at Docker. He works on security, developer tooling and more. He is always interested in new programming language technology.

10:35am - 11:25am

The Modern Platform in 2020

We are reshaping the platforms we build around language technology. This talk introduces this new track on compilation targets with an overview of how we got to this point where programming language technology is finding its way into every technology stack. First we have performance and efficiency trends, where we need to drive new heterogeneous hardware platforms such as vector registers and GPUs. Much of the work that we see in areas such as ML would not be possible without these changes. Then we have a huge range of exciting applications that are using tiny microcontrollers, perhaps scavenging power from the environment. But we need higher level programming languages for these, as we cannot scaleout C and assembly programming that have dominated this area. In addition we have a new set of platforms that are being enabled by Web Assembly, built around new safer ways of running isolated code, and promising cross language integration in a way that we have not seen before. Finally security and code safety issues are everywhere now. The stacks that we built our infrastructure on are vulnerable to memory safety and other bugs that are becoming easier to find with the rise of fuzzing and other analysis technologies. Languages again provide tools for type and concurrency safety that can fix these issues.

Justin Cormack, Developer @Docker

11:50am - 12:40pm

Modern Compilation Targets Open Space

Details to follow.

1:40pm - 2:30pm

TornadoVM: Java for GPUs and FPGAs

There is no single computer architecture that is best for executing all types of workloads efficiently. Therefore, the proliferation of heterogeneous hardware in recent years means that every system we program is likely to include a mix of computing elements; each of these with different hardware characteristics that enable programmers to improve performance while decreasing energy consumption. These new heterogeneous devices include multi-core CPUs, Graphics Processing Units (GPUs), and Field Programmable Gate Arrays (FPGAs). This trend has been followed by changes in software development norms that do not necessarily favor programmers.

A prime example is the two most popular heterogeneous programming languages, CUDA and OpenCL, which expose several low-level features to the API, making them difficult to use by non-expert users. Instead of using low-level programming languages, developers in industry and academia tend to use higher-level, object-oriented programming languages, typically executed on managed runtime environments, such as Java, R, Python, and JavaScript. Although many programmers might expect that such programming languages would have already been adapted for transparent execution on heterogeneous hardware, the reality is that their support is either very limited or absent.

In this talk, we present TornadoVM, a plugin for OpenJDK that allows Java programmers to automatically run on Heterogeneous Hardware such as multi-core CPUs, GPUs, and FPGAs. Furthermore, TornadoVM can perform live task-migration from one device to another entirely transparent for the user. To do so, TornadoVM consists of three software components: 1) A simple API for composing pipelines of existing Java methods. 2) An optimizing JIT compiler that extends the Graal compiler with hardware-aware optimizations that generate OpenCL C code. 3) A runtime system that executes TornadoVM specific bytecodes, it performs memory management. It also schedules the code for execution on GPUs, multi-core CPUs, and FPGAs, and it performs live task-migration between devices.

Juan Jose Fumero Alfonso, Research Associate @OfficialUoM (The University of Manchester)

2:55pm - 3:45pm

Build Your Own WebAssembly Compiler

For more than 20 years JavaScript has been the only 'native' language of the web. That's all changed with the release of WebAssembly. In the coming years, you'll see people writing web apps in Rust, C#, C++ and all manner of other languages. But just what is WebAssembly? And what’s all the fuss about?

WebAssembly is a low-level compilation target, which means that it is unlikely you’ll use it directly. However, as developers and hackers, we love to know how technology works!

In this talk, Colin will look at some of the internals of WebAssembly, explore how it works ‘under the hood’, and look at how you can create your own (simple) compiler that targets this runtime.

Colin Eberhardt, Technology Director @Scott_Logic

4:10pm - 5:00pm

Tiny Go: Small Is Going Big

The Go programming language has already won the war for cloud computing and containerization. But what about the small places, like embedded systems and WebAssembly?

TinyGo is a compiler for Go, written in Go itself, that uses LLVM to achieve very small, fast, and concurrent binaries that can also target devices where Go could never go before.

This talk will include live coding of devices, RISC-V, WebAssembly, and a drone, to show some of what you can do today using TinyGo.

Ron Evans, Technologist For Hire @hybrid_group

5:25pm - 6:15pm

Pony, Actors, Causality, Types, and Garbage Collection

I will give an overview of Pony’s programming model, actors, and causality. I will introduce the type system, how it is used to allow actors to send mutable state while also avoiding data races, and how the type system is used so as to allow the actors to perform garbage collection fully concurrently with one another and with normal execution.


Sophia Drossopoulou, Professor at Imperial College


This site is protected by reCAPTCHA and the Google Privacy Policy and Terms of Service apply.