Refine
Year of publication
Document Type
- Monograph/Edited Volume (16)
- Article (8)
Is part of the Bibliography
- yes (24)
Keywords
- Lively Kernel (3)
- JavaScript (2)
- Visualisierung (2)
- virtual machines (2)
- virtuelle Maschinen (2)
- visualization (2)
- Abhängigkeiten (1)
- Algorithmen (1)
- Anfragesprache (1)
- Architektur (1)
- Aspect-oriented Programming (1)
- Beschränkungen und Abhängigkeiten (1)
- Blockheizkraftwerke (1)
- CSCW (1)
- CoExist (1)
- Constraints (1)
- Context-oriented Programming (1)
- Context-oriented programming (1)
- ContextJS (1)
- Datenbank (1)
- Distributed debugging (1)
- Dynamic Type System (1)
- Dynamic adaptation (1)
- Dynamic analysis (1)
- Dynamische Typ Systeme (1)
- Effizienz (1)
- Energiesparen (1)
- Experimentation (1)
- FRP (1)
- Forschungskolleg (1)
- Functional Lenses (1)
- Geschäftsanwendungen (1)
- Hasso Plattner Institute (1)
- Hasso-Plattner-Institut (1)
- Hauptspeicherdatenbank (1)
- JCop (1)
- JIT compilers (1)
- Java (1)
- Klausurtagung (1)
- Languages (1)
- Live-Programmierung (1)
- Measurement (1)
- Mehrfamilienhäuser (1)
- Mobile Application Development (1)
- Morphic (1)
- Muster (1)
- Musterabgleich (1)
- Nebenläufigkeit (1)
- Newspeak (1)
- Object Constraint Programming (1)
- Object Versioning (1)
- Object-Oriented Programming (1)
- Objekt-Constraint Programmierung (1)
- Objekt-Orientiertes Programmieren (1)
- Objekt-orientiertes Programmieren mit Constraints (1)
- Open implementations (1)
- Optimierungen (1)
- Pattern Matching (1)
- Patterns (1)
- Performance (1)
- Ph.D. Retreat (1)
- Prognosen (1)
- Programmierkonzepte (1)
- Programming Environments (1)
- Programming Languages (1)
- Python (1)
- Racket (1)
- Record and refinement (1)
- Record and replay (1)
- Research School (1)
- Sammlungsdatentypen (1)
- Scope (1)
- Service-oriented Systems Engineering (1)
- Skript-Entwicklungsumgebungen (1)
- Smalltalk (1)
- Softwarearchitektur (1)
- Softwareproduktlinien (1)
- Softwaretests (1)
- Spaltenlayout (1)
- Speicheroptimierungen (1)
- Sprachspezifikation (1)
- Squeak (1)
- Synchronisation (1)
- Transaktionen (1)
- Travis CI (1)
- Unveränderlichkeit (1)
- Virtual machines (1)
- Virtuelle Maschinen (1)
- Web applications (1)
- Web browsers (1)
- Werkzeuge (1)
- Zugriffskontrolle (1)
- access control (1)
- algorithms (1)
- architecture (1)
- architecture recovery (1)
- ausführbare Semantiken (1)
- cogeneration units (1)
- collection types (1)
- comprehension (1)
- continuous integration (1)
- continuous testing (1)
- contracts (1)
- dependencies (1)
- design (1)
- direct manipulation (1)
- direkte Manipulation (1)
- dynamic typing (1)
- dynamic programming languages (1)
- dynamische Programmiersprachen (1)
- dynamische Sprachen (1)
- efficiency (1)
- energy savings (1)
- executable semantics (1)
- exploratory programming (1)
- forecasts (1)
- functional languages (1)
- functional lenses (1)
- functional programming (1)
- funktionale Programmierung (1)
- immutable values (1)
- kontinuierliche Integration (1)
- kontinuierliches Testen (1)
- language specification (1)
- languages (1)
- live programming (1)
- lively kernel (1)
- mehrdimensionale Belangtrennung (1)
- memory optimization (1)
- modularity (1)
- morphic (1)
- multi-dimensional separation of concerns (1)
- multi-family residential buildings (1)
- object-constraint programming (1)
- optimizations (1)
- periodic tasks (1)
- periodische Aufgaben (1)
- program (1)
- reactive (1)
- reaktive Programmierung (1)
- remodularization (1)
- runtime adaptations (1)
- scripting environments (1)
- separation of concerns (1)
- software architecture (1)
- software engineering (1)
- software product lines (1)
- software tests (1)
- synchronization (1)
- tools (1)
- traceability (1)
- tracing (1)
- use-cases (1)
Institute
- Hasso-Plattner-Institut für Digital Engineering gGmbH (24) (remove)
First-class concepts
(2022)
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.
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.
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.
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.
Transmorphic
(2016)
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.
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.
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.
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.
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.
ecoControl
(2015)
Eine dezentrale Energieversorgung ist ein erster Schritt in Richtung Energiewende. Dabei werden auch in Mehrfamilienhäusern vermehrt verschiedene Strom- und Wärmeerzeuger eingesetzt.
Besonders in Deutschland kommen in diesem Zusammenhang Blockheizkraftwerke immer häufiger zum Einsatz, weil sie Gas sehr effizient in Strom und Wärme umwandeln können. Außerdem ermöglichen sie, im Zusammenspiel mit anderen Energiesystemen wie beispielsweise Photovoltaik-Anlagen, eine kontinuierliche und dezentrale Energieversorgung.
Bei dem Betrieb von unterschiedlichen Energiesystemen ist es wünschenswert, dass die Systeme aufeinander abgestimmt arbeiten. Allerdings ist es bisher schwierig, heterogene Energiesysteme effizient miteinander zu betreiben. Dadurch bleiben Einsparungspotentiale ungenutzt.
Eine zentrale Steuerung kann deshalb die Effizienz des Gesamtsystems verbessern.
Mit ecoControl stellen wir einen erweiterbaren Prototypen vor, der die Kooperation von Energiesystemen optimiert und Umweltfaktoren miteinbezieht.
Dazu stellt die Software eine einheitliche Bedienungsoberfläche zur Konfiguration aller Systeme zur Verfügung. Außerdem bietet sie die Möglichkeit, Optimierungsalgorithmen mit Hilfe einer Programmierschnittstelle zu entwickeln, zu testen und auszuführen.
Innerhalb solcher Algorithmen können von ecoControl bereitgestellte Vorhersagen genutzt werden. Diese Vorhersagen basieren auf dem individuellen Verhalten von jedem Energiesystem, Wettervorhersagen und auf Prognosen des Energieverbrauchs. Mithilfe einer Simulation können Techniker unterschiedliche Konfigurationen und Optimierungen sofort ausprobieren, ohne diese über einen langen Zeitraum an realen Geräten testen zu müssen.
ecoControl hilft darüber hinaus auch Hausverwaltungen und Vermietern bei der Verwaltung und Analyse der Energiekosten.
Wir haben anhand von Fallbeispielen gezeigt, dass Optimierungsalgorithmen, welche die Nutzung von Wärmespeichern verbessern, die Effizienz des Gesamtsystems erheblich verbessern können.
Schließlich kommen wir zu dem Schluss, dass ecoControl in einem nächsten Schritt unter echten Bedingungen getestet werden muss, sobald eine geeignete Hardwarekomponente verfügbar ist. Über diese Schnittstelle werden die Messwerte an ecoControl gesendet und Steuersignale an die Geräte weitergeleitet.