Archive of posts in the category Research

• Sep 17, 2024: Instrumentation-based Profiling on JVMs is Broken!

  Last year, we looked at how well sampling profilers work on top of the JVM. Unfortunately, they suffer from issues such as safepoint bias and may not correctly attribute observed run time to the correct methods because of the complexities introduced by inlining and other compiler optimizations.

• Jun 18, 2024: 5 Reasons Why Box Plots are the Better Default Choice for Visualizing Performance

  Box Plots, Or Better!

• Feb 23, 2024: Why Are My Bytecode Interpreters Slow? Hunting Truffles with VTune

  As part of our work on the AST vs. Bytecode Interpreters paper, I briefly looked at how the native code of ahead-of-time-compiled bytecode loops looks like, but except for finding much more code than what I expected, I didn’t look too closely at what was going on.

• Feb 13, 2024: Rank 10 Language Implementations

  Please rank 10 language implementations by their median performance, based on your best guess or estimate.

• Nov 17, 2023: The Changing “Guarantees” Given by Python's Global Interpreter Lock

  In this blog post, I will look into the implementation details of CPython’s Global Interpreter Lock (GIL) and how they changed between Python 3.9 and the current development branch that will become Python 3.13.

• Oct 16, 2023: Which Interpreters are Faster, AST or Bytecode?

  This post is a brief overview of our new study of abstract-syntax-tree and bytecode interpreters on top of RPython and the GraalVM metacompilation systems, which we are presenting next week at OOPSLA.

• Sep 20, 2023: Don't Blindly Trust Your Java Profiler!

  How do we know on what to focus our attention when trying to optimize the performance of a program? I suspect at least some of us will reach for sampling profilers. They keep the direct impact on the program execution low, and collect stack traces every so often during the program execution. This gives us an approximate view of where a program spends its time. Though, this approximation as it turns out can be surprisingly unreliable.

• 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.

• Jun 6, 2023: Squeezing a Little More Performance Out of Bytecode Interpreters

• Nov 8, 2022: How Effective are Classic Lookup Optimizations for Rails Apps?

  We know that Ruby and especially Rails applications can be very dynamic and pretty large. Though, many of the optimizations interpreters and even just-in-time compilers use have been invented in the 1980s and 1990s before Ruby and Rails even existed. So, I was wondering: do these optimizations still have a chance of coping with the millions of lines of Ruby code that large Rails apps from Shopify, Stripe, or GitLab have? Unfortunately, we don’t have access to such applications. As the next best thing, we took the largest Ruby benchmarks we could get our hands on, and analyzed those.

• Oct 30, 2022: Reducing Memory Footprint by Minimizing Hidden Class Graphs

  Tomoharu noticed in his work on the eJSVM, a JavaScript virtual machine for embedded systems, that quite a bit of memory is needed for the data that helps us to represent JavaScript objects efficiently. So, we started to look into how the memory use could be reduced without sacrificing performance.

• Oct 10, 2022: The Cost of Safety in Java

  Overhead of Null Checks, Array Bounds, and Class Cast Exceptions in GraalVM Native Image

• Oct 5, 2022: Effortless Language Servers

  Ever since my blog post in 2016, I have wanted a good language server for SOM and Newspeak. Though, I didn’t really have the time to implement more than a few features.

• Oct 17, 2021: Actors! And now?

  An Implementer’s Perspective on High-level Concurrency Models, Debugging Tools, and the Future of Automatic Bug Mitigation

• Sep 30, 2021: How do we do Benchmarking?

  Impressions from Conversations with the Community

• 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

• Jan 2, 2021: Towards a Synthetic Benchmark to Assess VM Startup, Warmup, and Cold-Code Performance

  One of the hard problems in language implementation research is benchmarking. Some people argue, we should benchmark only applications that actually matter to people. Though, this has various issues. Often, such applications are embedded in larger systems, and it’s hard to isolate the relevant parts. In many cases, these applications can also not be made available to other researchers. And, of course, things change over time, which means maintaining projects like DaCapo, Renaissance, or Jet Stream is a huge effort.

