Ein einfacher Compiler-Compiler für Mikrocomputer / Α simple compiler-compiler for microcomputer. - Hanspeter Mössenböck (Elektron. Rechenanlagen, 1984)

Alex - A simple and efficient scanner generator. - Hanspeter Mössenböck (ACM SIGPLAN Notices, 1986)

Compilererzeugende Systeme für Mikrocomputer. - Hanspeter Mössenböck (1987)

A Convenient Way to Incorporate Semantic: Actions in Two-pass Compiling Scheme. - Hanspeter Mössenböck (Softw. Pract. Exp., 1988)

A compiler generator for microcomputers. - Peter Rechenberg; Hanspeter Mössenböck (Prentice Hall, 1989)

Object Oberon - A Modest Object-Oriented Language. - Hanspeter Mössenböck; Josef Templ (Struct. Program., 1989)

A Generator for Production Quality Compilers. - Hanspeter Mössenböck (CC, 1990)

Ein Programmeditor mit Hypertext-Fähigkeiten. - Hanspeter Mössenböck (Hypertext und Hypermedia, 1990)

Differences between Oberon and Oberon-2. - Hanspeter Mössenböck; Niklaus Wirth (Struct. Program., 1991)

The Programming Language Oberon-2. - Hanspeter Mössenböck; Niklaus Wirth (Struct. Program., 1991)

The Oberon System. - Hanspeter Mössenböck (TOOLS (7), 1992)

Treating statement sequences as block objects. - Hanspeter Mössenböck (ACM SIGPLAN Notices, 1992)

Objektorientierte Programmierung in Oberon-2 (2. Aufl.). - Hanspeter Mössenböck (Springer, 1994)

Extensibility in the Oberon System. - Hanspeter Mössenböck (Nord. J. Comput., 1994)

Single-Pass Generation of Static Single-Assignment Form for Structured Languages. - Marc M. Brandis; Hanspeter Mössenböck (ACM Trans. Program. Lang. Syst., 1994)

Object-oriented programming in Oberon-2 (2. ed.). - Hanspeter Mössenböck (Springer, 1995)

Designing a Framework by Stepwise Generalization. - Kai Koskimies; Hanspeter Mössenböck (ESEC, 1995)

Scene: Using Scenario Diagrams and Active Text for Illustrating Object-Oriented Programs. - Kai Koskimies; Hanspeter Mössenböck (ICSE, 1996)

Trends in Object-Oriented Programming. - Hanspeter Mössenböck (ACM Comput. Surv., 1996)

Active Text for Structuring and Understanding Source Code. - Hanspeter Mössenböck; Kai Koskimies (Softw. Pract. Exp., 1996)

Zero-Overhead Exeption Handling Using Metaprogramming. - Markus Hof; Hanspeter Mössenböck; Peter Pirkelbauer (SOFSEM, 1997)

Films as Graphical Comments in the Source Code of Programs. - Hanspeter Mössenböck (TOOLS (23), 1997)

Objektorientierte Programmierung in Oberon-2 (3. Aufl.). - Hanspeter Mössenböck (Springer, 1998)

Twin - A Design Pattern for Modeling Multiple Inheritance. - Hanspeter Mössenböck (Ershov Memorial Conference, 1999)

The Oberon-2 Reflection Model and Its Applications. - Hanspeter Mössenböck; Christoph Steindl (Reflection, 1999)

Compiler Construction - The Art of Niklaus Wirth. - Hanspeter Mössenböck (The School of Niklaus Wirth, 2000)

Niklaus Wirth - a Pioneer of Computer Science. - Gustav Pomberger; Hanspeter Mössenböck; Peter Rechenberg (The School of Niklaus Wirth, 2000)

Software entwickeln mit C# - ein kompakter Lehrgang. - Hanspeter Mössenböck (dpunkt.verlag, 2002)

Linear Scan Register Allocation in the Context of SSA Form and Register Constraints. - Hanspeter Mössenböck; Michael Pfeiffer 004 (CC, 2002)

Sprechen Sie Java? - eine Einführung in das systematische Programmieren (2. Aufl.). - Hanspeter Mössenböck (dpunkt.verlag, 2003)

Data Mappings in the Model-View-Controller Pattern. - Martin Rammerstorfer; Hanspeter Mössenböck (Ershov Memorial Conference, 2003)

