@article{HauptAdamsTimbermontetal.2009,
  author    = {Haupt, Michael and Adams, Bram and Timbermont, Stijn and Gibbs, Celina and Coady, Yvonne and Hirschfeld, Robert},
  title     = {Disentangling virtual machine architecture},
  issn      = {1751-8806},
  doi       = {10.1049/iet-sen.2007.0121},
  year      = {2009},
  abstract  = {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.},
  language  = {en}
}
@article{LinckeAppeltauerSteinertetal.2011,
  author    = {Lincke, Jens and Appeltauer, Malte and Steinert, Bastian and Hirschfeld, Robert},
  title     = {An open implementation for context-oriented layer composition in ContextJS},
  series = {Science of computer programming},
  volume    = {76},
  journal   = {Science of computer programming},
  number    = {12},
  publisher = {Elsevier},
  address   = {Amsterdam},
  issn      = {0167-6423},
  doi       = {10.1016/j.scico.2010.11.013},
  pages     = {1194 -- 1209},
  year      = {2011},
  abstract  = {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.},
  language  = {en}
}
@article{HirschfeldPerscheidHaupt2012,
  author    = {Hirschfeld, Robert and Perscheid, Michael and Haupt, Michael},
  title     = {Explicit use-case representation in object-oriented programming languages},
  series = {ACM SIGPLAN notices},
  volume    = {47},
  journal   = {ACM SIGPLAN notices},
  number    = {2},
  publisher = {Association for Computing Machinery},
  address   = {New York},
  issn      = {0362-1340},
  doi       = {10.1145/2168696.2047856},
  pages     = {51 -- 60},
  year      = {2012},
  abstract  = {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.},
  language  = {en}
}
@article{BaumanBolzHirschfeldetal.2015,
  author    = {Bauman, Spenser and Bolz, Carl Friedrich and Hirschfeld, Robert and Kirilichev, Vasily and Pape, Tobias and Siek, Jeremy G. and Tobin-Hochstadt, Sam},
  title     = {Pycket: A Tracing JIT for a Functional Language},
  series = {ACM SIGPLAN notices},
  volume    = {50},
  journal   = {ACM SIGPLAN notices},
  number    = {9},
  publisher = {Association for Computing Machinery},
  address   = {New York},
  issn      = {0362-1340},
  doi       = {10.1145/2784731.2784740},
  pages     = {22 -- 34},
  year      = {2015},
  abstract  = {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.},
  language  = {en}
}
@article{FreudenbergIngallsFelgentreffetal.2015,
  author    = {Freudenberg, Bert and Ingalls, Dan and Felgentreff, Tim and Pape, Tobias and Hirschfeld, Robert},
  title     = {SqueakJS A Modern and Practical Smalltalk that Runs in Any Browser},
  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/10.1145/2661088.2661100},
  pages     = {57 -- 66},
  year      = {2015},
  abstract  = {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.},
  language  = {en}
}
@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{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{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. <br /> 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. <br /> 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}
}