TY - JOUR
A1 - Perscheid, Michael
A1 - Siegmund, Benjamin
A1 - Taeumel, Marcel
A1 - Hirschfeld, Robert
T1 - Studying the advancement in debugging practice of professional software developers
JF - Software Quality Journal
N2 - 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.
KW - Debugging
KW - Literature review
KW - Field study
KW - Online survey
Y1 - 2016
U6 - https://doi.org/10.1007/s11219-015-9294-2
SN - 0963-9314
SN - 1573-1367
VL - 25
SP - 83
EP - 110
PB - Springer
CY - Dordrecht
ER -
TY - JOUR
A1 - Freudenberg, Bert
A1 - Ingalls, Dan
A1 - Felgentreff, Tim
A1 - Pape, Tobias
A1 - Hirschfeld, Robert
T1 - SqueakJS A Modern and Practical Smalltalk that Runs in Any Browser
JF - ACM SIGPLAN notices
N2 - We report our experience in implementing SqueakJS, a bitcompatible implementation of Squeak/Smalltalk written in pure JavaScript. SqueakJS runs entirely in theWeb browser with a virtual file system that can be directed to a server or client-side storage. Our implementation is notable for simplicity and performance gained through adaptation to the host object memory and deployment leverage gained through the Lively Web development environment. We present several novel techniques as well as performance measurements for the resulting virtual machine. Much of this experience is potentially relevant to preserving other dynamic language systems and making them available in a browser-based environment.
KW - Smalltalk
KW - Squeak
KW - Web browsers
KW - JavaScript
Y1 - 2015
U6 - https://doi.org/10.1145/10.1145/2661088.2661100
SN - 0362-1340
SN - 1558-1160
VL - 50
IS - 2
SP - 57
EP - 66
PB - Association for Computing Machinery
CY - New York
ER -
TY - JOUR
A1 - Bauman, Spenser
A1 - Bolz, Carl Friedrich
A1 - Hirschfeld, Robert
A1 - Kirilichev, Vasily
A1 - Pape, Tobias
A1 - Siek, Jeremy G.
A1 - Tobin-Hochstadt, Sam
T1 - Pycket: A Tracing JIT for a Functional Language
JF - ACM SIGPLAN notices
N2 - We present Pycket, a high-performance tracing JIT compiler for Racket. Pycket supports a wide variety of the sophisticated features in Racket such as contracts, continuations, classes, structures, dynamic binding, and more. On average, over a standard suite of benchmarks, Pycket outperforms existing compilers, both Racket's JIT and other highly-optimizing Scheme compilers. Further, Pycket provides much better performance for Racket proxies than existing systems, dramatically reducing the overhead of contracts and gradual typing. We validate this claim with performance evaluation on multiple existing benchmark suites.
The Pycket implementation is of independent interest as an application of the RPython meta-tracing framework (originally created for PyPy), which automatically generates tracing JIT compilers from interpreters. Prior work on meta-tracing focuses on bytecode interpreters, whereas Pycket is a high-level interpreter based on the CEK abstract machine and operates directly on abstract syntax trees. Pycket supports proper tail calls and first-class continuations. In the setting of a functional language, where recursion and higher-order functions are more prevalent than explicit loops, the most significant performance challenge for a tracing JIT is identifying which control flows constitute a loop-we discuss two strategies for identifying loops and measure their impact.
KW - Experimentation
KW - Languages
KW - Measurement
KW - Performance
KW - JIT compilers
KW - contracts
KW - tracing
KW - functional languages
KW - Racket
Y1 - 2015
U6 - https://doi.org/10.1145/2784731.2784740
SN - 0362-1340
SN - 1558-1160
VL - 50
IS - 9
SP - 22
EP - 34
PB - Association for Computing Machinery
CY - New York
ER -
TY - JOUR
A1 - Weiher, Marcel
A1 - Hirschfeld, Robert
T1 - Polymorphic identifiers: uniform resource access in objective-smalltalk
JF - ACM SIGPLAN notices
N2 - In object-oriented programming, polymorphic dispatch of operations decouples clients from specific providers of services and allows implementations to be modified or substituted without affecting clients.
The Uniform Access Principle (UAP) tries to extend these qualities to resource access by demanding that access to state be indistinguishable from access to operations. Despite language features supporting the UAP, the overall goal of substitutability has not been achieved for either alternative resources such as keyed storage, files or web pages, or for alternate access mechanisms: specific kinds of resources are bound to specific access mechanisms and vice versa. Changing storage or access patterns either requires changes to both clients and service providers and trying to maintain the UAP imposes significant penalties in terms of code-duplication and/or performance overhead.
We propose introducing first class identifiers as polymorphic names for storage locations to solve these problems. With these Polymorphic Identifiers, we show that we can provide uniform access to a wide variety of resource types as well as storage and access mechanisms, whether parametrized or direct, without affecting client code, without causing code duplication or significant performance penalties.
KW - Identifiers
KW - REST
KW - Uniform Access Principle
KW - Extensibility
Y1 - 2014
U6 - https://doi.org/10.1145/2508168.2508169
SN - 0362-1340
SN - 1558-1160
VL - 49
IS - 2
SP - 61
EP - 71
PB - Association for Computing Machinery
CY - New York
ER -
TY - JOUR
A1 - Steinert, Bastian
A1 - Thamsen, Lauritz
A1 - Felgentreff, Tim
A1 - Hirschfeld, Robert
T1 - Object Versioning to Support Recovery Needs Using Proxies to Preserve Previous Development States in Lively
JF - ACM SIGPLAN notices
N2 - 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.
KW - Programming Environments
KW - Object Versioning
KW - CoExist
KW - JavaScript
KW - Lively Kernel
Y1 - 2015
U6 - https://doi.org/10.1145/2661088.2661093
SN - 0362-1340
SN - 1558-1160
VL - 50
IS - 2
SP - 113
EP - 124
PB - Association for Computing Machinery
CY - New York
ER -
TY - JOUR
A1 - Rein, Patrick
A1 - Taeumel, Marcel
A1 - Hirschfeld, Robert
T1 - Making the domain tangible
BT - implicit object lookup for source code readability
JF - Design Thinking Research
N2 - 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.
KW - Source Code Readability
KW - Domain Objects
KW - StackOverflow
KW - Squeak
KW - Custom Writable Class
Y1 - 2017
SN - 978-3-319-60967-6
SN - 978-3-319-60966-9
U6 - https://doi.org/10.1007/978-3-319-60967-6_9
SP - 171
EP - 194
PB - Springer
CY - New York
ER -
TY - JOUR
A1 - Pape, Tobias
A1 - Felgentreff, Tim
A1 - Hirschfeld, Robert
A1 - Gulenko, Anton
A1 - Bolz, Carl Friedrich
T1 - Language-independent Storage Strategies for Tracing-JIT-based Virtual Machines
JF - ACM SIGPLAN notices
N2 - 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.
KW - Implementation
KW - collection types
KW - memory optimization
KW - dynamic typing
Y1 - 2016
U6 - https://doi.org/10.1145/2816707.2816716
SN - 0362-1340
SN - 1558-1160
VL - 51
SP - 104
EP - 113
PB - Association for Computing Machinery
CY - New York
ER -
TY - JOUR
A1 - Felgentreff, Tim
A1 - Perscheid, Michael
A1 - Hirschfeld, Robert
T1 - Implementing record and refinement for debugging timing-dependent communication
JF - Science of computer programming
N2 - 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.
KW - Distributed debugging
KW - Record and replay
KW - Dynamic analysis
KW - Record and refinement
Y1 - 2016
U6 - https://doi.org/10.1016/j.scico.2015.11.006
SN - 0167-6423
SN - 1872-7964
VL - 134
SP - 4
EP - 18
PB - Elsevier
CY - Amsterdam
ER -
TY - JOUR
A1 - Rein, Patrick
A1 - Ramson, Stefan
A1 - Lincke, Jens
A1 - Felgentreff, Tim
A1 - Hirschfeld, Robert
T1 - Group-Based Behavior Adaptation Mechanisms in Object-Oriented Systems
JF - IEEE software
N2 - 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.
KW - group-based behavior adaptation
KW - lively groups
KW - ContextErlang
KW - entity-component-system
KW - predicated generic functions
KW - active layers
KW - reactive object queries
KW - context groups
KW - implied methods
KW - object-oriented languages
KW - software engineering
KW - software development
KW - contextual-variability modeling
Y1 - 2017
U6 - https://doi.org/10.1109/MS.2017.4121224
SN - 0740-7459
SN - 1937-4194
VL - 34
IS - 6
SP - 78
EP - 82
PB - Inst. of Electr. and Electronics Engineers
CY - Los Alamitos
ER -
TY - JOUR
A1 - Mattis, Toni
A1 - Beckmann, Tom
A1 - Rein, Patrick
A1 - Hirschfeld, Robert
T1 - First-class concepts
BT - Reified architectural knowledge beyond dominant decompositions
JF - Journal of object technology : JOT / ETH Zürich, Department of Computer Science
N2 - 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.
KW - software engineering
KW - modularity
KW - exploratory programming
KW - program
KW - comprehension
KW - remodularization
KW - architecture recovery
Y1 - 2022
U6 - https://doi.org/10.5381/jot.2022.21.2.a6
SN - 1660-1769
VL - 21
IS - 2
SP - 1
EP - 15
PB - ETH Zürich, Department of Computer Science
CY - Zürich
ER -
TY - JOUR
A1 - Hirschfeld, Robert
A1 - Perscheid, Michael
A1 - Haupt, Michael
T1 - Explicit use-case representation in object-oriented programming languages
JF - ACM SIGPLAN notices
N2 - Use-cases are considered an integral part of most contemporary development processes since they describe a software system's expected behavior from the perspective of its prospective users. However, the presence of and traceability to use-cases is increasingly lost in later more code-centric development activities. Use-cases, being well-encapsulated at the level of requirements descriptions, eventually lead to crosscutting concerns in system design and source code. Tracing which parts of the system contribute to which use-cases is therefore hard and so limits understandability.
In this paper, we propose an approach to making use-cases first-class entities in both the programming language and the runtime environment. Having use-cases present in the code and the running system will allow developers, maintainers, and operators to easily associate their units of work with what matters to the users. We suggest the combination of use-cases, acceptance tests, and dynamic analysis to automatically associate source code with use-cases. We present UseCasePy, an implementation of our approach to use-case-centered development in Python, and its application to the Django Web framework.
KW - design
KW - languages
KW - use-cases
KW - separation of concerns
KW - traceability
Y1 - 2012
U6 - https://doi.org/10.1145/2168696.2047856
SN - 0362-1340
VL - 47
IS - 2
SP - 51
EP - 60
PB - Association for Computing Machinery
CY - New York
ER -
TY - JOUR
A1 - Hirschfeld, Robert
A1 - Kawarnura, Katsuya
T1 - Dynamic service adaptation
JF - Software : practice & experience
N2 - Change can be observed in our environment and in the technology we build. While changes in the environment happen continuously and implicitly, our technology has to be kept in sync with the changing world around it. Although we can prepare for some of the changes for most of them we cannot. This is especially true for next-generation mobile communication systems that are expected to support the creation of a ubiquitous society where virtually everything is connected and made available within an organic information network. Resources will frequently join or leave the network, new types of media or new combinations of existing types will be used to interact and cooperate, and services will be tailored to preferences and needs of individual customers to better meet their needs. This paper outlines our research in the area of dynamic service adaptation to provide concepts and technologies allowing for such environments. Copyright (C) 2006 John Wiley & Sons, Ltd.
KW - dynamic service adaptation
KW - DSA
KW - aspect-oriented programming
KW - dynamic AOP
Y1 - 2006
U6 - https://doi.org/10.1002/spe.766
SN - 0038-0644
SN - 1097-024X
VL - 36
IS - 11-12
SP - 1115
EP - 1131
PB - Wiley
CY - Chichester
ER -
TY - JOUR
A1 - Haupt, Michael
A1 - Adams, Bram
A1 - Timbermont, Stijn
A1 - Gibbs, Celina
A1 - Coady, Yvonne
A1 - Hirschfeld, Robert
T1 - Disentangling virtual machine architecture
N2 - Virtual machine (VM) implementations are made of intricately intertwined subsystems, interacting largely through implicit dependencies. As the degree of crosscutting present in VMs is very high, VM implementations exhibit significant internal complexity. This study proposes an architecture approach for VMs that regards a VM as a composite of service modules coordinated through explicit bidirectional interfaces. Aspect-oriented programming techniques are used to establish these interfaces, to coordinate module interaction, and to declaratively express concrete VM architectures. A VM architecture description language is presented in a case study, illustrating the application of the proposed architectural principles.
Y1 - 2009
UR - http://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=4124007
U6 - https://doi.org/10.1049/iet-sen.2007.0121
SN - 1751-8806
ER -
TY - JOUR
A1 - Steinert, Bastian
A1 - Cassou, Damien
A1 - Hirschfeld, Robert
T1 - CoExist overcoming aversion to change preserving immediate access to source code and run-time information of previous development states
JF - ACM SIGPLAN notices
N2 - Programmers make many changes to the program to eventually find a good solution for a given task. In this course of change, every intermediate development state can of value, when, for example, a promising ideas suddenly turn out inappropriate or the interplay of objects turns out more complex than initially expected before making changes. Programmers would benefit from tool support that provides immediate access to source code and run-time of previous development states of interest. We present IDE extensions, implemented for Squeak/Smalltalk, to preserve, retrieve, and work with this information. With such tool support, programmers can work without worries because they can rely on tools that help them with whatever their explorations will reveal. They no longer have to follow certain best practices only to avoid undesired consequences of changing code.
KW - Design
KW - Experimentation
KW - Human Factors
KW - Continuous Testing
KW - Continuous Versioning
KW - Debugging
KW - Evolution
KW - Explore-first Programming
KW - Fault Localization
KW - Prototyping
Y1 - 2013
U6 - https://doi.org/10.1145/2480360.2384591
SN - 0362-1340
VL - 48
IS - 2
SP - 107
EP - 117
PB - Association for Computing Machinery
CY - New York
ER -
TY - JOUR
A1 - Steinert, Bastian
A1 - Hirschfeld, Robert
T1 - Applying design knowledge to programming
Y1 - 2012
ER -
TY - JOUR
A1 - Lincke, Jens
A1 - Appeltauer, Malte
A1 - Steinert, Bastian
A1 - Hirschfeld, Robert
T1 - An open implementation for context-oriented layer composition in ContextJS
JF - Science of computer programming
N2 - Context-oriented programming (COP) provides dedicated support for defining and composing variations to a basic program behavior. A variation, which is defined within a layer, can be de-/activated for the dynamic extent of a code block. While this mechanism allows for control flow-specific scoping, expressing behavior adaptations can demand alternative scopes. For instance, adaptations can depend on dynamic object structure rather than control flow. We present scenarios for behavior adaptation and identify the need for new scoping mechanisms. The increasing number of scoping mechanisms calls for new language abstractions representing them. We suggest to open the implementation of scoping mechanisms so that developers can extend the COP language core according to their specific needs. Our open implementation moves layer composition into objects to be affected and with that closer to the method dispatch to be changed. We discuss the implementation of established COP scoping mechanisms using our approach and present new scoping mechanisms developed for our enhancements to Lively Kernel.
KW - ContextJS
KW - Context-oriented programming
KW - Open implementations
KW - Dynamic adaptation
KW - Scope
Y1 - 2011
U6 - https://doi.org/10.1016/j.scico.2010.11.013
SN - 0167-6423
VL - 76
IS - 12
SP - 1194
EP - 1209
PB - Elsevier
CY - Amsterdam
ER -
TY - JOUR
A1 - Hirschfeld, Robert
A1 - Steinert, Bastian
A1 - Lincke, Jens
T1 - Agile software development in virtual collaboration environments
Y1 - 2011
SN - 978-3-642-13756-3
ER -
TY - JOUR
A1 - Pape, Tobias
A1 - Bolz, Carl Friedrich
A1 - Hirschfeld, Robert
T1 - Adaptive just-in-time value class optimization for lowering memory consumption and improving execution time performance
JF - Science of computer programming
N2 - 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.
KW - Meta-tracing
KW - JIT
KW - Data structure optimization
KW - Value classes
Y1 - 2017
U6 - https://doi.org/10.1016/j.scico.2016.08.003
SN - 0167-6423
SN - 1872-7964
VL - 140
SP - 17
EP - 29
PB - Elsevier
CY - Amsterdam
ER -