LL(1) Conflict Resolution in a Recursive Descent Compiler Generator. - Albrecht Wöß; Markus Löberbauer; Hanspeter Mössenböck (JMLC, 2003)

Compiler generation tools for C#. - Albrecht Wöß; Markus Löberbauer; Hanspeter Mössenböck (IEE Proc. Softw., 2003)

Escape analysis in the context of dynamic compilation and deoptimization. - Thomas Kotzmann; Hanspeter Mössenböck (VEE, 2005)

Optimized interval splitting in a linear scan register allocator. - Christian Wimmer; Hanspeter Mössenböck (VEE, 2005)

Die .NET-Technologie - Grundlagen und Anwendungsprogrammierung: aktualisiert auf .NET 2.0, 2. Auflage. - Wolfgang Beer; Dietrich Birngruber; Hanspeter Mössenböck; Herbert Praehofer; Albrecht Wöß (dpunkt.verlag, 2006)

Automatic Object Colocation Based on Read Barriers. - Christian Wimmer; Hanspeter Mössenböck (JMLC, 2006)

A Component Plug-In Architecture for the .NET Platform. - Reinhard Wolfinger; Deepak Dhungana; Herbert Prähofer; Hanspeter Mössenböck (JMLC, 2006)

Run-Time Support for Optimizations Based on Escape Analysis. - Thomas Kotzmann; Hanspeter Mössenböck (CGO, 2007)

Array bounds check elimination for the Java HotSpot™ client compiler. - Thomas Würthinger; Christian Wimmer; Hanspeter Mössenböck (PPPJ, 2007)

Automatic feedback-directed object inlining in the java hotspotTM virtual machine. - Christian Wimmer; Hanspeter Mössenböck (VEE, 2007)

The Domain-Specific Language Monaco and its Visual Interactive Programming Environment. - Herbert Prähofer; Dominik Hurnaus; Christian Wirth 002; Hanspeter Mössenböck (VL/HCC, 2007)

Visualization of Program Dependence Graphs. - Thomas Würthinger; Christian Wimmer; Hanspeter Mössenböck (CC, 2008)

Automatic array inlining in java virtual machines. - Christian Wimmer; Hanspeter Mössenböck (CGO, 2008)

Software support for building end-user programming environments in the automation domain. - Herbert Prähofer; Dominik Hurnaus; Roland Schatz; Christian Wirth 002; Hanspeter Mössenböck (WEUSE@ICSE, 2008)

Optimized strings for the Java HotSpot™ virtual machine. - Christian Häubl; Christian Wimmer; Hanspeter Mössenböck (PPPJ, 2008)

Monaco: A DSL Approach for Programming Automation Systems. - Herbert Prähofer; Dominik Hurnaus; Roland Schatz; Christian Wirth 002; Hanspeter Mössenböck (Software Engineering, 2008)

Design of the Java HotSpot™ client compiler for Java 6. - Thomas Kotzmann; Christian Wimmer; Hanspeter Mössenböck; Thomas Rodriguez; Kenneth B. Russell; David Cox (ACM Trans. Archit. Code Optim., 2008)

Lazy continuations for Java virtual machines. - Lukas Stadler; Christian Wimmer; Thomas Würthinger; Hanspeter Mössenböck; John Rose (PPPJ, 2009)

Array bounds check elimination in the context of deoptimization. - Thomas Würthinger; Christian Wimmer; Hanspeter Mössenböck (Sci. Comput. Program., 2009)

Rule-Based Composition Behaviors in Dynamic Plug-In Systems. - Markus Jahn 001; Markus Löberbauer; Reinhard Wolfinger; Hanspeter Mössenböck (APSEC, 2010)

Improving aspect-oriented programming with dynamic code evolution in an enhanced Java virtual machine. - Thomas Würthinger; Walter Binder; Danilo Ansaloni; Philippe Moret; Hanspeter Mössenböck (RAM-SE@ECOOP, 2010)

Adding genericity to a plug-in framework. - Reinhard Wolfinger; Markus Löberbauer; Markus Jahn 001; Hanspeter Mössenböck (GPCE, 2010)

Applications of enhanced dynamic code evolution for Java in GUI development and dynamic aspect-oriented programming. - Thomas Würthinger; Walter Binder; Danilo Ansaloni; Philippe Moret; Hanspeter Mössenböck (GPCE, 2010)