• Dec 30, 2020: The Shape of 6M Lines of Ruby

  Following up on my last blog post, I am going to look at how Ruby is used to get a bit of an impression of whether there are major differences between Ruby and Smalltalk in their usage.

• Dec 14, 2020: The Shape of 1.7M Lines of Code

  Recently, I was wondering how large code bases look like when it comes to the basic properties compiler might care about. And here I am not thinking about dynamic properties, but simply static properties such as length of methods, number of methods per class, number of fields, and so on.

• 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!

• Jul 7, 2020: Is This Noise, or Does This Mean Something? #benchmarking

  Do my performance measurements allow me to conclude anything at all?

• 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.

• Jul 12, 2019: What if we could see all concurrency bugs in the debugger?

  Multiverse Debugging: Non-Deterministic Debugging for Non-Deterministic Programs

• Jul 11, 2019: SOMns 0.7.0 Release with Extension Modules and Artifacts

  It has been a while since we put together a release for SOMns. And it has been even longer, since I last wrote about it on this blog.

• 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.

• Sep 6, 2017: Building High-level Debuggers for Concurrent Languages with Truffle: The Missing Bits

  Note: This post is meant for people familiar with Truffle. For introductory material, please see for instance this list.

• Jul 5, 2017: A 10 Year Journey, Stop 5: Growing the SOM Family

• Jun 6, 2017: A 10 Year Journey, Stop 4: Concurrency and Tooling

  This post, the fourth in the series, is about my current work on concurrency and tooling. As mentioned before, I believe that there is not a single concurrency model that is suitable for all problems we might want to solve. Actually, I think, this can be stated even stronger: Not a single concurrency model is appropriate for a majority of the problems we want to solve.

• May 14, 2017: A 10 Year Journey, Stop 3: Performance, Performance, and Metaprogramming

  The third post of this series is about how I started using Truffle and Graal, pretty much 4 years ago. It might be in parts ranty, but I started using it when it was in a very early stage. So, things are a lot better today.

• May 7, 2017: A 10 Year Journey, Stop 2: Supporting All Kind of Concurrency Models on a Simple VM

  Last week, I started a series of posts to go over some of the projects I was involved in during my first 10 years working on language implementations. Today’s post focuses on my time as PhD student.

• Apr 30, 2017: 10 Years of Language Implementations

  First Stop: VMs, Compilers, and Modularity

• Mar 7, 2017: SOMns 0.2 Release with CSP, STM, Threads, and Fork/Join

  Since SOMns is a pure research project, we aren’t usually doing releases for SOMns yet. However, we added many different concurrency abstractions since December and have plans for bigger changes. So, it seems like a good time to wrap up another step, and get it into a somewhat stable shape.

• Jan 10, 2017: Communicating Sequential Processes for Newspeak/SOMns

  One possible way for modeling concurrent systems is Tony Hoare’s classic approach of having isolated processes communicate via channels, which is called Communicating Sequential Processes (CSP). Today, we see the approach used for instance in Go and Clojure.

• 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.

• Oct 22, 2016: Language Research with Truffle at the SPLASH'16 Conference

  Next weekend starts one of the major conferences of the programming languages research community. The conference hosts many events including our Meta’16 workshop on Metaprogramming, SPLASH-I with research and industry talks, the Dynamic Languages Symposium, and the OOPSLA research track.

• Aug 10, 2016: Can we get the IDE for free, too?

  With the Truffle language implementation framework, we got a powerful foundation for implementing languages as simple interpreters. In combination with the Graal compiler, Truffle interpreters execute their programs as very efficient native code. Now that we got just-in-time compilation essentially “for free”, can we get IDE integration for our Truffle languages as well?

• Jun 25, 2016: Writing Papers with Completely Automated Data Processing

  One of the first things that I found problematic about paper writing was the manual processing and updating of numbers based on experiments. Ever since my master thesis, this felt like a unnecessary and error prone step.

