Papers by Hanspeter Mössenböck
arXiv (Cornell University), Jul 1, 2019
C programs can use compiler builtins to provide functionality that the C language lacks. On Linux... more C programs can use compiler builtins to provide functionality that the C language lacks. On Linux, GCC provides several thousands of builtins that are also supported by other mature compilers, such as Clang and ICC. Maintainers of other tools lack guidance on whether and which builtins should be implemented to support popular projects. To assist tool developers who want to support GCC builtins, we analyzed builtin use in 4,913 C projects from GitHub. We found that 37% of these projects relied on at least one builtin. Supporting an increasing proportion of projects requires support of an exponentially increasing number of builtins; however, implementing only 10 builtins already covers over 30% of the projects. Since we found that many builtins in our corpus remained unused, the effort needed to support 90% of the projects is moderate, requiring about 110 builtins to be implemented. For each project, we analyzed the evolution of builtin use over time and found that the majority of projects mostly added builtins. This suggests that builtins are not a legacy feature and must be supported in future tools. Systematic testing of builtin support in existing tools revealed that many lacked support for builtins either partially or completely; we also discovered incorrect implementations in various tools, including the formally verified CompCert compiler. • Software and its engineering → Language features; Compilers.
Software engineering, 2010
Plug-in frameworks support the development of component-based software that is extensible and cus... more Plug-in frameworks support the development of component-based software that is extensible and customizable to the needs of specific users. However, most current frameworks are targeting single-user rich client applications but do not support plug-in-based web applications which can be extended by end users. We show how an existing plug-in framework (Plux.NET) can be enabled to support multi-user plug-in-based web applications which are dynamically extensible by end users through server-side and client-side extensions.
Lecture Notes in Computer Science, 2018
The actor model is an attractive foundation for developing concurrent applications because actors... more The actor model is an attractive foundation for developing concurrent applications because actors are isolated concurrent entities that communicate through asynchronous messages and do not share state. Thereby, they avoid concurrency bugs such as data races, but are not immune to concurrency bugs in general. This study taxonomizes concurrency bugs in actor-based programs reported in literature. Furthermore, it analyzes the bugs to identify the patterns causing them as well as their observable behavior. Based on this taxonomy, we further analyze the literature and find that current approaches to static analysis and testing focus on communication deadlocks and message protocol violations. However, they do not provide solutions to identify livelocks and behavioral deadlocks. The insights obtained in this study can be used to improve debugging support for actor-based programs with new debugging techniques to identify the root cause of complex concurrency bugs.
Springer eBooks, 1995
Oberon-2 is a small, clean, type-safe, general-purpose programming language developed in the trad... more Oberon-2 is a small, clean, type-safe, general-purpose programming language developed in the traditional of Pascal and Modula-2. Its most important features are block structure, modularity, separate compilation, strong type checking, and type extension with type bound procedures. The last mentioned properties make the language suitable for object oriented programming. Let us cite the words of Niklaus Wirth from the Foreword of the book: "It is to the author's credit that he introduces the concepts of objectoriented programming in a constructive way, demonstrates them in an evolutionarily manner, and uses suitable examples to show how these concepts can be employed judiciously. The programming in Oberon-2 provides an excellent foundation because it adds only the few typically object-oriented concepts to those of conventional procedural programming but no more". After a short introduction into Oberon-2 (its definition is presented in Appendix), the author describes the main concepts of object-oriented programming such as: data abstraction, classes, inheritance, dynamic binding. However, the main part of the book deals with object-oriented design and programming. The programming examples are well chosen and ranges for very small illustrations to large practical system included at the end of the book. The material is well organized and presented in a concise and understandable way. The book may be considered as a good introductorily text for everyone interested in object-oriented programming. Reviewer: G.Grigas (Vilnius)
Springer eBooks, 2004
The model-view-controller pattern is used to keep a data model and its views consistent. Usually ... more The model-view-controller pattern is used to keep a data model and its views consistent. Usually there is a one-to-one correspondence between the data in the model and its representation in the views, which is sometimes too inflexible. We propose to add so-called data mappings between the model and its views. Data mappings are components that can be plugged together hierarchically. They can perform any transformations on the data as well on notifications, thus allowing a more flexible collaboration between a model and its views. GUI builders can be extended so that a user can add data mappings to a graphical user interface interactively, i.e. without programming.
Springer eBooks, 1998
Dieses Werk ist urheberrechtlich geschiitzt. Die dadurch begriindeten Rechte, insbesondere die de... more Dieses Werk ist urheberrechtlich geschiitzt. Die dadurch begriindeten Rechte, insbesondere die der Ubersetzung, des Nachdrucks, des Vortrags, der Entnahme von Abbildungen und Tabellen, der Funksendung, der Mikroverfilmung oder der Vervielfaltigung auf anderen Wegen und der Speicherung in Datenverarbeitungsanlagen, bleiben, auch bei nur auszugsweiser Verwertung, vorbehalten. Eine Vervielfaltigung dieses Werkes oder von Teilen dieses Werkes ist auch im Einzelfall nur in den Grenzen der gesetzlichen Bestimmungen des Urheberrechtsgesetzes der Bundesrepublik Deutschland Yom 9. September 1965 in der jeweils geltenden Fassung zuliissig. Sie ist grundsatzlich vergiitungspflichtig. Zuwiderhandlungen unterliegen den Strafbestimmungen des Urheberrechtsgesetzes.
Nordic Journal of Computing, Mar 1, 1994
We show how an object-oriented system-and in particular the Oberon System-can be used to write so... more We show how an object-oriented system-and in particular the Oberon System-can be used to write software that is extensible by end users even while the software is running. Extensibility instead of completeness may be a way out of the unpleasant situation in software industry where applications still tend to become bigger every year. Oberon is both an object-oriented programming language and an operating system with new concepts such as commands and dynamic loading. The language and the system make up an environment that is similar to Smalltalk in its flexibility but offers static typechecking and is much more efficient.
Sigplan Notices, Nov 1, 2016
The version in the Kent Academic Repository may differ from the final published version. Users ar... more The version in the Kent Academic Repository may differ from the final published version. Users are advised to check for the status of the paper. Users should always cite the published version of record.
Springer eBooks, 1991
This paper presents a compiler description language and its implementation Coco/R (Compiler Compi... more This paper presents a compiler description language and its implementation Coco/R (Compiler Compiler for Recursive Descent). Coco/R reads an attributed EBNF grammar of a language and translates it into a recursive descent parser and a scanner for that language. The programmer has to supply a main program that calls the parser and semantic modules that are called from within the parser. Coco/R evolved from two predecessors: the scanner generator Alex [Mrss86] and the parser generator Coco [ReM689]. Their input languages were merged and simplified due to our experiences with these tools over several years (a similar tool with a slightly different motivation also emerged from Alex and Coco [DoPi90]). Using Coco/R, compilers can be generated that are as efficient as hand-coded and carefully optimized production quality compilers. Almost as important as efficiency is the simplicity and adequacy of the system. Programmers are not willing to use a tool if it does not come in handy to their work, if it uses an arcane notation or a bulk of options and special cases. Coco/R puts simplicity and efficiency over power.
The version in the Kent Academic Repository may differ from the final published version. Users ar... more The version in the Kent Academic Repository may differ from the final published version. Users are advised to check for the status of the paper. Users should always cite the published version of record.
Software engineering, 2008
In this paper we present the language Monaco, which is a DSL for programming event-based, reactiv... more In this paper we present the language Monaco, which is a DSL for programming event-based, reactive automation solutions. The main purpose of the language is to bring automation programming closer to the domain experts and end users. Important design goals therefore have been to keep the language simple and allow writing programs which are close to the perception of domain experts. The language Monaco is similar to Statecharts in its expressive power, however, adopts an imperative notation. Moreover, Monaco adopts a state-of-the-art component approach with interfaces and polymorphic implementations and it enforces strict hierarchical communication architectures which support the hierarchical abstraction of control tasks. We discuss the main design goals, the essential programming elements, and the visual program representation and illustrate how the language supports hierarchical abstraction of control functionality by an example application.
Sigplan Notices, Oct 10, 2010
Plug-in components are a means for making feature-rich applications customizable. Combined with p... more Plug-in components are a means for making feature-rich applications customizable. Combined with plug-and-play composition, end users can assemble customized applications without programming. If plug-and-play composition is also dynamic, applications can be reconfigured on the fly to load only components the user needs for his current work. We have created Plux.NET, a plug-in framework that supports dynamic plug-and-play composition. The basis for plug-and-play in Plux is the composer which replaces programmatic composition by automatic composition. Components just specify their requirements and provisions using metadata. The composer then assembles the components based on that metadata by matching requirements and provisions. When the composer needs to reuse general-purpose components in different parts of an application, the component model requires genericity. The composer depends on metadata that specify which components should be connected and for general-purpose components those metadata need to be different on each reuse. We present an approach for generic plug-ins with component templates and an implementation for Plux. The general-purpose components become templates and the templates get parameterized when they are composed.
Springer eBooks, 1999
We describe the reflection model of Oberon-2, a language in the tradition of Pascal and Modula-2.... more We describe the reflection model of Oberon-2, a language in the tradition of Pascal and Modula-2. It provides run-time information about the structure of variables, types and procedures and allows the programmer t o manipulate the values of variables. The special aspect of the Oberon-2 reflection model is that metainformation is not obtained via metaclasses. It is rather organized as structured sequences of elements stored on a disk, which can be enumerated by an iterator. This results in a simple and uniform access mechanism and keeps the memory overhead to a minimum. We also show a number of challenging applications that have been implemented with this reflection model.
Coco/R 1 is a compiler generator, which takes an attributed grammar of a source language and gene... more Coco/R 1 is a compiler generator, which takes an attributed grammar of a source language and generates a scanner and a parser for this language. The scanner works as a deterministic finite automaton. The parser uses recursive descent. LL(1) conflicts can be resolved by a multi-symbol lookahead or by semantic checks. Thus the class of accepted grammars is LL(k) for an arbitrary k.
Where has all my memory gone?
Non-functional properties such as memory footprint have recently gained importance in software pr... more Non-functional properties such as memory footprint have recently gained importance in software product line research. However, determining the memory characteristics of individual features and product variants is extremely challenging. We present an approach that supports the monitoring of memory characteristics of individual features at the level of Java virtual machines. Our approach provides extensions to Java virtual machines to track memory allocations and deal-locations of individual features based on a feature-to-code mapping. The approach enables continuous monitoring at the level of features to detect anomalies such as memory leaks, excessive memory consumption, or abnormal garbage collection times in product variants. We provide an evaluation of our approach based on different product variants of the DesktopSearcher product line. Our experiment with different program inputs demonstrates the feasibility of our technique.
Proceedings of the IEEE/ACM 42nd International Conference on Software Engineering Workshops, 2020
We propose Knowledge-guided Genetic Improvement as a combination of Grammar-guided Genetic Progra... more We propose Knowledge-guided Genetic Improvement as a combination of Grammar-guided Genetic Programming with Tree-based Genetic Programming. Instead of utilizing a grammar directly, an operator graph based on that grammar is created, that is responsible for producing abstract syntax trees. Each operator contains knowledge about the grammar symbol it represents and returns only trees valid according to user-defined restrictions such as depth, complexity and approximated run-time performance. The expected benefits are a search space that excludes invalid individuals in an evolutionary run, ensuing a reduced overhead to evaluate invalid solutions and improving overall quality of the explored search space. The operator graph supports improvements based on previously run experiments and extensions towards further non-functional features. Software and its engineering Source code generation; Interpreters; Computing methodologies Genetic algorithms.
Data Abstraction
Object-Oriented Programming in Oberon-2, 1995
Dynamic Binding
Object-Oriented Programming, 1993
Memory anomalies such as memory leaks can dramatically impact application performance and can eve... more Memory anomalies such as memory leaks can dramatically impact application performance and can even lead to crashes. Thus, supporting developers in understanding the heap memory behavior of their systems is essential. Unfortunately, most memory analysis tools lack advanced visualizations that could facilitate developers in analyzing suspicious memory behavior. To analyze heap memory, it is common to group the heap’s objects, for example, by their types or by their allocation sites. Using multiple grouping criteria thus results in a tree-shaped representation of the heap content. Such a heap tree is then typically presented textually in a tree table. In this paper, we present ongoing research on using well-known tree visualization techniques to visualize such heap trees as well as their evolution over time. Such visualizations may ease the detection of proliferating heap objects, facilitating memory leak analysis. To demonstrate the feasibility and applicability of the presented appro...
Uploads
Papers by Hanspeter Mössenböck