Extending Web Applications with Client and Server Plug-ins. - Markus Jahn 001; Reinhard Wolfinger; Hanspeter Mössenböck (Software Engineering, 2010)

Compact and efficient strings for Java. - Christian Häubl; Christian Wimmer; Hanspeter Mössenböck (Sci. Comput. Program., 2010)

Automatic feedback-directed object fusing. - Christian Wimmer; Hanspeter Mössenböck (ACM Trans. Archit. Code Optim., 2010)

Safe and atomic run-time code evolution for Java and its application to dynamic AOP. - Thomas Würthinger; Danilo Ansaloni; Walter Binder; Christian Wimmer; Hanspeter Mössenböck (OOPSLA, 2011)

Trace-based compilation for the Java HotSpot virtual machine. - Christian Häubl; Hanspeter Mössenböck (PPPJ, 2011)

Optimized memory management for class metadata in a JVM. - Thomas Schatzl; Laurent Daynès; Hanspeter Mössenböck (PPPJ, 2011)

Erratum to "Compact and Efficient Strings for Java" [Science of Computer Programming 75 (2010) 1077-1094]. - Christian Häubl; Christian Wimmer; Hanspeter Mössenböck (Sci. Comput. Program., 2011)

A Comprehensive Solution for Deterministic Replay Debugging of SoftPLC Applications. - Herbert Prähofer; Roland Schatz; Christian Wirth 002; Hanspeter Mössenböck (IEEE Trans. Ind. Informatics, 2011)

Plux.Net - A dynamic Plug-in Platform for Desktop and Web Applications in .Net. - Markus Jahn 001; Markus Löberbauer; Reinhard Wölfinger; Hanspeter Mössenböck (STeP, 2012)

Compilation queuing and graph caching for dynamic compilers. - Lukas Stadler; Gilles Duboscq; Hanspeter Mössenböck; Thomas Würthinger (VMIL@SPLASH, 2012)

Evaluation of trace inlining heuristics for Java. - Christian Häubl; Christian Wimmer; Hanspeter Mössenböck (SAC, 2012)

Composition mechanisms classified by their contributor provision characteristics. - Markus Löberbauer; Reinhard Wolfinger; Markus Jahn 001; Hanspeter Mössenböck (SISY, 2012)

Supporting Model Maintenance in Component-based Product Lines. - Markus Jahn 001; Rick Rabiser; Paul Grünbacher; Markus Löberbauer; Reinhard Wolfinger; Hanspeter Mössenböck (WICSA/ECSA, 2012)

An experimental study of the influence of dynamic compiler optimizations on Scala performance. - Lukas Stadler; Gilles Duboscq; Hanspeter Mössenböck; Thomas Würthinger; Doug Simon (SCALA@ECOOP, 2013)

An intermediate representation for speculative optimizations in a dynamic compiler. - Gilles Duboscq; Thomas Würthinger; Lukas Stadler; Christian Wimmer; Doug Simon; Hanspeter Mössenböck (VMIL@SPLASH, 2013)

An efficient native function interface for Java. - Matthias Grimmer; Manuel Rigger; Lukas Stadler; Roland Schatz; Hanspeter Mössenböck (PPPJ, 2013)

Deriving code coverage information from profiling data recorded for a trace-based just-in-time compiler. - Christian Häubl; Christian Wimmer; Hanspeter Mössenböck (PPPJ, 2013)

Context-sensitive trace inlining for Java. - Christian Häubl; Christian Wimmer; Hanspeter Mössenböck (Comput. Lang. Syst. Struct., 2013)

Monaco - A domain-specific language solution for reactive process control programming with hierarchical components. - Herbert Prähofer; Roland Schatz; Christian Wirth 002; Dominik Hurnaus; Hanspeter Mössenböck (Comput. Lang. Syst. Struct., 2013)

Composing user-specific web applications from distributed plug-ins. - Markus Jahn 001; Reinhard Wolfinger; Markus Löberbauer; Hanspeter Mössenböck (Comput. Sci. Res. Dev., 2013)

Foreword. - Markus Aleksy; Ralf Gitzel; Andreas Krall; Hanspeter Mössenböck; Christian W. Probst; Ben Stephenson (Sci. Comput. Program., 2013)

Partial Escape Analysis and Scalar Replacement for Java. - Lukas Stadler; Thomas Würthinger; Hanspeter Mössenböck (CGO, 2014)

