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. <br /> Secondary constructs are easy to change and provide high flexibility in communicating cross-cutting concerns and other concepts among programmers. However, such secondary constructs usually have no reified representation that can be explored and manipulated as first-class entities through the programming environment. <br /> In this exploratory work, we discuss novel ways to express a wide range of concepts, including cross-cutting concerns, patterns, and lifecycle artifacts independently of the dominant decomposition imposed by an existing architecture. We propose the representation of concepts as first-class objects inside the programming environment that retain the capability to change as easily as code comments. We explore new tools that allow programmers to view, navigate, and change programs based on conceptual perspectives. In a small case study, we demonstrate how such views can be created and how the programming experience changes from draining programmers' attention by stretching it across multiple modules toward focusing it on cohesively presented concepts. Our designs are geared toward facilitating multiple secondary perspectives on a system to co-exist in symbiosis with the original architecture, hence making it easier to explore, understand, and explain complex contexts and narratives that are hard or impossible to express using primary modularity constructs.
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  - 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  - 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  - 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  - 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  -