@inproceedings{pimas2017garbage,
abstract = {In dynamic object-oriented languages, low-level mechanisms such as just-in-time compilation, object allocation, garbage collection (GC) and method dispatch are often handled by virtual machines (VMs). VMs are typically implemented using static languages, allowing only few changes at run time. In such systems, the VM is not part of the language and interfaces to memory management or method dispatch are fixed, not allowing for arbitrary adaptation. Furthermore, the implementation can typically not be inspected or debugged with standard tools used to work on application code.
This paper reports on our experience building Bee, a dynamic Smalltalk runtime, written in Smalltalk. Bee is a Dynamic Metacircular Runtime (DMR) and seamlessly integrates the VM into the application and thereby overcomes many restrictions of classic VMs, for instance by allowing arbitrary code modifications of the VM at run time. Furthermore, the approach enables developers to use their standard tools for application code also for the VM, allowing them to inspect, debug, understand, and modify a DMR seamlessly.
We detail our experience of implementing GC, compilation, and optimizations in a DMR. We discuss examples where we found that DMRs can improve understanding of the system, provide tighter control of the software stack, and facilitate research. We also show that in high-level benchmarks the Bee DMR performance is close to that of a widely used Smalltalk VM.},
acceptancerate = {0.64},
author = {Pimás, Javier and Burroni, Javier and Arnaud, Jean Baptiste and Marr, Stefan},
booktitle = {Proceedings of the 13th ACM SIGPLAN International Symposium on Dynamic Languages},
day = {24},
doi = {10.1145/3133841.3133845},
interhash = {2d6ee093c64feb5e1be6267505ee6c52},
intrahash = {9220c4cea7f8d3112d0b51e33bc348fa},
isbn = {978-1-4503-5526-1/17/10},
location = {Vancouver, Canada},
month = oct,
note = {(acceptance rate 64%)},
numpages = {12},
pdf = {http://stefan-marr.de/downloads/dls17-pimas-et-al-garbage-collection-and-efficiency-in-dynamic-metacircular-runtimes.pdf},
publisher = {ACM},
series = {DLS'17},
title = {{Garbage Collection and Efficiency in Dynamic Metacircular Runtimes}},
year = {2017},
month_numeric = {10}
}

@inproceedings{Grimmer:2017:TJ,
abstract = {While Java is a statically-typed language, some of its features make it behave like a dynamically-typed language at run time. This includes Java’s boxing of primitive values as well as generics, which rely on type erasure.
This paper investigates how runtime technology for dynamically-typed languages such as JavaScript and Python can be used for Java bytecode. Using optimistic optimizations, we specialize bytecode instructions that access references in such a way, that they can handle primitive data directly and also specialize data structures in order to avoid boxing for primitive types. Our evaluation shows that these optimizations can be successfully applied to a statically-typed language such as Java and can also improve performance significantly. With this approach, we get an efficient implementation of Java's generics, avoid changes to the Java language, and maintain backwards compatibility, allowing existing code to benefit from our optimization transparently.},
acceptancerate = {0.45},
author = {Grimmer, Matthias and Marr, Stefan and Kahlhofer, Mario and Wimmer, Christian and Würthinger, Thomas and Mössenböck, Hanspeter},
booktitle = {Proceedings of the 14th International Conference on Managed Languages and Runtimes},
doi = {10.1145/3132190.3132202},
interhash = {20a606d561a9bf2a0fab64448c175c23},
intrahash = {1425bd31ad71e92df378b7b7d340f1e8},
isbn = {978-1-4503-5340-3/17/09},
location = {Prague, Czech Republic},
month = sep,
numpages = {11},
pdf = {http://stefan-marr.de/downloads/manlang17-grimmer-et-al-applying-optimizations-for-dynamically-typed-languages-to-java.pdf},
publisher = {ACM},
series = {ManLang'17},
title = {{Applying Optimizations for Dynamically-typed Languages to Java}},
year = {2017},
month_numeric = {9}
}

@inproceedings{Eisl:2017:TRAP,
abstract = {Register allocation is an integral part of compilation, regardless of whether a compiler aims for fast compilation or optimal code quality. State-of-the-art dynamic compilers often use global register allocation approaches such as linear scan. Recent results suggest that non-global trace-based register allocation approaches can compete with global approaches in terms of allocation quality. Instead of processing the whole compilation unit (i.e., method) at once, a trace-based register allocator divides the problem into linear code segments, called traces.
In this work, we present a register allocation framework that can exploit the additional flexibility of traces to select different allocation strategies based on the characteristics of a trace. This provides us with fine-grained control over the trade-off between compile time and peak performance in a just-in-time compiler.
Our framework features three allocation strategies: a linear-scan-based approach that achieves good code quality, a single-pass bottom-up strategy that aims for short allocation times, and an allocator for trivial traces.
To demonstrate the flexibility of the framework, we select 8 allocation policies and show their impact on compile time and peak performance. This approach can reduce allocation time by 7%–43% at a peak performance penalty of about 1%–11% on average.
For systems that do not focus on peak performance, our approach allows to adjust the time spent for register allocation, and therefore the overall compilation time, thus finding the optimal balance between compile time and peak performance according to an application's requirements.},
acceptancerate = {0.45},
author = {Eisl, Josef and Marr, Stefan and Würthinger, Thomas and Mössenböck, Hanspeter},
booktitle = {Proceedings of the 14th International Conference on Managed Languages and Runtimes},
doi = {10.1145/3132190.3132209},
interhash = {fa5e3685a5ebbf4f73b568ca5c70b0f3},
intrahash = {f78206730c10f90108be1004431ab606},
isbn = {978-1-4503-5340-3/17/09},
location = {Prague, Czech Republic},
month = sep,
numpages = {13},
pdf = {http://stefan-marr.de/downloads/manlang17-eisl-et-al-trace-register-allocation-policies.pdf},
publisher = {ACM},
series = {ManLang'17},
title = {Trace Register Allocation Policies: Compile-time vs. Performance Trade-offs},
year = {2017},
month_numeric = {9}
}

@article{Vandercammen:2017:STRAF,
abstract = {Just-in-time compilation has proven an effective, though effort-intensive, choice for realizing performant language runtimes. Recently introduced JIT compilation frameworks advocate applying meta-compilation techniques such as partial evaluation or meta-tracing on simple interpreters to reduce the implementation effort. However, such frameworks are few and far between. Designed and highly optimized for performance, they are difficult to experiment with. We therefore present STRAF, a minimalistic yet flexible Scala framework for studying trace-based JIT compilation. STRAF is sufficiently general to support a diverse set of language interpreters, but also sufficiently extensible to enable experiments with trace recording and optimization. We demonstrate the former by plugging two different interpreters into STRAF. We demonstrate the latter by extending STRAF with e.g., constant folding and type-specialization optimizations, which are commonly found in dedicated trace-based JIT compilers. The evaluation shows that STRAF is suitable for prototyping new techniques and formalisms in the domain of trace-based JIT compilation.},
author = {Vandercammen, Maarten and Marr, Stefan and De Roover, Coen},
doi = {10.1016/j.cl.2017.07.005},
interhash = {c826370d03ce27908b5e8909669292a5},
intrahash = {e9700c4ced09b2eccfbafdae2d9f9d26},
issn = {1477-8424},
journal = {Computer Languages, Systems \& Structures},
month = jul,
pdf = {http://stefan-marr.de/downloads/comlan17-vandercammen-et-al-a-flexible-framework-for-studying-trace-based-just-in-time-compilation.pdf},
title = {{A Flexible Framework for Studying Trace-Based Just-In-Time Compilation}},
year = {2017},
month_numeric = {7}
}

@inproceedings{Chari:2017:JITMOP,
abstract = {Just-in-time compilers and their aggressive speculative optimizations reduced the performance gap between dynamic and static languages drastically. To successfully speculate, compilers rely on the program variability observed at run time to be low, and use heuristics to determine when optimization is beneficial. However, some variability patterns are hard to capture with heuristics. Specifically, ephemeral, warmup, rare, and highly indirect variability are challenges for today's compiler heuristics. As a consequence, they can lead to reduced application performance. However, these types of variability are identifiable at the application level and could be mitigated with information provided by developers. As a solution, we propose a metaobject protocol for dynamic compilation systems to enable application developers to provide such information at run time. As a proof of concept, we demonstrate performance improvements for a few scenarios in a dynamic language built on top of the Truffle and Graal system.},
author = {Chari, Guido and Garbervetsky, Diego and Marr, Stefan},
booktitle = {Proceedings of the 11th Workshop on Implementation, Compilation, Optimization of Object-Oriented Languages, Programs and Systems},
day = {19},
doi = {10.1145/3098572.3098577},
interhash = {c0c40883593a7f5b3eb7a7362d4b0dd1},
intrahash = {a5add0a4c187d02a62ec7d929f523cb5},
isbn = {978-1-4503-5088-4/17/06},
month = jun,
pages = {5},
pdf = {http://stefan-marr.de/downloads/icooolps17-chari-et-al-a-mop-for-optimizing-run-time-variability.pdf},
series = {ICOOOLPS '17},
title = {{A Metaobject Protocol for Optimizing Application-Specific Run-Time Variability}},
type = {Position Paper},
year = {2017},
month_numeric = {6}
}

@inproceedings{Chari:2017:FVR,
abstract = {It has become common for software systems to require or benefit from dynamic adaptation, i.e., to modify their behavior while they are running. Among the existing approaches to this problem, language-level solutions are appealing for scenarios in which fine-grained adaptation is needed, i.e., when the granularity of the modifications is that of individual objects, or for small applications where an architectural solution based on complex middleware is overkill. However, there is no consensus on which of the existing language-level approaches to adopt. A recent survey on self-adaptive systems asks [9]: Is it possible to adopt a single paradigm providing all required abstractions to implement adaptive systems?},
acmid = {3098422},
author = {Chari, Guido and Garbervetsky, Diego and Marr, Stefan},
booktitle = {Proceedings of the 39th International Conference on Software Engineering Companion},
doi = {10.1109/ICSE-C.2017.144},
interhash = {4bc35775c63fdfe67b6b1d279aab7254},
intrahash = {235d4fa85281485a6f93b6d864fce02c},
isbn = {978-1-5386-1589-8},
location = {Buenos Aires, Argentina},
month = may,
numpages = {3},
pages = {229--231},
pdf = {http://stefan-marr.de/downloads/icse17-chari-et-al-fully-reflective-vms-for-software-adaptation.pdf},
publisher = {IEEE},
series = {ICSE-C '17},
title = {Fully-reflective VMs for Ruling Software Adaptation},
type = {Poster},
year = {2017},
month_numeric = {5}
}

@presentation{Roberts:2017:VMAdaption,
abstract = {We adapt SOMns, a Truffle-based interpreter for Newspeak, to the Grace programming language. We highlight differences between the semantics of these languages and offer preliminary results showing that adaption is possible while retaining performance. The similarities between the languages promote the potential for adaption and code sharing between implementations. Through experimentation we intend to explore how the design of the tailored implementation; the flexibility of the underlying framework; and similarities between languages affect adaptability, and by doing so hope to realize a set of mechanisms that can be easily extended to create optimized VMs for object-orientated languages.},
author = {Roberts, Richard and Marr, Stefan and Homer, Michael and Noble, James},
booktitle = {Workshop on Modern Language Runtimes, Ecosystems, and VMs},
day = {3},
interhash = {35ccb15ed976f2592662a98d80cef1d2},
intrahash = {fbeac81c9f7f19f605bc968328386407},
month = apr,
pdf = {http://stefan-marr.de/downloads/morevms17-roberts-et-al-toward-virtual-machine-adaption.pdf},
series = {MoreVMs'17},
title = {{Toward Virtual Machine Adaption Rather than Reimplementation: Adapting SOMns for Grace}},
type = {Extended Abstract},
year = {2017},
month_numeric = {4}
}

@presentation{Marr:2017:KomposDemo,
abstract = {With the omnipresence of multicore processors, developers combine various concurrency abstractions such as actors, communicating sequential processes, or fork/join programming to utilize the available parallelism. Unfortunately, when we debug such systems today, we need to reason about low-level memory accesses, locks, and thread pools, because debuggers rarely know about actors, messages, channels, or fork/join tasks.
With Kómpos, we present a concurrent debugger that is designed to enable us to reason about our programs on the level of these abstractions. We will demonstrate some of the features of Kómpos and discuss the research challenges for building a concurrent debugger for a wide range of concurrency abstractions.},
author = {Marr, Stefan and Torres Lopez, Carmen and Aumayr, Dominik and Gonzalez Boix, Elisa and Mössenböck, Hanspeter},
booktitle = {Companion to the First International Conference on the Art, Science and Engineering of Programming},
day = {2},
doi = {10.1145/3079368.3079378},
interhash = {9abcfadddac4f838ffbbf883d41bbde9},
intrahash = {d6f3704a8e6a97b812d688dd85e2f74c},
isbn = {978-1-4503-4836-2},
month = apr,
pages = {2:1--2:2},
pdf = {http://stefan-marr.de/downloads/progdemo-marr-et-al-kompos-a-platform-for-debugging-complex-concurrent-applications.pdf},
publisher = {ACM},
series = {Programming'17},
title = {{Kómpos: A Platform for Debugging Complex Concurrent Applications}},
type = {Demo},
year = {2017},
month_numeric = {4}
}

@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},
day = {2},
doi = {10.1145/2983990.2984001},
interhash = {e308e02d9e1ea4c4e8187c56cd3770e8},
intrahash = {62830f65bdc9a0a1046a41c0aee771e4},
isbn = {978-1-4503-4444-9},
month = nov,
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},
month_numeric = {11}
}

@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},
day = {1},
doi = {10.1145/2989225.2989234},
interhash = {66c1f1202ee6785cfa6a4edbd6d0f27f},
intrahash = {957160cec332f01c43db90d9ff68ec56},
isbn = {978-1-4503-4445-6},
location = {Amsterdam, Netherlands},
month = nov,
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},
month_numeric = {11}
}

@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},
appendix = {https://github.com/smarr/are-we-fast-yet#readme},
author = {Marr, Stefan and Daloze, Benoit and Mössenböck, Hanspeter},
blog = {http://stefan-marr.de/2016/10/cross-language-compiler-benchmarking-are-we-fast-yet/},
booktitle = {Proceedings of the 12th Symposium on Dynamic Languages},
day = {1},
doi = {10.1145/2989225.2989232},
html = {http://stefan-marr.de/papers/dls-marr-et-al-cross-language-compiler-benchmarking-are-we-fast-yet/},
interhash = {b19a3027d653a0a8a59199c0f576571c},
intrahash = {0177b6515342452e425fd81ffb06eae9},
isbn = {978-1-4503-4445-6},
location = {Amsterdam, Netherlands},
month = nov,
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?}},
year = {2016},
month_numeric = {11}
}

@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 = oct,
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},
month_numeric = {10}
}

@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},
blog = {http://stefan-marr.de/2016/01/towards-meta-level-engineering-and-tooling-for-complex-concurrent-systems/},
booktitle = {Proceedings of the 9th Arbeitstagung Programmiersprachen},
day = {25},
html = {http://stefan-marr.de/papers/atps-marr-et-al-towards-meta-level-engineering-and-tooling-for-complex-concurrent-systems/},
interhash = {b0599561ea7514193ff3fa9a93eec376},
intrahash = {5094e9d82c7c0313586b5618ef39d2c8},
issn = {1613-0073},
location = {Vienna, Austria},
month = feb,
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},
month_numeric = {2}
}

@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},
blog = {http://stefan-marr.de/2015/10/optimizing-communicating-event-loop-languages-with-truffle/},
booktitle = {Presentation at 5th International Workshop on Programming based on Actors, Agents, and Decentralized Control},
day = {26},
html = {http://stefan-marr.de/papers/agere-marr-moessenboeck-optimizing-communicating-event-loop-languages-with-truffle/},
interhash = {0a0937a8e45344c88cbe6fb1ad8c42fa},
intrahash = {9f9881cc5d059f4916d4805e780b5e00},
location = {Pittsburgh, PA, USA},
month = oct,
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},
year = {2015},
month_numeric = {10}
}

@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},
blog = {http://stefan-marr.de/2015/10/jit-data-structures-fully-reflective-vms-and-meta-circular-meta-tracing/},
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 = oct,
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},
month_numeric = {10}
}

@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},
blog = {http://stefan-marr.de/2015/10/jit-data-structures-fully-reflective-vms-and-meta-circular-meta-tracing/},
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 = oct,
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},
month_numeric = {10}
}

@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},
appendix = {http://stefan-marr.de/papers/oopsla-marr-ducasse-meta-tracing-vs-partial-evaluation-artifacts/},
author = {Marr, Stefan and Ducasse, Stéphane},
blog = {http://stefan-marr.de/2015/10/tracing-vs-partial-evaluation-comparing-meta-compilation-approaches-for-self-optimizing-interpreters/},
booktitle = {Proceedings of the 2015 ACM International Conference on Object Oriented Programming Systems Languages \& Applications},
doi = {10.1145/2660193.2660194},
html = {http://stefan-marr.de/papers/oopsla-marr-ducasse-meta-tracing-vs-partial-evaluation/},
interhash = {626a639666ea884d5b1a8dc121e8457a},
intrahash = {7ca631f0fc852e48f2285e1a8d4cdfa0},
isbn = {978-1-4503-2585-1},
month = oct,
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},
year = {2015},
month_numeric = {10}
}

@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.},
appendix = {http://stefan-marr.de/papers/pldi-marr-et-al-zero-overhead-metaprogramming-artifacts/},
author = {Marr, Stefan and Seaton, Chris and Ducasse, Stéphane},
blog = {http://stefan-marr.de/2015/04/zero-overhead-metaprogramming/},
booktitle = {Proceedings of the 36th ACM SIGPLAN Conference on Programming Language Design and Implementation},
doi = {10.1145/2737924.2737963},
html = {http://stefan-marr.de/papers/pldi-marr-et-al-zero-overhead-metaprogramming/},
interhash = {c212198ae76c6205f6cdbf31185dcc1c},
intrahash = {84be3e9de039beab1ddee5414f9bec3c},
isbn = {978-1-4503-3468-6},
month = jun,
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},
month_numeric = {6}
}

@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},
blog = {http://stefan-marr.de/2014/03/domains-safe-sharing-among-actors/},
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 = feb,
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},
month_numeric = {2}
}

@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},
blog = {http://stefan-marr.de/2014/09/forkjoin-parallelism-in-the-wild/},
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 = sep,
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},
month_numeric = {9}
}