• Apr 8, 2016: Adding Debugging Support to a Truffle Language

  Beside the great performance after just-in-time compilation, the Truffle Language implementation framework provides a few other highly interesting features to language implementers. One of them is the instrumentation framework, which includes a REPL, profiler, and debugger.

• Feb 11, 2016: Domains: Sharing State in the Communicating Event-Loop Actor Model

  It has been a while since we started working on how to extended the Actor model with mechanisms to safely share state. Our workshop paper on Tanks was published in 2013. And now finally, an extended version of this work was accepted for publication. Below you can find the abstract with a few more details on the paper, and of course a preprint of the paper itself.

• Feb 4, 2016: Open PostDoc Position on Programming Technology for Complex Concurrent Systems

  We, or more specifically our colleagues from the Software Languages Lab in Brussels are looking for a post-doctoral researcher to work on a collaborative research project with us.

• Jan 25, 2016: Towards Meta-Level Engineering and Tooling for Complex Concurrent Systems

  Last December, we got a research project proposal accepted for a collaboration between the Software Languages Lab in Brussels and the Institute for System Software here in Linz. Together, we will be working on tooling for complex concurrent systems. And with that I mean systems that use multiple concurrency models in combination to solve different problems, each with the appropriate abstraction. I have been working on these issues already for a while. Some pointers are available here in an earlier post: Why Is Concurrent Programming Hard? And What Can We Do about It?

• Jan 12, 2016: Type Hierarchies and Guards in Truffle Languages

  Continuing a little bit with writing notes on Truffle and Graal, this one is based on my observations in SOMns and changes to its message dispatch mechanism. Specifically, I refactored the main message dispatch chain in SOMns. As in Self and Newspeak, all interactions with objects are message sends. Thus, field access and method invocation is essentially the same. This means that message sending is a key to good performance.

• Dec 8, 2015: Add Graal JIT Compilation to Your JVM Language in 5 Easy Steps, Step 5

  Step 5: Optimizing the Interpreter for Compilation

• Dec 1, 2015: Add Graal JIT Compilation to Your JVM Language in 5 Easy Steps, Step 4

  Step 4: Complete Support for Mandelbrot

• Nov 24, 2015: Add Graal JIT Compilation to Your JVM Language in 5 Easy Steps, Step 3

  Step 3: Interpreting a Simple Fibonacci Function with Golo+Truffle

• Nov 17, 2015: Add Graal JIT Compilation to Your JVM Language in 5 Easy Steps, Step 2

  Step 2: Adding Bit Operations To Golo

• Nov 10, 2015: Add Graal JIT Compilation to Your JVM Language in 5 Easy Steps, Step 1

  Over the course of the next four weeks, I plan to publish a new post every Tuesday to give a detailed introduction on how to use the Graal compiler and the Truffle framework to build fast languages. And this is the very first post to setup this series. The next posts are going to provide a bit of background on Golo, the language we are experimenting with, then build up the basic interpreter for executing a simple Fibonacci and later a Mandelbrot computation. To round off the series, we will also discuss how to use one of the tools that come with Graal to optimize the performance of an interpreter. But for today, let’s start with the basics.

• Oct 23, 2015: JIT Data Structures, Fully Reflective VMs, and Meta-Circular Meta-Tracing

  The year leading up to SPLASH has been pretty busy. Beside my own talks on Tracing vs. Partial Evaluation and Optimizing Communicating Event-Loop Languages with Truffle, there are going to be three other presentations on work I was involved in.

• Oct 21, 2015: Optimizing Communicating Event-Loop Languages with Truffle

  The past few month, I have been busy implementing a fast actor language for the JVM. The language is essentially Newspeak with a smaller class library and without proving access to the underlying platform, which can lead to violations of the language’s guarantees.

• Oct 19, 2015: Tracing vs. Partial Evaluation: Comparing Meta-Compilation Approaches for Self-Optimizing Interpreters

  Back in 2013 when looking for a way to show that my ideas on how to support concurrency in VMs are practical, I started to look into meta-compilation techniques. Truffle and RPython are the two most promising systems to build fast language implementations without having to implement a compiler on my own. While these two approaches have many similarities, from a conceptual perspective, they take two different approaches that can be seen as the opposite ends of a spectrum. So, I thought, it might be worthwhile to investigate them a little closer.

