@article{SteinertThamsenFelgentreffetal.2015,
author = {Steinert, Bastian and Thamsen, Lauritz and Felgentreff, Tim and Hirschfeld, Robert},
title = {Object Versioning to Support Recovery Needs Using Proxies to Preserve Previous Development States in Lively},
series = {ACM SIGPLAN notices},
volume = {50},
journal = {ACM SIGPLAN notices},
number = {2},
publisher = {Association for Computing Machinery},
address = {New York},
issn = {0362-1340},
doi = {10.1145/2661088.2661093},
pages = {113 -- 124},
year = {2015},
abstract = {We present object versioning as a generic approach to preserve access to previous development and application states. Version-aware references can manage the modifications made to the target object and record versions as desired. Such references can be provided without modifications to the virtual machine. We used proxies to implement the proposed concepts and demonstrate the Lively Kernel running on top of this object versioning layer. This enables Lively users to undo the effects of direct manipulation and other programming actions.},
language = {en}
}
@article{PapeFelgentreffHirschfeldetal.2016,
author = {Pape, Tobias and Felgentreff, Tim and Hirschfeld, Robert and Gulenko, Anton and Bolz, Carl Friedrich},
title = {Language-independent Storage Strategies for Tracing-JIT-based Virtual Machines},
series = {ACM SIGPLAN notices},
volume = {51},
journal = {ACM SIGPLAN notices},
publisher = {Association for Computing Machinery},
address = {New York},
issn = {0362-1340},
doi = {10.1145/2816707.2816716},
pages = {104 -- 113},
year = {2016},
abstract = {Storage strategies have been proposed as a run-time optimization for the PyPy Python implementation and have shown promising results for optimizing execution speed and memory requirements. However, it remained unclear whether the approach works equally well in other dynamic languages. Furthermore, while PyPy is based on RPython, a language to write VMs with reusable components such as a tracing just-in-time compiler and garbage collection, the strategies design itself was not generalized to be reusable across languages implemented using that same toolchain. In this paper, we present a general design and implementation for storage strategies and show how they can be reused across different RPython-based languages. We evaluate the performance of our implementation for RSqueak, an RPython-based VM for Squeak/Smalltalk and show that storage strategies may indeed off er performance benefits for certain workloads in other dynamic programming languages. We furthermore evaluate the generality of our implementation by applying it to Topaz, a Ruby VM, and Pycket, a Racket implementation.},
language = {en}
}
@article{ReinRamsonLinckeetal.2017,
author = {Rein, Patrick and Ramson, Stefan and Lincke, Jens and Felgentreff, Tim and Hirschfeld, Robert},
title = {Group-Based Behavior Adaptation Mechanisms in Object-Oriented Systems},
series = {IEEE software},
volume = {34},
journal = {IEEE software},
number = {6},
publisher = {Inst. of Electr. and Electronics Engineers},
address = {Los Alamitos},
issn = {0740-7459},
doi = {10.1109/MS.2017.4121224},
pages = {78 -- 82},
year = {2017},
abstract = {Dynamic and distributed systems require behavior adaptations for groups of objects. Group-based behavior adaptation mechanisms scope adaptations to objects matching conditions beyond class membership. The specification of groups can be explicit or implicit.},
language = {en}
}
@article{PerscheidSiegmundTaeumeletal.2017,
author = {Perscheid, Michael and Siegmund, Benjamin and Taeumel, Marcel and Hirschfeld, Robert},
title = {Studying the advancement in debugging practice of professional software developers},
series = {Software Quality Journal},
volume = {25},
journal = {Software Quality Journal},
publisher = {Springer},
address = {Dordrecht},
issn = {0963-9314},
doi = {10.1007/s11219-015-9294-2},
pages = {83 -- 110},
year = {2017},
abstract = {In 1997, Henry Lieberman stated that debugging is the dirty little secret of computer science. Since then, several promising debugging technologies have been developed such as back-in-time debuggers and automatic fault localization methods. However, the last study about the state-of-the-art in debugging is still more than 15 years old and so it is not clear whether these new approaches have been applied in practice or not. For that reason, we investigate the current state of debugging in a comprehensive study. First, we review the available literature and learn about current approaches and study results. Second, we observe several professional developers while debugging and interview them about their experiences. Third, we create a questionnaire that serves as the basis for a larger online debugging survey. Based on these results, we present new insights into debugging practice that help to suggest new directions for future research.},
language = {en}
}
@article{FelgentreffPerscheidHirschfeld2017,
author = {Felgentreff, Tim and Perscheid, Michael and Hirschfeld, Robert},
title = {Implementing record and refinement for debugging timing-dependent communication},
series = {Science of computer programming},
volume = {134},
journal = {Science of computer programming},
publisher = {Elsevier},
address = {Amsterdam},
issn = {0167-6423},
doi = {10.1016/j.scico.2015.11.006},
pages = {4 -- 18},
year = {2017},
abstract = {Distributed applications are hard to debug because timing-dependent network communication is a source of non-deterministic behavior. Current approaches to debug non deterministic failures include post-mortem debugging as well as record and replay. However, the first impairs system performance to gather data, whereas the latter requires developers to understand the timing-dependent communication at a lower level of abstraction than they develop at. Furthermore, both approaches require intrusive core library modifications to gather data from live systems. In this paper, we present the Peek-At-Talk debugger for investigating non-deterministic failures with low overhead in a systematic, top-down method, with a particular focus on tool-building issues in the following areas: First, we show how our debugging framework Path Tools guides developers from failures to their root causes and gathers run-time data with low overhead. Second, we present Peek-At-Talk, an extension to our Path Tools framework to record non-deterministic communication and refine behavioral data that connects source code with network events. Finally, we scope changes to the core library to record network communication without impacting other network applications.},
language = {en}
}
@article{ReinTaeumelHirschfeld2017,
author = {Rein, Patrick and Taeumel, Marcel and Hirschfeld, Robert},
title = {Making the domain tangible},
series = {Design Thinking Research},
journal = {Design Thinking Research},
publisher = {Springer},
address = {New York},
isbn = {978-3-319-60967-6},
doi = {10.1007/978-3-319-60967-6_9},
pages = {171 -- 194},
year = {2017},
abstract = {Programmers collaborate continuously with domain experts to explore the problem space and to shape a solution that fits the users' needs. In doing so, all parties develop a shared vocabulary, which is above all a list of named concepts and their relationships to each other. Nowadays, many programmers favor object-oriented programming because it allows them to directly represent real-world concepts and interactions from the vocabulary as code. However, when existing domain data is not yet represented as objects, it becomes a challenge to initially bring existing domain data into object-oriented systems and to keep the source code readable. While source code might be comprehensible to programmers, domain experts can struggle, given their non-programming background. We present a new approach to provide a mapping of existing data sources into the object-oriented programming environment. We support keeping the code of the domain model compact and readable while adding implicit means to access external information as internal domain objects. This should encourage programmers to explore different ways to build the software system quickly. Eventually, our approach fosters communication with the domain experts, especially at the beginning of a project. When the details in the problem space are not yet clear, the source code provides a valuable, tangible communication artifact.},
language = {en}
}
@article{PapeBolzHirschfeld2017,
author = {Pape, Tobias and Bolz, Carl Friedrich and Hirschfeld, Robert},
title = {Adaptive just-in-time value class optimization for lowering memory consumption and improving execution time performance},
series = {Science of computer programming},
volume = {140},
journal = {Science of computer programming},
publisher = {Elsevier},
address = {Amsterdam},
issn = {0167-6423},
doi = {10.1016/j.scico.2016.08.003},
pages = {17 -- 29},
year = {2017},
abstract = {The performance of value classes is highly dependent on how they are represented in the virtual machine. Value class instances are immutable, have no identity, and can only refer to other value objects or primitive values and since they should be very lightweight and fast, it is important to optimize them carefully. In this paper we present a technique to detect and compress common patterns of value class usage to improve memory usage and performance. The technique identifies patterns of frequent value object references and introduces abbreviated forms for them. This allows to store multiple inter-referenced value objects in an inlined memory representation, reducing the overhead stemming from meta data and object references. Applied to a small prototype and an implementation of the Racket language, we found improvements in memory usage and execution time for several micro-benchmarks. (C) 2016 Elsevier B.V. All rights reserved.},
language = {en}
}
@article{MattisBeckmannReinetal.2022,
author = {Mattis, Toni and Beckmann, Tom and Rein, Patrick and Hirschfeld, Robert},
title = {First-class concepts},
series = {Journal of object technology : JOT / ETH Z{\"u}rich, Department of Computer Science},
volume = {21},
journal = {Journal of object technology : JOT / ETH Z{\"u}rich, Department of Computer Science},
number = {2},
publisher = {ETH Z{\"u}rich, Department of Computer Science},
address = {Z{\"u}rich},
issn = {1660-1769},
doi = {10.5381/jot.2022.21.2.a6},
pages = {1 -- 15},
year = {2022},
abstract = {Ideally, programs are partitioned into independently maintainable and understandable modules. As a system grows, its architecture gradually loses the capability to accommodate new concepts in a modular way. While refactoring is expensive and not always possible, and the programming language might lack dedicated primary language constructs to express certain cross-cutting concerns, programmers are still able to explain and delineate convoluted concepts through secondary means: code comments, use of whitespace and arrangement of code, documentation, or communicating tacit knowledge.
Secondary constructs are easy to change and provide high flexibility in communicating cross-cutting concerns and other concepts among programmers. However, such secondary constructs usually have no reified representation that can be explored and manipulated as first-class entities through the programming environment.
In this exploratory work, we discuss novel ways to express a wide range of concepts, including cross-cutting concerns, patterns, and lifecycle artifacts independently of the dominant decomposition imposed by an existing architecture. We propose the representation of concepts as first-class objects inside the programming environment that retain the capability to change as easily as code comments. We explore new tools that allow programmers to view, navigate, and change programs based on conceptual perspectives. In a small case study, we demonstrate how such views can be created and how the programming experience changes from draining programmers' attention by stretching it across multiple modules toward focusing it on cohesively presented concepts. Our designs are geared toward facilitating multiple secondary perspectives on a system to co-exist in symbiosis with the original architecture, hence making it easier to explore, understand, and explain complex contexts and narratives that are hard or impossible to express using primary modularity constructs.},
language = {en}
}