Archive of posts with the tag Virtual Machines

• Sep 11, 2023: An Introduction to Interpreters and JIT Compilation

  Last week, I gave two lectures at the Programming Language Implementation Summer School (PLISS). PLISS was very well organized and the students and other presenters made for a very enjoyable week of new ideas, learning, and discussing.

• Jul 26, 2021: Interpreters, Compilation, and Concurrency Tooling in PLAS at Kent

  Here at Kent, we have a large group of researchers working on Programming Languages and Systems (PLAS), and within this group, we have a small team focusing on research on interpreters, compilation, and tooling to make programming easier.

• Jun 16, 2021: Interpreter Generators: A Brief Look at Existing Work

  Motivated by Tiger, a tool for generating interpreters, being mentioned on Twitter, I had a brief look at vmgen, Tiger, eJSTK, Truffle DSL, and DynSem. What follows are my rather rough notes and pointers. So, this is by no means a careful literature study, and I welcome further pointers.

• Feb 18, 2021: Open Postdoc Position on Language Implementation and Concurrency

• Dec 7, 2020: Preventing Concurrency Bugs from Causing Harm, Automatically

• Oct 19, 2020: Irrationally Annoyed: The SIGPLAN Blog Post writing 30 Years of PL Research Out of Existence

  I started writing this post when being very very annoyed by this blog post on the SIGPLAN blog. I could not understand how “THE SIGPLAN” blog could simply write 30 years of programming language research out of existence, only barely acknowledging Self and JavaScript. It felt like duty called…

• Aug 8, 2020: Metaprogramming, Metaobject Protocols, Gradual Type Checks: Optimizing the "Unoptimizable" Using Old Ideas

  Last year, I was asked to give a talk for the Meta’19 workshop. It’s a workshop on metaprogramming and reflection. The submission deadline for this year’s edition, is less than a month away: Check it out!

• Jun 26, 2020: An Introduction to Efficient and Safe Implementations of Dynamic Languages

  Last September, I had a lot of fun putting together a lecture on language implementation techniques. It is something I wanted to do for a while, but I had not had a good excuse before to actually do it.

• May 27, 2019: Generating an Artifact From a Benchmarking Setup as Part of CI

  Disclaimer: The artifact, for which I put this automation together, was rejected. I take this as a reminder that the technical bits still require good documentation to be useful.

• Apr 9, 2019: Another Decade of SOM Language Implementation

  SOM, the Simple Object Machine, is a little dynamic language designed for teaching object-oriented virtual machine design. It originates in Aarhus, Denmark, and according to Lars Bak, it was implemented in the course of two days by Kasper Lund. They used it back in 2001 for a course at the University of Aarhus.

• Aug 24, 2018: Efficient Deterministic Replay for Actors

  Debugging concurrent systems is pretty hard, and we worked already for a while to make things a bit better. However, a big remaining problem is that bugs are not easily reproduced.

• Mar 13, 2018: How to Design Collection Libraries?

  Programming languages naturally come with a library of containers or collection types. They allow us to easily work with arbitrary number of elements, which is something all major languages care about. Unfortunately, it seems like there is not much writing on how to design such libraries. Even asking a few people that worked for a long time on collection libraries did not yield much of a structured approach to such a central element for our languages. The one major piece of writing we found is the Scala people describing their experience with bit rot and how they redesigned their collection implementation to avoid it.

• Oct 15, 2017: Debugging Concurrency Is Hard, but We Can Do Something About It!

  When we have to debug applications that use concurrency, perhaps written in Java, all we get from the debugger is a list of threads, perhaps some information about held locks, and the ability to step through each thread separately.

• Apr 30, 2017: 10 Years of Language Implementations

  First Stop: VMs, Compilers, and Modularity

• Oct 25, 2016: Cross-Language Compiler Benchmarking: Are We Fast Yet?

  Research on programming languages is often more fun when we can use our own languages. However, for research on performance optimizations that can be a trap. In the end, we need to argue that what we did is comparable to state-of-the-art language implementations. Ideally, we are able to show that our own little language is not just a research toy, but that it is, at least performance-wise, competitive with for instance Java or JavaScript VMs.

• Sep 22, 2014: Are We There Yet? Simple Language-Implementation Techniques for the 21st Century

  The first results of my experiments with self-optimizing interpreters was finally published in IEEE Software. It is a brief and very high-level comparison of the Truffle approach with a classic bytecode-based interpreter on top of RPython. If you aren’t familiar with either of these approaches, the article is hopefully a good starting point. The experiments described in it use SOM, a simple Smalltalk.

