@article{HirschfeldKawarnura2006,
author = {Hirschfeld, Robert and Kawarnura, Katsuya},
title = {Dynamic service adaptation},
series = {Software : practice \& experience},
volume = {36},
journal = {Software : practice \& experience},
number = {11-12},
publisher = {Wiley},
address = {Chichester},
issn = {0038-0644},
doi = {10.1002/spe.766},
pages = {1115 -- 1131},
year = {2006},
abstract = {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.},
language = {en}
}
@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}
}
@book{GellerHirschfeldBracha2010,
author = {Geller, Felix and Hirschfeld, Robert and Bracha, Gilad},
title = {Pattern Matching for an object-oriented and dynamically typed programming language},
publisher = {Universit{\"a}tsverlag Potsdam},
address = {Potsdam},
isbn = {978-3-86956-065-6},
url = {http://nbn-resolving.de/urn:nbn:de:kobv:517-opus-43035},
publisher = {Universit{\"a}t Potsdam},
pages = {81},
year = {2010},
abstract = {Pattern matching is a well-established concept in the functional programming community. It provides the means for concisely identifying and destructuring values of interest. This enables a clean separation of data structures and respective functionality, as well as dispatching functionality based on more than a single value. Unfortunately, expressive pattern matching facilities are seldomly incorporated in present object-oriented programming languages. We present a seamless integration of pattern matching facilities in an object-oriented and dynamically typed programming language: Newspeak. We describe language extensions to improve the practicability and integrate our additions with the existing programming environment for Newspeak. This report is based on the first author's master's thesis.},
language = {en}
}
@book{HauptMarrHirschfeld2011,
author = {Haupt, Michael and Marr, Stefan and Hirschfeld, Robert},
title = {CSOM/PL : a virtual machine product line},
publisher = {Universit{\"a}tsverlag Potsdam},
address = {Potsdam},
isbn = {978-3-86956-134-9},
url = {http://nbn-resolving.de/urn:nbn:de:kobv:517-opus-52332},
publisher = {Universit{\"a}t Potsdam},
pages = {26},
year = {2011},
abstract = {CSOM/PL is a software product line (SPL) derived from applying multi-dimensional separation of concerns (MDSOC) techniques to the domain of high-level language virtual machine (VM) implementations. For CSOM/PL, we modularised CSOM, a Smalltalk VM implemented in C, using VMADL (virtual machine architecture description language). Several features of the original CSOM were encapsulated in VMADL modules and composed in various combinations. In an evaluation of our approach, we show that applying MDSOC and SPL principles to a domain as complex as that of VMs is not only feasible but beneficial, as it improves understandability, maintainability, and configurability of VM implementations without harming performance.},
language = {en}
}
@article{HirschfeldSteinertLincke2011,
author = {Hirschfeld, Robert and Steinert, Bastian and Lincke, Jens},
title = {Agile software development in virtual collaboration environments},
isbn = {978-3-642-13756-3},
year = {2011},
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}
}
@book{KleineHirschfeldBracha2011,
author = {Kleine, Matthias and Hirschfeld, Robert and Bracha, Gilad},
title = {An abstraction for version control systems},
series = {Technische Berichte des Hasso-Plattner-Instituts f{\"u}r Softwaresystemtechnik an der Universit{\"a}t Potsdam},
journal = {Technische Berichte des Hasso-Plattner-Instituts f{\"u}r Softwaresystemtechnik an der Universit{\"a}t Potsdam},
number = {54},
publisher = {Universit{\"a}tsverlag Potsdam},
address = {Potsdam},
isbn = {978-3-86956-158-5},
issn = {1613-5652},
url = {http://nbn-resolving.de/urn:nbn:de:kobv:517-opus-55629},
publisher = {Universit{\"a}t Potsdam},
pages = {77},
year = {2011},
abstract = {Versionsverwaltungssysteme (VCS) erm{\"o}glichen es Entwicklern, {\"A}nderungen an Softwareartifakten zu verwalten. VCS werden mit Hilfe einer Vielzahl verschiedener Werkzeuge bedient, wie z.\,B. graphische Front-ends oder Kommandozeilenwerkzeuge. Es ist w{\"u}nschenswert mit einzelnen solcher Werkzeuge unterschiedliche VCS bedienen zu k{\"o}nnen. Bislang hat sich jedoch keine Abstraktion f{\"u}r Versionsverwaltungssysteme durchgesetzt, mit deren Hilfe solche Werkzeuge erstellt werden k{\"o}nnen. Stattdessen implementieren Werkzeuge zur Interaktion mit mehreren VCS ad-hoc L{\"o}sungen. Diese Masterarbeit stellt Pur vor, eine Abstraktion {\"u}ber Versionsverwaltungskonzepte. Mit Hilfe von Pur k{\"o}nnen Anwendungsprogramme entwickelt werden, die mit mehreren Versionsverwaltungssystemen interagieren k{\"o}nnen. Im Rahmen dieser Arbeit wird eine Implementierung dieser Abstraktion bereitgestellt und mit Hilfe eines Anwendungsprogramms validiert.},
language = {en}
}
@article{SteinertHirschfeld2012,
author = {Steinert, Bastian and Hirschfeld, Robert},
title = {Applying design knowledge to programming},
year = {2012},
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}
}
@book{AppeltauerHirschfeld2012,
author = {Appeltauer, Malte and Hirschfeld, Robert},
title = {The JCop language specification : Version 1.0, April 2012},
publisher = {Universit{\"a}tsverlag Potsdam},
address = {Potsdam},
isbn = {978-3-86956-193-6},
url = {http://nbn-resolving.de/urn:nbn:de:kobv:517-opus-60208},
publisher = {Universit{\"a}t Potsdam},
pages = {iv, 48},
year = {2012},
abstract = {Program behavior that relies on contextual information, such as physical location or network accessibility, is common in today's applications, yet its representation is not sufficiently supported by programming languages. With context-oriented programming (COP), such context-dependent behavioral variations can be explicitly modularized and dynamically activated. In general, COP could be used to manage any context-specific behavior. However, its contemporary realizations limit the control of dynamic adaptation. This, in turn, limits the interaction of COP's adaptation mechanisms with widely used architectures, such as event-based, mobile, and distributed programming. The JCop programming language extends Java with language constructs for context-oriented programming and additionally provides a domain-specific aspect language for declarative control over runtime adaptations. As a result, these redesigned implementations are more concise and better modularized than their counterparts using plain COP. JCop's main features have been described in our previous publications. However, a complete language specification has not been presented so far. This report presents the entire JCop language including the syntax and semantics of its new language constructs.},
language = {en}
}
@book{CalmezHesseSiegmundetal.2013,
author = {Calmez, Conrad and Hesse, Hubert and Siegmund, Benjamin and Stamm, Sebastian and Thomschke, Astrid and Hirschfeld, Robert and Ingalls, Dan and Lincke, Jens},
title = {Explorative authoring of Active Web content in a mobile environment},
publisher = {Universit{\"a}tsverlag Potsdam},
address = {Potsdam},
isbn = {978-3-86956-232-2},
url = {http://nbn-resolving.de/urn:nbn:de:kobv:517-opus-64054},
publisher = {Universit{\"a}t Potsdam},
pages = {132},
year = {2013},
abstract = {Developing rich Web applications can be a complex job - especially when it comes to mobile device support. Web-based environments such as Lively Webwerkstatt can help developers implement such applications by making the development process more direct and interactive. Further the process of developing software is collaborative which creates the need that the development environment offers collaboration facilities. This report describes extensions of the webbased development environment Lively Webwerkstatt such that it can be used in a mobile environment. The extensions are collaboration mechanisms, user interface adaptations but as well event processing and performance measuring on mobile devices.},
language = {en}
}
@book{BerovHenningMattisetal.2013,
author = {Berov, Leonid and Henning, Johannes and Mattis, Toni and Rein, Patrick and Schreiber, Robin and Seckler, Eric and Steinert, Bastian and Hirschfeld, Robert},
title = {Vereinfachung der Entwicklung von Gesch{\"a}ftsanwendungen durch Konsolidierung von Programmierkonzepten und -technologien},
publisher = {Universit{\"a}tsverlag Potsdam},
address = {Potsdam},
isbn = {978-3-86956-231-5},
url = {http://nbn-resolving.de/urn:nbn:de:kobv:517-opus-64045},
publisher = {Universit{\"a}t Potsdam},
pages = {186},
year = {2013},
abstract = {Die Komplexit{\"a}t heutiger Gesch{\"a}ftsabl{\"a}ufe und die Menge der zu verwaltenden Daten stellen hohe Anforderungen an die Entwicklung und Wartung von Gesch{\"a}ftsanwendungen. Ihr Umfang entsteht unter anderem aus der Vielzahl von Modellentit{\"a}ten und zugeh{\"o}rigen Nutzeroberfl{\"a}chen zur Bearbeitung und Analyse der Daten. Dieser Bericht pr{\"a}sentiert neuartige Konzepte und deren Umsetzung zur Vereinfachung der Entwicklung solcher umfangreichen Gesch{\"a}ftsanwendungen. Erstens: Wir schlagen vor, die Datenbank und die Laufzeitumgebung einer dynamischen objektorientierten Programmiersprache zu vereinen. Hierzu organisieren wir die Speicherstruktur von Objekten auf die Weise einer spaltenorientierten Hauptspeicherdatenbank und integrieren darauf aufbauend Transaktionen sowie eine deklarative Anfragesprache nahtlos in dieselbe Laufzeitumgebung. Somit k{\"o}nnen transaktionale und analytische Anfragen in derselben objektorientierten Hochsprache implementiert werden, und dennoch nah an den Daten ausgef{\"u}hrt werden. Zweitens: Wir beschreiben Programmiersprachkonstrukte, welche es erlauben, Nutzeroberfl{\"a}chen sowie Nutzerinteraktionen generisch und unabh{\"a}ngig von konkreten Modellentit{\"a}ten zu beschreiben. Um diese abstrakte Beschreibung nutzen zu k{\"o}nnen, reichert man die Dom{\"a}nenmodelle um vormals implizite Informationen an. Neue Modelle m{\"u}ssen nur um einige Informationen erweitert werden um bereits vorhandene Nutzeroberfl{\"a}chen und -interaktionen auch f{\"u}r sie verwenden zu k{\"o}nnen. Anpassungen, die nur f{\"u}r ein Modell gelten sollen, k{\"o}nnen unabh{\"a}ngig vom Standardverhalten, inkrementell, definiert werden. Drittens: Wir erm{\"o}glichen mit einem weiteren Programmiersprachkonstrukt die zusammenh{\"a}ngende Beschreibung von Abl{\"a}ufen der Anwendung, wie z.B. Bestellprozesse. Unser Programmierkonzept kapselt Nutzerinteraktionen in synchrone Funktionsaufrufe und macht somit Prozesse als zusammenh{\"a}ngende Folge von Berechnungen und Interaktionen darstellbar. Viertens: Wir demonstrieren ein Konzept, wie Endnutzer komplexe analytische Anfragen intuitiver formulieren k{\"o}nnen. Es basiert auf der Idee, dass Endnutzer Anfragen als Konfiguration eines Diagramms sehen. Entsprechend beschreibt ein Nutzer eine Anfrage, indem er beschreibt, was sein Diagramm darstellen soll. Nach diesem Konzept beschriebene Diagramme enthalten ausreichend Informationen, um daraus eine Anfrage generieren zu k{\"o}nnen. Hinsichtlich der Ausf{\"u}hrungsdauer sind die generierten Anfragen {\"a}quivalent zu Anfragen, die mit konventionellen Anfragesprachen formuliert sind. Das Anfragemodell setzen wir in einem Prototypen um, der auf den zuvor eingef{\"u}hrten Konzepten aufsetzt.},
language = {de}
}
@article{SteinertCassouHirschfeld2013,
author = {Steinert, Bastian and Cassou, Damien and Hirschfeld, Robert},
title = {CoExist overcoming aversion to change preserving immediate access to source code and run-time information of previous development states},
series = {ACM SIGPLAN notices},
volume = {48},
journal = {ACM SIGPLAN notices},
number = {2},
publisher = {Association for Computing Machinery},
address = {New York},
issn = {0362-1340},
doi = {10.1145/2480360.2384591},
pages = {107 -- 117},
year = {2013},
abstract = {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.},
language = {en}
}
@book{FelgentreffBorningHirschfeld2013,
author = {Felgentreff, Tim and Borning, Alan and Hirschfeld, Robert},
title = {Babelsberg : specifying and solving constraints on object behavior},
publisher = {Universit{\"a}tsverlag Potsdam},
address = {Potsdam},
isbn = {978-3-86956-265-0},
url = {http://nbn-resolving.de/urn:nbn:de:kobv:517-opus-67296},
publisher = {Universit{\"a}t Potsdam},
pages = {53},
year = {2013},
abstract = {Constraints allow developers to specify desired properties of systems in a number of domains, and have those properties be maintained automatically. This results in compact, declarative code, avoiding scattered code to check and imperatively re-satisfy invariants. Despite these advantages, constraint programming is not yet widespread, with standard imperative programming still the norm. There is a long history of research on integrating constraint programming with the imperative paradigm. However, this integration typically does not unify the constructs for encapsulation and abstraction from both paradigms. This impedes re-use of modules, as client code written in one paradigm can only use modules written to support that paradigm. Modules require redundant definitions if they are to be used in both paradigms. We present a language - Babelsberg - that unifies the constructs for en- capsulation and abstraction by using only object-oriented method definitions for both declarative and imperative code. Our prototype - Babelsberg/R - is an extension to Ruby, and continues to support Ruby's object-oriented se- mantics. It allows programmers to add constraints to existing Ruby programs in incremental steps by placing them on the results of normal object-oriented message sends. It is implemented by modifying a state-of-the-art Ruby virtual machine. The performance of standard object-oriented code without con- straints is only modestly impacted, with typically less than 10\% overhead compared with the unmodified virtual machine. Furthermore, our architec- ture for adding multiple constraint solvers allows Babelsberg to deal with constraints in a variety of domains. We argue that our approach provides a useful step toward making con- straint solving a generic tool for object-oriented programmers. We also provide example applications, written in our Ruby-based implementation, which use constraints in a variety of application domains, including interactive graphics, circuit simulations, data streaming with both hard and soft constraints on performance, and configuration file Management.},
language = {en}
}
@book{PapeTrefferHirschfeldetal.2013,
author = {Pape, Tobias and Treffer, Arian and Hirschfeld, Robert and Haupt, Michael},
title = {Extending a Java Virtual Machine to Dynamic Object-oriented Languages},
publisher = {Universit{\"a}tsverlag Potsdam},
address = {Potsdam},
isbn = {978-3-86956-266-7},
url = {http://nbn-resolving.de/urn:nbn:de:kobv:517-opus-67438},
publisher = {Universit{\"a}t Potsdam},
pages = {163},
year = {2013},
abstract = {There are two common approaches to implement a virtual machine (VM) for a dynamic object-oriented language. On the one hand, it can be implemented in a C-like language for best performance and maximum control over the resulting executable. On the other hand, it can be implemented in a language such as Java that allows for higher-level abstractions. These abstractions, such as proper object-oriented modularization, automatic memory management, or interfaces, are missing in C-like languages but they can simplify the implementation of prevalent but complex concepts in VMs, such as garbage collectors (GCs) or just-in-time compilers (JITs). Yet, the implementation of a dynamic object-oriented language in Java eventually results in two VMs on top of each other (double stack), which impedes performance. For statically typed languages, the Maxine VM solves this problem; it is written in Java but can be executed without a Java virtual machine (JVM). However, it is currently not possible to execute dynamic object-oriented languages in Maxine. This work presents an approach to bringing object models and execution models of dynamic object-oriented languages to the Maxine VM and the application of this approach to Squeak/Smalltalk. The representation of objects in and the execution of dynamic object-oriented languages pose certain challenges to the Maxine VM that lacks certain variation points necessary to enable an effortless and straightforward implementation of dynamic object-oriented languages' execution models. The implementation of Squeak/Smalltalk in Maxine as a feasibility study is to unveil such missing variation points.},
language = {en}
}
@article{WeiherHirschfeld2014,
author = {Weiher, Marcel and Hirschfeld, Robert},
title = {Polymorphic identifiers: uniform resource access in objective-smalltalk},
series = {ACM SIGPLAN notices},
volume = {49},
journal = {ACM SIGPLAN notices},
number = {2},
publisher = {Association for Computing Machinery},
address = {New York},
issn = {0362-1340},
doi = {10.1145/2508168.2508169},
pages = {61 -- 71},
year = {2014},
abstract = {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.},
language = {en}
}
@book{MeinelPlattnerDoellneretal.2014,
author = {Meinel, Christoph and Plattner, Hasso and D{\"o}llner, J{\"u}rgen Roland Friedrich and Weske, Mathias and Polze, Andreas and Hirschfeld, Robert and Naumann, Felix and Giese, Holger and Baudisch, Patrick},
title = {Proceedings of the 7th Ph.D. Retreat of the HPI Research School on Service-oriented Systems Engineering},
publisher = {Universit{\"a}tsverlag Potsdam},
address = {Potsdam},
isbn = {978-3-86956-273-5},
url = {http://nbn-resolving.de/urn:nbn:de:kobv:517-opus-63490},
publisher = {Universit{\"a}t Potsdam},
pages = {ii, 218},
year = {2014},
abstract = {Design and Implementation of service-oriented architectures imposes a huge number of research questions from the fields of software engineering, system analysis and modeling, adaptability, and application integration. Component orientation and web services are two approaches for design and realization of complex web-based system. Both approaches allow for dynamic application adaptation as well as integration of enterprise application. Commonly used technologies, such as J2EE and .NET, form de facto standards for the realization of complex distributed systems. Evolution of component systems has lead to web services and service-based architectures. This has been manifested in a multitude of industry standards and initiatives such as XML, WSDL UDDI, SOAP, etc. All these achievements lead to a new and promising paradigm in IT systems engineering which proposes to design complex software solutions as collaboration of contractually defined software services. Service-Oriented Systems Engineering represents a symbiosis of best practices in object-orientation, component-based development, distributed computing, and business process management. It provides integration of business and IT concerns. The annual Ph.D. Retreat of the Research School provides each member the opportunity to present his/her current state of their research and to give an outline of a prospective Ph.D. thesis. Due to the interdisciplinary structure of the Research Scholl, this technical report covers a wide range of research topics. These include but are not limited to: Self-Adaptive Service-Oriented Systems, Operating System Support for Service-Oriented Systems, Architecture and Modeling of Service-Oriented Systems, Adaptive Process Management, Services Composition and Workflow Planning, Security Engineering of Service-Based IT Systems, Quantitative Analysis and Optimization of Service-Oriented Systems, Service-Oriented Systems in 3D Computer Graphics sowie Service-Oriented Geoinformatics.},
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}
}
@book{OttoPollakWerneretal.2015,
author = {Otto, Philipp and Pollak, Jaqueline and Werner, Daniel and Wolff, Felix and Steinert, Bastian and Thamsen, Lauritz and Taeumel, Marcel and Lincke, Jens and Krahn, Robert and Ingalls, Daniel H. H. and Hirschfeld, Robert},
title = {Exploratives Erstellen von interaktiven Inhalten in einer dynamischen Umgebung},
number = {101},
publisher = {Universit{\"a}tsverlag Potsdam},
address = {Potsdam},
isbn = {978-3-86956-346-6},
issn = {1613-5652},
url = {http://nbn-resolving.de/urn:nbn:de:kobv:517-opus4-83806},
publisher = {Universit{\"a}t Potsdam},
pages = {vii, 115},
year = {2015},
abstract = {Bei der Erstellung von Visualisierungen gibt es im Wesentlichen zwei Ans{\"a}tze. Zum einen k{\"o}nnen mit geringem Aufwand schnell Standarddiagramme erstellt werden. Zum anderen gibt es die M{\"o}glichkeit, individuelle und interaktive Visualisierungen zu programmieren. Dies ist jedoch mit einem deutlich h{\"o}heren Aufwand verbunden. Flower erm{\"o}glicht eine schnelle Erstellung individueller und interaktiver Visualisierungen, indem es den Entwicklungssprozess stark vereinfacht und die Nutzer bei den einzelnen Aktivit{\"a}ten wie dem Import und der Aufbereitung von Daten, deren Abbildung auf visuelle Elemente sowie der Integration von Interaktivit{\"a}t direkt unterst{\"u}tzt.},
language = {de}
}
@book{FelgentreffHirschfeldMillsteinetal.2015,
author = {Felgentreff, Tim and Hirschfeld, Robert and Millstein, Todd and Borning, Alan},
title = {Babelsberg/RML},
number = {103},
publisher = {Universit{\"a}tsverlag Potsdam},
address = {Potsdam},
isbn = {978-3-86956-348-0},
issn = {1613-5652},
url = {http://nbn-resolving.de/urn:nbn:de:kobv:517-opus4-83826},
publisher = {Universit{\"a}t Potsdam},
pages = {68},
year = {2015},
abstract = {New programming language designs are often evaluated on concrete implementations. However, in order to draw conclusions about the language design from the evaluation of concrete programming languages, these implementations need to be verified against the formalism of the design. To that end, we also have to ensure that the design actually meets its stated goals. A useful tool for the latter has been to create an executable semantics from a formalism that can execute a test suite of examples. However, this mechanism so far did not allow to verify an implementation against the design. Babelsberg is a new design for a family of object-constraint languages. Recently, we have developed a formal semantics to clarify some issues in the design of those languages. Supplementing this work, we report here on how this formalism is turned into an executable operational semantics using the RML system. Furthermore, we show how we extended the executable semantics to create a framework that can generate test suites for the concrete Babelsberg implementations that provide traceability from the design to the language. Finally, we discuss how these test suites helped us find and correct mistakes in the Babelsberg implementation for JavaScript.},
language = {en}
}
@book{HerbstMaschlerNiephausetal.2015,
author = {Herbst, Eva-Maria and Maschler, Fabian and Niephaus, Fabio and Reimann, Max and Steier, Julia and Felgentreff, Tim and Lincke, Jens and Taeumel, Marcel and Hirschfeld, Robert and Witt, Carsten},
title = {ecoControl},
number = {93},
publisher = {Universit{\"a}tsverlag Potsdam},
address = {Potsdam},
isbn = {978-3-86956-318-3},
issn = {1613-5652},
url = {http://nbn-resolving.de/urn:nbn:de:kobv:517-opus4-72147},
publisher = {Universit{\"a}t Potsdam},
pages = {viii, 142},
year = {2015},
abstract = {Eine dezentrale Energieversorgung ist ein erster Schritt in Richtung Energiewende. Dabei werden auch in Mehrfamilienh{\"a}usern vermehrt verschiedene Strom- und W{\"a}rmeerzeuger eingesetzt. Besonders in Deutschland kommen in diesem Zusammenhang Blockheizkraftwerke immer h{\"a}ufiger zum Einsatz, weil sie Gas sehr effizient in Strom und W{\"a}rme umwandeln k{\"o}nnen. Außerdem erm{\"o}glichen sie, im Zusammenspiel mit anderen Energiesystemen wie beispielsweise Photovoltaik-Anlagen, eine kontinuierliche und dezentrale Energieversorgung. Bei dem Betrieb von unterschiedlichen Energiesystemen ist es w{\"u}nschenswert, dass die Systeme aufeinander abgestimmt arbeiten. Allerdings ist es bisher schwierig, heterogene Energiesysteme effizient miteinander zu betreiben. Dadurch bleiben Einsparungspotentiale ungenutzt. Eine zentrale Steuerung kann deshalb die Effizienz des Gesamtsystems verbessern. Mit ecoControl stellen wir einen erweiterbaren Prototypen vor, der die Kooperation von Energiesystemen optimiert und Umweltfaktoren miteinbezieht. Dazu stellt die Software eine einheitliche Bedienungsoberfl{\"a}che zur Konfiguration aller Systeme zur Verf{\"u}gung. Außerdem bietet sie die M{\"o}glichkeit, Optimierungsalgorithmen mit Hilfe einer Programmierschnittstelle zu entwickeln, zu testen und auszuf{\"u}hren. Innerhalb solcher Algorithmen k{\"o}nnen von ecoControl bereitgestellte Vorhersagen genutzt werden. Diese Vorhersagen basieren auf dem individuellen Verhalten von jedem Energiesystem, Wettervorhersagen und auf Prognosen des Energieverbrauchs. Mithilfe einer Simulation k{\"o}nnen Techniker unterschiedliche Konfigurationen und Optimierungen sofort ausprobieren, ohne diese {\"u}ber einen langen Zeitraum an realen Ger{\"a}ten testen zu m{\"u}ssen. ecoControl hilft dar{\"u}ber hinaus auch Hausverwaltungen und Vermietern bei der Verwaltung und Analyse der Energiekosten. Wir haben anhand von Fallbeispielen gezeigt, dass Optimierungsalgorithmen, welche die Nutzung von W{\"a}rmespeichern verbessern, die Effizienz des Gesamtsystems erheblich verbessern k{\"o}nnen. Schließlich kommen wir zu dem Schluss, dass ecoControl in einem n{\"a}chsten Schritt unter echten Bedingungen getestet werden muss, sobald eine geeignete Hardwarekomponente verf{\"u}gbar ist. {\"U}ber diese Schnittstelle werden die Messwerte an ecoControl gesendet und Steuersignale an die Ger{\"a}te weitergeleitet.},
language = {de}
}
@book{WassermannFelgentreffPapeetal.2016,
author = {Wassermann, Lars and Felgentreff, Tim and Pape, Tobias and Bolz, Carl Friedrich and Hirschfeld, Robert},
title = {Tracing Algorithmic Primitives in RSqueak/VM},
number = {104},
publisher = {Universit{\"a}tsverlag Potsdam},
address = {Potsdam},
isbn = {978-3-86956-355-8},
issn = {1613-5652},
url = {http://nbn-resolving.de/urn:nbn:de:kobv:517-opus4-91277},
publisher = {Universit{\"a}t Potsdam},
pages = {45},
year = {2016},
abstract = {When realizing a programming language as VM, implementing behavior as part of the VM, as primitive, usually results in reduced execution times. But supporting and developing primitive functions requires more effort than maintaining and using code in the hosted language since debugging is harder, and the turn-around times for VM parts are higher. Furthermore, source artifacts of primitive functions are seldom reused in new implementations of the same language. And if they are reused, the existing API usually is emulated, reducing the performance gains. Because of recent results in tracing dynamic compilation, the trade-off between performance and ease of implementation, reuse, and changeability might now be decided adversely. In this work, we investigate the trade-offs when creating primitives, and in particular how large a difference remains between primitive and hosted function run times in VMs with tracing just-in-time compiler. To that end, we implemented the algorithmic primitive BitBlt three times for RSqueak/VM. RSqueak/VM is a Smalltalk VM utilizing the PyPy RPython toolchain. We compare primitive implementations in C, RPython, and Smalltalk, showing that due to the tracing just-in-time compiler, the performance gap has lessened by one magnitude to one magnitude.},
language = {en}
}
@book{SchreiberKrahnIngallsetal.2016,
author = {Schreiber, Robin and Krahn, Robert and Ingalls, Daniel H. H. and Hirschfeld, Robert},
title = {Transmorphic},
number = {110},
publisher = {Universit{\"a}tsverlag Potsdam},
address = {Potsdam},
isbn = {978-3-86956-387-9},
issn = {1613-5652},
url = {http://nbn-resolving.de/urn:nbn:de:kobv:517-opus4-98300},
publisher = {Universit{\"a}t Potsdam},
pages = {100},
year = {2016},
abstract = {Defining Graphical User Interfaces (GUIs) through functional abstractions can reduce the complexity that arises from mutable abstractions. Recent examples, such as Facebook's React GUI framework have shown, how modelling the view as a functional projection from the application state to a visual representation can reduce the number of interacting objects and thus help to improve the reliabiliy of the system. This however comes at the price of a more rigid, functional framework where programmers are forced to express visual entities with functional abstractions, detached from the way one intuitively thinks about the physical world. In contrast to that, the GUI Framework Morphic allows interactions in the graphical domain, such as grabbing, dragging or resizing of elements to evolve an application at runtime, providing liveness and directness in the development workflow. Modelling each visual entity through mutable abstractions however makes it difficult to ensure correctness when GUIs start to grow more complex. Furthermore, by evolving morphs at runtime through direct manipulation we diverge more and more from the symbolic description that corresponds to the morph. Given that both of these approaches have their merits and problems, is there a way to combine them in a meaningful way that preserves their respective benefits? As a solution for this problem, we propose to lift Morphic's concept of direct manipulation from the mutation of state to the transformation of source code. In particular, we will explore the design, implementation and integration of a bidirectional mapping between the graphical representation and a functional and declarative symbolic description of a graphical user interface within a self hosted development environment. We will present Transmorphic, a functional take on the Morphic GUI Framework, where the visual and structural properties of morphs are defined in a purely functional, declarative fashion. In Transmorphic, the developer is able to assemble different morphs at runtime through direct manipulation which is automatically translated into changes in the code of the application. In this way, the comprehensiveness and predictability of direct manipulation can be used in the context of a purely functional GUI, while the effects of the manipulation are reflected in a medium that is always in reach for the programmer and can even be used to incorporate the source transformations into the source files of the application.},
language = {en}
}
@book{TessenowFelgentreffBrachaetal.2016,
author = {Tessenow, Philipp and Felgentreff, Tim and Bracha, Gilad and Hirschfeld, Robert},
title = {Extending a dynamic programming language and runtime environment with access control},
number = {107},
publisher = {Universit{\"a}tsverlag Potsdam},
address = {Potsdam},
isbn = {978-3-86956-373-2},
issn = {1613-5652},
url = {http://nbn-resolving.de/urn:nbn:de:kobv:517-opus4-92560},
publisher = {Universit{\"a}t Potsdam},
pages = {83},
year = {2016},
abstract = {Complexity in software systems is a major factor driving development and maintenance costs. To master this complexity, software is divided into modules that can be developed and tested separately. In order to support this separation of modules, each module should provide a clean and concise public interface. Therefore, the ability to selectively hide functionality using access control is an important feature in a programming language intended for complex software systems. Software systems are increasingly distributed, adding not only to their inherent complexity, but also presenting security challenges. The object-capability approach addresses these challenges by defining language properties providing only minimal capabilities to objects. One programming language that is based on the object-capability approach is Newspeak, a dynamic programming language designed for modularity and security. The Newspeak specification describes access control as one of Newspeak's properties, because it is a requirement for the object-capability approach. However, access control, as defined in the Newspeak specification, is currently not enforced in its implementation. This work introduces an access control implementation for Newspeak, enabling the security of object-capabilities and enhancing modularity. We describe our implementation of access control for Newspeak. We adapted the runtime environment, the reflective system, the compiler toolchain, and the virtual machine. Finally, we describe a migration strategy for the existing Newspeak code base, so that our access control implementation can be integrated with minimal effort.},
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}
}
@book{NiephausFelgentreffHirschfeld2017,
author = {Niephaus, Fabio and Felgentreff, Tim and Hirschfeld, Robert},
title = {Squimera},
number = {120},
publisher = {Universit{\"a}tsverlag Potsdam},
address = {Potsdam},
isbn = {978-3-86956-422-7},
doi = {10.25932/publishup-40338},
url = {http://nbn-resolving.de/urn:nbn:de:kobv:517-opus4-403387},
publisher = {Universit{\"a}t Potsdam},
pages = {92},
year = {2017},
abstract = {Programmierwerkzeuge, die verschiedene Programmiersprachen unterst{\"u}tzen und sich konsistent bedienen lassen, sind hilfreich f{\"u}r Softwareentwickler, weil diese sich nicht erst mit neuen Werkzeugen vertraut machen m{\"u}ssen, wenn sie in einer neuen Sprache entwickeln wollen. Außerdem ist es n{\"u}tzlich, verschiedene Programmiersprachen in einer Anwendung kombinieren zu k{\"o}nnen, da Entwickler dann Softwareframeworks und -bibliotheken nicht in der jeweiligen Sprache nachbauen m{\"u}ssen und stattdessen bestehende Software wiederverwenden k{\"o}nnen. Dennoch haben Entwickler eine sehr große Auswahl, wenn sie nach Werkzeugen suchen, die teilweise zudem speziell nur f{\"u}r eine Sprache ausgelegt sind. Einige integrierte Entwicklungsumgebungen unterst{\"u}tzen verschiedene Programmiersprachen, k{\"o}nnen aber h{\"a}ufig keine konsistente Bedienung ihrer Werkzeuge gew{\"a}hrleisten, da die jeweiligen Ausf{\"u}hrungsumgebungen der Sprachen zu verschieden sind. Dar{\"u}ber hinaus gibt es bereits Mechansimen, die es erlauben, Programme aus anderen Sprachen in einem Programm wiederzuverwenden. Dazu werden h{\"a}ufig das Betriebssystem oder eine Netzwerkverbindung verwendet. Programmierwerkzeuge unterst{\"u}tzen jedoch h{\"a}ufig eine solche Indirektion nicht und sind deshalb nur eingeschr{\"a}nkt nutzbar bei beispielsweise Debugging Szenarien. In dieser Arbeit stellen wir einen neuartigen Ansatz vor, der das Programmiererlebnis in Bezug auf das Arbeiten mit mehreren dynamischen Programmiersprachen verbessern soll. Dazu verwenden wir die Werkzeuge einer Smalltalk Programmierumgebung wieder und entwickeln eine virtuelle Ausf{\"u}hrungsumgebung, die verschiedene Sprachen gleichermaßen unterst{\"u}tzt. Der auf unserem Ansatz basierende Prototyp Squimera demonstriert, dass es m{\"o}glich ist, Programmierwerkzeuge in der Art wiederzuverwenden, sodass sie sich f{\"u}r verschiedene Programmiersprachen gleich verhalten und somit die Arbeit f{\"u}r Entwickler vereinfachen. Außerdem erm{\"o}glicht Squimera einfaches Wiederverwenden und dar{\"u}ber hinaus das Verschmischen von in unterschiedlichen Sprachen geschriebenen Softwarebibliotheken und -frameworks und erlaubt dabei zus{\"a}tzlich Debugging {\"u}ber mehrere Sprachen hinweg.},
language = {en}
}
@book{WeyandChromikWolfetal.2017,
author = {Weyand, Christopher and Chromik, Jonas and Wolf, Lennard and K{\"o}tte, Steffen and Haase, Konstantin and Felgentreff, Tim and Lincke, Jens and Hirschfeld, Robert},
title = {Improving hosted continuous integration services},
number = {108},
publisher = {Universit{\"a}tsverlag Potsdam},
address = {Potsdam},
isbn = {978-3-86956-377-0},
issn = {1613-5652},
url = {http://nbn-resolving.de/urn:nbn:de:kobv:517-opus4-94251},
publisher = {Universit{\"a}t Potsdam},
pages = {viii, 114},
year = {2017},
abstract = {Developing large software projects is a complicated task and can be demanding for developers. Continuous integration is common practice for reducing complexity. By integrating and testing changes often, changesets are kept small and therefore easily comprehensible. Travis CI is a service that offers continuous integration and continuous deployment in the cloud. Software projects are build, tested, and deployed using the Travis CI infrastructure without interrupting the development process. This report describes how Travis CI works, presents how time-driven, periodic building is implemented as well as how CI data visualization can be done, and proposes a way of dealing with dependency problems.},
language = {en}
}
@book{ReschkeTaeumelPapeetal.2018,
author = {Reschke, Jakob and Taeumel, Marcel and Pape, Tobias and Niephaus, Fabio and Hirschfeld, Robert},
title = {Towards version control in object-based systems},
volume = {121},
publisher = {Universit{\"a}tsverlag Potsdam},
address = {Potsdam},
isbn = {978-3-86956-430-2},
issn = {1613-5652},
url = {http://nbn-resolving.de/urn:nbn:de:kobv:517-opus4-410812},
publisher = {Universit{\"a}t Potsdam},
pages = {100},
year = {2018},
abstract = {Version control is a widely used practice among software developers. It reduces the risk of changing their software and allows them to manage different configurations and to collaborate with others more efficiently. This is amplified by code sharing platforms such as GitHub or Bitbucket. Most version control systems track files (e.g., Git, Mercurial, and Subversion do), but some programming environments do not operate on files, but on objects instead (many Smalltalk implementations do). Users of such environments want to use version control for their objects anyway. Specialized version control systems, such as the ones available for Smalltalk systems (e.g., ENVY/Developer and Monticello), focus on a small subset of objects that can be versioned. Most of these systems concentrate on the tracking of methods, classes, and configurations of these. Other user-defined and user-built objects are either not eligible for version control at all, tracking them involves complicated workarounds, or a fixed, domain-unspecific serialization format is used that does not equally suit all kinds of objects. Moreover, these version control systems that are specific to a programming environment require their own code sharing platforms; popular, well-established platforms for file-based version control systems cannot be used or adapter solutions need to be implemented and maintained. To improve the situation for version control of arbitrary objects, a framework for tracking, converting, and storing of objects is presented in this report. It allows editions of objects to be stored in an exchangeable, existing backend version control system. The platforms of the backend version control system can thus be reused. Users and objects have control over how objects are captured for the purpose of version control. Domain-specific requirements can be implemented. The storage format (i.e. the file format, when file-based backend version control systems are used) can also vary from one object to another. Different editions of objects can be compared and sets of changes can be applied to graphs of objects. A generic way for capturing and restoring that supports most kinds of objects is described. It models each object as a collection of slots. Thus, users can begin to track their objects without first having to implement version control supplements for their own kinds of objects. The proposed architecture is evaluated using a prototype implementation that can be used to track objects in Squeak/Smalltalk with Git. The prototype improves the suboptimal standing of user objects with respect to version control described above and also simplifies some version control tasks for classes and methods as well. It also raises new problems, which are discussed in this report as well.},
language = {en}
}
@book{BeckmannHildebrandJascheketal.2019,
author = {Beckmann, Tom and Hildebrand, Justus and Jaschek, Corinna and Krebs, Eva and L{\"o}ser, Alexander and Taeumel, Marcel and Pape, Tobias and Fister, Lasse and Hirschfeld, Robert},
title = {The font engineering platform},
number = {128},
publisher = {Universit{\"a}tsverlag Potsdam},
address = {Potsdam},
isbn = {978-3-86956-464-7},
issn = {1613-5652},
doi = {10.25932/publishup-42748},
url = {http://nbn-resolving.de/urn:nbn:de:kobv:517-opus4-427487},
publisher = {Universit{\"a}t Potsdam},
pages = {viii, 115},
year = {2019},
abstract = {Creating fonts is a complex task that requires expert knowledge in a variety of domains. Often, this knowledge is not held by a single person, but spread across a number of domain experts. A central concept needed for designing fonts is the glyph, an elemental symbol representing a readable character. Required domains include designing glyph shapes, engineering rules to combine glyphs for complex scripts and checking legibility. This process is most often iterative and requires communication in all directions. This report outlines a platform that aims to enhance the means of communication, describes our prototyping process, discusses complex font rendering and editing in a live environment and an approach to generate code based on a user's live-edits.},
language = {en}
}
@book{BeinBraunDaaseetal.2020,
author = {Bein, Leon and Braun, Tom and Daase, Bj{\"o}rn and Emsbach, Elina and Matthes, Leon and Stiede, Maximilian and Taeumel, Marcel and Mattis, Toni and Ramson, Stefan and Rein, Patrick and Hirschfeld, Robert and M{\"o}nig, Jens},
title = {SandBlocks},
number = {132},
publisher = {Universit{\"a}tsverlag Potsdam},
address = {Potsdam},
isbn = {978-3-86956-482-1},
issn = {1613-5652},
doi = {10.25932/publishup-43926},
url = {http://nbn-resolving.de/urn:nbn:de:kobv:517-opus4-439263},
publisher = {Universit{\"a}t Potsdam},
pages = {viii, 212},
year = {2020},
abstract = {Visuelle Programmiersprachen werden heutzutage zugunsten textueller Programmiersprachen nahezu nicht verwendet, obwohl visuelle Programmiersprachen einige Vorteile bieten. Diese reichen von der Vermeidung von Syntaxfehlern, {\"u}ber die Nutzung konkreter dom{\"a}nenspezifischer Notation bis hin zu besserer Lesbarkeit und Wartbarkeit des Programms. Trotzdem greifen professionelle Softwareentwickler nahezu ausschließlich auf textuelle Programmiersprachen zur{\"u}ck. Damit Entwickler diese Vorteile visueller Programmiersprachen nutzen k{\"o}nnen, aber trotzdem nicht auf die ihnen bekannten textuellen Programmiersprachen verzichten m{\"u}ssen, gibt es die Idee, textuelle und visuelle Programmelemente gemeinsam in einer Programmiersprache nutzbar zu machen. Damit ist dem Entwickler {\"u}berlassen wann und wie er visuelle Elemente in seinem Programmcode verwendet. Diese Arbeit stellt das SandBlocks-Framework vor, das diese gemeinsame Nutzung visueller und textueller Programmelemente erm{\"o}glicht. Neben einer Auswertung visueller Programmiersprachen, zeigt es die technische Integration visueller Programmelemente in das Squeak/Smalltalk-System auf, gibt Einblicke in die Umsetzung und Verwendung in Live-Programmiersystemen und diskutiert ihre Verwendung in unterschiedlichen Dom{\"a}nen.},
language = {de}
}
@book{BaltzerHradilakPfennigschmidtetal.2021,
author = {Baltzer, Wanda and Hradilak, Theresa and Pfennigschmidt, Lara and Prestin, Luc Maurice and Spranger, Moritz and Stadlinger, Simon and Wendt, Leo and Lincke, Jens and Rein, Patrick and Church, Luke and Hirschfeld, Robert},
title = {An individual-centered approach to visualize people's opinions and demographic information},
number = {136},
publisher = {Universit{\"a}tsverlag Potsdam},
address = {Potsdam},
isbn = {978-3-86956-504-0},
issn = {1613-5652},
doi = {10.25932/publishup-49145},
url = {http://nbn-resolving.de/urn:nbn:de:kobv:517-opus4-491457},
publisher = {Universit{\"a}t Potsdam},
pages = {326},
year = {2021},
abstract = {The noble way to substantiate decisions that affect many people is to ask these people for their opinions. For governments that run whole countries, this means asking all citizens for their views to consider their situations and needs. Organizations such as Africa's Voices Foundation, who want to facilitate communication between decision-makers and citizens of a country, have difficulty mediating between these groups. To enable understanding, statements need to be summarized and visualized. Accomplishing these goals in a way that does justice to the citizens' voices and situations proves challenging. Standard charts do not help this cause as they fail to create empathy for the people behind their graphical abstractions. Furthermore, these charts do not create trust in the data they are representing as there is no way to see or navigate back to the underlying code and the original data. To fulfill these functions, visualizations would highly benefit from interactions to explore the displayed data, which standard charts often only limitedly provide. To help improve the understanding of people's voices, we developed and categorized 80 ideas for new visualizations, new interactions, and better connections between different charts, which we present in this report. From those ideas, we implemented 10 prototypes and two systems that integrate different visualizations. We show that this integration allows consistent appearance and behavior of visualizations. The visualizations all share the same main concept: representing each individual with a single dot. To realize this idea, we discuss technologies that efficiently allow the rendering of a large number of these dots. With these visualizations, direct interactions with representations of individuals are achievable by clicking on them or by dragging a selection around them. This direct interaction is only possible with a bidirectional connection from the visualization to the data it displays. We discuss different strategies for bidirectional mappings and the trade-offs involved. Having unified behavior across visualizations enhances exploration. For our prototypes, that includes grouping, filtering, highlighting, and coloring of dots. Our prototyping work was enabled by the development environment Lively4. We explain which parts of Lively4 facilitated our prototyping process. Finally, we evaluate our approach to domain problems and our developed visualization concepts. Our work provides inspiration and a starting point for visualization development in this domain. Our visualizations can improve communication between citizens and their government and motivate empathetic decisions. Our approach, combining low-level entities to create visualizations, provides value to an explorative and empathetic workflow. We show that the design space for visualizing this kind of data has a lot of potential and that it is possible to combine qualitative and quantitative approaches to data analysis.},
language = {en}
}
@book{SeitzLinckeReinetal.2021,
author = {Seitz, Klara and Lincke, Jens and Rein, Patrick and Hirschfeld, Robert},
title = {Language and tool support for 3D crochet patterns},
number = {137},
publisher = {Universit{\"a}tsverlag Potsdam},
address = {Potsdam},
isbn = {978-3-86956-505-7},
issn = {1613-5652},
doi = {10.25932/publishup-49253},
url = {http://nbn-resolving.de/urn:nbn:de:kobv:517-opus4-492530},
publisher = {Universit{\"a}t Potsdam},
pages = {vii, 94},
year = {2021},
abstract = {Crochet is a popular handcraft all over the world. While other techniques such as knitting or weaving have received technical support over the years through machines, crochet is still a purely manual craft. Not just the act of crochet itself is manual but also the process of creating instructions for new crochet patterns, which is barely supported by domain specific digital solutions. This leads to unstructured and often also ambiguous and erroneous pattern instructions. In this report, we propose a concept to digitally represent crochet patterns. This format incorporates crochet techniques which allows domain specific support for crochet pattern designers during the pattern creation and instruction writing process. As contributions, we present a thorough domain analysis, the concept of a graph structure used as domain specific language to specify crochet patterns and a prototype of a projectional editor using the graph as representation format of patterns and a diagramming system to visualize them in 2D and 3D. By analyzing the domain, we learned about crochet techniques and pain points of designers in their pattern creation workflow. These insights are the basis on which we defined the pattern representation. In order to evaluate our concept, we built a prototype by which the feasibility of the concept is shown and we tested the software with professional crochet designers who approved of the concept.},
language = {en}
}
@book{MeinelDoellnerWeskeetal.2021,
author = {Meinel, Christoph and D{\"o}llner, J{\"u}rgen Roland Friedrich and Weske, Mathias and Polze, Andreas and Hirschfeld, Robert and Naumann, Felix and Giese, Holger and Baudisch, Patrick and Friedrich, Tobias and B{\"o}ttinger, Erwin and Lippert, Christoph and D{\"o}rr, Christian and Lehmann, Anja and Renard, Bernhard and Rabl, Tilmann and Uebernickel, Falk and Arnrich, Bert and H{\"o}lzle, Katharina},
title = {Proceedings of the HPI Research School on Service-oriented Systems Engineering 2020 Fall Retreat},
number = {138},
publisher = {Universit{\"a}tsverlag Potsdam},
address = {Potsdam},
isbn = {978-3-86956-513-2},
issn = {1613-5652},
doi = {10.25932/publishup-50413},
url = {http://nbn-resolving.de/urn:nbn:de:kobv:517-opus4-504132},
publisher = {Universit{\"a}t Potsdam},
pages = {vi, 144},
year = {2021},
abstract = {Design and Implementation of service-oriented architectures imposes a huge number of research questions from the fields of software engineering, system analysis and modeling, adaptability, and application integration. Component orientation and web services are two approaches for design and realization of complex web-based system. Both approaches allow for dynamic application adaptation as well as integration of enterprise application. Service-Oriented Systems Engineering represents a symbiosis of best practices in object-orientation, component-based development, distributed computing, and business process management. It provides integration of business and IT concerns. The annual Ph.D. Retreat of the Research School provides each member the opportunity to present his/her current state of their research and to give an outline of a prospective Ph.D. thesis. Due to the interdisciplinary structure of the research school, this technical report covers a wide range of topics. These include but are not limited to: Human Computer Interaction and Computer Vision as Service; Service-oriented Geovisualization Systems; Algorithm Engineering for Service-oriented Systems; Modeling and Verification of Self-adaptive Service-oriented Systems; Tools and Methods for Software Engineering in Service-oriented Systems; Security Engineering of Service-based IT Systems; Service-oriented Information Systems; Evolutionary Transition of Enterprise Applications to Service Orientation; Operating System Abstractions for Service-oriented Computing; and Services Specification, Composition, and Enactment.},
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}
}
@book{EichenrothReinHirschfeld2022,
author = {Eichenroth, Friedrich and Rein, Patrick and Hirschfeld, Robert},
title = {Fast packrat parsing in a live programming environment},
series = {Technische Berichte des Hasso-Plattner-Instituts f{\"u}r Digital Engineering an der Universit{\"a}t Potsdam},
journal = {Technische Berichte des Hasso-Plattner-Instituts f{\"u}r Digital Engineering an der Universit{\"a}t Potsdam},
number = {135},
publisher = {Universit{\"a}tsverlag Potsdam},
address = {Potsdam},
isbn = {978-3-86956-503-3},
issn = {1613-5652},
doi = {10.25932/publishup-49124},
url = {http://nbn-resolving.de/urn:nbn:de:kobv:517-opus4-491242},
publisher = {Universit{\"a}t Potsdam},
pages = {79},
year = {2022},
abstract = {Language developers who design domain-specific languages or new language features need a way to make fast changes to language definitions. Those fast changes require immediate feedback. Also, it should be possible to parse the developed languages quickly to handle extensive sets of code. Parsing expression grammars provides an easy to understand method for language definitions. Packrat parsing is a method to parse grammars of this kind, but this method is unable to handle left-recursion properly. Existing solutions either partially rewrite left-recursive rules and partly forbid them, or use complex extensions to packrat parsing that are hard to understand and cost-intensive. We investigated methods to make parsing as fast as possible, using easy to follow algorithms while not losing the ability to make fast changes to grammars. We focused our efforts on two approaches. One is to start from an existing technique for limited left-recursion rewriting and enhance it to work for general left-recursive grammars. The second approach is to design a grammar compilation process to find left-recursion before parsing, and in this way, reduce computational costs wherever possible and generate ready to use parser classes. Rewriting parsing expression grammars is a task that, if done in a general way, unveils a large number of cases such that any rewriting algorithm surpasses the complexity of other left-recursive parsing algorithms. Lookahead operators introduce this complexity. However, most languages have only little portions that are left-recursive and in virtually all cases, have no indirect or hidden left-recursion. This means that the distinction of left-recursive parts of grammars from components that are non-left-recursive holds great improvement potential for existing parsers. In this report, we list all the required steps for grammar rewriting to handle left-recursion, including grammar analysis, grammar rewriting itself, and syntax tree restructuring. Also, we describe the implementation of a parsing expression grammar framework in Squeak/Smalltalk and the possible interactions with the already existing parser Ohm/S. We quantitatively benchmarked this framework directing our focus on parsing time and the ability to use it in a live programming context. Compared with Ohm, we achieved massive parsing time improvements while preserving the ability to use our parser it as a live programming tool. The work is essential because, for one, we outlined the difficulties and complexity that come with grammar rewriting. Also, we removed the existing limitations that came with left-recursion by eliminating them before parsing.},
language = {en}
}
@book{FreundRaetschHradilaketal.2022,
author = {Freund, Rieke and R{\"a}tsch, Jan Philip and Hradilak, Franziska and Vidic, Benedikt and Heß, Oliver and Lißner, Nils and W{\"o}lert, Hendrik and Lincke, Jens and Beckmann, Tom and Hirschfeld, Robert},
title = {Implementing a crowd-sourced picture archive for Bad Harzburg},
number = {149},
publisher = {Universit{\"a}tsverlag Potsdam},
address = {Potsdam},
isbn = {978-3-86956-545-3},
issn = {1613-5652},
doi = {10.25932/publishup-56029},
url = {http://nbn-resolving.de/urn:nbn:de:kobv:517-opus4-560291},
publisher = {Universit{\"a}t Potsdam},
pages = {x, 191},
year = {2022},
abstract = {Pictures are a medium that helps make the past tangible and preserve memories. Without context, they are not able to do so. Pictures are brought to life by their associated stories. However, the older pictures become, the fewer contemporary witnesses can tell these stories. Especially for large, analog picture archives, knowledge and memories are spread over many people. This creates several challenges: First, the pictures must be digitized to save them from decaying and make them available to the public. Since a simple listing of all the pictures is confusing, the pictures should be structured accessibly. Second, known information that makes the stories vivid needs to be added to the pictures. Users should get the opportunity to contribute their knowledge and memories. To make this usable for all interested parties, even for older, less technophile generations, the interface should be intuitive and error-tolerant. The resulting requirements are not covered in their entirety by any existing software solution without losing the intuitive interface or the scalability of the system. Therefore, we have developed our digital picture archive within the scope of a bachelor project in cooperation with the Bad Harzburg-Stiftung. For the implementation of this web application, we use the UI framework React in the frontend, which communicates via a GraphQL interface with the Content Management System Strapi in the backend. The use of this system enables our project partner to create an efficient process from scanning analog pictures to presenting them to visitors in an organized and annotated way. To customize the solution for both picture delivery and information contribution for our target group, we designed prototypes and evaluated them with people from Bad Harzburg. This helped us gain valuable insights into our system's usability and future challenges as well as requirements. Our web application is already being used daily by our project partner. During the project, we still came up with numerous ideas for additional features to further support the exchange of knowledge.},
language = {en}
}
@book{KlinkeVerhoevenRothetal.2022,
author = {Klinke, Paula and Verhoeven, Silvan and Roth, Felix and Hagemann, Linus and Alnawa, Tarik and Lincke, Jens and Rein, Patrick and Hirschfeld, Robert},
title = {Tool support for collaborative creation of interactive storytelling media},
number = {141},
publisher = {Universit{\"a}tsverlag Potsdam},
address = {Potsdam},
isbn = {978-3-86956-521-7},
issn = {1613-5652},
doi = {10.25932/publishup-51857},
url = {http://nbn-resolving.de/urn:nbn:de:kobv:517-opus4-518570},
publisher = {Universit{\"a}t Potsdam},
pages = {x, 167},
year = {2022},
abstract = {Scrollytellings are an innovative form of web content. Combining the benefits of books, images, movies, and video games, they are a tool to tell compelling stories and provide excellent learning opportunities. Due to their multi-modality, creating high-quality scrollytellings is not an easy task. Different professions, such as content designers, graphics designers, and developers, need to collaborate to get the best out of the possibilities the scrollytelling format provides. Collaboration unlocks great potential. However, content designers cannot create scrollytellings directly and always need to consult with developers to implement their vision. This can result in misunderstandings. Often, the resulting scrollytelling will not match the designer's vision sufficiently, causing unnecessary iterations. Our project partner Typeshift specializes in the creation of individualized scrollytellings for their clients. Examined existing solutions for authoring interactive content are not optimally suited for creating highly customized scrollytellings while still being able to manipulate all their elements programmatically. Based on their experience and expertise, we developed an editor to author scrollytellings in the lively.next live-programming environment. In this environment, a graphical user interface for content design is combined with powerful possibilities for programming behavior with the morphic system. The editor allows content designers to take on large parts of the creation process of scrollytellings on their own, such as creating the visible elements, animating content, and fine-tuning the scrollytelling. Hence, developers can focus on interactive elements such as simulations and games. Together with Typeshift, we evaluated the tool by recreating an existing scrollytelling and identified possible future enhancements. Our editor streamlines the creation process of scrollytellings. Content designers and developers can now both work on the same scrollytelling. Due to the editor inside of the lively.next environment, they can both work with a set of tools familiar to them and their traits. Thus, we mitigate unnecessary iterations and misunderstandings by enabling content designers to realize large parts of their vision of a scrollytelling on their own. Developers can add advanced and individual behavior. Thus, developers and content designers benefit from a clearer distribution of tasks while keeping the benefits of collaboration.},
language = {en}
}
@book{DuerschReinMattisetal.2022,
author = {D{\"u}rsch, Falco and Rein, Patrick and Mattis, Toni and Hirschfeld, Robert},
title = {Learning from failure},
number = {145},
publisher = {Universit{\"a}tsverlag Potsdam},
address = {Potsdam},
isbn = {978-3-86956-528-6},
issn = {1613-5652},
doi = {10.25932/publishup-53755},
url = {http://nbn-resolving.de/urn:nbn:de:kobv:517-opus4-537554},
publisher = {Universit{\"a}t Potsdam},
pages = {87},
year = {2022},
abstract = {Regression testing is a widespread practice in today's software industry to ensure software product quality. Developers derive a set of test cases, and execute them frequently to ensure that their change did not adversely affect existing functionality. As the software product and its test suite grow, the time to feedback during regression test sessions increases, and impedes programmer productivity: developers wait longer for tests to complete, and delays in fault detection render fault removal increasingly difficult. Test case prioritization addresses the problem of long feedback loops by reordering test cases, such that test cases of high failure probability run first, and test case failures become actionable early in the testing process. We ask, given test execution schedules reconstructed from publicly available data, to which extent can their fault detection efficiency improved, and which technique yields the most efficient test schedules with respect to APFD? To this end, we recover regression 6200 test sessions from the build log files of Travis CI, a popular continuous integration service, and gather 62000 accompanying changelists. We evaluate the efficiency of current test schedules, and examine the prioritization results of state-of-the-art lightweight, history-based heuristics. We propose and evaluate a novel set of prioritization algorithms, which connect software changes and test failures in a matrix-like data structure. Our studies indicate that the optimization potential is substantial, because the existing test plans score only 30\% APFD. The predictive power of past test failures proves to be outstanding: simple heuristics, such as repeating tests with failures in recent sessions, result in efficiency scores of 95\% APFD. The best-performing matrix-based heuristic achieves a similar score of 92.5\% APFD. In contrast to prior approaches, we argue that matrix-based techniques are useful beyond the scope of effective prioritization, and enable a number of use cases involving software maintenance. We validate our findings from continuous integration processes by extending a continuous testing tool within development environments with means of test prioritization, and pose further research questions. We think that our findings are suited to propel adoption of (continuous) testing practices, and that programmers' toolboxes should contain test prioritization as an existential productivity tool.},
language = {en}
}
@techreport{DoellnerFriedrichArnrichetal.2022,
author = {D{\"o}llner, J{\"u}rgen Roland Friedrich and Friedrich, Tobias and Arnrich, Bert and Hirschfeld, Robert and Lippert, Christoph and Meinel, Christoph},
title = {Abschlussbericht KI-Labor ITSE},
doi = {10.25932/publishup-57860},
url = {http://nbn-resolving.de/urn:nbn:de:kobv:517-opus4-578604},
pages = {60},
year = {2022},
abstract = {Der Abschlussbericht beschreibt Aufgaben und Ergebnisse des KI-Labors "ITSE". Gegenstand des KI-Labors bildeten Methodik, Technik und Ausbildung in der IT-Systemtechnik zur Analyse, Planung und Konstruktion KI-basierter, komplexer IT-Systeme.},
language = {de}
}