• Sep 11, 2015: Why Is Concurrent Programming Hard? And What Can We Do about It? #vmm2015

  Yesterday at the Virtual Machine Meetup, I was giving a talk about why I think concurrent programming is hard, and what we can do about it.

• Apr 28, 2015: Zero-Overhead Metaprogramming

  Runtime metaprogramming and reflection are slow. That’s a common wisdom. Unfortunately. Using refection for instance with Java’s reflection API, its dynamic proxies, Ruby’s #send or #method_missing, PHP’s magic methods such as __call, Python’s __getattr__, C#’s DynamicObjects, or really any metaprogramming abstraction in modern languages unfortunately comes at a price. The fewest language implementations optimize these operations. For instance, on Java’s HotSpot VM, reflective method invocation and dynamic proxies have an overhead of 6-7x compared to direct operations.

• Jan 31, 2015: FOSDEM 2015: Building High-Performance Language Implementations With Low Effort

  Today, I gave a talk on implementing languages based on the ideas behind RPython and Truffle at FOSDEM on the main track. Please find abstract and slides below.

• Jan 27, 2015: Partitioned Global Address Space Languages

  More than a decade ago, programmer productivity was identified as one of the main hurdles for future parallel systems. The so-called Partitioned Global Address Space (PGAS) languages try to improve productivity and explore a range of language design ideas. These PGAS languages are designed for large-scale high-performance parallel programming and provide the notion of a globally shared address space, while exposing the notion of explicit locality on the language level. Even so the main focus is high-performance computing, the language ideas are also relevant for the parallel and concurrent programming world in general.

• Nov 19, 2014: SOM Performance Numbers

  Today, I got a few more benchmarks running to get a better idea of where RTruffleSOM and TruffleSOM stand in terms of their absolute performance.

• 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.

• Sep 17, 2014: Fork/Join Parallelism in the Wild: Documenting Patterns and Anti-Patterns in Java Programs using the Fork/Join Framework

  Parallel programming is frequently claimed to be hard and all kind of approaches have been proposed to solve the complexity issues. The Fork/Join programming style introduced with Cilk enables the parallel decomposition of problems in a recursive divide-and-conquer style, and on the surface looks very simple with its minimalistic approach of having a fork and a join language construct. But is it actually simple to use? To find out, Mattias started to dig through the Java open source projects on GitHub and tried to identify common patterns. Next week, he will present our findings at PPPJ’14.

• Jul 15, 2014: Why is Concurrent Programming hard?

  In short, I think, it is hard because on the one hand there is not a single concurrency abstraction that fits all problems, and on the other hand the various different abstractions are rarely designed to be used in combination with each other.

• Mar 3, 2014: Domains: Safe Sharing Among Actors

  The actor model is a pretty nice abstraction to reason about completely independent entities that interact purely by exchanging messages. However, for software development, some see the pure actor model as too fine-grained and too restrictive exposing many of the low-level issues such as data races again on a higher level again, and thereby forgoing some of its conceptual benefits.

• Feb 17, 2014: Towards Composable Concurrency Abstractions

  One of the big questions that came up during my PhD was: ok, now you got your fancy ownership-based metaobject protocol, and you can implement actors, agents, communicating sequential processes, software transactional memory, and many others, but now what? How are you going to use all of these in concert in one application? Finding a satisfying answer is unfortunately far from trivial.

• Feb 13, 2014: Parallel Gesture Recognition with Soft Real-Time Guarantees

  More than three years ago, Lode and I started thinking about parallel event processing for realtime systems. The main use case back then was gesture and motion detection based on cameras such as the Kinect. Thierry created the first fully functional prototype called PARTE, and in addition to his master thesis, we wrote a workshop paper about it. Now, we finally got also the revised and extended version of this paper accepted.

