TY - BOOK
A1 - Schreiber, Robin
A1 - Krahn, Robert
A1 - Ingalls, Daniel H. H.
A1 - Hirschfeld, Robert
T1 - Transmorphic
T1 - Transmorphic
BT - mapping direct manipulation to source code transformations
BT - Abbilden von direkter Manipulation zu Transformationen im Programmtext
N2 - 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.
N2 - Das Definieren von graphischen Benutzeroberflächen mittels funktionaler Abstraktionen, kann die Komplexität der Verwaltung des Zustandes der Anwendung erheblich reduzieren. Aktuelle Beispiele, wie Facebook's Framework *React*, zeigen auf, wie das modellieren der visuellen Schnittstelle als eine funktionale Projektion vom Zustand der Anwendung zur graphischen Repräsentation, die Anzahl der agierenden Objekte erheblich reduzieren und so die Verlässlichkeit des Systems erhöhen kann. Der Preis für die so erreichte Stabilität, ist eine relativ statische graphische Repräsentation, die sich zur Laufzeit nicht dynamisch anpassen lässt und in der jede visuelle Entität nur mittles funktionaler Abstraktionen beschrieben werden kann, was nicht unserem intuitiven Verständnis der Welt entspricht.
Im Gegensatz dazu, erlaubt das Rahmenwerk Morphic mittles Interaktionen wie Ziehen, Greifen oder Skalieren von visuellen Elementen, die grahische Darstellung der Anwendung zur Laufzeit in einer unmittelbaren ("live") und direkten Art und Weise weiter zu entwickeln. Um diese Flexibilität zu erreichen, modelliert Morphic allerdings jedes graphische Objekt mittels veränderlichem Zustand, was das Garantieren der Fehlerfreiheit von graphischen Oberfläche, insbesondere bei sehr komplexen Schnittstellen, deutlich erschwehrt. Hinzu kommt, dass die dynamischen Anpassungen zur Laufzeit dazu führen, dass sich die Oberfläche mehr und mehr von ihrer ursprünglichen symbolischen Definition entfernt, da Morphic von selbst die Änderungen in der Laufzeit nicht im Quellcode reflektieren kann. Die Frage ist also ob es eine Kombination beider Ansätze gibt, welche es vermag die Vorteile zu erhalten und Nachteile wenn möglich auszugleichen.
Als Lösung für dieses Problem schlagen wir vor das Konzept der direkten Manipulation aus Morphic auf Transformationen im Quellcode zu übertragen. Hierfür werden wir das Design, die Implementierung und Integration einer bidirektionalen Abbildung zwischen graphischer Darstellung und einer funktionalen, deklarativen symbolischen Beschreibung in einer selbsterhaltenden Entwicklungsumgebung erörtern. Wir werden Transmorphic vorstellen, eine funktionale Variante des Morphic Frameworks, in der visuelle und strukturelle Eigenschaften in einer strikt funktionalen und daher deklarativen Art und Weise definiert werden. Innerhalb von Transmorphic hat der Entwickler die Möglichkeit verschieden Morphs zur Laufzeit mittels direkter Manipulation zusammenzusetzen, was direkt zu Änderungen im Quellcode der Anwendung übersetzt wird. Auf diese Weise kann die verständliche und nachvollziehbare direkte Interaktion aus Morphic, im Kontext einer vollständig funktional beschriebenen graphischen Benutzeroberfläche verwendet werden.
T3 - Technische Berichte des Hasso-Plattner-Instituts für Digital Engineering an der Universität Potsdam - 110
KW - functional programming
KW - morphic
KW - functional lenses
KW - direct manipulation
KW - synchronization
KW - FRP
KW - reactive
KW - immutable values
KW - live programming
KW - funktionale Programmierung
KW - Morphic
KW - Functional Lenses
KW - direkte Manipulation
KW - Synchronisation
KW - FRP
KW - reaktive Programmierung
KW - Unveränderlichkeit
KW - Live-Programmierung
Y1 - 2016
U6 - http://nbn-resolving.de/urn/resolver.pl?urn:nbn:de:kobv:517-opus4-98300
SN - 978-3-86956-387-9
SN - 1613-5652
SN - 2191-1665
IS - 110
PB - Universitätsverlag Potsdam
CY - Potsdam
ER -
TY - JOUR
A1 - Rein, Patrick
A1 - Ramson, Stefan
A1 - Lincke, Jens
A1 - Felgentreff, Tim
A1 - Hirschfeld, Robert
T1 - Group-Based Behavior Adaptation Mechanisms in Object-Oriented Systems
JF - IEEE software
N2 - Dynamic and distributed systems require behavior adaptations for groups of objects. Group-based behavior adaptation mechanisms scope adaptations to objects matching conditions beyond class membership. The specification of groups can be explicit or implicit.
KW - group-based behavior adaptation
KW - lively groups
KW - ContextErlang
KW - entity-component-system
KW - predicated generic functions
KW - active layers
KW - reactive object queries
KW - context groups
KW - implied methods
KW - object-oriented languages
KW - software engineering
KW - software development
KW - contextual-variability modeling
Y1 - 2017
U6 - https://doi.org/10.1109/MS.2017.4121224
SN - 0740-7459
SN - 1937-4194
VL - 34
IS - 6
SP - 78
EP - 82
PB - Inst. of Electr. and Electronics Engineers
CY - Los Alamitos
ER -
TY - JOUR
A1 - Hirschfeld, Robert
A1 - Kawarnura, Katsuya
T1 - Dynamic service adaptation
JF - Software : practice & experience
N2 - Change can be observed in our environment and in the technology we build. While changes in the environment happen continuously and implicitly, our technology has to be kept in sync with the changing world around it. Although we can prepare for some of the changes for most of them we cannot. This is especially true for next-generation mobile communication systems that are expected to support the creation of a ubiquitous society where virtually everything is connected and made available within an organic information network. Resources will frequently join or leave the network, new types of media or new combinations of existing types will be used to interact and cooperate, and services will be tailored to preferences and needs of individual customers to better meet their needs. This paper outlines our research in the area of dynamic service adaptation to provide concepts and technologies allowing for such environments. Copyright (C) 2006 John Wiley & Sons, Ltd.
KW - dynamic service adaptation
KW - DSA
KW - aspect-oriented programming
KW - dynamic AOP
Y1 - 2006
U6 - https://doi.org/10.1002/spe.766
SN - 0038-0644
SN - 1097-024X
VL - 36
IS - 11-12
SP - 1115
EP - 1131
PB - Wiley
CY - Chichester
ER -
TY - JOUR
A1 - Mattis, Toni
A1 - Beckmann, Tom
A1 - Rein, Patrick
A1 - Hirschfeld, Robert
T1 - First-class concepts
BT - Reified architectural knowledge beyond dominant decompositions
JF - Journal of object technology : JOT / ETH Zürich, Department of Computer Science
N2 - Ideally, programs are partitioned into independently maintainable and understandable modules. As a system grows, its architecture gradually loses the capability to accommodate new concepts in a modular way. While refactoring is expensive and not always possible, and the programming language might lack dedicated primary language constructs to express certain cross-cutting concerns, programmers are still able to explain and delineate convoluted concepts through secondary means: code comments, use of whitespace and arrangement of code, documentation, or communicating tacit knowledge.
Secondary constructs are easy to change and provide high flexibility in communicating cross-cutting concerns and other concepts among programmers. However, such secondary constructs usually have no reified representation that can be explored and manipulated as first-class entities through the programming environment.
In this exploratory work, we discuss novel ways to express a wide range of concepts, including cross-cutting concerns, patterns, and lifecycle artifacts independently of the dominant decomposition imposed by an existing architecture. We propose the representation of concepts as first-class objects inside the programming environment that retain the capability to change as easily as code comments. We explore new tools that allow programmers to view, navigate, and change programs based on conceptual perspectives. In a small case study, we demonstrate how such views can be created and how the programming experience changes from draining programmers' attention by stretching it across multiple modules toward focusing it on cohesively presented concepts. Our designs are geared toward facilitating multiple secondary perspectives on a system to co-exist in symbiosis with the original architecture, hence making it easier to explore, understand, and explain complex contexts and narratives that are hard or impossible to express using primary modularity constructs.
KW - software engineering
KW - modularity
KW - exploratory programming
KW - program
KW - comprehension
KW - remodularization
KW - architecture recovery
Y1 - 2022
U6 - https://doi.org/10.5381/jot.2022.21.2.a6
SN - 1660-1769
VL - 21
IS - 2
SP - 1
EP - 15
PB - ETH Zürich, Department of Computer Science
CY - Zürich
ER -
TY - BOOK
A1 - Haupt, Michael
A1 - Marr, Stefan
A1 - Hirschfeld, Robert
T1 - CSOM/PL : a virtual machine product line
N2 - 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.
N2 - CSOM/PL ist eine Softwareproduktfamilie (software product line, SPL), die erstellt wurde, indem Techniken der mehrdimensionalen Belangtrennung (multi-dimensional separation of concerns, MDSOC) auf die Domäne der virtuellen Maschinen (VM) für höhere Programmiersprachen angewendet wurden. Dazu wurde CSOM, eine in C implementierte Smalltalk-VM, mittels VMADL (virtual machine architecture description language) in Module zerlegt. Etliche Eigenschaften von CSOM wurden in VMADL-Module gekapselt und auf unterschiedliche Weisen komponiert. Die Auswertung des Ansatzes zeigt, dass die Anwendung von MDSOC- und SPL-Prinzipien auf die komplexe VM-Domäne nicht nur machbar ist, sondern darüber hinaus auch Vorteile mit sich bringt, da die Verständlichkeit, Wartbarkeit und Konfigurierbarkeit von VM-Implementierungen ohne Beeinträchtigung der Ausführungsgeschwindigkeit verbessert werden.
T3 - Technische Berichte des Hasso-Plattner-Instituts für Digital Engineering an der Universität Potsdam - 48
KW - Virtuelle Maschinen
KW - Architektur
KW - Softwareproduktlinien
KW - mehrdimensionale Belangtrennung
KW - Virtual machines
KW - architecture
KW - software product lines
KW - multi-dimensional separation of concerns
Y1 - 2011
U6 - http://nbn-resolving.de/urn/resolver.pl?urn:nbn:de:kobv:517-opus-52332
SN - 978-3-86956-134-9
PB - Universitätsverlag Potsdam
CY - Potsdam
ER -
TY - BOOK
A1 - Calmez, Conrad
A1 - Hesse, Hubert
A1 - Siegmund, Benjamin
A1 - Stamm, Sebastian
A1 - Thomschke, Astrid
A1 - Hirschfeld, Robert
A1 - Ingalls, Dan
A1 - Lincke, Jens
T1 - Explorative authoring of Active Web content in a mobile environment
N2 - 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.
N2 - Vielseitige Webanwendungen zu entwickeln kann eine komplexe Aufgabe sein - besonders wenn es die Unterstützung mobiler Geräte betrifft. Webbasierte Umgebungen wie Lively Kernel können Entwicklern helfen Webanwendungen zu entwickeln, indem sie den Entwicklungsprozess direkter und interaktiver gestalten. Zudem sind Entwicklungsprozesse von Software kollaborativ, d.h. Enwicklungsumgebungen müssen so gestaltet sein, dass sie mit kollaborativen Elementen zu unterstützen. Diese Arbeit beschreibt die Erweiterungen der webbasierten Entwicklungsumgebung Lively Webwerkstatt, so dass diese in einer mobilen Umgebung genutzt werden kann. Die Reichweite dieser Erweiterungen erstreckt sich von Kollaborationsmechanismen und Benutzerschnittstellen bis hin zu Eventbehandlung und Performanzmessungen auf mobilen Geräten.
T3 - Technische Berichte des Hasso-Plattner-Instituts für Digital Engineering an der Universität Potsdam - 72
KW - Web applications
KW - Mobile Application Development
KW - CSCW
KW - Lively Kernel
Y1 - 2013
U6 - http://nbn-resolving.de/urn/resolver.pl?urn:nbn:de:kobv:517-opus-64054
SN - 978-3-86956-232-2
PB - Universitätsverlag Potsdam
CY - Potsdam
ER -
TY - BOOK
A1 - Geller, Felix
A1 - Hirschfeld, Robert
A1 - Bracha, Gilad
T1 - Pattern Matching for an object-oriented and dynamically typed programming language
N2 - 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.
T3 - Technische Berichte des Hasso-Plattner-Instituts für Digital Engineering an der Universität Potsdam - 36
KW - Pattern Matching
KW - Musterabgleich
KW - Muster
KW - Objekt-Orientiertes Programmieren
KW - Dynamische Typ Systeme
KW - Pattern Matching
KW - Patterns
KW - Object-Oriented Programming
KW - Dynamic Type System
Y1 - 2010
U6 - http://nbn-resolving.de/urn/resolver.pl?urn:nbn:de:kobv:517-opus-43035
SN - 978-3-86956-065-6
PB - Universitätsverlag Potsdam
CY - Potsdam
ER -
TY - JOUR
A1 - Perscheid, Michael
A1 - Siegmund, Benjamin
A1 - Taeumel, Marcel
A1 - Hirschfeld, Robert
T1 - Studying the advancement in debugging practice of professional software developers
JF - Software Quality Journal
N2 - In 1997, Henry Lieberman stated that debugging is the dirty little secret of computer science. Since then, several promising debugging technologies have been developed such as back-in-time debuggers and automatic fault localization methods. However, the last study about the state-of-the-art in debugging is still more than 15 years old and so it is not clear whether these new approaches have been applied in practice or not. For that reason, we investigate the current state of debugging in a comprehensive study. First, we review the available literature and learn about current approaches and study results. Second, we observe several professional developers while debugging and interview them about their experiences. Third, we create a questionnaire that serves as the basis for a larger online debugging survey. Based on these results, we present new insights into debugging practice that help to suggest new directions for future research.
KW - Debugging
KW - Literature review
KW - Field study
KW - Online survey
Y1 - 2016
U6 - https://doi.org/10.1007/s11219-015-9294-2
SN - 0963-9314
SN - 1573-1367
VL - 25
SP - 83
EP - 110
PB - Springer
CY - Dordrecht
ER -
TY - JOUR
A1 - Felgentreff, Tim
A1 - Perscheid, Michael
A1 - Hirschfeld, Robert
T1 - Implementing record and refinement for debugging timing-dependent communication
JF - Science of computer programming
N2 - Distributed applications are hard to debug because timing-dependent network communication is a source of non-deterministic behavior. Current approaches to debug non deterministic failures include post-mortem debugging as well as record and replay. However, the first impairs system performance to gather data, whereas the latter requires developers to understand the timing-dependent communication at a lower level of abstraction than they develop at. Furthermore, both approaches require intrusive core library modifications to gather data from live systems. In this paper, we present the Peek-At-Talk debugger for investigating non-deterministic failures with low overhead in a systematic, top-down method, with a particular focus on tool-building issues in the following areas: First, we show how our debugging framework Path Tools guides developers from failures to their root causes and gathers run-time data with low overhead. Second, we present Peek-At-Talk, an extension to our Path Tools framework to record non-deterministic communication and refine behavioral data that connects source code with network events. Finally, we scope changes to the core library to record network communication without impacting other network applications.
KW - Distributed debugging
KW - Record and replay
KW - Dynamic analysis
KW - Record and refinement
Y1 - 2016
U6 - https://doi.org/10.1016/j.scico.2015.11.006
SN - 0167-6423
SN - 1872-7964
VL - 134
SP - 4
EP - 18
PB - Elsevier
CY - Amsterdam
ER -
TY - JOUR
A1 - Rein, Patrick
A1 - Taeumel, Marcel
A1 - Hirschfeld, Robert
T1 - Making the domain tangible
BT - implicit object lookup for source code readability
JF - Design Thinking Research
N2 - Programmers collaborate continuously with domain experts to explore the problem space and to shape a solution that fits the users’ needs. In doing so, all parties develop a shared vocabulary, which is above all a list of named concepts and their relationships to each other. Nowadays, many programmers favor object-oriented programming because it allows them to directly represent real-world concepts and interactions from the vocabulary as code. However, when existing domain data is not yet represented as objects, it becomes a challenge to initially bring existing domain data into object-oriented systems and to keep the source code readable. While source code might be comprehensible to programmers, domain experts can struggle, given their non-programming background. We present a new approach to provide a mapping of existing data sources into the object-oriented programming environment. We support keeping the code of the domain model compact and readable while adding implicit means to access external information as internal domain objects. This should encourage programmers to explore different ways to build the software system quickly. Eventually, our approach fosters communication with the domain experts, especially at the beginning of a project. When the details in the problem space are not yet clear, the source code provides a valuable, tangible communication artifact.
KW - Source Code Readability
KW - Domain Objects
KW - StackOverflow
KW - Squeak
KW - Custom Writable Class
Y1 - 2017
SN - 978-3-319-60967-6
SN - 978-3-319-60966-9
U6 - https://doi.org/10.1007/978-3-319-60967-6_9
SP - 171
EP - 194
PB - Springer
CY - New York
ER -
TY - JOUR
A1 - Steinert, Bastian
A1 - Cassou, Damien
A1 - Hirschfeld, Robert
T1 - CoExist overcoming aversion to change preserving immediate access to source code and run-time information of previous development states
JF - ACM SIGPLAN notices
N2 - Programmers make many changes to the program to eventually find a good solution for a given task. In this course of change, every intermediate development state can of value, when, for example, a promising ideas suddenly turn out inappropriate or the interplay of objects turns out more complex than initially expected before making changes. Programmers would benefit from tool support that provides immediate access to source code and run-time of previous development states of interest. We present IDE extensions, implemented for Squeak/Smalltalk, to preserve, retrieve, and work with this information. With such tool support, programmers can work without worries because they can rely on tools that help them with whatever their explorations will reveal. They no longer have to follow certain best practices only to avoid undesired consequences of changing code.
KW - Design
KW - Experimentation
KW - Human Factors
KW - Continuous Testing
KW - Continuous Versioning
KW - Debugging
KW - Evolution
KW - Explore-first Programming
KW - Fault Localization
KW - Prototyping
Y1 - 2013
U6 - https://doi.org/10.1145/2480360.2384591
SN - 0362-1340
VL - 48
IS - 2
SP - 107
EP - 117
PB - Association for Computing Machinery
CY - New York
ER -
TY - JOUR
A1 - Haupt, Michael
A1 - Adams, Bram
A1 - Timbermont, Stijn
A1 - Gibbs, Celina
A1 - Coady, Yvonne
A1 - Hirschfeld, Robert
T1 - Disentangling virtual machine architecture
N2 - Virtual machine (VM) implementations are made of intricately intertwined subsystems, interacting largely through implicit dependencies. As the degree of crosscutting present in VMs is very high, VM implementations exhibit significant internal complexity. This study proposes an architecture approach for VMs that regards a VM as a composite of service modules coordinated through explicit bidirectional interfaces. Aspect-oriented programming techniques are used to establish these interfaces, to coordinate module interaction, and to declaratively express concrete VM architectures. A VM architecture description language is presented in a case study, illustrating the application of the proposed architectural principles.
Y1 - 2009
UR - http://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=4124007
U6 - https://doi.org/10.1049/iet-sen.2007.0121
SN - 1751-8806
ER -
TY - JOUR
A1 - Steinert, Bastian
A1 - Hirschfeld, Robert
T1 - Applying design knowledge to programming
Y1 - 2012
ER -
TY - JOUR
A1 - Hirschfeld, Robert
A1 - Steinert, Bastian
A1 - Lincke, Jens
T1 - Agile software development in virtual collaboration environments
Y1 - 2011
SN - 978-3-642-13756-3
ER -
TY - JOUR
A1 - Hirschfeld, Robert
A1 - Perscheid, Michael
A1 - Haupt, Michael
T1 - Explicit use-case representation in object-oriented programming languages
JF - ACM SIGPLAN notices
N2 - Use-cases are considered an integral part of most contemporary development processes since they describe a software system's expected behavior from the perspective of its prospective users. However, the presence of and traceability to use-cases is increasingly lost in later more code-centric development activities. Use-cases, being well-encapsulated at the level of requirements descriptions, eventually lead to crosscutting concerns in system design and source code. Tracing which parts of the system contribute to which use-cases is therefore hard and so limits understandability.
In this paper, we propose an approach to making use-cases first-class entities in both the programming language and the runtime environment. Having use-cases present in the code and the running system will allow developers, maintainers, and operators to easily associate their units of work with what matters to the users. We suggest the combination of use-cases, acceptance tests, and dynamic analysis to automatically associate source code with use-cases. We present UseCasePy, an implementation of our approach to use-case-centered development in Python, and its application to the Django Web framework.
KW - design
KW - languages
KW - use-cases
KW - separation of concerns
KW - traceability
Y1 - 2012
U6 - https://doi.org/10.1145/2168696.2047856
SN - 0362-1340
VL - 47
IS - 2
SP - 51
EP - 60
PB - Association for Computing Machinery
CY - New York
ER -
TY - JOUR
A1 - Lincke, Jens
A1 - Appeltauer, Malte
A1 - Steinert, Bastian
A1 - Hirschfeld, Robert
T1 - An open implementation for context-oriented layer composition in ContextJS
JF - Science of computer programming
N2 - Context-oriented programming (COP) provides dedicated support for defining and composing variations to a basic program behavior. A variation, which is defined within a layer, can be de-/activated for the dynamic extent of a code block. While this mechanism allows for control flow-specific scoping, expressing behavior adaptations can demand alternative scopes. For instance, adaptations can depend on dynamic object structure rather than control flow. We present scenarios for behavior adaptation and identify the need for new scoping mechanisms. The increasing number of scoping mechanisms calls for new language abstractions representing them. We suggest to open the implementation of scoping mechanisms so that developers can extend the COP language core according to their specific needs. Our open implementation moves layer composition into objects to be affected and with that closer to the method dispatch to be changed. We discuss the implementation of established COP scoping mechanisms using our approach and present new scoping mechanisms developed for our enhancements to Lively Kernel.
KW - ContextJS
KW - Context-oriented programming
KW - Open implementations
KW - Dynamic adaptation
KW - Scope
Y1 - 2011
U6 - https://doi.org/10.1016/j.scico.2010.11.013
SN - 0167-6423
VL - 76
IS - 12
SP - 1194
EP - 1209
PB - Elsevier
CY - Amsterdam
ER -
TY - JOUR
A1 - Weiher, Marcel
A1 - Hirschfeld, Robert
T1 - Polymorphic identifiers: uniform resource access in objective-smalltalk
JF - ACM SIGPLAN notices
N2 - In object-oriented programming, polymorphic dispatch of operations decouples clients from specific providers of services and allows implementations to be modified or substituted without affecting clients.
The Uniform Access Principle (UAP) tries to extend these qualities to resource access by demanding that access to state be indistinguishable from access to operations. Despite language features supporting the UAP, the overall goal of substitutability has not been achieved for either alternative resources such as keyed storage, files or web pages, or for alternate access mechanisms: specific kinds of resources are bound to specific access mechanisms and vice versa. Changing storage or access patterns either requires changes to both clients and service providers and trying to maintain the UAP imposes significant penalties in terms of code-duplication and/or performance overhead.
We propose introducing first class identifiers as polymorphic names for storage locations to solve these problems. With these Polymorphic Identifiers, we show that we can provide uniform access to a wide variety of resource types as well as storage and access mechanisms, whether parametrized or direct, without affecting client code, without causing code duplication or significant performance penalties.
KW - Identifiers
KW - REST
KW - Uniform Access Principle
KW - Extensibility
Y1 - 2014
U6 - https://doi.org/10.1145/2508168.2508169
SN - 0362-1340
SN - 1558-1160
VL - 49
IS - 2
SP - 61
EP - 71
PB - Association for Computing Machinery
CY - New York
ER -
TY - JOUR
A1 - Bauman, Spenser
A1 - Bolz, Carl Friedrich
A1 - Hirschfeld, Robert
A1 - Kirilichev, Vasily
A1 - Pape, Tobias
A1 - Siek, Jeremy G.
A1 - Tobin-Hochstadt, Sam
T1 - Pycket: A Tracing JIT for a Functional Language
JF - ACM SIGPLAN notices
N2 - We present Pycket, a high-performance tracing JIT compiler for Racket. Pycket supports a wide variety of the sophisticated features in Racket such as contracts, continuations, classes, structures, dynamic binding, and more. On average, over a standard suite of benchmarks, Pycket outperforms existing compilers, both Racket's JIT and other highly-optimizing Scheme compilers. Further, Pycket provides much better performance for Racket proxies than existing systems, dramatically reducing the overhead of contracts and gradual typing. We validate this claim with performance evaluation on multiple existing benchmark suites.
The Pycket implementation is of independent interest as an application of the RPython meta-tracing framework (originally created for PyPy), which automatically generates tracing JIT compilers from interpreters. Prior work on meta-tracing focuses on bytecode interpreters, whereas Pycket is a high-level interpreter based on the CEK abstract machine and operates directly on abstract syntax trees. Pycket supports proper tail calls and first-class continuations. In the setting of a functional language, where recursion and higher-order functions are more prevalent than explicit loops, the most significant performance challenge for a tracing JIT is identifying which control flows constitute a loop-we discuss two strategies for identifying loops and measure their impact.
KW - Experimentation
KW - Languages
KW - Measurement
KW - Performance
KW - JIT compilers
KW - contracts
KW - tracing
KW - functional languages
KW - Racket
Y1 - 2015
U6 - https://doi.org/10.1145/2784731.2784740
SN - 0362-1340
SN - 1558-1160
VL - 50
IS - 9
SP - 22
EP - 34
PB - Association for Computing Machinery
CY - New York
ER -
TY - BOOK
A1 - Appeltauer, Malte
A1 - Hirschfeld, Robert
T1 - The JCop language specification : Version 1.0, April 2012
N2 - 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.
N2 - Das Verhalten von modernen Software-Anwendungen benötigt häufig Informationen über den Kontext ihrer Ausführung, z.B. die geografische Position, die Tageszeit oder die aktuelle Netzwerkbandbreite. Dennoch bieten heutige Programmiersprachen nur wenig Unterstützung für die Repräsentation kontextspezifischen Verhaltens. Kontextorientiertes Programmieren ist ein Ansatz, der die explizite Modularisierung und Laufzeitaktivierung von kontextspezifischem Verhalten auf der Ebene von Programmiersprachkonstrukten ermöglicht. Die bisherigen Umsetzungen von kontextorientiertem Programmieren schränken jedoch die Kontrolle der Laufzeitaktivierungen solches kontextspezifischen Verhaltens ein. Daraus folgt eine Einschränkung der Anwendungsbereiche für kontextorientiertes Programmieren, unter anderem für solche Domänen, in denen Programme sehr häufig kontextabhängiges Verhalten bereitstellen, z.B. ereignisbasierte, mobile und dienstorientierte Systeme. Die Programmiersprache JCop erweitert Java um Sprachkonstrukte für kontextorientieres Programmieren und bietet zusätzlich eine domänenspezifische Aspektsprach an, mit deren Hilfe Laufzeitadaptionen deklarativ spezifiziert werden können. Die Kernkonzepte von JCop wurden bereits in mehrern Publikationen vorgestellt, dieser Bericht enthält nun eine umfassende Sprachspezifikation von JCop.
T3 - Technische Berichte des Hasso-Plattner-Instituts für Digital Engineering an der Universität Potsdam - 59
KW - Programming Languages
KW - Context-oriented Programming
KW - Aspect-oriented Programming
KW - Java
KW - JCop
KW - runtime adaptations
Y1 - 2012
U6 - http://nbn-resolving.de/urn/resolver.pl?urn:nbn:de:kobv:517-opus-60208
SN - 978-3-86956-193-6
PB - Universitätsverlag Potsdam
CY - Potsdam
ER -
TY - BOOK
A1 - Kleine, Matthias
A1 - Hirschfeld, Robert
A1 - Bracha, Gilad
T1 - An abstraction for version control systems
T3 - Technische Berichte des Hasso-Plattner-Instituts für Softwaresystemtechnik an der Universität Potsdam
N2 - Versionsverwaltungssysteme (VCS) ermöglichen es Entwicklern, Ä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ünschenswert mit einzelnen solcher Werkzeuge unterschiedliche VCS bedienen zu können. Bislang hat sich jedoch keine Abstraktion für Versionsverwaltungssysteme durchgesetzt, mit deren Hilfe solche Werkzeuge erstellt werden können. Stattdessen implementieren Werkzeuge zur Interaktion mit mehreren VCS ad-hoc Lösungen. Diese Masterarbeit stellt Pur vor, eine Abstraktion über Versionsverwaltungskonzepte. Mit Hilfe von Pur können Anwendungsprogramme entwickelt werden, die mit mehreren Versionsverwaltungssystemen interagieren können. Im Rahmen dieser Arbeit wird eine Implementierung dieser Abstraktion bereitgestellt und mit Hilfe eines Anwendungsprogramms validiert.
N2 - Version Control Systems (VCS) allow developers to manage changes to software artifacts. Developers interact with VCSs through a variety of client programs, such as graphical front-ends or command line tools. It is desirable to use the same version control client program against different VCSs. Unfortunately, no established abstraction over VCS concepts exists. Instead, VCS client programs implement ad-hoc solutions to support interaction with multiple VCSs. This thesis presents Pur, an abstraction over version control concepts that allows building rich client programs that can interact with multiple VCSs. We provide an implementation of this abstraction and validate it by implementing a client application.
T3 - Technische Berichte des Hasso-Plattner-Instituts für Digital Engineering an der Universität Potsdam - 54
Y1 - 2011
U6 - http://nbn-resolving.de/urn/resolver.pl?urn:nbn:de:kobv:517-opus-55629
SN - 978-3-86956-158-5
SN - 1613-5652
SN - 2191-1665
IS - 54
PB - Universitätsverlag Potsdam
CY - Potsdam
ER -
TY - JOUR
A1 - Freudenberg, Bert
A1 - Ingalls, Dan
A1 - Felgentreff, Tim
A1 - Pape, Tobias
A1 - Hirschfeld, Robert
T1 - SqueakJS A Modern and Practical Smalltalk that Runs in Any Browser
JF - ACM SIGPLAN notices
N2 - We report our experience in implementing SqueakJS, a bitcompatible implementation of Squeak/Smalltalk written in pure JavaScript. SqueakJS runs entirely in theWeb browser with a virtual file system that can be directed to a server or client-side storage. Our implementation is notable for simplicity and performance gained through adaptation to the host object memory and deployment leverage gained through the Lively Web development environment. We present several novel techniques as well as performance measurements for the resulting virtual machine. Much of this experience is potentially relevant to preserving other dynamic language systems and making them available in a browser-based environment.
KW - Smalltalk
KW - Squeak
KW - Web browsers
KW - JavaScript
Y1 - 2015
U6 - https://doi.org/10.1145/10.1145/2661088.2661100
SN - 0362-1340
SN - 1558-1160
VL - 50
IS - 2
SP - 57
EP - 66
PB - Association for Computing Machinery
CY - New York
ER -
TY - JOUR
A1 - Steinert, Bastian
A1 - Thamsen, Lauritz
A1 - Felgentreff, Tim
A1 - Hirschfeld, Robert
T1 - Object Versioning to Support Recovery Needs Using Proxies to Preserve Previous Development States in Lively
JF - ACM SIGPLAN notices
N2 - We present object versioning as a generic approach to preserve access to previous development and application states. Version-aware references can manage the modifications made to the target object and record versions as desired. Such references can be provided without modifications to the virtual machine. We used proxies to implement the proposed concepts and demonstrate the Lively Kernel running on top of this object versioning layer. This enables Lively users to undo the effects of direct manipulation and other programming actions.
KW - Programming Environments
KW - Object Versioning
KW - CoExist
KW - JavaScript
KW - Lively Kernel
Y1 - 2015
U6 - https://doi.org/10.1145/2661088.2661093
SN - 0362-1340
SN - 1558-1160
VL - 50
IS - 2
SP - 113
EP - 124
PB - Association for Computing Machinery
CY - New York
ER -
TY - JOUR
A1 - Pape, Tobias
A1 - Bolz, Carl Friedrich
A1 - Hirschfeld, Robert
T1 - Adaptive just-in-time value class optimization for lowering memory consumption and improving execution time performance
JF - Science of computer programming
N2 - The performance of value classes is highly dependent on how they are represented in the virtual machine. Value class instances are immutable, have no identity, and can only refer to other value objects or primitive values and since they should be very lightweight and fast, it is important to optimize them carefully. In this paper we present a technique to detect and compress common patterns of value class usage to improve memory usage and performance. The technique identifies patterns of frequent value object references and introduces abbreviated forms for them. This allows to store multiple inter-referenced value objects in an inlined memory representation, reducing the overhead stemming from meta data and object references. Applied to a small prototype and an implementation of the Racket language, we found improvements in memory usage and execution time for several micro-benchmarks. (C) 2016 Elsevier B.V. All rights reserved.
KW - Meta-tracing
KW - JIT
KW - Data structure optimization
KW - Value classes
Y1 - 2017
U6 - https://doi.org/10.1016/j.scico.2016.08.003
SN - 0167-6423
SN - 1872-7964
VL - 140
SP - 17
EP - 29
PB - Elsevier
CY - Amsterdam
ER -
TY - BOOK
A1 - Wassermann, Lars
A1 - Felgentreff, Tim
A1 - Pape, Tobias
A1 - Bolz, Carl Friedrich
A1 - Hirschfeld, Robert
T1 - Tracing Algorithmic Primitives in RSqueak/VM
N2 - 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.
N2 - Wenn man eine Programmiersprache als Virtuelle Maschine (VM) realisiert, dann wird Verhalten, das man als Teil der VM, also primitiv, implementiert normalerweise schneller ausgeführt, als vergleichbare Funktionen die in der implementierten Sprache verfasst wurden. Aber die Entwicklung und Wartung von primitiven Funktionen erfordert mehr Anstrengung als die Wartung und Benutzung von Funktionen der implementierten Sprache, da Fehlerbehebung schwerer ist, und die Entwicklungszyklen für VM-Teile länger sind. Im Gegensatz zu Programmen, die in der implementierten Programmiersprache geschrieben sind, wird Quelltext von Primitiven selten wiederverwendet. Und falls sie wiederverwendet werden, dann wird die Schnittstelle zur VM meist emuliert, was den Geschwindigkeitsvorteil reduziert. Aber aufgrund von neueren Resultaten der ablaufverfolgenden dynamischen Kompilierung, könnte die Abwägung zwischen Geschwindigkeit einerseits und Implementierungsaufwand, Wiederverwendbarkeit und Änderbarkeit andererseits nun zugunsten von letzteren ausfallen.
In dieser Arbeit untersuchen wir, welche Abstriche bei der Implementierung von Verhalten als Primitive gemacht werden müssen, insbesondere wie hoch die Laufzeitunterschiede zwischen Primitiven und gehosteten Funktionen noch sind. Um das zu erreichen haben wir die algorithmische Primitive BitBlt drei mal für RSqueak/VM implementiert. RSqueak/VM ist eine Smalltalk VM, die die PyPy RPython-Toolkette verwendet. Wir vergleichen die Primitivenimplementierungen in C, RPython und Smalltalk, und zeigen, dass aufgrund eines ablaufverfolgenden just-in-time-Übersetzers der Geschwindigkeitsunterschied um eine Größenordnung auf eine Größenordnung gefallen ist.
T3 - Technische Berichte des Hasso-Plattner-Instituts für Digital Engineering an der Universität Potsdam - 104
KW - virtual machines
KW - collection types
KW - memory optimization
KW - dynamic typing
KW - virtuelle Maschinen
KW - Sammlungsdatentypen
KW - Speicheroptimierungen
KW - dynamische Sprachen
Y1 - 2016
U6 - http://nbn-resolving.de/urn/resolver.pl?urn:nbn:de:kobv:517-opus4-91277
SN - 978-3-86956-355-8
SN - 1613-5652
SN - 2191-1665
IS - 104
PB - Universitätsverlag Potsdam
CY - Potsdam
ER -
TY - BOOK
A1 - Baltzer, Wanda
A1 - Hradilak, Theresa
A1 - Pfennigschmidt, Lara
A1 - Prestin, Luc Maurice
A1 - Spranger, Moritz
A1 - Stadlinger, Simon
A1 - Wendt, Leo
A1 - Lincke, Jens
A1 - Rein, Patrick
A1 - Church, Luke
A1 - Hirschfeld, Robert
T1 - An individual-centered approach to visualize people’s opinions and demographic information
N2 - 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.
N2 - Der noble Weg, Entscheidungen, die viele Menschen betreffen, zu begründen, besteht darin, diese Menschen nach ihrer Meinung zu fragen. Für Regierungen, die ganze Länder führen, bedeutet dies, alle Bürger nach ihrer Meinung zu fragen, um ihre Situationen und Bedürfnisse zu berücksichtigen.
Organisationen wie die Africa's Voices Foundation, die die Kommunikation zwischen Entscheidungsträgern und Bürgern eines Landes erleichtern wollen, haben Schwierigkeiten, zwischen diesen Gruppen zu vermitteln. Um Verständnis zu ermöglichen, müssen die Aussagen zusammengefasst und visualisiert werden. Diese Ziele auf eine Weise zu erreichen, die den Stimmen und Situationen der Bürgerinnen und Bürger gerecht wird, erweist sich als Herausforderung. Standardgrafiken helfen dabei nicht weiter, da es ihnen nicht gelingt, Empathie für die Menschen hinter ihren grafischen Abstraktionen zu schaffen. Darüber hinaus schaffen diese Diagramme kein Vertrauen in die Daten, die sie darstellen, da es keine Möglichkeit gibt, den verwendeten Code und die Originaldaten zu sehen oder zu ihnen zurück zu navigieren. Um diese Funktionen zu erfüllen, würden Visualisierungen sehr von Interaktionen zur Erkundung der angezeigten Daten profitieren, die Standardgrafiken oft nur begrenzt bieten.
Um das Verständnis der Stimmen der Menschen zu verbessern, haben wir 80 Ideen für neue Visualisierungen, neue Interaktionen und bessere Verbindungen zwischen verschiedenen Diagrammen entwickelt und kategorisiert, die wir in diesem Bericht vorstellen. Aus diesen Ideen haben wir 10 Prototypen und zwei Systeme implementiert, die verschiedene Visualisierungen integrieren. Wir zeigen, dass diese Integration ein einheitliches Erscheinungsbild und Verhalten der Visualisierungen ermöglicht. Die Visualisierungen haben alle das gleiche Grundkonzept: Jedes Individuum wird durch einen einzigen Punkt dargestellt. Um diese Idee zu verwirklichen, diskutieren wir Technologien, die die effiziente Darstellung einer großen Anzahl dieser Punkte ermöglichen. Mit diesen Visualisierungen sind direkte Interaktionen mit Darstellungen von Individuen möglich, indem man auf sie klickt oder eine Auswahl um sie herumzieht. Diese direkte Interaktion ist nur mit einer bidirektionalen Verbindung von der Visualisierung zu den angezeigten Daten möglich. Wir diskutieren verschiedene Strategien für bidirektionale Mappings und die damit verbundenen Kompromisse. Ein einheitliches Verhalten über Visualisierungen hinweg verbessert die Exploration. Für unsere Prototypen umfasst dies Gruppierung, Filterung, Hervorhebung und Einfärbung von Punkten. Unsere Arbeit an den Prototypen wurde durch die Entwicklungsumgebung Lively4 ermöglicht. Wir erklären, welche Teile von Lively4 unseren Prototyping-Prozess erleichtert haben. Schließlich bewerten wir unsere Herangehensweise an Domänenprobleme und die von uns entwickelten Visualisierungskonzepte.
Unsere Arbeit liefert Inspiration und einen Ausgangspunkt für die Entwicklung von Visualisierungen in diesem Bereich. Unsere Visualisierungen können die Kommunikation zwischen Bürgern und ihrer Regierung verbessern und einfühlsame Entscheidungen motivieren. Unser Ansatz, bei dem wir niedrigstufige Entitäten zur Erstellung von Visualisierungen kombinieren, bietet einen wertvollen Ansatz für einen explorativen und einfühlsamen Arbeitsablauf. Wir zeigen, dass der Designraum für die Visualisierung dieser Art von Daten ein großes Potenzial hat und dass es möglich ist, qualitative und quantitative Ansätze zur Datenanalyse zu kombinieren.
T3 - Technische Berichte des Hasso-Plattner-Instituts für Digital Engineering an der Universität Potsdam - 136
KW - data visualization
KW - demographic information
KW - visualization concept exploration
KW - web-based development environment
KW - Datenvisualisierung
KW - demografische Informationen
KW - Visualisierungskonzept-Exploration
KW - web-basierte Entwicklungsumgebung
Y1 - 2021
U6 - http://nbn-resolving.de/urn/resolver.pl?urn:nbn:de:kobv:517-opus4-491457
SN - 978-3-86956-504-0
SN - 1613-5652
SN - 2191-1665
IS - 136
PB - Universitätsverlag Potsdam
CY - Potsdam
ER -
TY - BOOK
A1 - Seitz, Klara
A1 - Lincke, Jens
A1 - Rein, Patrick
A1 - Hirschfeld, Robert
T1 - Language and tool support for 3D crochet patterns
BT - virtual crochet with a graph structure
N2 - 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.
N2 - Häkeln ist eine weltweit verbreitete Handarbeitskunst. Obwohl andere Techniken, wie stricken und weben über die Zeit maschinelle Unterstützung erhalten haben, ist Häkeln noch heute ein komplett manueller Vorgang. Nicht nur das Häkeln an sich, sondern auch der Prozess zur Anleitungserstellung von neuen Häkeldesigns ist kaum unterstützt mit digitalen Lösungen. In dieser Arbeit stellen wir ein Konzept vor, das Häkelanleitungen digital repräsentiert. Das entwickelte Format integriert Häkeltechniken, wodurch wir den Prozess des Anleitungschreibens für Designer spezifisch für die Häkeldomäne unterstützen können. Als Beiträge analysieren wir umfassend die Häkeldomäne, entwickeln ein Konzept zur Repräsentation von Häkelanleitungen basierend auf einer Graphenstruktur als domänenspezifische Sprache und implementieren einen projektionalen Editor, der auf der besagten Graphenstruktur aufbaut und weiterhin die erstellten Anleitungen als schematische Darstellung in 2D und 3D visualisiert. Durch die Analyse der Domäne lernen wir Häkeltechniken und Schwachstellen beim Ablauf des Anleitungserstellens kennen. Basierend auf diesen Erkenntnissen entwickeln wir das digitale Format, um Anleitungen zu repräsentieren. Für die Evaluierung unseres Konzepts, haben wir einen Prototypen implementiert, der die Machbarkeit demonstriert. Zudem haben wir die Software von professionellen Häkeldesignern testen lassen, die unsere Herangehensweise gutheißen.
T3 - Technische Berichte des Hasso-Plattner-Instituts für Digital Engineering an der Universität Potsdam - 137
KW - crochet
KW - visual language
KW - tools
KW - computer-aided design
KW - Häkeln
KW - visuelle Sprache
KW - Werkzeuge
KW - rechnerunterstütztes Konstruieren
Y1 - 2021
U6 - http://nbn-resolving.de/urn/resolver.pl?urn:nbn:de:kobv:517-opus4-492530
SN - 978-3-86956-505-7
SN - 1613-5652
SN - 2191-1665
IS - 137
PB - Universitätsverlag Potsdam
CY - Potsdam
ER -
TY - BOOK
A1 - Eichenroth, Friedrich
A1 - Rein, Patrick
A1 - Hirschfeld, Robert
T1 - Fast packrat parsing in a live programming environment
BT - improving left-recursion in parsing expression grammars
T3 - Technische Berichte des Hasso-Plattner-Instituts für Digital Engineering an der Universität Potsdam
N2 - 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.
T3 - Technische Berichte des Hasso-Plattner-Instituts für Digital Engineering an der Universität Potsdam - 135
KW - packrat parsing
KW - parsing expression grammars
KW - left recursion
Y1 - 2022
U6 - http://nbn-resolving.de/urn/resolver.pl?urn:nbn:de:kobv:517-opus4-491242
SN - 978-3-86956-503-3
SN - 1613-5652
SN - 2191-1665
IS - 135
PB - Universitätsverlag Potsdam
CY - Potsdam
ER -
TY - BOOK
A1 - Reschke, Jakob
A1 - Taeumel, Marcel
A1 - Pape, Tobias
A1 - Niephaus, Fabio
A1 - Hirschfeld, Robert
T1 - Towards version control in object-based systems
T1 - Ein Vorschlag zur Versionsverwaltung in objektbasierten Systemen
N2 - 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.
N2 - Versionsverwaltung ist unter Softwareentwicklern weit verbreitet. Sie verringert das Risiko beim Ändern der Software und erlaubt den Entwicklern verschiedene Konfigurationen zu verwalten und effizienter zusammenzuarbeiten. Dies wird durch Plattformen zum Teilen von Code wie GitHub oder Bitbucket zusätzlich unterstützt. Die meisten Versionsverwaltungssysteme verfolgen Dateien (z.B. Git, Mercurial und Subversion), aber manche Programmierumgebungen arbeiten nicht mit Dateien, sondern mit Objekten (viele Smalltalk-Implementierungen tun dies). Nutzer dieser Umgebungen möchten Versionsverwaltung für ihre Objekte dennoch einsetzen können. Spezialisierte Versionsverwaltungssysteme, wie die für Smalltalk verfügbaren (z.B. ENVY/Developer und Monticello), konzentrieren sich auf Methoden, Klassen und Konfigurationen selbiger. Andere von Benutzern definierte und konstruierte Objekte können damit oftmals gar nicht oder nur über komplizierte Umwege erfasst werden oder es wird ein fest vorgegebenes Format zur Serialisierung verwendet, das nicht für alle Arten von Objekten gleichermaßen geeignet ist. Desweiteren können beliebte, bereits existierende Plattformen für dateibasierte Versionsverwaltung von diesen Systemen nicht verwendet werden oder Adapterlösungen müssen implementiert und gepflegt werden.
Um die Situation von Versionsverwaltung für beliebige Objekte zu verbessern, stellt diese Arbeit ein Framework zum Nachverfolgen, Konvertieren und Speichern von Objekten vor. Es erlaubt Editionen von Objekten in einem austauschbaren, bestehenden Backend-Versionsverwaltungssystem zu speichern. Plattformen für dieses System können daher weiterbenutzt werden. Nutzer und Objekte können beeinflussen, wie Objekte zur Versionsverwaltung erfasst werden. Domänenspezifische Anforderungen lassen sich umsetzen. Das Speicherformat (d.h. das Dateiformat, wenn ein dateibasiertes Backend benutzt wird) kann auch von Objekt zu Objekt anders sein. Verschiedene Editionen von Objekten können verglichen und Änderungen auf Objektgraphen übertragen werden. Ein allgemeiner Ansatz zum Erfassen und Wiederherstellen von Objekten wird beschrieben, welcher jedes Objekt als eine Ansammlung von Slots betrachtet. Dadurch können Nutzer sofort anfangen ihre Objekte zu versionieren, ohne dass sie ihre Objekte zunächst zur Versionsverwaltung erweitern müssen. Die vorgeschlagene Architektur wird anhand einer Prototyp-Implementierung evaluiert, die es erlaubt Objekte in Squeak/Smalltalk mit Git zu versionieren. Der Prototyp verbessert den oben beschriebenen benachteiligten Status von Benutzerobjekten im Bezug auf Versionsverwaltung und erleichtert auch manche Versionsverwaltungs-Operationen für Klassen und Methoden. Er fördert auch neue Probleme zutage, die ebenfalls in dieser Arbeit diskutiert werden. Insofern ist diese Arbeit als ein erster Schritt in Richtung vollumfänglicher Versionsverwaltung für beliebige Objekte zu betrachten.
T3 - Technische Berichte des Hasso-Plattner-Instituts für Digital Engineering an der Universität Potsdam - 121
KW - version control
KW - object-oriented programming
KW - exploratory programming
KW - serialization
KW - Versionsverwaltung
KW - objektorientiertes Programmieren
KW - exploratives Programmieren
KW - Serialisierung
Y1 - 2018
U6 - http://nbn-resolving.de/urn/resolver.pl?urn:nbn:de:kobv:517-opus4-410812
SN - 978-3-86956-430-2
SN - 1613-5652
SN - 2191-1665
VL - 121
PB - Universitätsverlag Potsdam
CY - Potsdam
ER -
TY - BOOK
A1 - Niephaus, Fabio
A1 - Felgentreff, Tim
A1 - Hirschfeld, Robert
T1 - Squimera
BT - a live, Smalltalk-based IDE for dynamic programming languages
N2 - Programmierwerkzeuge, die verschiedene Programmiersprachen unterstützen und sich konsistent bedienen lassen, sind hilfreich für Softwareentwickler, weil diese sich nicht erst mit neuen Werkzeugen vertraut machen müssen, wenn sie in einer neuen Sprache entwickeln wollen. Außerdem ist es nützlich, verschiedene Programmiersprachen in einer Anwendung kombinieren zu können, da Entwickler dann Softwareframeworks und -bibliotheken nicht in der jeweiligen Sprache nachbauen müssen und stattdessen bestehende Software wiederverwenden können.
Dennoch haben Entwickler eine sehr große Auswahl, wenn sie nach Werkzeugen suchen, die teilweise zudem speziell nur für eine Sprache ausgelegt sind. Einige integrierte Entwicklungsumgebungen unterstützen verschiedene Programmiersprachen, können aber häufig keine konsistente Bedienung ihrer Werkzeuge gewährleisten, da die jeweiligen Ausführungsumgebungen der Sprachen zu verschieden sind. Darüber hinaus gibt es bereits Mechansimen, die es erlauben, Programme aus anderen Sprachen in einem Programm wiederzuverwenden. Dazu werden häufig das Betriebssystem oder eine Netzwerkverbindung verwendet. Programmierwerkzeuge unterstützen jedoch häufig eine solche Indirektion nicht und sind deshalb nur eingeschrä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ührungsumgebung, die verschiedene Sprachen gleichermaßen unterstützt.
Der auf unserem Ansatz basierende Prototyp Squimera demonstriert, dass es möglich ist, Programmierwerkzeuge in der Art wiederzuverwenden, sodass sie sich für verschiedene Programmiersprachen gleich verhalten und somit die Arbeit für Entwickler vereinfachen. Außerdem ermöglicht Squimera einfaches Wiederverwenden und darüber hinaus das Verschmischen von in unterschiedlichen Sprachen geschriebenen Softwarebibliotheken und -frameworks und erlaubt dabei zusätzlich Debugging über mehrere Sprachen hinweg.
N2 - Software development tools that work and behave consistently across different programming languages are helpful for developers, because they do not have to familiarize themselves with new tooling whenever they decide to use a new language. Also, being able to combine multiple programming languages in a program increases reusability, as developers do not have to recreate software frameworks and libraries in the language they develop in and can reuse existing software instead.
However, developers often have a broad choice with regard to tools, some of which are designed for only one specific programming language. Various Integrated Development Environments have support for multiple languages, but are usually unable to provide a consistent programming experience due to different features of language runtimes. Furthermore, common mechanisms that allow reuse of software written in other languages usually use the operating system or a network connection as the abstract layer. Tools, however, often cannot support such indirections well and are therefore less useful in debugging scenarios for example.
In this report, we present a novel approach that aims to improve the programming experience with regard to working with multiple high-level programming languages. As part of this approach, we reuse the tools of a Smalltalk programming environment for other languages and build a multi-language virtual execution environment which is able to provide the same runtime capabilities for all languages.
The prototype system Squimera is an implementation of our approach and demonstrates that it is possible to reuse development tools, so that they behave in the same way across all supported programming languages. In addition, it provides convenient means to reuse and even mix software libraries and frameworks written in different languages without breaking the debugging experience.
T3 - Technische Berichte des Hasso-Plattner-Instituts für Digital Engineering an der Universität Potsdam - 120
KW - Programmiererlebnis
KW - integrierte Entwicklungsumgebungen
KW - mehrsprachige Ausführungsumgebungen
KW - Interpreter
KW - Debugging
KW - Smalltalk
KW - Python
KW - Ruby
KW - programming experience
KW - integrated development environments
KW - polyglot execution environments
KW - interpreters
KW - debugging
KW - small talk
KW - Python
KW - Ruby
Y1 - 2017
U6 - http://nbn-resolving.de/urn/resolver.pl?urn:nbn:de:kobv:517-opus4-403387
SN - 978-3-86956-422-7
IS - 120
PB - Universitätsverlag Potsdam
CY - Potsdam
ER -
TY - BOOK
A1 - Freund, Rieke
A1 - Rätsch, Jan Philip
A1 - Hradilak, Franziska
A1 - Vidic, Benedikt
A1 - Heß, Oliver
A1 - Lißner, Nils
A1 - Wölert, Hendrik
A1 - Lincke, Jens
A1 - Beckmann, Tom
A1 - Hirschfeld, Robert
T1 - Implementing a crowd-sourced picture archive for Bad Harzburg
N2 - 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.
N2 - Bilder können dabei helfen, die Vergangenheit greifbar zu machen und Erinnerungen zu bewahren, doch alleinstehende Bilder ohne Kontext erreichen das nur schwer. Der große Wert besteht in den Geschichten, die mit den Bildern verbunden sind. Je älter die Bilder jedoch werden, desto weniger Zeitzeugen können von diesen Geschichten berichten.
Besonders für große analoge Bildarchive, bei denen sich das Wissen und die Erinnerungen auf viele Personen verteilen, entstehen dadurch verschiedene Herausforderungen: Zunächst müssen die Bilder digitalisiert werden, um sie vor dem Zerfall zu schützen und um sie der Öffentlichkeit zugänglich machen zu können. Da eine einfache Aufreihung aller Bilder unübersichtlich ist, sollten die Bilder in eine zugängliche Struktur gebracht werden. Des Weiteren müssen zu den Bildern bekannte Informationen, aus denen ihre Geschichten erfahrbar werden, hinzugefügt werden. Nutzende sollen die Möglichkeit haben, eigenes Wissen und Erinnerungen beizutragen. Um dies für alle Interessierten, auch für ältere, evtl. wenig technikaffine Personen, nutzbar zu machen, sollte die Oberfläche eine intuitive und fehlertolerante Nutzung ermöglichen.
Die sich daraus ergebenden Anforderungen werden von keiner existierenden Softwarelösung im Gesamten abgedeckt, ohne die intuitive Oberfläche oder die Skalierbarkeit des Systems zu verlieren.
Daher haben wir im Rahmen eines Bachelorprojekts in Zusammenarbeit mit der Bad Harzburg-Stiftung ein eigenes digitales Bildarchiv entwickelt. Für die Umsetzung dieser Webapplikation nutzen wir das UI-Framework React im Frontend, welches über eine GraphQL-Schnittstelle mit dem Content Management System Strapi im Backend kommuniziert. Die Nutzung dieses Systems ermöglicht unserem Projektpartner einen effizienten Prozess vom Scannen der analogen Bilder bis zum geordneten und annotierten Darstellen für Besuchende. Um die Lösung sowohl für das Bereitstellen der Bilder als auch für das Beitragen von Informationen auf unsere Zielgruppe zuzuschneiden, haben wir Prototypen entworfen und mit Menschen aus Bad Harzburg getestet, um ihre Eindrücke auszuwerten. Mit diesen konnten wir wertvolle Erkenntnisse über die Nutzbarkeit und noch offene Herausforderungen und Anforderungen gewinnen.
Unsere Webanwendung ist bei unserem Projektpartner bereits im täglichen Einsatz. Trotzdem haben wir während des Projekts noch zahlreiche Ideen für zusätzliche Funktionen erarbeitet, um den Wissensaustausch weiter zu fördern.
T3 - Technische Berichte des Hasso-Plattner-Instituts für Digital Engineering an der Universität Potsdam - 149
KW - digital picture archive
KW - analog-to-digital conversion
KW - user-generated content
KW - intuitive interfaces
KW - digitales Bildarchiv
KW - Analog-zu-Digital-Konvertierung
KW - benutzergenerierte Inhalte
KW - intuitive Benutzeroberflächen
Y1 - 2022
U6 - http://nbn-resolving.de/urn/resolver.pl?urn:nbn:de:kobv:517-opus4-560291
SN - 978-3-86956-545-3
SN - 1613-5652
SN - 2191-1665
IS - 149
PB - Universitätsverlag Potsdam
CY - Potsdam
ER -
TY - BOOK
A1 - Klinke, Paula
A1 - Verhoeven, Silvan
A1 - Roth, Felix
A1 - Hagemann, Linus
A1 - Alnawa, Tarik
A1 - Lincke, Jens
A1 - Rein, Patrick
A1 - Hirschfeld, Robert
T1 - Tool support for collaborative creation of interactive storytelling media
N2 - 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.
N2 - Scrollytellings sind innovative Webinhalte. Indem sie die Vorteile von Büchern, Bildern, Filmen und Videospielen vereinen, sind sie ein Werkzeug um Geschichten fesselnd zu erzählen und Lehrinhalte besonders effektiv zu vermitteln. Die Erstellung von Scrollytellings ist aufgrund ihrer Multimodalität keine einfache Aufgabe. Verschiedene Berufszweige wie Content-Designer:innen, Grafikdesigner:innen und Entwickler:innen müssen zusammenarbeiten, um das volle Potential des Scrollytelingformats auszuschöpfen. Jedoch können ContentDesigner:innen Scrollytellings nicht direkt selbst erstellen, sondern müssen ihre Vision stets gemeinsam mit Entwickler:innen umsetzen. Dabei können unnötige Iterationen über das Scrollytelling auftreten, wenn dieses den Visionen der Content-Designer:innen noch nicht entspricht. Außerdem können Missverständnisse entstehen. Unser Projektpartner Typeshift hat sich auf die Erstellung von, für seine Kund:innen individualisierten, Scrollytellings spezialisiert. Aufbauend auf Typeshifts Erfahrungen und Expertise haben wir einen Editor entwickelt, um Scrollytellings in der Live-Programmierumgebung lively.next zu erstellen. In lively.next wird eine graphische Oberfläche für die Erstellung von Inhalten mit weitreichenden Möglichkeiten zur Programmierung von Verhalten durch das Morphic-System kombiniert. Der Editor erlaubt es Content-Designer:innen eigenständig große Teile des Erstellungsprozesses von Scrollytellings durchzuführen, zum Beispiel das Erzeugen visueller Elemente, deren Animation sowie die Feinjustierung des gesamten Scrollytellings. So können Entwickler:innen sich auf die Erstellung von komplexen interaktiven Elementen, wie Simulationen oder Spiele, konzentrieren. Zusammen mit Typeshift haben wir die Nutzbarkeit unseres Editors durch die Nachbildung eines bereits existierenden Scrollytellings evaluiert und mögliche Verbesserungen identifiziert. Unser Editor vereinfacht den Erstellungsprozess von Scrollytellings. Content Designer:innen und Entwickler:innen können jetzt beide an demselben Scrollytelling arbeiten. Durch den Editor, der in lively.next integriert ist, können beide Parteien mit den ihnen bekannten und vertrauten Werkzeugen arbeiten. Durch den Editor verringern wir unnötige Iterationen und Missverständnisse und erlauben Content-Designer:innen große Teile ihrer Vision eines Scrollytellings eigenständig umzusetzen. Entwickler:innen können zusätzliches, individuelles Verhalten hinzufügen. So profitieren Entwickler:innen und Content-Designer:innen von einer besseren Aufgabenteilung, während die Vorteile von Zusammenarbeit bestehen bleiben.
T3 - Technische Berichte des Hasso-Plattner-Instituts für Digital Engineering an der Universität Potsdam - 141
KW - scrollytelling
KW - interactive media
KW - web-based development
KW - Lively Kernel
KW - Scrollytelling
KW - interaktive Medien
KW - webbasierte Entwicklung
KW - Lively Kernel
Y1 - 2022
U6 - http://nbn-resolving.de/urn/resolver.pl?urn:nbn:de:kobv:517-opus4-518570
SN - 978-3-86956-521-7
SN - 1613-5652
SN - 2191-1665
IS - 141
PB - Universitätsverlag Potsdam
CY - Potsdam
ER -
TY - BOOK
A1 - Dürsch, Falco
A1 - Rein, Patrick
A1 - Mattis, Toni
A1 - Hirschfeld, Robert
T1 - Learning from failure
BT - a history-based, lightweight test prioritization technique connecting software changes to test failures
N2 - 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.
N2 - Regressionstests sind in der heutigen Softwareindustrie weit verbreitete Praxis um die Qualität eines Softwareprodukts abzusichern. Dabei leiten Entwickler von den gestellten Anforderungen Testfälle ab und führen diese wiederholt aus, um sicherzustellen, dass ihre Änderungen die bereits existierende Funktionalität nicht negativ beeinträchtigen. Steigt die Größe und Komplexität der Software und ihrer Testsuite, so wird die Feedbackschleife der Testausführungen länger, und mindert die Produktivität der Entwickler: Sie warten länger auf das Testergebnis, und die Fehlerbehebung gestaltet sich umso schwieriger, je länger die Ursache zurückliegt.
Um die Feedbackschleife zu verkürzen, ändern Testpriorisierungs-Algorithmen die Reihenfolge der Testfälle, sodass Testfälle, die mit hoher Wahrscheinlichkeit fehlschlagen, zuerst ausgeführt werden. Der vorliegende Bericht beschäftigt sich mit der Frage nach der Effizienz von Testplänen, welche aus öffentlich einsehbaren Daten rekonstruierbar sind, und welche anwendbaren Priorisierungs-Techniken die effizienteste Testreihenfolge in Bezug auf APFD hervorbringen.
Zu diesem Zweck werden 6200 Testsitzungen aus den Logdateien von Travis CI, einem oft verwendeten Dienst für Continuous Integration, und über 62000 Änderungslisten rekonstruiert. Auf dieser Grundlage wird die Effizienz der derzeitigen Testpläne bewertet, als auch solcher, die aus der Neupriorisierung durch leichtgewichtige, verlaufsbasierte Algorithmen hervorgehen. Zudem schlägt der vorliegende Bericht eine neue Gruppe von Ansätzen vor, die Testfehlschläge und Softwareänderungen mit Hilfe einer Matrix in Bezug setzt.
Da die beobachteten Testreihenfolgen nur 30% APFD erzielen, liegt wesentliches Potential für Optimierung vor. Dabei besticht die Vorhersagekraft der unmittelbar vorangegangen Testfehlschläge: einfache Heuristiken, wie das Wiederholen von Tests, welche kürzlich fehlgeschlagen sind, führen zu Testplänen mit einer Effizienz von 95% APFD. Matrix-basierte Ansätze erreichen eine Fehlererkennungsrate von bis zu 92.5% APFD. Im Gegensatz zu den bisher bekannten Ansätzen sind die matrix-basierten Techniken auch über den Zweck der Testpriorisierung hinaus nützlich, und sind in der Softwarewartung anwendbar.
Zusätzlich werden die Ergebnisse der vorliegenden Studie für Continuous Integration Systeme im Kontext integrierter Entwicklungsumgebungen validiert, indem ein Tool für Continuous Testing um Testpriorisierung erweitert wird. Dies führt zu neuen Forschungsfragen. Die Untersuchungsergebnisse sind geeignet die Einführung von Continuous Testing zu befördern, und untermauern, dass Werkzeuge der Testpriorisierung für produktive Softwareentwicklung essenziell sind.
T3 - Technische Berichte des Hasso-Plattner-Instituts für Digital Engineering an der Universität Potsdam - 145
KW - test case prioritization
KW - continuous integration
KW - regression testing
KW - version control
KW - live programming
KW - heuristics
KW - data set
KW - test results
KW - GitHub
KW - Java
KW - Testpriorisierungs
KW - kontinuierliche Integration
KW - Regressionstests
KW - Versionsverwaltung
KW - Live-Programmierung
KW - Heuristiken
KW - Datensatz
KW - Testergebnisse
KW - GitHub
KW - Java
Y1 - 2022
U6 - http://nbn-resolving.de/urn/resolver.pl?urn:nbn:de:kobv:517-opus4-537554
SN - 978-3-86956-528-6
SN - 1613-5652
SN - 2191-1665
IS - 145
PB - Universitätsverlag Potsdam
CY - Potsdam
ER -
TY - BOOK
A1 - Felgentreff, Tim
A1 - Hirschfeld, Robert
A1 - Millstein, Todd
A1 - Borning, Alan
T1 - Babelsberg/RML
BT - executable semantics and language testing with RML
N2 - 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.
N2 - Neue Programmiersprachdesigns werden typischerweise anhand konkreter Implementierungen bewertet. Um jedoch Schlüsse aus den Erfahrungen mit einer konkreten Programmiersprache auf ein Sprachdesign ziehen zu können, muss die konkrete Sprache verifizierbar dem Design entsprechen. Zudem muss sichergestellt sein, dass das formale Design seine gesetzten Ziele auch erfüllt. Dabei haben sich ausführbare Semantiken als ein nützliches Werkzeug erwiesen, um letzteres sicherzustellen. Allerdings half dieses Werkzeug bisher nicht, auch die konkrete Implementierung gegen das Design zu verifizieren.
Babelsberg ist ein neues Design für eine Familie von Objekt-Constraint Programmiersprachen, zu der wir eine formale Semantik entwickelt haben, die einige Details des Designs klarstellt. Ergänzend dazu berichten wir hier, wie dieser Formalismus in eine ausführbare Semantik mithilfe des RML Systems umgewandelt werden kann. Weiterhin zeigen wir, wie wir diese ausführbare Semantik um ein Rahmenwerk erweitert haben, mit dem sich programmatische Tests für die konkreten Babelsberg Implementierungen erzeugen lassen, welche Rückverfolgbarkeit von der Sprachimplementierung zum Sprachdesign sicherstellen. Schlussendlich diskutieren wir, wie diese Tests uns erlaubten, Fehler in der Babelsberg Implementierung für JavaScript zu finden und zu beheben.
T3 - Technische Berichte des Hasso-Plattner-Instituts für Digital Engineering an der Universität Potsdam - 103
KW - object-constraint programming
KW - executable semantics
KW - language specification
KW - Objekt-Constraint Programmierung
KW - ausführbare Semantiken
KW - Sprachspezifikation
Y1 - 2015
U6 - http://nbn-resolving.de/urn/resolver.pl?urn:nbn:de:kobv:517-opus4-83826
SN - 978-3-86956-348-0
SN - 1613-5652
SN - 2191-1665
IS - 103
PB - Universitätsverlag Potsdam
CY - Potsdam
ER -
TY - BOOK
A1 - Weyand, Christopher
A1 - Chromik, Jonas
A1 - Wolf, Lennard
A1 - Kötte, Steffen
A1 - Haase, Konstantin
A1 - Felgentreff, Tim
A1 - Lincke, Jens
A1 - Hirschfeld, Robert
T1 - Improving hosted continuous integration services
T1 - Verbesserung gehosteter Dienste für kontinuierliche Integration
N2 - 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.
N2 - Große Softwareprojekte zu entwickeln, ist eine komplizierte Aufgabe und fordernd für Entwickler. Kontinuierliche Integration ist eine geläufige Praxis zur Komplexitätsreduktion. Durch häufiges Integrieren und Testen werden Änderungen klein gehalten und sind daher übersichtlich. Travis CI ist ein Dienst, der kontinuierliche Integration und kontinuierliche Bereitstellung in der Cloud anbietet. Softwareprojekte werden auf der Travis CI Infrastruktur gebaut, getestet und bereitgestellt, ohne dass der Entwicklungsprozess unterbrochen wird. Dieser Bericht beschreibt, die Travis CI funktioniert, zeigt wie zeitgesteuertes, periodisches Bauen implentiert wurde, wie CI-Daten visualisiert werden können und schlägt ein Verfahren vor mit dem Abhängigkeitsprobleme gelöst werden können.
T3 - Technische Berichte des Hasso-Plattner-Instituts für Digital Engineering an der Universität Potsdam - 108
KW - Travis CI
KW - continuous integration
KW - continuous testing
KW - software tests
KW - software architecture
KW - periodic tasks
KW - dependencies
KW - visualization
KW - Travis CI
KW - kontinuierliche Integration
KW - kontinuierliches Testen
KW - Softwaretests
KW - Softwarearchitektur
KW - periodische Aufgaben
KW - Abhängigkeiten
KW - Visualisierung
Y1 - 2017
U6 - http://nbn-resolving.de/urn/resolver.pl?urn:nbn:de:kobv:517-opus4-94251
SN - 978-3-86956-377-0
SN - 1613-5652
SN - 2191-1665
IS - 108
PB - Universitätsverlag Potsdam
CY - Potsdam
ER -
TY - BOOK
A1 - Tessenow, Philipp
A1 - Felgentreff, Tim
A1 - Bracha, Gilad
A1 - Hirschfeld, Robert
T1 - Extending a dynamic programming language and runtime environment with access control
T1 - Verbesserung gehosteter Dienste für kontinuierliche Integration
N2 - 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.
N2 - Die Komplexität von Softwaresystemen hat einen hohen Einfluss auf Entwicklungs- und Wartungskosten. Um diese Komplexität zu beherschen, werden Softwaresysteme in Module unterteilt, da diese getrennt leichter zu entwickeln und zu testen sind. Zur Unterstützung einer sauberen Aufteilung von Modulen, sollten sie minimale und klar definierte Schnittstellen haben. Dafür ist die Fähigkeit, mit Hilfe der Berechtigungskontrolle selektiv die Sichtbarkeit von Funktionen eines Modules einzuschränken, von zentraler Bedeutung.
Softwaresysteme sind immer stärker verteilt, was nicht nur zu ihrer Komplexität beiträgt, sondern auch Herausforderungen bezüglich der Sicherheit mit sich bringt. Der Object-Capability-Ansatz löst genau jene Sicherheitsprobleme, da dadurch Programmobjekten nur die minimal erforderlichen Fähigkeiten gegeben werden. Für diesen Ansatz ist es essentiell, dass die öffentliche Schnittstelle eines Objektes durch Berechtigungskontrolle eingeschränkt werden kann. Auf dem Object-Capability-Ansatz basiert Newspeak, eine moderne und dynamische Programmiersprache, die besonders auf Sicherheit sowie Modularität Wert legt.
Die Berechtigungskontrolle ist eine zentrale Funktion, sowohl für die Modularität, als auch für die Sicherheit von Newspeak. Daher ist sie auch in der Spezifikation von Newspeak definiert. Bisher gibt es allerdings keine Implementierung, die die Berechtigungskontrolle durchsetzt.
In dieser Arbeit stellen wir eine Implementierung der Berechtigungskontrolle für Newspeak vor. Damit wird sowohl die Modularität von Newspeak Programmen verbessert, als auch die Sicherheit durch den Object-Capability-Ansatz erst ermöglicht. Wir beschreiben eine Implementierung der Berechtigungskontrolle für Newspeak und passen dabei die Laufzeitumgebung, die Reflexions- und Introspektionsmodule, den Compiler sowie die virtuelle Maschine an. Große Teile des Newspeak-Programmcodes müssen für die Benutzung der Berechtigungskontrolle angepasst werden. Durch eine Migration des Newspeak-Programmcodes wird es möglich, unsere Implementierung mit existierenden Newspeak-Programmen zu benutzen.
T3 - Technische Berichte des Hasso-Plattner-Instituts für Digital Engineering an der Universität Potsdam - 107
KW - access control
KW - virtual machines
KW - Newspeak
KW - dynamic programming languages
KW - Zugriffskontrolle
KW - virtuelle Maschinen
KW - Newspeak
KW - dynamische Programmiersprachen
Y1 - 2016
U6 - http://nbn-resolving.de/urn/resolver.pl?urn:nbn:de:kobv:517-opus4-92560
SN - 978-3-86956-373-2
SN - 1613-5652
SN - 2191-1665
IS - 107
PB - Universitätsverlag Potsdam
CY - Potsdam
ER -
TY - BOOK
A1 - Beckmann, Tom
A1 - Hildebrand, Justus
A1 - Jaschek, Corinna
A1 - Krebs, Eva
A1 - Löser, Alexander
A1 - Taeumel, Marcel
A1 - Pape, Tobias
A1 - Fister, Lasse
A1 - Hirschfeld, Robert
T1 - The font engineering platform
T1 - Eine Plattform für Schriftarten
BT - collaborative font creation in a self-supporting programming environment
BT - kollaborative Schriftartgestaltung in Einer selbsttragenden Programmierumgebung
N2 - 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.
N2 - Die Erstellung von Schriften ist eine komplexe Aufgabe, die Expertenwissen aus einer Vielzahl von Bereichen erfordert. Oftmals liegt dieses Wissen nicht bei einer einzigen Person, sondern bei einer Reihe von Fachleuten. Ein zentrales Konzept für die Gestaltung von Schriften ist der Glyph, ein elementares Symbol, das ein einzelnes lesbares Zeichen darstellt. Zu den erforderlichen Domänen gehören das Entwerfen der Glyphenformen, technische Regeln zur Kombination von Glyphen für komplexe Skripte und das Prüfen der Lesbarkeit. Dieser Prozess ist meist iterativ und erfordert ständige Kommunikation zwischen den Experten. Dieser Bericht skizziert eine Plattform, die darauf abzielt, die Kommunikationswege zu verbessern, beschreibt unseren Prototyping-Prozess, diskutiert komplexe Schriftrendering und -bearbeitung in einer Echtzeitumgebung und einen Ansatz zur Generierung von Code basierend auf direkter Manipulation eines Nutzers.
T3 - Technische Berichte des Hasso-Plattner-Instituts für Digital Engineering an der Universität Potsdam - 128
KW - smalltalk
KW - squeak
KW - font rendering
KW - font engineering
KW - prototyping
KW - Smalltalk
KW - Squeak
KW - Schriftrendering
KW - Schriftartgestaltung
KW - Prototyping
Y1 - 2019
U6 - http://nbn-resolving.de/urn/resolver.pl?urn:nbn:de:kobv:517-opus4-427487
SN - 978-3-86956-464-7
SN - 1613-5652
SN - 2191-1665
IS - 128
PB - Universitätsverlag Potsdam
CY - Potsdam
ER -
TY - BOOK
A1 - Meinel, Christoph
A1 - Plattner, Hasso
A1 - Döllner, Jürgen Roland Friedrich
A1 - Weske, Mathias
A1 - Polze, Andreas
A1 - Hirschfeld, Robert
A1 - Naumann, Felix
A1 - Giese, Holger
A1 - Baudisch, Patrick
T1 - Proceedings of the 7th Ph.D. Retreat of the HPI Research School on Service-oriented Systems Engineering
N2 - 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.
N2 - Der Entwurf und die Realisierung dienstbasierender Architekturen wirft eine Vielzahl von Forschungsfragestellungen aus den Gebieten der Softwaretechnik, der Systemmodellierung und -analyse, sowie der Adaptierbarkeit und Integration von Applikationen auf. Komponentenorientierung und WebServices sind zwei Ansätze für den effizienten Entwurf und die Realisierung komplexer Web-basierender Systeme. Sie ermöglichen die Reaktion auf wechselnde Anforderungen ebenso, wie die Integration großer komplexer Softwaresysteme. Heute übliche Technologien, wie J2EE und .NET, sind de facto Standards für die Entwicklung großer verteilter Systeme. Die Evolution solcher Komponentensysteme führt über WebServices zu dienstbasierenden Architekturen. Dies manifestiert sich in einer Vielzahl von Industriestandards und Initiativen wie XML, WSDL, UDDI, SOAP. All diese Schritte führen letztlich zu einem neuen, vielversprechenden Paradigma für IT Systeme, nach dem komplexe Softwarelösungen durch die Integration vertraglich vereinbarter Software-Dienste aufgebaut werden sollen. "Service-Oriented Systems Engineering" repräsentiert die Symbiose bewährter Praktiken aus den Gebieten der Objektorientierung, der Komponentenprogrammierung, des verteilten Rechnen sowie der Geschäftsprozesse und berücksichtigt auch die Integration von Geschäftsanliegen und Informationstechnologien. Die Klausurtagung des Forschungskollegs "Service-oriented Systems Engineering" findet einmal jährlich statt und bietet allen Kollegiaten die Möglichkeit den Stand ihrer aktuellen Forschung darzulegen. Bedingt durch die Querschnittstruktur des Kollegs deckt dieser Bericht ein große Bandbreite aktueller Forschungsthemen ab. Dazu zählen unter anderem 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.
T3 - Technische Berichte des Hasso-Plattner-Instituts für Digital Engineering an der Universität Potsdam - 83
KW - Hasso-Plattner-Institut
KW - Forschungskolleg
KW - Klausurtagung
KW - Service-oriented Systems Engineering
KW - Hasso Plattner Institute
KW - Research School
KW - Ph.D. Retreat
KW - Service-oriented Systems Engineering
Y1 - 2014
U6 - http://nbn-resolving.de/urn/resolver.pl?urn:nbn:de:kobv:517-opus-63490
SN - 978-3-86956-273-5
PB - Universitätsverlag Potsdam
CY - Potsdam
ER -
TY - BOOK
A1 - Felgentreff, Tim
A1 - Borning, Alan
A1 - Hirschfeld, Robert
T1 - Babelsberg : specifying and solving constraints on object behavior
N2 - 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.
N2 - Constraints – Beschränkungen und Abhängigkeiten zwischen Systemteilen – erlauben es Entwicklern, erwünschte Eigenschaften von Systemen zu spezifizieren, sodass diese automatisch sichergestellt werden. Das führt zu kompaktem, deklarativem Quelltext, und vermeidet verstreute Anweisungen, die wiederholt Invarianten prüfen und wiederherstellen müssen. Trotz dieser Vorteile ist Programmieren mit Constraints nicht verbreitet, sondern imperatives Programmieren die Norm. Es gibt eine lange Forschungsgeschichte zur Integration von Constraints mit imperativem Programmieren. Jedoch vereinheitlicht diese Integration nicht die Programmierkonstrukte zur Abstraktion und Kapselung beider Paradigmen. Das verhindert die Wiederverwendung von Modulen, da Quelltext, der in einem Paradigma geschrieben wurde, nur Module verwenden kann, die so geschrieben sind, dass sie dieses Paradigma unterstützen. Module benötigen daher redundante Definitionen, wenn sie in beiden Paradigmen zur Verfügung stehen sollen. Wir präsentieren hier eine Sprache – Babelsberg – welche die Konstrukte zur Abstraktion und Kapselung vereinheitlicht, indem sie bekannte objektorientierte Methodendefinitionen sowohl für deklarativen, als auch für imperativen Code verwendet. Unser Prototyp –Babelsberg/R – ist eine Erweiterung von Ruby, und unterstützt Rubys objektorientierte Semantik. Dieser erlaubt es Programmieren, Constraints schrittweise zu existierenden Ruby Programmen hinzuzufügen, indem diese auf den Ergebnissen von Methodenaufrufen deklariert werden. Der Prototyp ist auf Basis einer virtuellen Maschine für Ruby implementiert, wobei die Ausführungsgeschwindigkeit von objektorienterten Programmteilen ohne Constraints nur minimal – typischerweise weniger als 10% – beeinträchtigt wird. Weiterhin erlaubt es unsere Architektur, je nach Anwendungsfall, mehrere Lösungsalgorithmen für Constraints zu verwenden. Wir argumentieren, dass unser Ansatz einen nützlichen Schritt darstellt, um Programmieren mit Constraints zu einem allgemeinen Werkzeug für objektorientierte Programmierer zu machen. Wir zeigen Beispielanwendungen, die unserer Ruby-basierten Implementierung geschrieben sind, welche Constraints in einer Reihe von Anwendungen verwenden: Für interaktive Grafik, Schaltkreissimulation, Datenströme mit sowohl harten, als auch weichen Constraints bezüglich ihrer Geschwindigkeit, und Konfigurationsverwaltung.
T3 - Technische Berichte des Hasso-Plattner-Instituts für Digital Engineering an der Universität Potsdam - 81
KW - Constraints
KW - Beschränkungen und Abhängigkeiten
KW - Objekt-orientiertes Programmieren mit Constraints
KW - Constraints
KW - Object Constraint Programming
Y1 - 2013
U6 - http://nbn-resolving.de/urn/resolver.pl?urn:nbn:de:kobv:517-opus-67296
SN - 978-3-86956-265-0
PB - Universitätsverlag Potsdam
CY - Potsdam
ER -
TY - BOOK
A1 - Pape, Tobias
A1 - Treffer, Arian
A1 - Hirschfeld, Robert
A1 - Haupt, Michael
T1 - Extending a Java Virtual Machine to Dynamic Object-oriented Languages
N2 - 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.
N2 - Es gibt zwei übliche Wege, um eine virtuelle Maschine (VM) für eine dynamische objektorientierte Programmiersprache zu implementieren. Einerseits kann sie in einer C-ähnlichen Programmiersprache geschrieben werden, um bestmögliche Leistung zu erzielen und größtmöglichen Einfluss auf das sich ergebende ausführbare Programm zu haben. Andererseits kann sie in einer Sprache wie Java geschrieben werden, die weitreichendere Abstraktionen als die C-ähnlichen Sprachen erlaubt. Diese Abstraktionen, beispielsweise echte objektorientierte Modularisierung, automatische Speicherverwaltung oder explizite Schnittstellen, erlauben eine vereinfachtes Implementieren von VM-typischen, aber komplexen Konzepten, wie Speicherbereinigung (garbage collector, GCs) oder just-in-time-Compilern (JITs). Wird eine dynamische objektorientierte Programmiersprache in Java geschrieben, ist jedoch mit Leistungseinbußen zu rechen, da effektiv zwei aufeinander aufbauende virtuelle Maschinen entstehen. Die Maxine VM löst diese Problem für statisch getypte Programmiersprachen; sie ist in Java geschrieben, kann aber ohne jegliche Java VM (JVM) laufen. Es ist jedoch momentan nicht möglich, dynamische objektorientierte Programmiersprachen in Maxine auszuführen. Diese Arbeit stellt einen Ansatz zur Umsetzung von Objekt- und Ausführungsmodellen dynamischer objektorientierter Programmiersprachen innerhalb der Maxine VM vor, sowie dessen Anwendung auf Squeak/Smalltalk. Dabei stellt die Representation von Objekten und die Ausführung dynamischer objektorientierter Programmiersprachen bestimmte Heraus- und Anforderungen an die Maxine VM, die trotz des Fokus auf Modularität und Konfigurierbarkeit einige Variationspunkte vermissen lässt, welche wiederum für eine einfache Implementierung von besagten Ausführungsmodellen jedoch unerlässlich sind. Daher sollen durch eine testweise Implementierung von Squeak/Smalltalk in Maxine eben jene Variationspunkte identifiziert werden.
T3 - Technische Berichte des Hasso-Plattner-Instituts für Digital Engineering an der Universität Potsdam - 82
Y1 - 2013
U6 - http://nbn-resolving.de/urn/resolver.pl?urn:nbn:de:kobv:517-opus-67438
SN - 978-3-86956-266-7
PB - Universitätsverlag Potsdam
CY - Potsdam
ER -
TY - JOUR
A1 - Pape, Tobias
A1 - Felgentreff, Tim
A1 - Hirschfeld, Robert
A1 - Gulenko, Anton
A1 - Bolz, Carl Friedrich
T1 - Language-independent Storage Strategies for Tracing-JIT-based Virtual Machines
JF - ACM SIGPLAN notices
N2 - Storage strategies have been proposed as a run-time optimization for the PyPy Python implementation and have shown promising results for optimizing execution speed and memory requirements. However, it remained unclear whether the approach works equally well in other dynamic languages. Furthermore, while PyPy is based on RPython, a language to write VMs with reusable components such as a tracing just-in-time compiler and garbage collection, the strategies design itself was not generalized to be reusable across languages implemented using that same toolchain. In this paper, we present a general design and implementation for storage strategies and show how they can be reused across different RPython-based languages. We evaluate the performance of our implementation for RSqueak, an RPython-based VM for Squeak/Smalltalk and show that storage strategies may indeed off er performance benefits for certain workloads in other dynamic programming languages. We furthermore evaluate the generality of our implementation by applying it to Topaz, a Ruby VM, and Pycket, a Racket implementation.
KW - Implementation
KW - collection types
KW - memory optimization
KW - dynamic typing
Y1 - 2016
U6 - https://doi.org/10.1145/2816707.2816716
SN - 0362-1340
SN - 1558-1160
VL - 51
SP - 104
EP - 113
PB - Association for Computing Machinery
CY - New York
ER -
TY - BOOK
A1 - Meinel, Christoph
A1 - Döllner, Jürgen Roland Friedrich
A1 - Weske, Mathias
A1 - Polze, Andreas
A1 - Hirschfeld, Robert
A1 - Naumann, Felix
A1 - Giese, Holger
A1 - Baudisch, Patrick
A1 - Friedrich, Tobias
A1 - Böttinger, Erwin
A1 - Lippert, Christoph
A1 - Dörr, Christian
A1 - Lehmann, Anja
A1 - Renard, Bernhard
A1 - Rabl, Tilmann
A1 - Uebernickel, Falk
A1 - Arnrich, Bert
A1 - Hölzle, Katharina
T1 - Proceedings of the HPI Research School on Service-oriented Systems Engineering 2020 Fall Retreat
N2 - 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.
N2 - Der Entwurf und die Realisierung dienstbasierender Architekturen wirft eine Vielzahl von Forschungsfragestellungen aus den Gebieten der Softwaretechnik, der Systemmodellierung und -analyse, sowie der Adaptierbarkeit und Integration von Applikationen auf. Komponentenorientierung und WebServices sind zwei Ansätze für den effizienten Entwurf und die Realisierung komplexer Web-basierender Systeme. Sie ermöglichen die Reaktion auf wechselnde Anforderungen ebenso, wie die Integration großer komplexer Softwaresysteme.
"Service-Oriented Systems Engineering" repräsentiert die Symbiose bewährter Praktiken aus den Gebieten der Objektorientierung, der Komponentenprogrammierung, des verteilten Rechnen sowie der Geschäftsprozesse und berücksichtigt auch die Integration von Geschäftsanliegen und Informationstechnologien.
Die Klausurtagung des Forschungskollegs "Service-oriented Systems Engineering" findet einmal jährlich statt und bietet allen Kollegiaten die Möglichkeit den Stand ihrer aktuellen Forschung darzulegen. Bedingt durch die Querschnittstruktur des Kollegs deckt dieser Bericht ein weites Spektrum aktueller Forschungsthemen ab. Dazu zählen unter anderem 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; sowie Services Specification, Composition, and Enactment.
T3 - Technische Berichte des Hasso-Plattner-Instituts für Digital Engineering an der Universität Potsdam - 138
KW - Hasso Plattner Institute
KW - research school
KW - Ph.D. retreat
KW - service-oriented systems engineering
KW - Hasso-Plattner-Institut
KW - Forschungskolleg
KW - Klausurtagung
KW - Service-oriented Systems Engineering
Y1 - 2021
U6 - http://nbn-resolving.de/urn/resolver.pl?urn:nbn:de:kobv:517-opus4-504132
SN - 978-3-86956-513-2
SN - 1613-5652
SN - 2191-1665
IS - 138
PB - Universitätsverlag Potsdam
CY - Potsdam
ER -