The concept of Virtual Machines is pervasive in the design and implementation of programming systems. Virtual Machines and the languages they implement are crucial in the specification, implementation and/or user-facing deployment of most programming technologies.

The VMIL workshop is a forum for researchers and cutting-edge practitioners in language virtual machines, the intermediate languages they use, and related issues.

Conference Proceedings in the ACM DL

https://dl.acm.org/doi/proceedings/10.1145/3427765

How to access and participate in VMIL this year?

Thank you for joining VMIL. This year, VMIL will be a virtual event, collocated with all SPLASH events.

We will start the workshop at 9 am Central Standard Time. See the whole program here:

https://2020.splashcon.org/home/vmil-2020?plenary=Hide%20plenary%20sessions#program

There are two ways to follow all talks and engage with participants.

1) Via Clowdr platform.

This option needs registration (https://2020.splashcon.org/attending/Registration), and you will access a web portal with all-conference, workshops, and events at SPLASH.

To access VMIL, enter the breakout room and access the Zoom meeting listed. You can also follow the event in the YouTube link provided and ask questions in the chat for VMIL.

Access to Clowdr: https://splash2020.clowdr.org/

2) Via YouTube

The whole VMIL workshop will be streamed on YouTube, under the SPLASH-V stream from the ACM.

Follow this link: https://www.youtube.com/watch?v=yG77a8stuDI

How to handle live questions?

After each presentation, we will take questions using the Clowdr platform from the VMIL Breakout room.

Accepted Papers

The workshop is intended to be welcoming to a wide range of topics and perspectives, covering all areas relevant to the workshop’s theme. Aspects of interest include, but are not limited to:

• Design issues in VMs and IRs (e.g. IR design, VM modularity, polyglotism);
• Compilation (static and dynamic compilation strategies, optimizations, data representations);
• VM embeddings in other systems (e.g., DBMSs, Big Data frameworks, Microservices, etc.)
• Memory management;
• Concurrency (both internal and user-facing);
• Tool support and related infrastructure (profiling, debugging, liveness, persistence); the experience of VM development (use of high-level languages, bootstrapping and self-hosting, reusability, portability, developer tooling, etc). empirical studies on related topics, such as usage patterns, the usability of languages or tools, experimental methodology, or benchmark design.

Submission Guidelines

We invite high-quality papers in the following two categories:

• Research and experience papers: These submissions should describe work that advances the current state of the art in the above or related areas. The suggested length of these submissions is 6–10 pages (maximum 10pp).

• Work-in-progress or position papers: These papers should document ongoing efforts in an area of interest which have not yet yielded final results, and/or should present and defend the authors’ position on a topic related to the broad area of the workshop. The maximum length of these submissions is 6 pages, but we will consider shorter submissions (e.g. a well-written 2-page abstract).

For the first submission deadline, all paper types are considered for publication in the ACM Digital Library, except if the authors prefer not to be included. Publication of work-in-progress and position papers at VMIL is not intended to preclude later publication elsewhere.

Submissions will be judged on novelty, clarity, timeliness, relevance, and potential to stimulate discussion during the workshop.

For the second deadline, we will consider only work-in-progress and position papers. Abstracts do not have to be submitted before the deadline. These will not be published in the ACM DL, and will only appear on the web site.

The address of the submission site is: https://vmil20.hotcrp.com/

All deadlines are Anywhere on Earth (AoE), i.e. GMT/UTC−12:00 hour

Format Instructions

Please use the SIGPLAN acmart style for all papers: http://www.sigplan.org/Resources/Author/. The provided double-column template is available for Latex and Word.

Matthew Flatt, University of Utah

Racket’s Intermediate Language for Control

As a language that is intended for building languages in a composable way, Racket provides an especially rich set of constructs for control, including delimited continuations and efficient reflection on continuations. This talk will explain Racket’s constructs for control and describe how the implementation is built in layers.

Mark Stoodley, IBM Canada

In pursuit of easy(er) JITs

In the early days of the Eclipse OMR project, we created the unimaginatively named JitBuilder API aiming to make it easier to build a JIT compiler. JitBuilder has been used to create prototype JIT compilers in a few thousand lines of C++ for WebAssembly, Lua, Smalltalk, Javascript, the Rosie Pattern Language, BF, Kaleidoscope, and Base9, as well as a number of other less language-centric dynamic code generators (including an alternative code generator for LLVM IR). Although it brings key facilities for privatizing virtual machine state and translating bytecode handlers, the JitBuilder API did not completely meet the “easy” goal particularly in the areas of extensibility and debuggability, and did not offer strong DSL optimization possibilities. In this talk, I’ll explain and summarize the key features of the JitBuilder API before introducing some recent exploratory work to create the next version: JitBuilder2. This new fully-fledged (if currently incomplete) compiler IL shares some directions with MLIR, but has some unique challenges and features, all designed around the pursuit of “easy” JIT compiler construction. Through the talk, I’ll show off some of these features (that’s right, I’ll demo a compiler IL!) and highlight some of the interesting directions I think we could take it from here.

Chris Seaton, Shopify

Understanding Graal IR

The Graal compiler uses a graphical sea-of-nodes IR that can be difficult to understand and work with when trying to improve performance of complicated programs. When used with an automatic partial evaluator, such as Truffle, and with a high-level language with complex semantics such as Ruby, the resulting IR graphs become even harder to work with. At Shopify we’re working on new tools to understand complex Graal IR graphs generated from the TruffleRuby and Sulong interpreters, as used to run a large, complex, production application. We’ll show what these tools enable us to do and what innovative ideas we can bring to understand the relevant parts of the graph without getting swamped in the expanse of it.

Vyacheslav Egorov, Google

10 years of Dart

Dart might be the only contemporary programming language that changed its core principles so radically between two major versions. 10 years ago, in 2010, it was born as a dynamically typed programming language with optional static types - ideas of Strongtalk wrapped into familiar C-like syntax. A language destined to be executed in a native VM with an adaptive JIT compiler. Yet over the years Dart has evolved into a language with a sound static type system, and is being deployed in contexts that require ahead-of-time compilation and prohibit JITing. Now, it is even trying to get rid of the “billion-dollar mistake” - null - and incrementally transition to non-nullable by default reference types. This talk focuses on the architecture of Dart Virtual Machine and how it followed the evolution of the Dart language, adapting to the new semantics and new execution environments, where users wanted to bring Dart to.