• Feb 10, 2014: OMOP Ported to Opal on top of Pharo 3

  To prepare some experiments with Pharo’s new compiler infrastructure and a simple AST interpreter, I ported my implementation of the Ownership-based Metaobject Protocol (OMOP) to the Pharo 3. Loading the OMOP into an image will give you an STM implementation, a basic actor system, communicating sequential processes, Clojure-like agents, and active objects. Eventually, the goal is to provide a more extensive set of such concurrent programming mechanisms on top of the OMOP, but for now these five should already give an impression of how the OMOP itself works.

• 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.

• Oct 24, 2013: Tanks: Multiple Reader, Single Writer Actors

  And another paper that’s going to be presented by Joeri is our work on Tanks, a variation of communicating event loops (à la E or AmbientTalk). Tanks add synchronous and consistent read access to the event loop model.

• Oct 24, 2013: Cloud PARTE: Elastic Complex Event Processing based on Mobile Actors

  On Sunday, I am going to present work on a distributed Rete engine I have been involved in over the last year. The presentation will be at the AGERE workshop co-located with SPLASH. Note that most of the work has been done by Janwillem and Thierry over the last two years. They did a great job in first implementing and parallelizing our Rete engine and now distributing it to scale up for “big data” scenarios.

• Mar 10, 2013: Replacing plyr's ddply with data.table to improve an R script's performance

  Since quite a while, I am using R as a scripting language to generate graphs to the benchmarking results of various experiments. Since we have a new 64 core machine at the lab, I happen to run into performance issues with scripts that process the benchmark results, because the number of measurements increased significantly and the plyr library I use was designed with ease of use in mind, instead of performance. Concretely, I was experiencing script runtimes of up to 25min for a data set with roughly 50.000 measurements.

• 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.

• Jan 9, 2013: Parallel Gesture Recognition with Soft Real-Time Guarantees

  It has been a while since SPLASH’12, but I got finally around to put up a copy of our paper at the AGERE’12 workshop. It is based on Thierry’s master thesis and presents his work on parallelizing a Rete engine for gesture recognition. Lode and I were his advisors and are happily working with him on what we promised in the future work section.

• 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.

• Nov 8, 2012: What If: Developing Applications in the Multicore Era

  Yesterday was the first day of Smalltalks 2012 in Puerto Madryn. The organizers invited my to give a keynote on a topic of my choice, which I gladly did. Having just handed in my thesis draft, I chose to put my research into the context of Smalltalk and try to relate it to one of the main open questions: How do we actually want to program multicore systems.

• Nov 3, 2012: Brief Introduction to Multicore Programming

  Yesterday, I gave a brief lecture at the University of Quilmes half an hour outside of Buenos Aires. Since the students were from all levels of the bachelor program, I tried to give them a little impression of why we have multicore processors in the first place, and how fork/join with work-stealing as well as event-loop actors could be used to program these systems.

• Sep 10, 2012: RACES'12: Public Reviews + Paper Drafts + Voting on Agenda == Workshop 2.0?

  [Disclaimer: I am one of the assistants supporting the RACES’12 organizers and a PC member.]

• Jul 14, 2012: WritingStats: Track and Visualize Your Writing Progress

  Writing a PhD dissertation, a master thesis, a bachelor thesis, or any other kind of lengthy document can be a lot less rewarding than hacking on something that gives real feedback once it starts working…

• Jun 25, 2012: Workshop on Relaxing Synchronization for Multicore and Manycore Scalability

  You got a big multicore, or manycore machine, but do not have a clue of how to actually use it, because your application doesn’t seem to scale naturally? Well, that seems to be a problem many people are facing in our new manycore age. One possible solution might be to accept less precise answers by relaxing synchronization constraints. That could allow us to circumvent Amdahl’s law when Gustafson is out of reach.

• 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…

• Dec 24, 2011: Synchronization Views for Event-loop Actors

  With Joeri we have been working already for a while on a paper to extend the standard actor model with more parallelism. This work is not completed yet, and there are still some theoretical issues with the approach he designed. But we are working on it!

