Track: Modern Compilation Targets

Location: Windsor, 5th flr.

Day of week: Tuesday

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 compute platforms, such as GPUs and FPGAs. GPUs in particular are a really important compute platform now, and we want to be ableto 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 compilcation 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

Modern Compilation Targets

Session details to follow.

Anil Madhavapeddy, Docker Engineer, Leads OCaml Labs Group, & Lecturer @Cambridge_Uni

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 Fumero, 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

Modern Compilation Targets

Details to follow.

5:25pm - 6:15pm

Modern Compilation Targets

Details to follow.

Tracks

  • Architectures You've Always Wondered About

    Hard-earned lessons from the names you know on scalability, reliability, security, and performance.

  • Machine Learning: The Latest Innovations

    AI and machine learning is more approachable than ever. Discover how ML, deep learning, and other modern approaches are being used in practice.

  • Kubernetes and Cloud Architectures

    Learn about cloud native architectural approaches from the leading industry experts who have operated Kubernetes and FaaS at scale, and explore the associated modern DevOps practices.

  • Evolving Java

    JVM futures, JIT directions and improvements to the runtimes stack is the theme of this year’s JVM track.

  • Next Generation Microservices: Building Distributed Systems the Right Way

    Microservice-based applications are everywhere, but well-built distributed systems are not so common. Early adopters of microservices share their insights on how to design systems the right way.

  • Chaos and Resilience: Architecting for Success

    Making systems resilient involves people and tech. Learn about strategies being used, from cognitive systems engineering to chaos engineering.

  • The Future of the API: REST, gRPC, GraphQL and More

    The humble web-based API is evolving. This track provides the what, how, and why of future APIs.

  • Streaming Data Architectures

    Today's systems move huge volumes of data. Hear how the innovators in this space are designing systems and leveraging modern data stream processing platforms.

  • Modern Compilation Targets

    Learn about the innovation happening in the compilation target space. WebAssembly is only the tip of the iceberg.

  • Leaving the Ivory Tower: Modern CS Research in the Real World

    Thoughts pushing software forward, including consensus, CRDT's, formal methods & probabilistic programming.

  • Bare Knuckle Performance

    Crushing latency and getting the most out of your hardware.

  • Leading Distributed Teams

    Remote and distributed working are increasing in popularity, but many organisations underestimate the leadership challenges. Learn from those who are doing this effectively.

  • Driving Full Cycle Engineering Teams at Every Level

    "Full cycle developers" is not just another catch phrase; it's about engineers taking ownership and delivering value, and doing so with the support of their entire organisation. Learn more from the pioneers.

  • JavaScript: Pushing the Client Beyond the Browser

    JavaScript is not just the language of the web. Join this track to learn how the innovators are pushing the boundaries of this classic language and ecosystem

  • When Things Go Wrong: GDPR, Ethics, & Politics

    Privacy, confidentiality, safety and security: learning from the frontlines, from both good and bad experiences

  • Growing Unicorns in the EU: Building, Leading and Scaling Financial Tech Start Ups

    Learn how EU FinTech innovators have designed, built, and led both their technologies and organisations.

  • Building High Performing Teams

    There are many discussions outlining the secret sauce of high-performing teams. Learn how to balance the essential ingredients of high performing teams such as trust and delegation, as well as recognising the pitfalls and problems that will ruin any recipe.

  • Scaling Security, from Device to Cloud

    Implementing effective security is vitally important, regardless of where you are deploying software applications