VMIL '20: "Programming Microcontrollers ..."
Programming Microcontrollers through High-Level Abstractions
Steven Varoumas, Basile Pesin, Benoît Vaugon, and Emmanuel Chailloux
(Sorbonne University, France; CNRS, France; LIP6, France; Inria, France; Armadillo, France)
In this paper, we present an approach for programming microcontrollers that provides more expressivity and safety than a low-level language approach traditionally used to program such devices. To this end, we provide various abstraction layers (abstraction of the microcontroller, of the electronic components of the circuit, and of concurrency) which, while being adapted to the scarce resources of the hardware, offer high-level programming traits for the development of embedded applications. The various presented abstractions make use of an OCaml virtual machine able to run on devices with limited resources and take advantage of the expressivity and extensibility of the language. We illustrate the interest of our work on both entertainment applications and embedded software examples.
@InProceedings{VMIL20p5,
author = {Steven Varoumas and Basile Pesin and Benoît Vaugon and Emmanuel Chailloux},
title = {Programming Microcontrollers through High-Level Abstractions},
booktitle = {Proc.\ VMIL},
publisher = {ACM},
pages = {5--14},
doi = {10.1145/3427765.3428495},
year = {2020},
}
Publisher's Version
VMIL '20: "10 Years of Dart (Invited ..."
10 Years of Dart (Invited Talk)
Vyacheslav Egorov
(Google, Denmark)
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.
@InProceedings{VMIL20p4,
author = {Vyacheslav Egorov},
title = {10 Years of Dart (Invited Talk)},
booktitle = {Proc.\ VMIL},
publisher = {ACM},
pages = {4--4},
doi = {10.1145/3427765.3432355},
year = {2020},
}
Publisher's Version
VMIL '20: "Racket’s Intermediate Language ..."
Racket’s Intermediate Language for Control (Invited Talk)
Matthew Flatt
(University of Utah, USA)
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.
@InProceedings{VMIL20p1,
author = {Matthew Flatt},
title = {Racket’s Intermediate Language for Control (Invited Talk)},
booktitle = {Proc.\ VMIL},
publisher = {ACM},
pages = {1--1},
doi = {10.1145/3427765.3432352},
year = {2020},
}
Publisher's Version
VMIL '20: "Programming Microcontrollers ..."
Programming Microcontrollers through High-Level Abstractions
Steven Varoumas, Basile Pesin, Benoît Vaugon, and Emmanuel Chailloux
(Sorbonne University, France; CNRS, France; LIP6, France; Inria, France; Armadillo, France)
In this paper, we present an approach for programming microcontrollers that provides more expressivity and safety than a low-level language approach traditionally used to program such devices. To this end, we provide various abstraction layers (abstraction of the microcontroller, of the electronic components of the circuit, and of concurrency) which, while being adapted to the scarce resources of the hardware, offer high-level programming traits for the development of embedded applications. The various presented abstractions make use of an OCaml virtual machine able to run on devices with limited resources and take advantage of the expressivity and extensibility of the language. We illustrate the interest of our work on both entertainment applications and embedded software examples.
@InProceedings{VMIL20p5,
author = {Steven Varoumas and Basile Pesin and Benoît Vaugon and Emmanuel Chailloux},
title = {Programming Microcontrollers through High-Level Abstractions},
booktitle = {Proc.\ VMIL},
publisher = {ACM},
pages = {5--14},
doi = {10.1145/3427765.3428495},
year = {2020},
}
Publisher's Version
VMIL '20: "Understanding Graal IR (Invited ..."
Understanding Graal IR (Invited Talk)
Chris Seaton
(Shopify, USA)
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.
@InProceedings{VMIL20p3,
author = {Chris Seaton},
title = {Understanding Graal IR (Invited Talk)},
booktitle = {Proc.\ VMIL},
publisher = {ACM},
pages = {3--3},
doi = {10.1145/3427765.3432354},
year = {2020},
}
Publisher's Version
VMIL '20: "In Pursuit of Easy(er) JITs ..."
In Pursuit of Easy(er) JITs (Invited Talk)
Mark Stoodley
(IBM, Canada)
n 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 in complete) 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.
@InProceedings{VMIL20p2,
author = {Mark Stoodley},
title = {In Pursuit of Easy(er) JITs (Invited Talk)},
booktitle = {Proc.\ VMIL},
publisher = {ACM},
pages = {2--2},
doi = {10.1145/3427765.3432353},
year = {2020},
}
Publisher's Version
VMIL '20: "Programming Microcontrollers ..."
Programming Microcontrollers through High-Level Abstractions
Steven Varoumas, Basile Pesin, Benoît Vaugon, and Emmanuel Chailloux
(Sorbonne University, France; CNRS, France; LIP6, France; Inria, France; Armadillo, France)
In this paper, we present an approach for programming microcontrollers that provides more expressivity and safety than a low-level language approach traditionally used to program such devices. To this end, we provide various abstraction layers (abstraction of the microcontroller, of the electronic components of the circuit, and of concurrency) which, while being adapted to the scarce resources of the hardware, offer high-level programming traits for the development of embedded applications. The various presented abstractions make use of an OCaml virtual machine able to run on devices with limited resources and take advantage of the expressivity and extensibility of the language. We illustrate the interest of our work on both entertainment applications and embedded software examples.
@InProceedings{VMIL20p5,
author = {Steven Varoumas and Basile Pesin and Benoît Vaugon and Emmanuel Chailloux},
title = {Programming Microcontrollers through High-Level Abstractions},
booktitle = {Proc.\ VMIL},
publisher = {ACM},
pages = {5--14},
doi = {10.1145/3427765.3428495},
year = {2020},
}
Publisher's Version
VMIL '20: "Programming Microcontrollers ..."
Programming Microcontrollers through High-Level Abstractions
Steven Varoumas, Basile Pesin, Benoît Vaugon, and Emmanuel Chailloux
(Sorbonne University, France; CNRS, France; LIP6, France; Inria, France; Armadillo, France)
In this paper, we present an approach for programming microcontrollers that provides more expressivity and safety than a low-level language approach traditionally used to program such devices. To this end, we provide various abstraction layers (abstraction of the microcontroller, of the electronic components of the circuit, and of concurrency) which, while being adapted to the scarce resources of the hardware, offer high-level programming traits for the development of embedded applications. The various presented abstractions make use of an OCaml virtual machine able to run on devices with limited resources and take advantage of the expressivity and extensibility of the language. We illustrate the interest of our work on both entertainment applications and embedded software examples.
@InProceedings{VMIL20p5,
author = {Steven Varoumas and Basile Pesin and Benoît Vaugon and Emmanuel Chailloux},
title = {Programming Microcontrollers through High-Level Abstractions},
booktitle = {Proc.\ VMIL},
publisher = {ACM},
pages = {5--14},
doi = {10.1145/3427765.3428495},
year = {2020},
}
Publisher's Version