@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 = jul,
numpages = {4},
pages = {2:1--2:4},
series = {ICOOOLPS},
title = {Data Interface + Algorithms = Efficient Programs: Separating Logic from Representation to Improve Performance},
year = {2014},
month_numeric = {7}
}

@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},
blog = {http://stefan-marr.de/2014/02/towards-composable-concurrency-abstractions/},
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 = apr,
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},
month_numeric = {4}
}

@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},
blog = {http://stefan-marr.de/2013/10/tanks-multiple-reader-single-writer-actors/},
booktitle = {Proceedings of AGERE! 2013, 3rd International Workshop on Programming based on Actors, Agents, and Decentralized Control},
day = {27},
interhash = {c1db1b07f46be7b49019a847b90ae145},
intrahash = {7263458a77c11ab88ae282ab71fc7327},
isbn = {978-1-4503-2602-5},
location = {Indianapolis, Indiana, USA},
month = oct,
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},
month_numeric = {10}
}

@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},
blog = {http://stefan-marr.de/2013/10/cloud-parte-elastic-complex-event-processing-based-on-mobile-actors/},
booktitle = {Proceedings of AGERE! 2013, 3rd International Workshop on Programming based on Actors, Agents, and Decentralized Control},
interhash = {7fc89cd94011a7d61fece752a317db98},
intrahash = {3f1a2b2371c1e151b759ce43b0005e69},
month = oct,
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},
month_numeric = {10}
}

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

@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},
blog = {http://stefan-marr.de/2012/01/modularity-and-conventions-for-maintainable-concurrent-language-implementations-a-review-of-our-experiences-and-practices/},
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 = mar,
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},
month_numeric = {3}
}

@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},
blog = {http://stefan-marr.de/2011/12/synchronization-views-for-event-loop-actors/},
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 = feb,
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},
month_numeric = {2}
}

@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},
blog = {http://stefan-marr.de/2010/07/doctoral-symposium-at-splash-2010/},
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 = oct,
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},
month_numeric = {10}
}

@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 = {fbe640af05dfdd44636b03c67f3ded79},
intrahash = {d34bf3515af0d293bdc98e727d4ef2a5},
month = oct,
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},
month_numeric = {10}
}

@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},
blog = {http://stefan-marr.de/2010/02/virtual-machine-support-for-many-core-architectures-decoupling-abstract-from-concrete-concurrency-models/},
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 = feb,
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},
month_numeric = {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},
blog = {http://www.stefan-marr.de/2010/02/intermediate-language-design-of-high-level-language-virtual-machines-towards-comprehensive-concurrency-support/},
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 = oct,
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},
month_numeric = {10}
}