An efficient approach for accessing C data structures from JavaScript. - Matthias Grimmer; Thomas Würthinger; Andreas Wöß; Hanspeter Mössenböck (ICOOOLPS@ECOOP, 2014)

Speculation without regret: reducing deoptimization meta-data in the Graal compiler. - Gilles Duboscq; Thomas Würthinger; Hanspeter Mössenböck (PPPJ, 2014)

TruffleC: dynamic execution of C on a Java virtual machine. - Matthias Grimmer; Manuel Rigger; Roland Schatz; Lukas Stadler; Hanspeter Mössenböck (PPPJ, 2014)

Fast Java profiling with scheduling-aware stack fragment sampling and asynchronous analysis. - Peter Hofer; Hanspeter Mössenböck (PPPJ, 2014)

An object storage model for the truffle language implementation framework. - Andreas Wöß; Christian Wirth 002; Daniele Bonetta; Chris Seaton; Christian Humer; Hanspeter Mössenböck (PPPJ, 2014)

Where has all my memory gone?: determining memory characteristics of product variants using virtual-machine-level monitoring. - Philipp Lengauer; Verena Bitto; Florian Angerer; Paul Grünbacher; Hanspeter Mössenböck (VaMoS, 2014)

Efficient and accurate stack trace sampling in the Java hotspot virtual machine. - Peter Hofer; Hanspeter Mössenböck (ICPE, 2014)

The taming of the shrew: increasing performance by automatic parameter tuning for java garbage collectors. - Philipp Lengauer; Hanspeter Mössenböck (ICPE, 2014)

Trace transitioning and exception handling in a trace-based JIT compiler for java. - Christian Häubl; Christian Wimmer; Hanspeter Mössenböck (ACM Trans. Archit. Code Optim., 2014)

Dynamically composing languages in a modular way: supporting C extensions for dynamic languages. - Matthias Grimmer; Chris Seaton; Thomas Würthinger; Hanspeter Mössenböck (MODULARITY, 2015)

High-performance cross-language interoperability in a multi-language runtime. - Matthias Grimmer; Chris Seaton; Roland Schatz; Thomas Würthinger; Hanspeter Mössenböck (DLS, 2015)

Java-to-JavaScript translation via structured control flow reconstruction of compiler IR. - David Leopoldseder; Lukas Stadler; Christian Wimmer; Hanspeter Mössenböck (DLS, 2015)

Techniques and applications for guest-language safepoints. - Benoit Daloze; Chris Seaton; Daniele Bonetta; Hanspeter Mössenböck (ICOOOLPS@ECOOP, 2015)

Memory-safe Execution of C on a Java VM. - Matthias Grimmer; Roland Schatz; Chris Seaton; Thomas Würthinger; Hanspeter Mössenböck (PLAS@ECOOP, 2015)

Efficient dynamic analysis of the synchronization performance of Java applications. - Peter Hofer; David Gnedt; Hanspeter Mössenböck (WODA@SPLASH, 2015)

Efficient Rebuilding of Large Java Heaps from Event Traces. - Verena Bitto; Philipp Lengauer; Hanspeter Mössenböck (PPPJ, 2015)

Lightweight Java Profiling with Partial Safepoints and Incremental Stack Tracing. - Peter Hofer; David Gnedt; Hanspeter Mössenböck (ICPE, 2015)

Sampling-based Steal Time Accounting under Hardware Virtualization. - Peter Hofer; Florian Hörschläger; Hanspeter Mössenböck (ICPE, 2015)

Accurate and Efficient Object Tracing for Java Applications. - Philipp Lengauer; Verena Bitto; Hanspeter Mössenböck (ICPE, 2015)

Cross-language compiler benchmarking: are we fast yet? - Stefan Marr; Benoit Daloze; Hanspeter Mössenböck (DLS, 2016)

Sulong - execution of LLVM-based languages on the JVM: position paper. - Manuel Rigger; Matthias Grimmer; Hanspeter Mössenböck (ICOOOLPS@ECOOP, 2016)

Efficient and thread-safe objects for dynamically-typed languages. - Benoit Daloze; Stefan Marr; Daniele Bonetta; Hanspeter Mössenböck (OOPSLA, 2016)

Bringing low-level languages to the JVM: efficient execution of LLVM IR on Truffle. - Manuel Rigger; Matthias Grimmer; Christian Wimmer; Thomas Würthinger; Hanspeter Mössenböck (VMIL@SPLASH, 2016)

