## Research

### Projects

• Safely Combining Concurrency Abstractions (since 2012)
Concurrent programming is hard, and we make it harder by using abstractions that cannot be combined safely.
In this project, we search for safe and efficient combinations.
• Meta-Level Engineering and Tooling for Complex Concurrent Systems (since 2016)
In this project, we work on instrumentation and tooling for applications that combine concurrency abstractions.
Partners: Vrije Universiteit Brussel, Johannes Kepler University Linz

• Building Faster Languages Faster! (since 2013)
Writing custom VMs for DSLs or research languages is not practical.
So, how can we reuse JIT compilers for new languages?
• SOM: Simple Object Machine (maintainer since 2012)
A simple Smalltalk for teaching and experimenting with language implementation techniques. Implemented among others in Java, C, C++, Smalltalk, and Python.
Current high-lights:
• SOM++
SOM++ used by IBM to showcase Project OMR‘s GC and JIT compiler
• TruffleSOM
SOM implemented based on Oracle Lab’s Truffle and Graal platform.
• RTruffleSOM
SOM implemented with RPython, similar to TruffleSOM, showcasing the power of self-optimizing interpreters.

• OMOP: Supporting Concurrency Abstractions in Virtual Machines (2008-2013)
An Ownership-based Metaobject Protocol to support concurrent programming in multi-language VMs

• Project Renaissance: Harness Emergence (2009-2011)
Avoid the Concurrency Trap by Embracing Non-Determinism.
Partners: IBM Research, Portland State University, and Vrije Universiteit Brussel

### My Publications

#### 2016