• Feb 1, 2014: How to get a JIT Compiler for Free: Implementing SOM Smalltalk with RPython and Truffle

  Today at FOSDEM, I gave a brief talk on implementing SOM, a little Smalltalk, with RPython and Truffle. RPython, probably best known for the PyPy implementation, uses meta-tracing JIT compilation to make simple interpreters fast. Truffle, a research project of Oracle Lab, is an approach for building self-optimizing interpreters and in combination with Graal, it gives a JIT compiler for AST-like interpreters. In the talk, I briefly sketch both of them, without going into many details.

• Jan 21, 2013: Supporting Concurrency Abstractions in High-level Language Virtual Machines

  Last Friday, I defended my PhD dissertation. Finally, after 4 years and a bit, I am done. Finally. I am very grateful to all the people supporting me along the way and of course to my colleagues for their help.

• Nov 14, 2012: Sly and the RoarVM: Exploring the Manycore Future of Programming

  My second talk at Smalltalks 2012 was most likely the reason why the organizers invited me in the first place. It was a slightly extended version of the Sly and RoarVM talk for the FOSDEM Smalltalk Dev Room from the beginning of the year, reporting on the Renaissance Project.

• Mar 9, 2012: Identifying A Unifying Mechanism for the Implementation of Concurrency Abstractions on Multi-Language Virtual Machines

  My paper, on how to support various concurrency models, with an ownership-based meta-object protocol (MOP) was accepted at TOOLS’12. Below, you will find a preprint version of the paper. A later post will provide details on how to use it and how to experiment with the MOP in Pharo 1.3.

• Jan 24, 2012: Modularity and Conventions for Maintainable Concurrent Language Implementations: A Review of Our Experiences and Practices

  Modularity: AOSD’12 will be in Potsdam at the end of March, and I am looking forward especially to the MISS’12 workshop.

• Dec 28, 2011: CSOM/PL: A Virtual Machine Product Line

  Welcome to Academia. That is how I take this one…

• Oct 26, 2011: DLS'11 and VMIL'11 @SPLASH2011

  The second conference day was unfortunately full of “conflicts of interest”… It was pretty hard to choose between all the talks on the schedule.

• Sep 27, 2011: Which Problems Does a Multi-Language Virtual Machine Need to Solve in the Multicore/Manycore Era?

  As preparation for SPLASH’11, here my paper for the VMIL workshop. It is a position paper discussing in which direction virtual machines should evolve in the future with regard to the challenges manycore architectures and concurrent programming bring.

• Sep 18, 2011: Using R to Understand Benchmarking Results

  Why R?

• Aug 24, 2011: Sly and the RoarVM: Exploring the Manycore Future of Programming

  Today, I gave a talk at the ExaScience Lab, Intel Labs Europe in Leuven at IMEC. I talked mainly about the idea of nondeterministic programming, the Sly programming language and some details on our Smalltalk manycore virtual machine that enables those experiments. Thus, tried to spread the word about our Renaissance project at bit further.

• Dec 7, 2010: The Price of the Free Lunch: Programming in the Multicore Era

  Last Friday was the annual Lab event of our Software Languages Lab. Like last year, many people related to the lab in one or the other way came to get an overview of what the current topics of our research are.

• May 25, 2010: Locality and Encapsulation: My Student’s Presentation at the TiC Summer School

  On the first day here at the summer school, the organizers gave us the opportunity to present our research ideas to the lecturers and other participants.

• Feb 20, 2010: Towards an Actor-based Concurrent Machine Model

  Already quite a while ago, I was involved in writing a workshop paper about an actor model for virtual machines. Actually, the main idea was to find a concurrency model for a VM which supports multi-dimensional separation of concerns. However, AOP is not that interesting for me at the moment, so I am focussing on the concurrency, especially the actor-based VM model.

• Feb 14, 2010: Intermediate Language Design of High-level Language Virtual Machines: Towards Comprehensive Concurrency Support

  My second workshop paper got published at the ACM Digital Library. This is actually only an abstract, but nonetheless, it might be interesting for people looking into the design of virtual machines and especially bytecodes/intermediate languages.

• Feb 7, 2010: Virtual Machine Support for Many-Core Architectures: Decoupling Abstract from Concrete Concurrency Models

  Finally, my first workshop paper got published, which was a little odyssey with some misunderstandings, but anyway, now it is out. It is just a position paper, thus, do not expect to many insights. However, what it describes is my big plan, and hopefully the story of my PhD. Am working on it…