Trace-based Register Allocation in a JIT Compiler. - Josef Eisl; Matthias Grimmer; Doug Simon; Thomas Würthinger; Hanspeter Mössenböck (PPPJ, 2016)

Efficient Memory Traces with Full Pointer Information. - Philipp Lengauer; Verena Bitto; Stefan Fitzek; Markus Weninger; Hanspeter Mössenböck (PPPJ, 2016)

Towards Meta-Level Engineering and Tooling for Complex Concurrent Systems. - Stefan Marr; Elisa Gonzalez Boix; Hanspeter Mössenböck (Software Engineering (Workshops), 2016)

Efficient Tracing and Versatile Analysis of Lock Contention in Java Applications on the Virtual Machine Level. - Peter Hofer; David Gnedt; Andreas Schörgenhumer; Hanspeter Mössenböck (ICPE, 2016)

Efficient and Viable Handling of Large Object Traces. - Philipp Lengauer; Verena Bitto; Hanspeter Mössenböck (ICPE, 2016)

A principled approach towards debugging communicating event-loops. - Carmen Torres Lopez; Elisa Gonzalez Boix; Christophe Scholliers; Stefan Marr; Hanspeter Mössenböck (AGERE!@SPLASH, 2017)

A concurrency-agnostic protocol for multi-paradigm concurrent debugging tools. - Stefan Marr; Carmen Torres Lopez; Dominik Aumayr; Elisa Gonzalez Boix; Hanspeter Mössenböck (DLS, 2017)

Trace Register Allocation Policies: Compile-time vs. Performance Trade-offs. - Josef Eisl; Stefan Marr; Thomas Würthinger; Hanspeter Mössenböck (ManLang, 2017)

Applying Optimizations for Dynamically-typed Languages to Java. - Matthias Grimmer; Stefan Marr; Mario Kahlhofer; Christian Wimmer; Thomas Würthinger; Hanspeter Mössenböck (ManLang, 2017)

Lenient Execution of C on a Java Virtual Machine: or: How I Learned to Stop Worrying and Run the Code. - Manuel Rigger; Roland Schatz; Matthias Grimmer; Hanspeter Mössenböck (ManLang, 2017)

Κόμπος: A Platform for Debugging Complex Concurrent Applications. - Stefan Marr; Carmen Torres Lopez; Dominik Aumayr; Elisa Gonzalez Boix; Hanspeter Mössenböck (Programming, 2017)

DuckTracks: Path-based Object Allocation Tracking. - Stefan Fitzek; Philipp Lengauer; Hanspeter Mössenböck (ICPE, 2017)

A Comprehensive Java Benchmark Study on Memory and Garbage Collection Behavior of DaCapo, DaCapo Scala, and SPECjvm2008. - Philipp Lengauer; Verena Bitto; Hanspeter Mössenböck; Markus Weninger (ICPE, 2017)

Efficient Sampling-based Lock Contention Profiling for Java. - Andreas Schörgenhumer; Peter Hofer; David Gnedt; Hanspeter Mössenböck (ICPE, 2017)

User-centered Offline Analysis of Memory Monitoring Data. - Markus Weninger; Philipp Lengauer; Hanspeter Mössenböck (ICPE, 2017)

A Study of Concurrency Bugs and Advanced Development Support for Actor-based Programs. - Carmen Torres Lopez; Stefan Marr; Hanspeter Mössenböck; Elisa Gonzalez Boix (CoRR, 2017)

Sulong, and Thanks for All the Bugs: Finding Errors in C Programs by Abstracting from the Native Execution Model. - Manuel Rigger; Roland Schatz; René Mayrhofer; Matthias Grimmer; Hanspeter Mössenböck (ASPLOS, 2018)

Dominance-based duplication simulation (DBDS): code duplication to enable compiler optimizations. - David Leopoldseder; Lukas Stadler; Thomas Würthinger; Josef Eisl; Doug Simon; Hanspeter Mössenböck (CGO, 2018)

Dynamic fitness functions for genetic improvement in compilers and interpreters. - Oliver Krauss; Hanspeter Mössenböck; Michael Affenzeller (GECCO (Companion), 2018)

Context-Aware Failure-Oblivious Computing as a Means of Preventing Buffer Overflows. - Manuel Rigger; Daniel Pekarek; Hanspeter Mössenböck (NSS, 2018)