• Nov 2, 2011: OOSPLA 2011 @SPLASH2011, Day 3

  The third day started with Brendan Eich’s keynote on JavaScript’s world domination plan. It was a very technical keynote, not very typical I suppose. And he was rushing through his slides with an enormous speed. Good that I have some JavaScript background. Aside all the small things he mentioned, interesting for me is that he seemed to be very interested to get Intel’s RiverTrail approach to data-parallelism into ECMAScript in one or another form. That is kind of contradicting the position I heard so far, that ECMAScript would be done with having WebWorkers as a model for concurrency and parallel programming.

• Oct 31, 2011: OOSPLA 2011 @SPLASH2011, Day 2

  The second day of the technical tracks started with a keynote by Markus Püschel. He is not the typical programming language researcher you meet at OOPSLA, but he does research in automatic optimization of programs. In his keynote, he showed a number of examples how to get the best performance for a given algorithm out of a particular processor architecture. Today’s compilers are still not up to the task, and will probably never be up to it. Given a naïve implementation, hand-optimized C code can have 10x speedup when dependencies are made explicit, and the compiler knows that no aliasing can happen. He was then discussing how that can be approached in an automated way, and was also thinking about what programming languages could do.

• Oct 29, 2011: OOSPLA 2011 @SPLASH2011, Day 1

  The first day of the technical tracks including OOPSLA started with a keynote by Ivan Sutherland titled The Sequential Prison. His main point was that the way we think and the way we build machines and software is based on sequential concepts. The words we use to communicate and express ourselves are often of a very sequential nature. His examples included: call, do, repeat, program, and instruction. Other examples that shape and restrict our way of thinking are for instance basic data structures and concepts like strings (character sequences). However, we also use words that enable thinking about concurrency and parallelism much better. His examples for these included: configure, pipeline, connect, channel, network, and path.

• 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.

• Oct 24, 2011: Transitioning to Multicore @SPLASH2011

  And here we go again: SPLASH 2011 has started with its first day of workshops.

• 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.

• Aug 19, 2011: The Sly3 Programming Language

  The following introduction and analysis of the Sly3 programming language was written by Pablo Inostroza Valdera as part of his course work for the Multicore Programming course of Tom Van Cutsem. The assignment was to write a blog post about a topic of their own choice, and I repost Pablo’s work here with his permission to spread the word about Sly a bit wider. We made his article also available as part of his work for the Renaissance project itself.

• Dec 15, 2010: PHP.next: Traits – Presentation for AFUP in Paris

  Today, I gave a presentation on Traits for PHP in Paris. It was a quite interesting audience, ca. 35 professional PHP developers and all interested in Traits.

• 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.

• Nov 3, 2010: RoarVM: The Manycore SqueakVM

  We are happy to announce, now officially, RoarVM: the first single-image manycore virtual machine for Smalltalk.

• Nov 2, 2010: RVM Open Sourced, Soon to be known as RoarVM

  Just a brief heads up before the actual announcement of RoarVM.

• Nov 2, 2010: SPLASH'10 Main Conference

  Tuesday – Evolution, Onward!, FPGAs, and the Hera-JVM

• Oct 30, 2010: Workshops at SPLASH 2010

  As usual I will write about a few of my personal highlights of SPLASH and the co-located workshops. That is mostly from my spotty notes, and from memory, so I don’t guarantee 100% accuracy, especially with respect to what other people might have said.

• Sep 22, 2010: Highlights of HPCC 2010

  The 12th IEEE Internal Conference on High Performance Computing and Communications was not the first conference I attended. However, it was the first one where I actually presented a paper in the main research track.

• Aug 4, 2010: Poster at SPLASH’10

  On a related note to the last post, my poster got also accepted for SPLASH’10.

• Jul 30, 2010: Doctoral Symposium at SPLASH 2010

  In October, I will give a brief presentation on the state of affairs with my PhD research at the SPLASH 2010 Doctoral Symposium. The basic idea has not changed since my last presentation at the TiC’10 summer school. I haven’t been able to do a lot of real work for it, but the ideas are a bit clearer now. The following two-page proposal will be published as part of the conference proceedings.

