@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{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{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{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}
}