A cost model for a graph-based intermediate-representation in a dynamic compiler. - David Leopoldseder; Lukas Stadler; Manuel Rigger; Thomas Würthinger; Hanspeter Mössenböck (VMIL@SPLASH, 2018)

Efficient and deterministic record & replay for actor languages. - Dominik Aumayr; Stefan Marr; Clément Béra; Elisa Gonzalez Boix; Hanspeter Mössenböck (ManLang, 2018)

Parallel trace register allocation. - Josef Eisl; David Leopoldseder; Hanspeter Mössenböck (ManLang, 2018)

Debugging native extensions of dynamic languages. - Jacob Kreindl; Manuel Rigger; Hanspeter Mössenböck (ManLang, 2018)

Fast-path loop unrolling of non-counted loops to enable subsequent compiler optimizations. - David Leopoldseder; Roland Schatz; Lukas Stadler; Manuel Rigger; Thomas Würthinger; Hanspeter Mössenböck (ManLang, 2018)

Utilizing object reference graphs and garbage collection roots to detect memory leaks in offline memory monitoring. - Markus Weninger; Elias Gander; Hanspeter Mössenböck (ManLang, 2018)

Sulong, and thanks for all the fish. - Manuel Rigger; Roland Schatz; Jacob Kreindl; Christian Häubl; Hanspeter Mössenböck (Programming, 2018)

Using Crash Frequency Analysis to Identify Error-Prone Software Technologies in Multi-System Monitoring. - Andreas Schörgenhumer; Mario Kahlhofer; Hanspeter Mössenböck; Paul Grünbacher (QRS, 2018)

An Analysis of x86-64 Inline Assembly in C Programs. - Manuel Rigger; Stefan Marr; Stephen Kell; David Leopoldseder; Hanspeter Mössenböck (VEE, 2018)

User-defined Classification and Multi-level Grouping of Objects in Memory Monitoring. - Markus Weninger; Hanspeter Mössenböck (ICPE, 2018)

Parallelization of dynamic languages: synchronizing built-in collections. - Benoit Daloze; Arie Tal; Stefan Marr; Hanspeter Mössenböck; Erez Petrank (Proc. ACM Program. Lang., 2018)

Introspection for C and its Applications to Library Robustness. - Manuel Rigger; Rene Mayrhofer; Roland Schatz; Matthias Grimmer; Hanspeter Mössenböck (Art Sci. Eng. Program., 2018)

A Study of Concurrency Bugs and Advanced Development Support for Actor-based Programs. - Carmen Torres Lopez; Stefan Marr; Elisa Gonzalez Boix; Hanspeter Mössenböck (Programming with Actors, 2018)

Promoting Talents for Computer Science. - Sara Hinterplattner; Barbara Sabitzer; Heike Demarle-Meusel; Hanspeter Mössenböck (CSEDU (1), 2019)

A Framework for Preprocessing Multivariate, Topology-Aware Time Series and Event Data in a Multi-System Environment. - Andreas Schörgenhumer; Mario Kahlhofer; Peter Chalupar; Paul Grünbacher; Hanspeter Mössenböck (HASE, 2019)

Mining patterns from genetic improvement experiments. - Oliver Krauss; Hanspeter Mössenböck; Michael Affenzeller (GI@ICSE, 2019)

Asynchronous snapshots of actor systems for latency-sensitive applications. - Dominik Aumayr; Stefan Marr; Elisa Gonzalez Boix; Hanspeter Mössenböck (MPLR, 2019)

Towards efficient, multi-language dynamic taint analysis. - Jacob Kreindl; Daniele Bonetta; Hanspeter Mössenböck (MPLR, 2019)

Supporting on-stack replacement in unstructured languages by loop reconstruction and extraction. - Raphael Mosaner; David Leopoldseder; Manuel Rigger; Roland Schatz; Hanspeter Mössenböck (MPLR, 2019)

Detection of suspicious time windows in memory monitoring. - Markus Weninger; Elias Gander; Hanspeter Mössenböck (MPLR, 2019)

Understanding GCC builtins to develop better tools. - Manuel Rigger; Stefan Marr; Bram Adams; Hanspeter Mössenböck (ESEC/SIGSOFT FSE, 2019)

Can we Predict Performance Events with Time Series Data from Monitoring Multiple Systems? - Andreas Schörgenhumer; Mario Kahlhofer; Paul Grünbacher; Hanspeter Mössenböck (ICPE Companion, 2019)