• B. Daloze, S. Marr, D. Bonetta, and H. Mössenböck, "Efficient and Thread-Safe Objects for Dynamically-Typed Languages," in Proceedings of the 2016 ACM International Conference on Object Oriented Programming Systems Languages \& Applications, 2016, pp. 642-659.
@inproceedings{Daloze:2016:TSO, abstract = {We are in the multi-core era. Dynamically-typed languages are in widespread use, but their support for multithreading still lags behind. One of the reasons is that the sophisticated techniques they use to efficiently represent their dynamic object models are often unsafe in multithreaded environments. This paper defines safety requirements for dynamic object models in multithreaded environments. Based on these requirements, a language-agnostic and thread-safe object model is designed that maintains the efficiency of sequential approaches. This is achieved by ensuring that field reads do not require synchronization and field updates only need to synchronize on objects shared between threads. Basing our work on JRuby+Truffle, we show that our safe object model has zero overhead on peak performance for thread-local objects and only 3\% average overhead on parallel benchmarks where field updates require synchronization. Thus, it can be a foundation for safe and efficient multithreaded VMs for a wide range of dynamic languages.},   acceptancerate = {0.25},   author = {Daloze, Benoit and Marr, Stefan and Bonetta, Daniele and Mössenböck, Hanspeter},   booktitle = {Proceedings of the 2016 ACM International Conference on Object Oriented Programming Systems Languages \& Applications},   doi = {10.1145/2983990.2984001},   interhash = {e308e02d9e1ea4c4e8187c56cd3770e8},   intrahash = {62830f65bdc9a0a1046a41c0aee771e4},   isbn = {978-1-4503-4444-9},   note = {(acceptance rate 25%)},   numpages = {18},   pages = {642--659},   pdf = {http://stefan-marr.de/downloads/oopsla16-daloze-et-al-efficient-and-thread-safe-objects-for-dynamically-typed-languages.pdf},   publisher = {ACM},   series = {OOPSLA '16},   title = {{Efficient and Thread-Safe Objects for Dynamically-Typed Languages}},   year = 2016 }
• L. Salucci, D. Bonetta, S. Marr, and W. Binder, "Generic Messages: Capability-based Shared Memory Parallelism for Event-loop Systems," in Proceedings of the 21st ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, 2016, p. 40:1-40:2.
@inproceedings{Salucci:2016:GMC, abstract = {Systems based on event-loops have been popularized by Node.JS, and are becoming a key technology in the domain of cloud computing. Despite their popularity, such systems support only share-nothing parallelism via message passing between parallel entities usually called workers. In this paper, we introduce a novel parallel programming abstraction called Generic Messages (GEMs), which enables shared-memory parallelism for share-nothing event-based systems. A key characteristic of GEMs is that they enable workers to share state by specifying how the state can be accessed once it is shared. We call this aspect of the GEMs model capability-based parallelism.},   acmid = {2851184},   articleno = {40},   author = {Salucci, Luca and Bonetta, Daniele and Marr, Stefan and Binder, Walter},   booktitle = {Proceedings of the 21st ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming},   doi = {10.1145/2851141.2851184},   interhash = {edd3c26941aa2809420091a2380c438d},   intrahash = {4133a85dbb12c04c9a93137c3d7f5207},   isbn = {978-1-4503-4092-2},   location = {Barcelona, Spain},   numpages = {2},   pages = {40:1--40:2},   pdf = {http://stefan-marr.de/downloads/ppopp-salucci-et-al-generic-messages-capability-based-shared-memory-parallelism-for-event-loop-systems.pdf},   publisher = {ACM},   series = {PPoPP '16},   title = {{Generic Messages: Capability-based Shared Memory Parallelism for Event-loop Systems}},   year = 2016 }
• J. De Koster, S. Marr, T. Van Cutsem, and T. D’Hondt, "Domains: Sharing State in the Communicating Event-Loop Actor Model," Computer Languages, Systems & Structures, vol. 45, pp. 132-160, 2016.
@article{DeKoster2016, abstract = {The actor model is a message-passing concurrency model that avoids deadlocks and low-level data races by construction. This facilitates concurrent programming, especially in the context of complex interactive applications where modularity, security and fault-tolerance are required. The tradeoff is that the actor model sacrifices expressiveness and safety guarantees with respect to parallel access to shared state. In this paper we present domains as a set of novel language abstractions for safely encapsulating and sharing state within the actor model. We introduce four types of domains, namely immutable, isolated, observable and shared domains that each are tailored to a certain access pattern on that shared state. The domains are characterized with an operational semantics. For each we discuss how the actor model's safety guarantees are upheld even in the presence of conceptually shared state. Furthermore, the proposed language abstractions are evaluated with a case study in Scala comparing them to other synchonisation mechanisms to demonstrate their benefits in deadlock freedom, parallel reads, and enforced isolation. },   author = {De Koster, Joeri and Marr, Stefan and Van Cutsem, Tom and D'Hondt, Theo},   doi = {10.1016/j.cl.2016.01.003},   interhash = {3adbb692105fd701eebdc50807bb2c44},   intrahash = {3f42af6453ef131d10096ac04866c6c9},   issn = {1477-8424},   journal = {Computer Languages, Systems & Structures },   month = {April},   numpages = {39},   pages = {132-160},   pdf = {http://stefan-marr.de/downloads/comlan-de-koster-et-al-domains-sharing-state-in-the-communicating-event-loop-actor-model.pdf},   publisher = {Elsevier},   title = {Domains: Sharing State in the Communicating Event-Loop Actor Model},   volume = 45, year = 2016 }
• Torres Lopez, Carmen and Marr, Stefan and Mössenböck, Hanspeter and Gonzalez Boix, Elisa, Towards Advanced Debugging Support for Actor Languages: Studying Concurrency Bugs in Actor-based Programs, 2016.
@presentation{TorresLopez:2016:TAD, abstract = {With the ubiquity of multicore hardware, concurrent and parallel programming has become a fundamental part of software development. If writing concurrent programs is hard, debugging them is even harder. The actor model is attractive for developing concurrent applications because actors are isolated concurrent entities that communicates through asynchronous message sending and do not share state, thus they avoid common concurrency bugs such as race conditions. However, they are not immune to bugs. This paper presents initial work on a taxonomy of concurrent bugs for actor-based applications. Based on this study, we propose debugging tooling to assist the development process of actor-based applications.},   author = {Torres Lopez, Carmen and Marr, Stefan and Mössenböck, Hanspeter and Gonzalez Boix, Elisa},   booktitle = {Presentation at 6th International Workshop on Programming based on Actors, Agents, and Decentralized Control},   day = 30, interhash = {0c12f719358d2728a5c41b9d0b2c218a},   intrahash = {dc162dd8731b5e2779765fb4c50a737e},   month = {October},   numpages = {5},   pdf = {http://stefan-marr.de/downloads/agere16-torres-lopez-et-al-towards-advanced-debugging-support-for-actor-languages.pdf},   series = {AGERE! '16},   title = {{Towards Advanced Debugging Support for Actor Languages: Studying Concurrency Bugs in Actor-based Programs}},   year = 2016 }
• S. Marr, E. Gonzalez Boix, and H. Mössenböck, "Towards Meta-Level Engineering and Tooling for Complex Concurrent Systems," in Proceedings of the 9th Arbeitstagung Programmiersprachen, 2016, pp. 91-95.
@inproceedings{Marr:2016:MetaConc, abstract = {With the widespread use of multicore processors, software becomes more and more diverse in its use of parallel computing resources. To address all application requirements, each with the appropriate abstraction, developers mix and match various concurrency abstractions made available to them via libraries and frameworks. Unfortunately, today's tools such as debuggers and profilers do not support the diversity of these abstractions. Instead of enabling developers to reason about the high-level programming concepts, they used to express their programs, the tools work only on the library's implementation level. While this is a common problem also for other libraries and frameworks, the complexity of concurrency exacerbates the issue further, and reasoning on the higher levels of the concurrency abstractions is essential to manage the associated complexity. In this position paper, we identify open research issues and propose to build tools based on a common meta-level interface to enable developers to reasons about their programs based on the high-level concepts they used to implement them.},   author = {Marr, Stefan and Gonzalez Boix, Elisa and Mössenböck, Hanspeter},   booktitle = {Proceedings of the 9th Arbeitstagung Programmiersprachen},   day = 25, interhash = {b0599561ea7514193ff3fa9a93eec376},   intrahash = {5094e9d82c7c0313586b5618ef39d2c8},   issn = {1613-0073},   location = {Vienna, Austria},   month = {February},   pages = {91--95},   pdf = {http://stefan-marr.de/downloads/atps-marr-et-al-towards-meta-level-engineering-and-tooling-for-complex-concurrent-systems.pdf},   publisher = {CEUR-WS},   series = {ATPS'16},   title = {Towards Meta-Level Engineering and Tooling for Complex Concurrent Systems},   type = {Position Paper},   url = {http://stefan-marr.de/papers/atps-marr-et-al-towards-meta-level-engineering-and-tooling-for-complex-concurrent-systems/},   volume = 1559, year = 2016 }
• S. Marr, B. Daloze, and H. Mössenböck, "Cross-Language Compiler Benchmarking—Are We Fast Yet?," in Proceedings of the 12th Symposium on Dynamic Languages, 2016, pp. 120-131.
@inproceedings{Marr:2016:AWFY, abstract = {Comparing the performance of programming languages is difficult because they differ in many aspects including preferred programming abstractions, available frameworks, and their runtime systems. Nonetheless, the question about relative performance comes up repeatedly in the research community, industry, and wider audience of enthusiasts. This paper presents 14 benchmarks and a novel methodology to assess the compiler effectiveness across language implementations. Using a set of common language abstractions, the benchmarks are implemented in Java, JavaScript, Ruby, Crystal, Newspeak, and Smalltalk. We show that the benchmarks exhibit a wide range of characteristics using language-agnostic metrics. Using four different languages on top of the same compiler, we show that the benchmarks perform similarly and therefore allow for a comparison of compiler effectiveness across languages. Based on anecdotes, we argue that these benchmarks help language implementers to identify performance bugs and optimization potential by comparing to other language implementations.},   acceptancerate = {0.55},   author = {Marr, Stefan and Daloze, Benoit and Mössenböck, Hanspeter},   booktitle = {Proceedings of the 12th Symposium on Dynamic Languages},   doi = {10.1145/2989225.2989232},   interhash = {b19a3027d653a0a8a59199c0f576571c},   intrahash = {0177b6515342452e425fd81ffb06eae9},   isbn = {978-1-4503-4445-6},   location = {Amsterdam, Netherlands},   note = {(acceptance rate 55%)},   numpages = {12},   pages = {120--131},   pdf = {http://stefan-marr.de/downloads/dls16-marr-et-al-cross-language-compiler-benchmarking-are-we-fast-yet.pdf},   publisher = {ACM},   series = {DLS'16},   title = {{Cross-Language Compiler Benchmarking---Are We Fast Yet?}},   url = {http://stefan-marr.de/papers/dls-marr-et-al-cross-language-compiler-benchmarking-are-we-fast-yet/},   year = 2016 }
• D. Bonetta, L. Salucci, S. Marr, and W. Binder, "GEMs: Shared-memory Parallel Programming for Node.js," in Proceedings of the 2016 ACM International Conference on Object Oriented Programming Systems Languages \& Applications, 2016, pp. 531-547.
@inproceedings{Bonetta:2016:GEMs, abstract = {JavaScript is the most popular programming language for client-side Web applications, and Node.js has popularized the language for server-side computing, too. In this domain, the minimal support for parallel programming remains however a major limitation. In this paper we introduce a novel parallel programming abstraction called Generic Messages (GEMs). GEMs allow one to combine message passing and shared-memory parallelism, extending the classes of parallel applications that can be built with Node.js. GEMs have customizable semantics and enable several forms of thread safety, isolation, and concurrency control. GEMs are designed as convenient JavaScript abstractions that expose high-level and safe parallelism models to the developer. Experiments show that GEMs outperform equivalent Node.js applications thanks to their usage of shared memory.},   acceptancerate = {0.25},   author = {Bonetta, Daniele and Salucci, Luca and Marr, Stefan and Binder, Walter},   booktitle = {Proceedings of the 2016 ACM International Conference on Object Oriented Programming Systems Languages \& Applications},   doi = {10.1145/2983990.2984039},   interhash = {03ef98ec7bc5ec5346ad4e4daf7202f5},   intrahash = {ff7fca234fe287ef685c0a5d3713c39a},   isbn = {978-1-4503-4444-9},   location = {Amsterdam, Netherlands},   note = {(acceptance rate 25%)},   numpages = {18},   pages = {531--547},   pdf = {http://stefan-marr.de/downloads/oopsla16-bonetta-et-al-gems-shared-memory-parallel-programming-for-nodejs.pdf},   publisher = {ACM},   series = {OOPSLA '16},   title = {{GEMs: Shared-memory Parallel Programming for Node.js}},   year = 2016 }
• G. Chari, D. Garbervetsky, and S. Marr, "Building Efficient and Highly Run-time Adaptable Virtual Machines," in Proceedings of the 12th Symposium on Dynamic Languages, 2016, pp. 60-71.
@inproceedings{Chari:2016:Mate2, abstract = {Programming language virtual machines (VMs) realize language semantics, enforce security properties, and execute applications efficiently. Fully Reflective Execution Environments (EEs) are VMs that additionally expose their whole structure and behavior to applications. This enables developers to observe and adapt VMs at run time. However, there is a belief that reflective EEs are not viable for practical usages because such flexibility would incur a high performance overhead. To refute this belief, we built a reflective EE on top of a highly optimizing dynamic compiler. We introduced a new optimization model that, based on the conjecture that variability of low-level (EE-level) reflective behavior is low in many scenarios, mitigates the most significant sources of the performance overheads related to the reflective capabilities in the EE. Our experiments indicate that reflective EEs can reach peak performance in the order of standard VMs. Concretely, that a) if reflective mechanisms are not used the execution overhead is negligible compared to standard VMs, b) VM operations can be redefined at language-level without incurring in significant overheads, c) for several software adaptation tasks, applying the reflection at the VM level is not only lightweight in terms of engineering effort, but also competitive in terms of performance in comparison to other ad-hoc solutions.},   acceptancerate = {0.55},   author = {Chari, Guido and Garbervetsky, Diego and Marr, Stefan},   booktitle = {Proceedings of the 12th Symposium on Dynamic Languages},   doi = {10.1145/2989225.2989234},   interhash = {66c1f1202ee6785cfa6a4edbd6d0f27f},   intrahash = {957160cec332f01c43db90d9ff68ec56},   isbn = {978-1-4503-4445-6},   location = {Amsterdam, Netherlands},   note = {(acceptance rate 55%)},   numpages = {12},   pages = {60--71},   pdf = {http://stefan-marr.de/downloads/dls16-chari-et-al-building-efficient-and-highly-run-time-adaptable-virtual-machines.pdf},   publisher = {ACM},   series = {DLS'16},   title = {{Building Efficient and Highly Run-time Adaptable Virtual Machines}},   year = 2016 }
• Marr, Stefan and Jul, Eric, Proceedings of the 11th Workshop on Implementation, Compilation, Optimization of Object-Oriented Languages, Programs and Systems, ACM, 2016.
@proceedings{Marr:2016:ICOOOLPS,   author = {Marr, Stefan and Jul, Eric},   editor = {Marr, Stefan and Jul, Eric},   interhash = {9cbd12d12e78a58daab28f6ddeaa089f},   intrahash = {8c387980fd0fc424e060017fd0c1490a},   isbn = {978-1-4503-4837-9},   location = {Rome, Italy},   month = {July},   publisher = {ACM},   series = {ICOOOLPS '16},   title = {Proceedings of the 11th Workshop on Implementation, Compilation, Optimization of Object-Oriented Languages, Programs and Systems},   url = {http://dl.acm.org/citation.cfm?id=3012408},   year = 2016 }

#### 2015

• S. Marr, C. Seaton, and S. Ducasse, "Zero-Overhead Metaprogramming: Reflection and Metaobject Protocols Fast and without Compromises," in Proceedings of the 36th ACM SIGPLAN Conference on Programming Language Design and Implementation, 2015, pp. 545-554.
@inproceedings{ZeroOverhead, abstract = {Runtime metaprogramming enables many useful applications and is often a convenient solution to solve problems in a generic way, which makes it widely used in frameworks, middleware, and domain-specific languages. However, powerful metaobject protocols are rarely supported and even common concepts such as reflective method invocation or dynamic proxies are not optimized. Solutions proposed in literature either restrict the metaprogramming capabilities or require application or library developers to apply performance improving techniques. For overhead-free runtime metaprogramming, we demonstrate that dispatch chains, a generalized form of polymorphic inline caches common to self-optimizing interpreters, are a simple optimization at the language-implementation level. Our evaluation with self-optimizing interpreters shows that unrestricted metaobject protocols can be realized for the first time without runtime overhead, and that this optimization is applicable for just-in-time compilation of interpreters based on meta-tracing as well as partial evaluation. In this context, we also demonstrate that optimizing common reflective operations can lead to significant performance improvements for existing applications.},   author = {Marr, Stefan and Seaton, Chris and Ducasse, Stéphane},   booktitle = {Proceedings of the 36th ACM SIGPLAN Conference on Programming Language Design and Implementation},   doi = {10.1145/2737924.2737963},   interhash = {c212198ae76c6205f6cdbf31185dcc1c},   intrahash = {84be3e9de039beab1ddee5414f9bec3c},   isbn = {978-1-4503-3468-6},   note = {(acceptance rate 19%)},   numpages = {10},   pages = {545--554},   pdf = {http://stefan-marr.de/downloads/pldi15-marr-et-al-zero-overhead-metaprogramming.pdf},   publisher = {ACM},   series = {PLDI '15},   title = {Zero-Overhead Metaprogramming: Reflection and Metaobject Protocols Fast and without Compromises},   year = 2015 }
• M. De Wael, S. Marr, B. De Fraine, T. Van Cutsem, and W. De Meuter, "Partitioned Global Address Space Languages," ACM Computing Surveys, vol. 47, iss. 4, p. 62:1-62:27, 2015.
@article{PGASSurvey, abstract = {The Partitioned Global Address Space (PGAS) model is a parallel programming model that aims to improve programmer productivity while at the same time aiming for high performance. The main premise of PGAS is that a globally shared address space improves productivity, but that a distinction between local and remote data accesses is required to allow performance optimizations and to support scalability on large-scale parallel architectures. To this end, PGAS preserves the global address space while embracing awareness of non-uniform communication costs. Today, about a dozen languages exist that adhere to the PGAS model. This survey proposes a definition and a taxonomy along four axes: how parallelism is introduced, how the address space is partitioned, how data is distributed among the partitions and finally how data is accessed across partitions. Our taxonomy reveals that today's PGAS languages focus on distributing regular data and distinguish only between local and remote data access cost, whereas the distribution of irregular data and the adoption of richer data access cost models remain open challenges.},   articleno = {62},   author = {De Wael, Mattias and Marr, Stefan and De Fraine, Bruno and Van Cutsem, Tom and De Meuter, Wolfgang},   doi = {10.1145/2716320},   impactfactor2014 = {3.373},   impactfactor5y2014 = {5.949},   interhash = {e0e73b5f03d2594bbf77e7b648bac11e},   intrahash = {6f4cfd566380f590de88b6606e8f14b2},   issn = {0360-0300},   journal = {ACM Computing Surveys},   month = {June},   number = 4, numpages = {27},   pages = {62:1--62:27},   pdf = {http://stefan-marr.de/downloads/acm-csur-de-wael-et-al-partitioned-global-address-space-languages.pdf},   publisher = {ACM},   title = {Partitioned Global Address Space Languages},   url = {http://stefan-marr.de/papers/acm-csur-de-wael-et-al-partitioned-global-address-space-languages/},   volume = 47, year = 2015 }
• J. De Koster, S. Marr, T. D’Hondt, and T. Van Cutsem, "Domains: safe sharing among actors," Science of Computer Programming, vol. 98, Part 2, pp. 140-158, 2015.
@article{DeKoster2014, abstract = {The actor model is a concurrency model that avoids issues such as deadlocks and data races by construction, and thus facilitates concurrent programming. While it has mainly been used for expressing distributed computations, it is equally useful for modeling concurrent computations in a single shared memory machine. In component based software, the actor model lends itself to divide the components naturally over different actors and use message-passing concurrency for the interaction between these components. The tradeoff is that the actor model sacrifices expressiveness and efficiency with respect to parallel access to shared state. This paper gives an overview of the disadvantages of the actor model when trying to express shared state and then formulates an extension of the actor model to solve these issues. Our solution proposes domains and synchronization views to solve the issues without compromising on the semantic properties of the actor model. Thus, the resulting concurrency model maintains deadlock-freedom and avoids low-level data races.},   author = {De Koster, Joeri and Marr, Stefan and D'Hondt, Theo and Van Cutsem, Tom},   doi = {10.1016/j.scico.2014.02.008},   impactfactor2014 = {0.715},   impactfactor5year2014 = {0.837},   interhash = {50ad0d471e74b756b23455837579b53d},   intrahash = {a229fb5407e13cc4a9897df3a3b39ee8},   issn = {0167-6423},   journal = {Science of Computer Programming },   month = {February},   pages = {140--158},   pdf = {http://stefan-marr.de/downloads/scp14-de-koster-et-al-domains-safe-sharing-among-actors.pdf},   title = {Domains: safe sharing among actors },   volume = {98, Part 2},   year = 2015 }
• M. Vandercammen, J. Nicolay, S. Marr, J. De Koster, T. D’Hondt, and C. De Roover, "A Formal Foundation for Trace-Based JIT Compilers," in Proceedings of the 13th International Workshop on Dynamic Analysis, Pittsburgh, PA, USA, 2015, pp. 25-30.
@inproceedings{Vandercammen:15:WODA, abstract = {Trace-based JIT compilers identify frequently executed program paths at run-time and subsequently record, compile and optimize their execution. In order to improve the performance of the generated machine instructions, JIT compilers heavily rely on dynamic analysis of the code. Existing work treats the components of a JIT compiler as a monolithic whole, tied to particular execution semantics. We propose a formal framework that facilitates the design and implementation of a tracing JIT compiler and its accompanying dynamic analyses by decoupling the tracing, optimization, and interpretation processes. This results in a framework that is more configurable and extensible than existing formal tracing models. We formalize the tracer and interpreter as two abstract state machines that communicate through a minimal, well-defined interface. Developing a tracing JIT compiler becomes possible for arbitrary interpreters that implement this interface. The abstract machines also provide the necessary hooks to plug in custom analyses and optimizations.},   address = {Pittsburgh, PA, USA},   author = {Vandercammen, Maarten and Nicolay, Jens and Marr, Stefan and De Koster, Joeri and D'Hondt, Theo and De Roover, Coen},   booktitle = {Proceedings of the 13th International Workshop on Dynamic Analysis},   doi = {10.1145/2823363.2823369},   interhash = {28d42ec8ccafdeee3a41395c56db4eb8},   intrahash = {3184db3b6ac1ff499bdcb1b0d356e359},   month = {October},   numpages = {6},   pages = {25--30},   pdf = {stefan-marr.de/downloads/woda15-vandercammen-et-al-a-formal-foundation-for-trace-based-jit-compilers.pdf},   publisher = {ACM},   series = {WODA '15},   title = {A Formal Foundation for Trace-Based JIT Compilers},   year = 2015 }
• S. Marr and S. Ducasse, "Tracing vs. Partial Evaluation: Comparing Meta-Compilation Approaches for Self-Optimizing Interpreters," in Proceedings of the 2015 ACM International Conference on Object Oriented Programming Systems Languages \& Applications, 2015, pp. 821-839.
@inproceedings{Marr:2015:MTPE, abstract = {Tracing and partial evaluation have been proposed as meta-compilation techniques for interpreters to make just-in-time compilation language-independent. They promise that programs executing on simple interpreters can reach performance of the same order of magnitude as if they would be executed on state-of-the-art virtual machines with highly optimizing just-in-time compilers built for a specific language. Tracing and partial evaluation approach this meta-compilation from two ends of a spectrum, resulting in different sets of tradeoffs. This study investigates both approaches in the context of self-optimizing interpreters, a technique for building fast abstract-syntax-tree interpreters. Based on RPython for tracing and Truffle for partial evaluation, we assess the two approaches by comparing the impact of various optimizations on the performance of an interpreter for SOM, an object-oriented dynamically-typed language. The goal is to determine whether either approach yields clear performance or engineering benefits. We find that tracing and partial evaluation both reach roughly the same level of performance. SOM based on meta-tracing is on average 3x slower than Java, while SOM based on partial evaluation is on average 2.3x slower than Java. With respect to the engineering, tracing has however significant benefits, because it requires language implementers to apply fewer optimizations to reach the same level of performance.},   acceptancerate = {0.25},   acmid = {2660194},   author = {Marr, Stefan and Ducasse, Stéphane},   booktitle = {Proceedings of the 2015 ACM International Conference on Object Oriented Programming Systems Languages \& Applications},   doi = {10.1145/2660193.2660194},   interhash = {626a639666ea884d5b1a8dc121e8457a},   intrahash = {7ca631f0fc852e48f2285e1a8d4cdfa0},   isbn = {978-1-4503-2585-1},   note = {(acceptance rate 25%)},   numpages = {19},   pages = {821--839},   pdf = {http://stefan-marr.de/downloads/oopsla15-marr-ducasse-meta-tracing-vs-partial-evaluation.pdf},   publisher = {ACM},   series = {OOPSLA '15},   title = {Tracing vs. Partial Evaluation: Comparing Meta-Compilation Approaches for Self-Optimizing Interpreters},   url = {http://stefan-marr.de/papers/oopsla-marr-ducasse-meta-tracing-vs-partial-evaluation/},   year = 2015 }
• G. Chari, D. Garbervetsky, S. Marr, and S. Ducasse, "Towards Fully Reflective Environments," in Proceedings of the 2015 ACM International Symposium on New Ideas, New Paradigms, and Reflections on Programming \& Software, 2015, pp. 240-253.
@inproceedings{Chari:15:Mate, abstract = {Modern development environments promote live programming (LP) mechanisms because it enhances the development experience by providing instantaneous feed- back and interaction with live objects. LP is typically supported with advanced reflective techniques within dynamic languages. These languages run on top of Virtual Machines (VMs) that are built in a static manner so that most of their components are bound at compile time. As a consequence, VM developers are forced to work using the traditional edit-compile-run cycle, even when they are designing LP-supporting environments. In this paper we explore the idea of bringing LP techniques to the VM domain for improving their observability, evolution and adaptability at run-time. We define the notion of fully reflective execution environments (EEs), systems that provide reflection not only at the application level but also at the level of the VM. We characterize such systems, propose a design, and present Mate v1, a prototypical implementation. Based on our prototype, we analyze the feasibility and applicability of incorporating reflective capabilities into different parts of EEs. Furthermore, the evaluation demonstrates the opportunities such reflective capabilities provide for unanticipated dynamic adaptation scenarios, benefiting thus, a wider range of users.},   author = {Chari, Guido and Garbervetsky, Diego and Marr, Stefan and Ducasse, Stéphane},   booktitle = {Proceedings of the 2015 ACM International Symposium on New Ideas, New Paradigms, and Reflections on Programming \& Software},   doi = {10.1145/2814228.2814241},   interhash = {360e220beb08b9d61c893249074dd412},   intrahash = {57686db3a8a1b49c6f802d72ccd3f26b},   isbn = {978-1-4503-3688-8},   location = {Pittsburgh, PA, USA},   month = {October},   numpages = {14},   pages = {240--253},   pdf = {http://stefan-marr.de/downloads/onward15-chari-et-al-towards-fully-reflective-environments.pdf},   publisher = {ACM},   series = {Onward! '15},   title = {Towards Fully Reflective Environments},   year = 2015 }
• M. De Wael, S. Marr, J. De Koster, J. B. Sartor, and W. De Meuter, "Just-in-Time Data Structures," in Proceedings of the 2015 ACM International Symposium on New Ideas, New Paradigms, and Reflections on Programming \& Software, 2015, pp. 61-75.
@inproceedings{DeWael:15:JitData, abstract = {Today, software engineering practices focus on finding the single right data representation (i.e., data structure) for a program. The right data representation, however, might not exist: relying on a single representation of the data for the lifetime of the program can be suboptimal in terms of performance. We explore the idea of developing data structures for which changing the data representation is an intrinsic property. To this end we introduce Just-in-Time Data Structures, which enable representation changes at runtime, based on declarative input from a performance expert programmer. Just-in-Time Data Structures are an attempt to shift the focus from finding the right’’ data structure to finding the right sequence of data representations. We present JitDS-Java, an extension to the Java language, to develop Just-in-Time Data Structures. Further, we show two example programs that benefit from changing the representation at runtime.},   author = {De Wael, Mattias and Marr, Stefan and De Koster, Joeri and Sartor, Jennifer B. and De Meuter, Wolfgang},   booktitle = {Proceedings of the 2015 ACM International Symposium on New Ideas, New Paradigms, and Reflections on Programming \& Software},   doi = {10.1145/2814228.2814231},   interhash = {ca767ff263c76e39ba25305e658771f5},   intrahash = {889bbc4c57b61960cdfb2a93147bce23},   isbn = {978-1-4503-3688-8},   location = {Pittsburgh, PA, USA},   month = {October},   numpages = {15},   pages = {61--75},   pdf = {http://stefan-marr.de/downloads/onward15-de-wael-et-al-just-in-time-data-structures.pdf},   publisher = {ACM},   series = {Onward! '15},   title = {Just-in-Time Data Structures},   url = {http://soft.vub.ac.be/~madewael/jitds/},   year = 2015 }
• S. Marr, T. Renaux, L. Hoste, and W. De Meuter, "Parallel Gesture Recognition with Soft Real-Time Guarantees," Science of Computer Programming, vol. 98, Part 2, pp. 159-183, 2015.
@article{marr2014parallel, abstract = {Using imperative programming to process event streams, such as those generated by multi-touch devices and 3D cameras, has significant engineering drawbacks. Declarative approaches solve common problems but so far, they have not been able to scale on multicore systems while providing guaranteed response times. We propose PARTE, a parallel scalable complex event processing engine that allows for a declarative definition of event patterns and provides soft real-time guarantees for their recognition. The proposed approach extends the classical Rete algorithm and maps event matching onto a graph of actor nodes. Using a tiered event matching model, PARTE provides upper bounds on the detection latency by relying on a combination of non-blocking message passing between Rete nodes and safe memory management techniques. The performance evaluation shows the scalability of our approach on up to 64 cores. Moreover, it indicates that PARTE's design choices lead to more predictable performance compared to a PARTE variant without soft real-time guarantees. Finally, the evaluation indicates further that gesture recognition can benefit from the exposed parallelism with superlinear speedups.},   author = {Marr, Stefan and Renaux, Thierry and Hoste, Lode and De Meuter, Wolfgang},   doi = {10.1016/j.scico.2014.02.012},   impactfactor2014 = {0.715},   impactfactor5year2014 = {0.837},   interhash = {e427ac910ad10a3b4f055fe6eee0822e},   intrahash = {2d7459399733edbfdc8c1ff5ba8c1e3b},   issn = {0167-6423},   journal = {Science of Computer Programming},   pages = {159--183},   pdf = {http://stefan-marr.de/downloads/scp14-marr-et-al-parallel-gesture-recognition-with-soft-real-time-guarantees.pdf},   title = {Parallel Gesture Recognition with Soft Real-Time Guarantees},   url = {http://stefan-marr.de/downloads/scp14-marr-et-al-parallel-gesture-recognition-with-soft-real-time-guarantees.pdf},   volume = {98, Part 2},   year = 2015 }
• Marr, Stefan and Mössenböck, Hanspeter, Optimizing Communicating Event-Loop Languages with Truffle, 2015.
@presentation{OptCELWithTruffle, abstract = {Communicating Event-Loop Languages similar to E and AmbientTalk are recently gaining more traction as a subset of actor languages. With the rise of JavaScript, E’s notion of vats and non-blocking communication based on promises entered the mainstream. For implementations, the combination of dynamic typing, asynchronous message sending, and promise resolution pose new optimization challenges. This paper discusses these challenges and presents initial experiments for a Newspeak implementation based on the Truffle framework. Our implementation is on average 1.65x slower than Java on a set of 14 benchmarks. Initial optimizations improve the performance of asynchronous messages and reduce the cost of encapsulation on microbenchmarks by about 2x. Parallel actor benchmarks further show that the system scales based on the workload characteristics. Thus, we conclude that Truffle is a promising platform also for communicating event-loop languages.},   author = {Marr, Stefan and Mössenböck, Hanspeter},   booktitle = {Presentation at 5th International Workshop on Programming based on Actors, Agents, and Decentralized Control},   day = 26, interhash = {0a0937a8e45344c88cbe6fb1ad8c42fa},   intrahash = {9f9881cc5d059f4916d4805e780b5e00},   location = {Pittsburgh, PA, USA},   month = {October},   pdf = {http://stefan-marr.de/downloads/agere15-agere-marr-moessenboeck-optimizing-communicating-event-loop-languages-with-truffle.pdf},   series = {AGERE '15},   title = {Optimizing Communicating Event-Loop Languages with Truffle},   type = {Work-in-Progress-Paper},   url = {http://stefan-marr.de/papers/agere-marr-moessenboeck-optimizing-communicating-event-loop-languages-with-truffle/},   year = 2015 }

#### 2014

• M. De Wael, S. Marr, and W. De Meuter, "Data Interface + Algorithms = Efficient Programs: Separating Logic from Representation to Improve Performance," in Proceedings of the 9th Workshop on Implementation, Compilation, Optimization of Object-Oriented Languages, Programs and Systems, 2014, p. 2:1-2:4.
@inproceedings{dewael2014interface, abstract = {Finding the right algorithm–data structure combination is easy, but finding the right data structure for a set of algorithms is much less trivial. Moreover, using the same data representation throughout the whole program might be sub-optimal. Depending on several factors, often only known at runtime, some programs benefit from changing the data representation during execution. In this position paper we introduce the idea of Just-In-Time data structures, a combination of a data interface and a set of concrete data representations with different performance characteristics. These Just-In- Time data structures can dynamically swap their internal data representation when the cost of swapping is payed back many times in the remainder of the computation. To make Just-In-Time data structures work, research is needed at three fronts: 1. We need to better understand the synergy between different data representations and algorithms; 2. We need a structured approach to handle the transitions between data representations; 3. We need descriptive programming constructs to express which representation fits a program fragment best. Combined, this research will result in a structured programming approach where separating data interface from data representation, not only improves understandability and maintainability, but also improves performance through automated transitions of data representation.},   articleno = {2},   author = {De Wael, Mattias and Marr, Stefan and De Meuter, Wolfgang},   booktitle = {Proceedings of the 9th Workshop on Implementation, Compilation, Optimization of Object-Oriented Languages, Programs and Systems},   doi = {10.1145/2633301.2633303},   interhash = {84cfdcd7e08274f05427bc73fb4f3691},   intrahash = {bdb4aed31f7a97673e7711808b73064c},   isbn = {978-1-4503-2914-9},   location = {Uppsala, Sweden},   month = {July},   numpages = {4},   pages = {2:1--2:4},   series = {ICOOOLPS},   title = {Data Interface + Algorithms = Efficient Programs: Separating Logic from Representation to Improve Performance},   year = 2014 }
• M. De Wael, S. Marr, and T. Van Cutsem, "Fork/Join Parallelism in the Wild: Documenting Patterns and Anti-Patterns in Java Programs using the Fork/Join Framework," in Proceedings of the 2014 International Conference on Principles and Practices of Programming on the Java Platform: Virtual Machines, Languages, and Tools, 2014, pp. 39-50.
@inproceedings{dewael2014forkjoin, abstract = {Now that multicore processors are commonplace, developing parallel software has escaped the confines of high-performance computing and enters the mainstream. The Fork/Join framework, for instance, is part of the standard Java platform since version 7. Fork/Join is a high-level parallel programming model advocated to make parallelizing recursive divide-and-conquer algorithms particularly easy. While, in theory, Fork/Join is a simple and effective technique to expose parallelism in applications, it has not been investigated before whether and how the technique is applied in practice. We therefore performed an empirical study on a corpus of 120 open source Java projects that use the framework for roughly 362 different tasks. On the one hand, we confirm the frequent use of four best-practice patterns (Sequential Cutoff, Linked Subtasks, Leaf Tasks, and avoiding unnecessary forking) in actual projects. On the other hand, we also discovered three recurring anti-patterns that potentially limit parallel performance: sub-optimal use of Java collections when splitting tasks into subtasks as well as when merging the results of subtasks, and finally the inappropriate sharing of resources between tasks. We document these anti-patterns and study their impact on performance.},   acceptancerate = {0.39},   author = {De Wael, Mattias and Marr, Stefan and Van Cutsem, Tom},   booktitle = {Proceedings of the 2014 International Conference on Principles and Practices of Programming on the Java Platform: Virtual Machines, Languages, and Tools},   doi = {10.1145/2647508.2647511},   interhash = {6a67e3d8a05209a4aa4bc3b18dd49699},   intrahash = {2f24495a3090c2527290e57d045313a0},   isbn = {978-1-4503-2926-2},   month = {September},   note = {(acceptance rate 39%)},   numpages = {12},   pages = {39--50},   pdf = {http://stefan-marr.de/downloads/pppj14-dewael-et-al-forkjoin-parallelism-in-the-wild.pdf},   series = {PPPJ '14},   title = {Fork/Join Parallelism in the Wild: Documenting Patterns and Anti-Patterns in Java Programs using the Fork/Join Framework},   url = {http://stefan-marr.de/downloads/pppj14-dewael-et-al-forkjoin-parallelism-in-the-wild.pdf},   year = 2014 }
• S. Marr, T. Pape, and W. De Meuter, "Are We There Yet? Simple Language Implementation Techniques for the 21st Century," IEEE Software, vol. 31, iss. 5, pp. 60-67, 2014.
@article{marr2014there, abstract = {Research on language implementation techniques has regained importance with the rise of domain-specific languages (DSLs). Although DSLs can help manage a domain’s complexity, building highly optimizing compilers or virtual machines is rarely affordable. So, performance remains an issue. Ideally, you would implement a simple interpreter and still be able to achieve acceptable performance. RPython and Truffle are implementation techniques based on simple interpreters; they promise to perform at the same order of magnitude as highly optimizing virtual machines. This case study compares the two techniques to identify their similarities, weaknesses, and areas for further research.},   author = {Marr, Stefan and Pape, Tobias and De Meuter, Wolfgang},   day = 15, doi = {10.1109/MS.2014.98},   impactfactor2014 = {1.053},   impactfactor5y2014 = {1.397},   interhash = {cf1741034f10e8abf2bfe2a9e30ebbc5},   intrahash = {c5e0f03749a6e4b18d92461f5a015821},   issn = {0740-7459},   journal = {IEEE Software},   month = {September},   number = 5, numpages = {8},   pages = {60--67},   pdf = {http://stefan-marr.de/downloads/ieee-soft-marr-et-al-are-we-there-yet.pdf},   title = {Are We There Yet? Simple Language Implementation Techniques for the 21st Century},   url = {http://stefan-marr.de/papers/ieee-soft-marr-et-al-are-we-there-yet/},   volume = 31, year = 2014 }
• J. Swalens, S. Marr, J. De Koster, and T. Van Cutsem, "Towards Composable Concurrency Abstractions," in Proceedings of the Workshop on Programming Language Approaches to Concurrency and communication-cEntric Software (PLACES), 2014, pp. 54-60.
@inproceedings{swalens2014towards, abstract = {In the past decades, many different programming models for managing concurrency in applications have been proposed, such as the actor model, Communicating Sequential Processes, and Software Transactional Memory. The ubiquity of multi-core processors has made harnessing concurrency even more important. We observe that modern languages, such as Scala, Clojure, or F\#, provide not one, but \emph{multiple} concurrency models that help developers manage concurrency. Large end-user applications are rarely built using just a single concurrency model. Programmers need to manage a responsive UI, deal with file or network I/O, asynchronous workflows, and shared resources. Different concurrency models facilitate different requirements. This raises the issue of how these concurrency models interact, and whether they are \emph{composable}. After all, combining different concurrency models may lead to subtle bugs or inconsistencies. In this paper, we perform an in-depth study of the concurrency abstractions provided by the Clojure language. We study all pairwise combinations of the abstractions, noting which ones compose without issues, and which do not. We make an attempt to abstract from the specifics of Clojure, identifying the general properties of concurrency models that facilitate or hinder composition.},   author = {Swalens, Janwillem and Marr, Stefan and De Koster, Joeri and Van Cutsem, Tom},   booktitle = {Proceedings of the Workshop on Programming Language Approaches to Concurrency and communication-cEntric Software (PLACES)},   doi = {10.4204/EPTCS.155.8},   interhash = {2f7580427b696dba54a55639ea954133},   intrahash = {8858476277e853211d32fca6e2abfe2e},   journal = {EPTCS},   month = {April},   pages = {54--60},   pdf = {http://arxiv.org/pdf/1406.3485},   series = {PLACES '14},   title = {Towards Composable Concurrency Abstractions},   url = {http://arxiv.org/abs/1406.3485},   volume = 155, year = 2014 }

#### 2013

• S. Marr, "Supporting Concurrency Abstractions in High-level Language Virtual Machines," PhD Thesis , Pleinlaan 2, B-1050 Brussels, Belgium, 2013.
@phdthesis{marr2013phd, abstract = {During the past decade, software developers widely adopted JVM and CLI as multi-language virtual machines (VMs). At the same time, the multicore revolution burdened developers with increasing complexity. Language implementers devised a wide range of concurrent and parallel programming concepts to address this complexity but struggle to build these concepts on top of common multi-language VMs. Missing support in these VMs leads to tradeoffs between implementation simplicity, correctly implemented language semantics, and performance guarantees. Departing from the traditional distinction between concurrency and parallelism, this dissertation finds that parallel programming concepts benefit from performance-related VM support, while concurrent programming concepts benefit from VM support that guarantees correct semantics in the presence of reflection, mutable state, and interaction with other languages and libraries. Focusing on these concurrent programming concepts, this dissertation finds that a VM needs to provide mechanisms for managed state, managed execution, ownership, and controlled enforcement. Based on these requirements, this dissertation proposes an ownership-based metaobject protocol (OMOP) to build novel multi-language VMs with proper concurrent programming support. This dissertation demonstrates the OMOP's benefits by building concurrent programming concepts such as agents, software transactional memory, actors, active objects, and communicating sequential processes on top of the OMOP. The performance evaluation shows that OMOP-based implementations of concurrent programming concepts can reach performance on par with that of their conventionally implemented counterparts if the OMOP is supported by the VM. To conclude, the OMOP proposed in this dissertation provides a unifying and minimal substrate to support concurrent programming on top of multi-language VMs. The OMOP enables language implementers to correctly implement language semantics, while simultaneously enabling VMs to provide efficient implementations.},   address = {Pleinlaan 2, B-1050 Brussels, Belgium},   author = {Marr, Stefan},   interhash = {2a637e553d371aa60c7da444baefb1d1},   intrahash = {3ffcd10c078075ce8acfd048c6ebb397},   isbn = {978-90-5718-256-3},   month = {January},   pdf = {http://www.stefan-marr.de/downloads/marr-phd-2013-supporting-concurrency-abstractions-in-high-level-language-virtual-machines.pdf},   publisher = {VUBPress},   school = {Software Languages Lab, Vrije Universiteit Brussel},   title = {Supporting Concurrency Abstractions in High-level Language Virtual Machines},   url = {http://www.stefan-marr.de/2013/01/supporting-concurrency-abstractions-in-high-level-language-virtual-machines/},   year = 2013 }
• J. De Koster, S. Marr, T. D’Hondt, and T. Van Cutsem, "Tanks: Multiple reader, single writer actors," in Proceedings of AGERE! 2013, 3rd International Workshop on Programming based on Actors, Agents, and Decentralized Control, 2013, pp. 61-68.
@inproceedings{dekoster2013tanks, abstract = {In the past, the Actor Model has mainly been explored in a distributed context. However, more and more application developers are also starting to use it to program shared-memory multicore machines because of the safety guarantees it provides. It avoids issues such as deadlocks and race conditions by construction, and thus facilitates concurrent programming. The tradeoff is that the Actor Model sacrifices expressiveness with respect to accessing shared state because actors are fully isolated from each other (a.k.a. "shared-nothing parallelism"). There is a need for more high level synchronization mechanisms that integrate with the actor model without sacrificing the safety and liveness guarantees it provides. This paper introduces a variation on the communicating event-loops actor model called the Tank model. A tank is an actor that can expose part of its state as a shared read-only resource. The model ensures that any other actor will always observe a consistent version of that state, even in the face of concurrent updates of the actor that owns that state.},   author = {De Koster, Joeri and Marr, Stefan and D'Hondt, Theo and Van Cutsem, Tom},   booktitle = {Proceedings of AGERE! 2013, 3rd International Workshop on Programming based on Actors, Agents, and Decentralized Control},   interhash = {c1db1b07f46be7b49019a847b90ae145},   intrahash = {7263458a77c11ab88ae282ab71fc7327},   isbn = {978-1-4503-2602-5},   location = {Indianapolis, Indiana, USA},   numpages = {8},   pages = {61--68},   pdf = {http://stefan-marr.de/downloads/agere13-de-koster-et-al-tanks-multiple-reader-single-writer-actors.pdf},   title = {Tanks: Multiple reader, single writer actors},   url = {http://soft.vub.ac.be/~smarr/downloads/agere13-de-koster-et-al-tanks-multiple-reader-single-writer-actors.pdf},   year = 2013 }
• J. Swalens, T. Renaux, L. Hoste, S. Marr, and W. De Meuter, "Cloud PARTE: Elastic Complex Event Processing based on Mobile Actors," in Proceedings of AGERE! 2013, 3rd International Workshop on Programming based on Actors, Agents, and Decentralized Control, 2013, pp. 3-12.
@inproceedings{Swalens2013cloud, abstract = {Traffic monitoring or crowd management systems produce large amounts of data in the form of events that need to be processed to detect relevant incidents. Rule-based pattern recognition is a promising approach for these applications, however, increasing amounts of data as well as large and complex rule sets demand for more and more processing power and memory. In order to scale such applications, a rule-based pattern detection system needs to be distributable over multiple machines. Today's approaches are however focused on static distribution of rules or do not support reasoning over the full set of events. We propose Cloud PARTE, a complex event detection system that implements the Rete algorithm on top of mobile actors. These actors can migrate between machines to respond to changes in the work load distribution. Cloud PARTE is an extension of PARTE and offers the first rule engine specifically tailored for continuous complex event detection that is able to benefit from elastic systems as provided by cloud computing platforms. It supports fully automatic load balancing and supports online rules with access to the entire event pool.},   author = {Swalens, Janwillem and Renaux, Thierry and Hoste, Lode and Marr, Stefan and De Meuter, Wolfgang},   booktitle = {Proceedings of AGERE! 2013, 3rd International Workshop on Programming based on Actors, Agents, and Decentralized Control},   interhash = {7fc89cd94011a7d61fece752a317db98},   intrahash = {3f1a2b2371c1e151b759ce43b0005e69},   month = {October},   pages = {3--12},   pdf = {http://soft.vub.ac.be/~smarr/downloads/agere13-swalens-et-al-cloud-parte-elastic-complex-event-processing-based-on-mobile-actors.pdf},   publisher = {ACM},   series = {AGERE! '13},   title = {Cloud PARTE: Elastic Complex Event Processing based on Mobile Actors},   url = {http://soft.vub.ac.be/~smarr/downloads/agere13-swalens-et-al-cloud-parte-elastic-complex-event-processing-based-on-mobile-actors.pdf},   year = 2013 }

#### 2012

• S. Marr, J. Nicolay, T. Van Cutsem, and T. D’Hondt, "Modularity and Conventions for Maintainable Concurrent Language Implementations: A Review of Our Experiences and Practices," in Proceedings of the 2nd Workshop on Modularity In Systems Software (MISS’2012), 2012, pp. 21-26.
@inproceedings{MISS2012, abstract = {In this paper, we review what we have learned from implementing languages for parallel and concurrent programming, and investigate the role of modularity. To identify the approaches used to facilitate correctness and maintainability, we ask the following questions: What guides modularization? Are informal approaches used to facilitate correctness? Are concurrency concerns modularized? And, where is language support lacking most? Our subjects are AmbientTalk, SLIP, and the RoarVM. All three evolved over the years, enabling us to look back at specific experiments to understand the impact of concurrency on modularity. We conclude from our review that concurrency concerns are one of the strongest drivers for the definition of module boundaries. It helps when languages offer sophisticated modularization constructs. However, with respect to concurrency, other language features like single-assignment are of greater importance. Furthermore, tooling that enables remodularization taking concurrency invariants into account would be of great value.},   acmid = {2162031},   author = {Marr, Stefan and Nicolay, Jens and Van Cutsem, Tom and D'Hondt, Theo},   booktitle = {Proceedings of the 2nd Workshop on Modularity In Systems Software (MISS'2012)},   doi = {10.1145/2162024.2162031},   interhash = {f6aa985b183f15b014127ac282ce73d5},   intrahash = {442f0063842536e3628d10a4244620b6},   isbn = {978-1-4503-1217-2},   location = {Potsdam, Germany},   month = {March},   numpages = {6},   pages = {21--26},   pdf = {http://www.stefan-marr.de/downloads/miss12-smarr-et-al-modularity-and-conventions-for-maintainable-concurrent-language-implementations.pdf},   publisher = {ACM},   series = {MISS'12},   title = {Modularity and Conventions for Maintainable Concurrent Language Implementations: A Review of Our Experiences and Practices},   url = {http://www.stefan-marr.de/2012/01/modularity-and-conventions-for-maintainable-concurrent-language-implementations-a-review-of-our-experiences-and-practices/},   year = 2012 }
• J. De Koster, S. Marr, and T. D’Hondt, "Synchronization Views for Event-loop Actors," in Proceedings of the 17th ACM SIGPLAN symposium on Principles and Practice of Parallel Programming, New York, NY, USA, 2012, pp. 317-318.
@inproceedings{SyncViewsPoster, abstract = {The actor model has already proven itself as an interesting concurrency model that avoids issues such as deadlocks and race conditions by construction, and thus facilitates concurrent programming. The tradeoff is that it sacrifices expressiveness and efficiency especially with respect to data parallelism. However, many standard solutions to computationally expensive problems employ data parallel algorithms for better performance on parallel systems. We identified three problems that inhibit the use of data-parallel algorithms within the actor model. Firstly, one of the main properties of the actor model, the fact that no data is shared, is one of the most severe performance bottlenecks. Especially the fact that shared state can not be read truly in parallel. Secondly, the actor model on its own does not provide a mechanism to specify extra synchronization conditions on batches of messages which leads to event-level data-races. And lastly, programmers are forced to write code in a continuation-passing style (CPS) to handle typical request-response situations. However, CPS breaks the sequential flow of the code and is often hard to understand, which increases complexity and lowers maintainability. We proposes \emph{synchronization views} to solve these three issues without compromising the semantic properties of the actor model. Thus, the resulting concurrency model maintains deadlock-freedom, avoids low-level race conditions, and keeps the semantics of macro-step execution.},   address = {New York, NY, USA},   author = {De Koster, Joeri and Marr, Stefan and D'Hondt, Theo},   booktitle = {Proceedings of the 17th ACM SIGPLAN symposium on Principles and Practice of Parallel Programming},   doi = {10.1145/2145816.2145873},   interhash = {e727f9c6a21c1e3b6370fbf9db8b7e35},   intrahash = {22ee75102212d0b030d513d742e45fdc},   month = {February},   note = {(Poster)},   pages = {317--318},   pdf = {http://soft.vub.ac.be/~smarr/downloads/ppopp12-dekoster-synchronization-views-for-event-loop-actors.pdf},   publisher = {ACM},   series = {PPoPP '12},   title = {Synchronization Views for Event-loop Actors},   url = {http://www.stefan-marr.de/2011/12/synchronization-views-for-event-loop-actors/},   year = 2012 }
• S. Marr and T. D’Hondt, "Identifying A Unifying Mechanism for the Implementation of Concurrency Abstractions on Multi-Language Virtual Machines," in Objects, Models, Components, Patterns, 50th International Conference, TOOLS 2012, Berlin / Heidelberg, 2012, pp. 171-186.
@inproceedings{MOP_TOOLS, abstract = {Supporting all known abstractions for concurrent and parallel programming in a virtual machines (VM) is a futile undertaking, but it is required to give programmers appropriate tools and performance. Instead of supporting all abstractions directly, VMs need a unifying mechanism similar to \texttt{INVOKEDYNAMIC} for JVMs. Our survey of parallel and concurrent programming concepts identifies concurrency abstractions as the ones benefiting most from support in a VM. Currently, their semantics is often weakened, reducing their engineering benefits. They require a mechanism to define flexible language guarantees. Based on this survey, we define an ownership-based meta-object protocol as candidate for VM support. We demonstrate its expressiveness by implementing actor semantics, software transactional memory, agents, CSP, and active objects. While the performance of our prototype confirms the need for VM support, it also shows that the chosen mechanism is appropriate to express a wide range of concurrency abstractions in a unified way.},   acceptancerate = {0.31},   address = {Berlin / Heidelberg},   author = {Marr, Stefan and D'Hondt, Theo},   booktitle = {Objects, Models, Components, Patterns, 50th International Conference, TOOLS 2012},   doi = {10.1007/978-3-642-30561-0_13},   interhash = {e95335bd7d37bc29f2bb45e9ad362572},   intrahash = {534230490269cbc736c0c6c510686b3b},   isbn = {978-3-642-30560-3},   month = may, note = {(acceptance rate 31%)},   pages = {171-186},   pdf = {http://www.stefan-marr.de/downloads/tools12-smarr-dhondt-identifying-a-unifying-mechanism-for-the-implementation-of-concurrency-abstractions-on-multi-language-virtual-machines.pdf},   publisher = {Springer},   series = {Lecture Notes in Computer Science},   title = {Identifying A Unifying Mechanism for the Implementation of Concurrency Abstractions on Multi-Language Virtual Machines},   url = {http://www.stefan-marr.de/2012/03/identifying-a-unifying-mechanism-for-the-implementation-of-concurrency-abstractions-on-multi-language-virtual-machines/},   volume = 7304, year = 2012 }
• T. Renaux, L. Hoste, S. Marr, and W. De Meuter, "Parallel Gesture Recognition with Soft Real-Time Guarantees," in Proceedings of the 2nd edition on Programming Systems, Languages and Applications based on Actors, Agents, and Decentralized Control Abstractions, 2012, pp. 35-46.
@inproceedings{renaux2012parte, abstract = {Applying imperative programming techniques to process event streams, like those generated by multi-touch devices and 3D cameras, has significant engineering drawbacks. Declarative approaches solve these problems but have not been able to scale on multicore systems while providing guaranteed response times.

We propose PARTE, a parallel scalable complex event processing engine which allows a declarative definition of event patterns and provides soft real-time guarantees for their recognition. It extends the state-saving Rete algorithm and maps the event matching onto a graph of actor nodes. Using a tiered event matching model, PARTEprovides upper bounds on the detection latency. Based on the domain-specific constraints, PARTE's design relies on a combination of 1) lock-free data structures; 2) safe memory management techniques; and 3) message passing between Rete nodes. In our benchmarks, we measured scalability up to 8 cores, outperforming highly optimized sequential implementations.},   acmid = {2414646},   author = {Renaux, Thierry and Hoste, Lode and Marr, Stefan and De Meuter, Wolfgang},   booktitle = {Proceedings of the 2nd edition on Programming Systems, Languages and Applications based on Actors, Agents, and Decentralized Control Abstractions},   doi = {10.1145/2414639.2414646},   interhash = {97c79f5ee7d0e355dcb0ebb862fd5bd5},   intrahash = {c1c4eb8dd3e5c14161c2fe9bab8a865b},   isbn = {978-1-4503-1630-9},   location = {Tucson, Arizona, USA},   month = {October},   numpages = {12},   pages = {35--46},   pdf = {http://www.stefan-marr.de/downloads/agere12-parallel-gesture-recognition-with-soft-real-time-guarantees.pdf},   series = {SPLASH '12 Workshops},   title = {Parallel Gesture Recognition with Soft Real-Time Guarantees},   url = {http://www.stefan-marr.de/2013/01/parallel-gesture-recognition-with-soft-real-time-guarantees/},   year = 2012 }

#### 2011

• S. Marr, M. De Wael, M. Haupt, and T. D’Hondt, "Which Problems Does a Multi-Language Virtual Machine Need to Solve in the Multicore/Manycore Era?," in Proceedings of the 5th Workshop on Virtual Machines and Intermediate Languages, 2011, pp. 341-348.
@inproceedings{VMIL11, abstract = {While parallel programming for very regular problems has been used in the scientific community by non-computer-scientists successfully for a few decades now, concurrent programming and solving irregular problems remains hard. Furthermore, we shift from few expert system programmers mastering concurrency for a constrained set of problems to mainstream application developers being required to master concurrency for a wide variety of problems. Consequently, high-level language virtual machine (VM) research faces interesting questions. What are processor design changes that have an impact on the abstractions provided by VMs to provide platform independence? How can application programmers' diverse needs be facilitated to solve concurrent programming problems? We argue that VMs will need to be ready for a wide range of different concurrency models that allow solving concurrency problems with appropriate abstractions. Furthermore, they need to abstract from heterogeneous processor architectures, varying performance characteristics, need to account for memory access cost and inter-core communication mechanisms but should only expose the minimal useful set of notions like locality, explicit communication, and adaptable scheduling to maintain their abstracting nature. Eventually, language designers need to be enabled to guarantee properties like encapsulation, scheduling guarantees, and immutability also when an interaction between different problem-specific concurrency abstractions is required.},   acmid = {2095104},   author = {Marr, Stefan and De Wael, Mattias and Haupt, Michael and D'Hondt, Theo},   booktitle = {Proceedings of the 5th Workshop on Virtual Machines and Intermediate Languages},   doi = {10.1145/2095050.2095104},   interhash = {a4cd5f8252cc120bc766688434d535fa},   intrahash = {f67c508d81780a9a7e987cb4f5bdaeda},   isbn = {978-1-4503-1183-0},   location = {Portland, Oregon, USA},   month = {October},   numpages = {8},   pages = {341--348},   pdf = {http://www.stefan-marr.de/downloads/vmil11-smarr-et-al-which-problems-does-a-multi-language-virtual-machine-need-to-solve-in-the-multicore-manycore-era.pdf},   publisher = {ACM},   series = {VMIL '11},   title = {Which Problems Does a Multi-Language Virtual Machine Need to Solve in the Multicore/Manycore Era?},   url = {http://www.stefan-marr.de/2011/09/which-problems-does-a-multi-language-virtual-machine-need-to-solve-in-the-multicoremanycore-era/},   year = 2011 }
• M. Haupt, S. Marr, and R. Hirschfeld, "CSOM/PL: A Virtual Machine Product Line*," Hasso Plattner Institute, Am Neuen Palais 10, 14469 Potsdam, 48, 2011.
@techreport{CSOMPL_TR, abstract = {CSOM/PL is a software product line (SPL) derived from applying multi-dimensional separation of concerns (MDSOC) techniques to the domain of high-level language virtual machine (VM) implementations. For CSOM/PL, we modularised CSOM, a Smalltalk VM implemented in C, using VMADL (virtual machine architecture description language). Several features of the original CSOM were encapsulated in VMADL modules and composed in various combinations. In an evaluation of our approach, we show that applying MDSOC and SPL principles to a domain as complex as that of VMs is not only feasible but beneﬁcial, as it improves understandability, maintainability, and conﬁgurability of VM implementations without harming performance.},   address = {Am Neuen Palais 10, 14469 Potsdam},   author = {Haupt, Michael and Marr, Stefan and Hirschfeld, Robert},   day = 18, institution = {Hasso Plattner Institute },   interhash = {b739ed923a0c65e0a687575c5ae724b3},   intrahash = {6ce830821a88a512aa679299a493dc8d},   month = {April},   number = 48, pages = 26, publisher = {Universitätsverlag Potsdam},   title = {CSOM/PL: A Virtual Machine Product Line*},   url = {http://www.amazon.de/CSOM-PL-virtual-machine-product/dp/3869561343},   year = 2011 }
• Marr, Stefan and Ungar, David and D’Hondt, Theo, Evolving A Virtual Machine to Execute Applications Fully in Parallel: Approaching the Multi- and Manycore Challenge with a Simplified Design, 2011.
@unpublished{marr2011evolving,   author = {Marr, Stefan and Ungar, David and D'Hondt, Theo},   interhash = {959d45151e16ba1939e8e5ef03dca641},   intrahash = {11636c2dbca224016e63efe65e8c6cfc},   month = may, note = {(unpublished)},   title = {Evolving A Virtual Machine to Execute Applications Fully in Parallel: Approaching the Multi- and Manycore Challenge with a Simplified Design},   year = 2011 }
• M. Haupt, S. Marr, and R. Hirschfeld, "CSOM/PL: A Virtual Machine Product Line," Journal of Object Technology, vol. 10, iss. 12, pp. 1-30, 2011.
@article{CSOMPL_JOT, abstract = {CSOM/PL is a software product line (SPL) derived from applying multi-dimensional separation of concerns (MDSOC) techniques to the domain of high-level language virtual machine (VM) implementations. For CSOM/PL, we modularised CSOM, a Smalltalk VM implemented in C, using VMADL (virtual machine architecture description language). Several features of the original CSOM were encapsulated in VMADL modules and composed in various combinations. In an evaluation of our approach, we show that applying MDSOC and SPL principles to a domain as complex as that of VMs is not only feasible but beneficial, as it improves understandability, maintainability, and configurability of VM implementations without harming performance. },   author = {Haupt, Michael and Marr, Stefan and Hirschfeld, Robert},   doi = {10.5381/jot.2011.10.1.a12},   interhash = {b739ed923a0c65e0a687575c5ae724b3},   intrahash = {410111b6472d242e566afe4d27c3b7de},   issn = {1660-1769},   journal = {Journal of Object Technology},   number = 12, pages = {1-30},   pdf = {http://www.stefan-marr.de/downloads/jot11-mhaupt-csompl-a-virtual-machine-product-line.pdf},   title = {CSOM/PL: A Virtual Machine Product Line},   url = {http://www.stefan-marr.de/2011/12/csompl-a-virtual-machine-product-line/},   volume = 10, year = 2011 }

#### 2010

• S. Marr, M. Haupt, S. Timbermont, B. Adams, T. D’Hondt, P. Costanza, and W. De Meuter, "Virtual Machine Support for Many-Core Architectures: Decoupling Abstract From Concrete Concurrency Models," in Second International Workshop on Programming Languages Approaches to Concurrency and Communication-cEntric Software, York, UK, 2010, pp. 63-77.
@inproceedings{places09, abstract = {The upcoming many-core architectures require software developers to exploit concurrency to utilize available computational power. Today's high-level language virtual machines (VMs), which are a cornerstone of software development, do not provide sufficient abstraction for concurrency concepts. We analyze concrete and abstract concurrency models and identify the challenges they impose for VMs. To provide sufficient concurrency support in VMs, we propose to integrate concurrency operations into VM instruction sets. Since there will always be VMs optimized for special purposes, our goal is to develop a methodology to design instruction sets with concurrency support. Therefore, we also propose a list of trade-offs that have to be investigated to advise the design of such instruction sets. As a first experiment, we implemented one instruction set extension for shared memory and one for non-shared memory concurrency. From our experimental results, we derived a list of requirements for a full-grown experimental environment for further research.},   address = {York, UK},   author = {Marr, Stefan and Haupt, Michael and Timbermont, Stijn and Adams, Bram and D'Hondt, Theo and Costanza, Pascal and De Meuter, Wolfgang},   booktitle = {Second International Workshop on Programming Languages Approaches to Concurrency and Communication-cEntric Software},   doi = {10.4204/EPTCS.17.6},   interhash = {951ffceb7deb0e7a0880a89ac3df470b},   intrahash = {88f7f1a18d61f2db356e0658d392215c},   month = {February},   pages = {63-77},   pdf = {http://arxiv.org/pdf/1002.0939v1},   series = {Electronic Proceedings in Theoretical Computer Science},   title = {Virtual Machine Support for Many-Core Architectures: Decoupling Abstract From Concrete Concurrency Models},   url = {http://www.stefan-marr.de/2010/02/virtual-machine-support-for-many-core-architectures-decoupling-abstract-from-concrete-concurrency-models/},   volume = 17, year = 2010 }
• M. Haupt, R. Hirschfeld, T. Pape, G. Gabrysiak, S. Marr, A. Bergmann, A. Heise, M. Kleine, and R. Krahn, "The SOM Family: Virtual Machines for Teaching and Research," in Proceedings of the 15th Annual Conference on Innovation and Technology in Computer Science Education (ITiCSE), 2010, pp. 18-22.
@inproceedings{SOMFamily, abstract = {This paper introduces the SOM (Simple Object Machine) family of virtual machine (VM) implementations. Starting from a Java-based implementation, several ports of the VM to different programming languages have been developed and put to successful use in teaching at both undergraduate and graduate levels since 2006. Moreover, the VMs have been used in various research projects. We document the rationale behind each of the SOM VMs and results that have been achieved in teaching and research.},   acceptancerate = {0.51},   author = {Haupt, Michael and Hirschfeld, Robert and Pape, Tobias and Gabrysiak, Gregor and Marr, Stefan and Bergmann, Arne and Heise, Arvid and Kleine, Matthias and Krahn, Robert},   booktitle = {Proceedings of the 15th Annual Conference on Innovation and Technology in Computer Science Education (ITiCSE)},   day = {26--30},   doi = {10.1145/1822090.1822098},   interhash = {60d5f63bfbb8aad1fddc8fedff16c905},   intrahash = {71f674a8a2bc44dd50dbe7ac9b4be344},   isbn = {978-1-60558-729-5},   location = {Bilkent, Ankara, Turkey},   month = {June},   note = {(acceptance rate 51%)},   pages = {18--22},   pdf = {http://www.hpi.uni-potsdam.de/hirschfeld/publications/media/HauptHirschfeldPapeGabrysiakMarrBergmannHeiseKleineKrahn_2010_TheSomFamily_AcmDL.pdf},   publisher = {ACM Press},   title = {The SOM Family: Virtual Machines for Teaching and Research},   url = {http://www.hpi.uni-potsdam.de/hirschfeld/publications/media/HauptHirschfeldPapeGabrysiakMarrBergmannHeiseKleineKrahn_2010_TheSomFamily_AcmDL.pdf},   year = 2010 }
• Van Cutsem, Tom and Marr, Stefan and De Meuter, Wolfgang, A Language-oriented Approach to Teaching ConcurrencySPLASH’10, Reno, Nevada, USA: , 2010.
@presentation{MulticoreProgramming, abstract = {This paper argues in favour of a language-oriented approach to teach the principles of concurrency to graduate students. Over the past years, the popularity of programming lan- guages that promote a functional programming style has steadily grown. We want to promote the use of such lan- guages as the appropriate basic tools to deal with the “mul- ticore revolution”. We describe some of these programming languages and highlight two of them: Erlang and Clojure. We use these languages in a new graduate-level course that we will teach starting next academic year. Our goal is not to convince the reader that Erlang and Clojure are the best possible choices among this pool of candidate languages. Rather, our goal is to promote a functional programming style to tackle concurrency issues, and to teach this style in a programming language that makes it easy, straightforward and convenient to use that style. We do not want to get bogged down in a discussion on the usefulness or importance of learning new programming languages. For a good summary of the diverse advantages of studying new programming languages, we refer to a recent white paper by the ACM SIGPLAN education board [6].},   address = {SPLASH'10, Reno, Nevada, USA},   author = {{Van Cutsem},   Tom and Marr, Stefan and {De Meuter},   Wolfgang},   booktitle = {Workshop on Curricula for Concurrency and Parallelism},   day = 17, interhash = {766ec8b17c02daf69cccbf74ac981032},   intrahash = {d34bf3515af0d293bdc98e727d4ef2a5},   month = {October},   pages = 3, pdf = {http://soft.vub.ac.be/Publications/2010/vub-tr-soft-10-12.pdf},   title = {A Language-oriented Approach to Teaching Concurrency},   url = {http://soft.vub.ac.be/Publications/2010/vub-tr-soft-10-12.pdf},   year = 2010 }
• S. Marr, S. Verhaegen, B. De Fraine, T. D’Hondt, and W. De Meuter, "Insertion Tree Phasers: Efficient and Scalable Barrier Synchronization for Fine-grained Parallelism," in Proceedings of the 12th IEEE International Conference on High Performance Computing and Communications, 2010, pp. 130-137.
@inproceedings{InsertionTreePhasers, abstract = {This paper presents an algorithm and a data structure for scalable dynamic synchronization in fine-grained parallelism. The algorithm supports the full generality of phasers with dynamic, two-phase, and point-to-point synchronization. It retains the scalability of classical tree barriers, but provides unbounded dynamicity by employing a tailor-made insertion tree data structure. It is the first completely documented implementation strategy for a scalable phaser synchronization construct. Our evaluation shows that it can be used as a drop-in replacement for classic barriers without harming performance, despite its additional complexity and potential for performance optimizations. Furthermore, our approach overcomes performance and scalability limitations which have been present in other phaser proposals.},   author = {Marr, Stefan and Verhaegen, Stijn and De Fraine, Bruno and D'Hondt, Theo and De Meuter, Wolfgang},   booktitle = {Proceedings of the 12th IEEE International Conference on High Performance Computing and Communications},   doi = {10.1109/HPCC.2010.30},   interhash = {db46bfb816422a5055237a1b387e3dfe},   intrahash = {e0e488ee39b6fcbeedb6f7d221df958a},   isbn = {978-0-7695-4214-0},   month = {September},   note = {Best Student Paper AwardAcceptance Rate: 19,1% (58/304)},   pages = {130-137},   pdf = {http://www.stefan-marr.de/downloads/hpcc2010-marr-etal-insertion-tree-phasers.pdf},   publisher = {IEEE Computer Society},   title = {Insertion Tree Phasers: Efficient and Scalable Barrier Synchronization for Fine-grained Parallelism},   url = {http://www.stefan-marr.de/2010/07/insertion-tree-phasers-efficient-and-scalable-barrier-synchronization-for-fine-grained-parallelism/},   year = 2010 }
• S. Marr, "Encapsulation And Locality: A Foundation for Concurrency Support in Multi-Language Virtual Machines?," in SPLASH ’10: Proceedings of the ACM International Conference Companion on Object Oriented Programming Systems Languages and Applications Companion, New York, NY, USA, 2010, pp. 221-222.
@inproceedings{SplashDocSymp2010, abstract = {We propose to search for common abstractions for different concurrency models to enable high-level language virtual machines to support a wide range of different concurrency models. This would enable domain-specific solutions for the concurrency problem. Furthermore, advanced knowledge about concurrency in the VM model will most likely lead to better implementation opportunities on top of the different upcoming many-core architectures. The idea is to investigate the concepts of encapsulation and locality to this end. Thus, we are going to experiment with different language abstractions for concurrency on top of a virtual machine, which supports encapsulation and locality, to see how language designers could benefit, and how virtual machines could optimize programs using these concepts.},   address = {New York, NY, USA},   author = {Marr, Stefan},   booktitle = {SPLASH '10: Proceedings of the ACM International Conference Companion on Object Oriented Programming Systems Languages and Applications Companion},   day = {17-21},   doi = {10.1145/1869542.1869583},   interhash = {0a2db296019a5c54a8711b76dd6fd06e},   intrahash = {ffe71139af84c53ef5f448d4137bc943},   isbn = {978-1-4503-0240-1},   location = {Reno/Tahoe, Nevada, USA},   month = {October},   pages = {221--222},   pdf = {http://www.stefan-marr.de/downloads/docsymp-smarr.pdf},   publisher = {ACM},   title = {Encapsulation And Locality: A Foundation for Concurrency Support in Multi-Language Virtual Machines?},   type = {Doctoral Symposium},   url = {http://www.stefan-marr.de/2010/07/doctoral-symposium-at-splash-2010/},   year = 2010 }
• S. Marr and T. D’Hondt, "Many-Core Virtual Machines: Decoupling Abstract from Concrete Concurrency," in SPLASH ’10: Proceedings of the ACM International Conference Companion on Object Oriented Programming Systems Languages and Applications Companion, 2010, pp. 239-240.
@inproceedings{SplashPoster2010, abstract = {We propose to search for common abstractions for concurrency models to enable multi-language virtual machines to support a wide range of them. This would enable domain-specific solutions for concurrency problems. Furthermore, such an abstraction could improve portability of virtual machines to the vastly different upcoming many-core architectures.},   author = {Marr, Stefan and D'Hondt, Theo},   booktitle = {SPLASH '10: Proceedings of the ACM International Conference Companion on Object Oriented Programming Systems Languages and Applications Companion},   doi = {10.1145/1869542.1869593},   interhash = {dd6e347dcdbd2585fd2fb1b279369252},   intrahash = {479a17625b9786f51c8f7e8f24595fda},   isbn = {978-1-4503-0240-1},   location = {Reno/Tahoe, Nevada, USA},   month = {October},   note = {(Poster)},   pages = {239--240},   pdf = {http://www.stefan-marr.de/downloads/docsymp-smarr.pdf},   title = {Many-Core Virtual Machines: Decoupling Abstract from Concrete Concurrency},   url = {http://www.stefan-marr.de/2010/08/poster-at-splash10/},   year = 2010 }

#### 2009

• H. Schippers, T. V. Cutsem, S. Marr, M. Haupt, and R. Hirschfeld, "Towards an Actor-based Concurrent Machine Model," in Proceedings of the Fourth Workshop on the Implementation, Compilation, Optimization of Object-Oriented Languages, Programs and Systems (ICOOOLPS), New York, NY, USA, 2009, pp. 4-9.
@inproceedings{TowardsACMM, abstract = {In this position paper we propose to extend an existing delegation-based machine model with concurrency primitives. The original machine model which is built on the concepts of objects, messages, and delegation, provides support for languages enabling multi-dimensional separation of concerns (MDSOC). We propose to extend this model with an actor-based concurrency model, allowing for both true parallelism as well as lightweight concurrency primitives such as coroutines. In order to demonstrate its expressiveness, we informally describe how three high-level languages supporting different concurrency models can be mapped onto our extended machine model. We also provide an outlook on the extended model's potential to support concurrency-related MDSOC features.},   address = {New York, NY, USA},   author = {Schippers, Hans and Cutsem, Tom Van and Marr, Stefan and Haupt, Michael and Hirschfeld, Robert},   booktitle = {Proceedings of the Fourth Workshop on the Implementation, Compilation, Optimization of Object-Oriented Languages, Programs and Systems (ICOOOLPS)},   day = 6, doi = {10.1145/1565824.1565825},   interhash = {6b2514a55e250ff8f88ac54a52b71323},   intrahash = {f62f875aa5558a336acf130919b225dc},   isbn = {978-1-60558-541-3},   location = {Genova, Italy},   month = {July},   pages = {4--9},   pdf = {http://www.stefan-marr.de/downloads/icooolps09-schippers.pdf},   publisher = {ACM},   title = {Towards an Actor-based Concurrent Machine Model},   url = {http://www.stefan-marr.de/2010/02/towards-an-actor-based-concurrent-machine-model/},   year = 2009 }
• S. Marr, M. Haupt, and T. D’Hondt, "Intermediate Language Design of High-level Language Virtual Machines: Towards Comprehensive Concurrency Support," in Proceedings of the 3rd Workshop on Virtual Machines and Intermediate Languages, New York, NY, USA, 2009, p. 3:1-3:2.
@inproceedings{VMIL09, abstract = {Today's major high-level language virtual machines (VMs) are becoming successful in being multi-language execution platforms, hosting a wide range of languages. With the transition from few-core to many-core processors, we argue that VMs will also have to abstract from concrete concurrency models at the hardware level, to be able to support a wide range of abstract concurrency models on a language level. To overcome the lack of sufficient abstractions for concurrency concepts in VMs, we proposed earlier to extend VM intermediate languages by special concurrency constructs. As a first step towards this goal, we try to fill a gap in the current literature and survey the intermediate language design of VMs. Our goal is to identify currently used techniques and principles as well as to gain an overview over the available concurrency related features in intermediate languages. Another aspect of interest is the influence of the particular target language, for which the VM is originally intended, on the intermediate language.},   address = {New York, NY, USA},   author = {Marr, Stefan and Haupt, Michael and D'Hondt, Theo},   booktitle = {Proceedings of the 3rd Workshop on Virtual Machines and Intermediate Languages},   doi = {10.1145/1711506.1711509},   interhash = {2b7468ff600c441ea322f28dfdac938e},   intrahash = {4cadae2ab990d54d761d2233f8a21505},   isbn = {978-1-60558-874-2},   month = {October},   note = {(extended abstract)},   pages = {3:1--3:2},   pdf = {http://www.stefan-marr.de/downloads/vmil09-smarr.pdf},   publisher = {ACM},   title = {Intermediate Language Design of High-level Language Virtual Machines: Towards Comprehensive Concurrency Support},   url = {http://www.stefan-marr.de/2010/02/intermediate-language-design-of-high-level-language-virtual-machines-towards-comprehensive-concurrency-support/},   year = 2009 }

#### 2008

• S. Marr, "Modularisierung Virtueller Maschinen," Master’s Dissertation , Potsdam, Germany, 2008.
@mastersthesis{MAThesis, address = {Potsdam, Germany},   author = {Marr, Stefan},   interhash = {5e1e1e699ff09e4ff0e9a15937aad116},   intrahash = {b55cd84fb04798e86e1ed74d902e2755},   month = {September},   pdf = {http://soft.vub.ac.be/downloads/Masterarbeit-Modularisierung-virtueller-Maschinen.pdf},   school = {Hasso Plattner Institute},   title = {Modularisierung Virtueller Maschinen},   url = {http://www.stefan-marr.de/2008/10/i-am-done-eventually/},   year = 2008 }

### Research Related Posts

@inproceedings{Spiegelman:2016:TDS,   author = {Spiegelman, Alexander and Golan-Gueta, Guy and Keidar, Idit},   booktitle = {Proceedings of the 37th ACM SIGPLAN Conference on Programming Language Design and Implementation},   doi = {10.1145/2908080.2908112},   interhash = {e9bb0835860b6ca07ea2dffb84954804},   intrahash = {039595d2f1ddcd7c35c720dffa364c5e},   isbn = {978-1-4503-4261-2},   location = {Santa Barbara, CA, USA},   numpages = {15},   pages = {682--696},   publisher = {ACM},   series = {PLDI '16},   title = {{Transactional Data Structure Libraries}},   year = 2016 }
@inproceedings{Castanos:2012:BPE,   author = {Castanos, Jose and Edelsohn, David and Ishizaki, Kazuaki and Nagpurkar, Priya and Nakatani, Toshio and Ogasawara, Takeshi and Wu, Peng},   booktitle = {Proceedings of the ACM International Conference on Object Oriented Programming Systems Languages and Applications},   doi = {10.1145/2384616.2384631},   interhash = {89cf42818f20c02829ed1d03cd51dc80},   intrahash = {ca6a240262f56008b64ce9022dbf9e77},   isbn = {978-1-4503-1561-6},   location = {Tucson, Arizona, USA},   numpages = {18},   pages = {195--212},   publisher = {ACM},   series = {OOPSLA '12},   title = {On the Benefits and Pitfalls of Extending a Statically Typed Language JIT Compiler for Dynamic Scripting Languages},   year = 2012 }
@inproceedings{Lauterburg:2010:BTS, abstract = {This paper presents Basset, a tool for systematic testing of JVM-based actor programs. The actor programming model offers a promising approach for developing reliable concurrent and distributed systems. Since the actor model is based on message passing and disallows shared state, it avoids some of the problems inherent in shared-memory programming, e.g., low-level dataraces involving access to shared data. However, actor programs can still have bugs that result from incorrect orders of messages among actors or processing of messages by individual actors. To systematically test an actor program, it is necessary to explore different message delivery schedules that might occur during execution. Basset facilitates such exploration and provides a generic platform that can support actor systems that compile to Java bytecode. Our current implementation of Basset supports testing of programs developed using the ActorFoundry library and the Scala programming language.},   acmid = {1882349},   address = {New York, NY, USA},   author = {Lauterburg, Steven and Karmani, Rajesh K. and Marinov, Darko and Agha, Gul},   booktitle = {Proceedings of the Eighteenth ACM SIGSOFT International Symposium on Foundations of Software Engineering},   doi = {10.1145/1882291.1882349},   interhash = {7a4cebb4587540207ef90e03e9b906c8},   intrahash = {3d50b1ae7b9c5b2850b22ca855cab515},   isbn = {978-1-60558-791-2},   location = {Santa Fe, New Mexico, USA},   numpages = {2},   pages = {363--364},   publisher = {ACM},   series = {FSE '10},   title = {{Basset: A Tool for Systematic Testing of Actor Programs}},   url = {http://doi.acm.org/10.1145/1882291.1882349},   year = 2010 }
@inproceedings{5431748, abstract = {The actor programming model offers a promising model for developing reliable parallel and distributed code. Actors provide flexibility and scalability: local execution may be interleaved, and distributed nodes may operate asynchronously. The resulting nondeterminism is captured by nondeterministic processing of messages. To automate testing, researchers have developed several tools tailored to specific actor systems. As actor languages and libraries continue to evolve, such tools have to be reimplemented. Because many actor systems are compiled to Java bytecode, we have developed Basset, a general framework for testing actor systems compiled to Java bytecode. We illustrate Basset by instantiating it for the Scala programming language and for the ActorFoundry library for Java. Our implementation builds on Java PathFinder, a widely used model checker for Java. Experiments show that Basset can effectively explore executions of actor programs; e.g., it discovered a previously unknown bug in a Scala application.},   author = {Lauterburg, Steven and Dotta, Mirco and Marinov, Darko and Agha, Gul A.},   booktitle = {2009 IEEE/ACM International Conference on Automated Software Engineering},   doi = {10.1109/ASE.2009.88},   interhash = {bc7bed301924323ad36310665ccf48e7},   intrahash = {69d5a29aab3e21cb689e3655dbb2d188},   issn = {1938-4300},   month = nov, pages = {468--479},   title = {{A Framework for State-Space Exploration of Java-Based Actor Programs}},   year = 2009 }
@inproceedings{Zheng:2011:SLW, abstract = {Ajax becomes more and more important for web applications that care about client side user experience. It allows sending requests asynchronously, without blocking clients from continuing execution. Callback functions are only executed upon receiving the responses. While such mechanism makes browsing a smooth experience, it may cause severe problems in the presence of unexpected network latency, due to the non-determinism of asynchronism. In this paper, we demonstrate the possible problems caused by the asynchronism and propose a static program analysis to automatically detect such bugs in web applications. As client side Ajax code is often wrapped in server-side scripts, we also develop a technique that extracts client-side JavaScript code from server-side scripts. We evaluate our technique on a number of real-world web applications. Our results show that it can effectively identify real bugs. We also discuss possible ways to avoid such bugs.},   author = {Zheng, Yunhui and Bao, Tao and Zhang, Xiangyu},   booktitle = {Proceedings of the 20th International Conference on World Wide Web},   doi = {10.1145/1963405.1963517},   interhash = {522f507c8f9dcc45fcd3d52e6a1a7b01},   intrahash = {b2368afb4d04cffd6b754937fc0d63a9},   isbn = {978-1-4503-0632-4},   location = {Hyderabad, India},   numpages = {10},   pages = {805--814},   publisher = {ACM},   series = {WWW '11},   title = {{Statically Locating Web Application Bugs Caused by Asynchronous Calls}},   year = 2011 }