• Jul 6, 2010: Insertion Tree Phasers: Efficient and Scalable Barrier Synchronization for Fine-grained Parallelism

  The last half year was an interesting departure from my actual PhD research. First, I though the idea of barriers and phasers might be interesting to incorporate into a virtual machine as part of my thesis, but as it turned out, they are much to high-level and are better off implemented in a library. The gain for direct support in a VM is just not proportional to the effort and restrictions which come with that step.

• Jun 21, 2010: Trends in Concurrency 2010, part 3

  This is the last post about the TiC’10 summer school and covers the two remaining lectures. Mark Moir talked about concurrent data structures and transactional memory, and last but not least, Madan Musuvathi presented the work they did at Microsoft Research to improve the testing of concurrent applications.

• Jun 14, 2010: Trends in Concurrency 2010, part 2

  This post is a follow up on my first report on the TiC’10 summer school. It covers mainly the talks about X10 and formal aspects of concurrency.

• Jun 7, 2010: Trends in Concurrency 2010, part 1

  I already posted the presentation I gave at the summer school earlier. In the following posts, I will report a bit about the lectures of the summer school, similar to my posts about the TPLI summer school of last year.

• 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…

• Dec 17, 2009: This year at the MoVES event: Winning the Poster Award :)

  Spending the time on coming up with a nice poster eventually paid off. And here is the winner of this year’s MoVES poster award:

• Sep 20, 2009: Theory and Practice of Language Implementation, part 3

  The third and last part of the summer school started with Ondrej Lhotak talking about pointer analysis. David Bacon presented a basic introduction to garbage collection and detailed description of the real-time Metronome GC. The last lecturer for this summer school was Patrick Cousot, who gave a very basic and thus understandable introduction to abstract interpretation.

• Sep 5, 2009: How to use Pharo/Squeak from the Command-line

  Along the way to measure the performance of a Smalltalk implementation for commodity multi-core systems, I tried to use Pharo as a more convenient development platform. Well, and I failed in the first attempt…

• Sep 3, 2009: Traits Patch Updated, Backported, and Available on GitHub

  PHP 5.3 is already released for a while and starts to settle in.

• Aug 3, 2009: Theory and Practice of Language Implementation, part 2

  The second part of the summer school was a bit more applied and more in the direction of my own interests. Chandra Krintz talked about managed runtime environments. Yannis Smaragdakis introduced multi-threaded programming and transactional memory. Sumit Gulwani as the third lecturer taught us symbolic bounds computation.

• Jul 28, 2009: Theory and Practice of Language Implementation, part 1

  Thanks to the financial support of FWO and a grant by the summer school itself, I was able to go to Eugene, Oregon and learn about theory and practice of language implementation.

• Jan 18, 2009: New Traits Patch Ready for Testing

  Finally, I managed to complete the changes for the traits patch. Since, PHP 5.3 already entered the release cycle and it is not sure whether there will be a PHP 5.4 with new language features, the new patch is written for the PHP6 codebase.

• Oct 6, 2008: I am done, finally :)

  Yes! Finally! I am done with my Master’s Thesis.

• Aug 10, 2008: Software Variability: a Programmers’ Perspective

  One important part in research is the discussion with other people about your research topic, and well, the SVPP’08 was my first real research event and I really enjoyed it 🙂

• Apr 27, 2008: PHP Unconference 2008

  Heute, am zweiten Tag der Unconference hier in Hamburg, hab ich endlich ein wenig Zeit mir auch ein paar Vorträge an zu hören. Gestern musste ich unerwarteter Weise gleich zwei mal ran.

• Feb 18, 2008: Traits for PHP

  During the last six months I’ve studied a language construct called Traits. It is a construct enabling fine-grained code reuse beside single inheritance in classical object oriented languages. A first implementation of this concept has been around for Squeak. Since I’ve used PHP already for a quite long time now, I decided to dig into its internals and implement Traits for PHP, too.