Analyzing Data Structure Growth Over Time to Facilitate Memory Leak Detection. - Markus Weninger; Elias Gander; Hanspeter Mössenböck (ICPE, 2019)

AntTracks TrendViz: Configurable Heap Memory Visualization Over Time. - Markus Weninger; Lukas Makor; Elias Gander; Hanspeter Mössenböck (ICPE Companion, 2019)

Using Multi-System Monitoring Time Series to Predict Performance Events. - Andreas Schörgenhumer; Mario Kahlhofer; Peter Chalupar; Hanspeter Mössenböck; Paul Grünbacher (Softwaretechnik-Trends, 2019)

On the Difficulties of Supervised Event Prediction based on Unbalanced Real-World Data in Multi-System Monitoring. - Andreas Schörgenhumer; Mario Kahlhofer; Peter Chalupar; Hanspeter Mössenböck; Paul Grünbacher (Softwaretechnik-Trends, 2019)

Analyzing the Evolution of Data Structures in Trace-Based Memory Monitoring. - Markus Weninger; Elias Gander; Hanspeter Mössenböck (Softwaretechnik-Trends, 2019)

Memory Leak Visualization using Evolving Software Cities. - Markus Weninger; Lukas Makor; Hanspeter Mössenböck (Softwaretechnik-Trends, 2019)

Memory Leak Analysis using Time-Travel-based and Timeline-based Tree Evolution Visualizations. - Markus Weninger; Lukas Makor; Hanspeter Mössenböck (STAG, 2020)

Towards Knowledge-guided Genetic Improvement. - Oliver Krauss; Hanspeter Mössenböck; Michael Affenzeller (ICSE (Workshops), 2020)

SymJEx: symbolic execution on the GraalVM. - Sebastian Kloibhofer; Thomas Pointhuber; Maximilian Heisinger; Hanspeter Mössenböck; Lukas Stadler; David Leopoldseder (MPLR, 2020)

Multi-language dynamic taint analysis in a polyglot virtual machine. - Jacob Kreindl; Daniele Bonetta; Lukas Stadler; David Leopoldseder; Hanspeter Mössenböck (MPLR, 2020)

trcview: interactive architecture agnostic execution trace analysis. - Daniel Pekarek; Hanspeter Mössenböck (MPLR, 2020)

Memory Cities: Visualizing Heap Memory Evolution Using the Software City Metaphor. - Markus Weninger; Lukas Makor; Hanspeter Mössenböck (VISSOFT, 2020)

Selecting Time Series Clustering Methods based on Run-Time Costs. - Andreas Schörgenhumer; Paul Grünbacher; Hanspeter Mössenböck (Softwaretechnik-Trends, 2020)

Investigating High Memory Churn via Object Lifetime Analysis to Improve Software Performance. - Markus Weninger; Elias Gander; Hanspeter Mössenböck (Softwaretechnik-Trends, 2020)

Heap Evolution Analysis Using Tree Visualizations. - Markus Weninger; Lukas Makor; Hanspeter Mössenböck (Softwaretechnik-Trends, 2020)

CompGen: generation of fast JIT compilers in a multi-language VM. - Florian Latifi; David Leopoldseder; Christian Wimmer; Hanspeter Mössenböck (DLS, 2021)

An Approach for Ranking Feature-based Clustering Methods and its Application in Multi-System Infrastructure Monitoring. - Andreas Schörgenhumer; Thomas Natschläger; Paul Grünbacher; Mario Kahlhofer; Peter Chalupar; Hanspeter Mössenböck (SEAA, 2021)

Low-overhead multi-language dynamic taint analysis on managed runtimes through speculative optimization. - Jacob Kreindl; Daniele Bonetta; Lukas Stadler; David Leopoldseder; Hanspeter Mössenböck (MPLR, 2021)

Using machine learning to predict the code size impact of duplication heuristics in a dynamic compiler. - Raphael Mosaner; David Leopoldseder; Lukas Stadler; Hanspeter Mössenböck (MPLR, 2021)

Architecture-agnostic dynamic type recovery. - Daniel Pekarek; Hanspeter Mössenböck (MPLR, 2021)

Guided Exploration: A Method for Guiding Novice Users in Interactive Memory Monitoring Tools. - Markus Weninger; Elias Gander; Hanspeter Mössenböck (Proc. ACM Hum. Comput. Interact., 2021)

Capturing High-level Nondeterminism in Concurrent Programs for Practical Concurrency Model Agnostic Record & Replay. - Dominik Aumayr; Stefan Marr; Sophie Kaleba; Elisa Gonzalez Boix; Hanspeter Mössenböck (Art Sci. Eng. Program., 2021)

Improving Vectorization Heuristics in a Dynamic Compiler with Machine Learning Models. - Raphael Mosaner; Gergö Barany; David Leopoldseder; Hanspeter Mössenböck (VMIL@SPLASH, 2022)

Automatically Transforming Arrays to Columnar Storage at Run Time✱. - Sebastian Kloibhofer; Lukas Makor; David Leopoldseder; Daniele Bonetta; Lukas Stadler; Hanspeter Mössenböck (MPLR, 2022)

Polyglot, Label-Defined Dynamic Taint Analysis in TruffleTaint. - Jacob Kreindl; Daniele Bonetta; David Leopoldseder; Lukas Stadler; Hanspeter Mössenböck (MPLR, 2022)

Dynamic Taint Analysis with Label-Defined Semantics. - Jacob Kreindl; Daniele Bonetta; Lukas Stadler; David Leopoldseder; Hanspeter Mössenböck (MPLR, 2022)

Automatic Array Transformation to Columnar Storage at Run Time. - Lukas Makor; Sebastian Kloibhofer; David Leopoldseder; Daniele Bonetta; Lukas Stadler; Hanspeter Mössenböck (MPLR, 2022)

Machine-Learning-Based Self-Optimizing Compiler Heuristics✱. - Raphael Mosaner; David Leopoldseder; Wolfgang Kisling; Lukas Stadler; Hanspeter Mössenböck (MPLR, 2022)

Generating Java Interfaces for Accessing Foreign Objects in GraalVM (Work in Progress). - Julian Garn; Florian Angerer; Hanspeter Mössenböck (MPLR, 2023)

Extraction of Virtual Machine Execution Traces. - Daniel Pekarek; Hanspeter Mössenböck (VMIL@SPLASH, 2023)

Hybrid Execution: Combining Ahead-of-Time and Just-in-Time Compilation. - Christoph Pichler; Paley Li; Roland Schatz; Hanspeter Mössenböck (VMIL@SPLASH, 2023)

Compilation Forking: A Fast and Flexible Way of Generating Data for Compiler-Internal Machine Learning Tasks. - Raphael Mosaner; David Leopoldseder; Wolfgang Kisling; Lukas Stadler; Hanspeter Mössenböck (Art Sci. Eng. Program., 2023)

Control Flow Duplication for Columnar Arrays in a Dynamic Compiler. - Sebastian Kloibhofer; Lukas Makor; David Leopoldseder; Daniele Bonetta; Lukas Stadler; Hanspeter Mössenböck (Art Sci. Eng. Program., 2023)

Taking a Closer Look: An Outlier-Driven Approach to Compilation-Time Optimization. - Florian Huemer; David Leopoldseder; Aleksandar Prokopec; Raphael Mosaner; Hanspeter Mössenböck (ECOOP, 2024)

LOOL: Low-Overhead, Optimization-Log-Guided Compiler Fuzzing (Registered Report). - Florian Schwarcz; Felix Berlakovich; Gergö Barany; Hanspeter Mössenböck (FUZZING, 2024)

Lazy Sparse Conditional Constant Propagation in the Sea of Nodes. - Christoph Aigner; Gergö Barany; Hanspeter Mössenböck (MPLR, 2024)

On Automating Hybrid Execution of Ahead-of-Time and Just-in-Time Compiled Code. - Christoph Pichler; Paley Li; Roland Schatz; Hanspeter Mössenböck (VMIL@SPLASH, 2024)

Compiler Construction - Fundamentals and Applications - Hanspeter Mössenböck (Springer, 2025)

Profile-Guided Field Externalization in an Ahead-Of-Time Compiler. - Sebastian Kloibhofer; Lukas Makor; Peter Hofer; David Leopoldseder; Hanspeter Mössenböck (ECOOP, 2025)

Automated Profile-Guided Replacement of Data Structures to Reduce Memory Allocation. - Lukas Makor; Sebastian Kloibhofer; Peter Hofer; David Leopoldseder; Hanspeter Mössenböck (Art Sci. Eng. Program., 2025)