Filtern
Erscheinungsjahr
Dokumenttyp
- Monographie/Sammelband (27)
- Wissenschaftlicher Artikel (18)
- Bericht (1)
Gehört zur Bibliographie
- ja (46)
Schlagworte
- Lively Kernel (4)
- Smalltalk (4)
- Debugging (3)
- Squeak (3)
- Experimentation (2)
- Forschungskolleg (2)
- Hasso Plattner Institute (2)
- Hasso-Plattner-Institut (2)
- Java (2)
- JavaScript (2)
- Klausurtagung (2)
- Live-Programmierung (2)
- Prototyping (2)
- Python (2)
- Service-oriented Systems Engineering (2)
- Versionsverwaltung (2)
- Visualisierung (2)
- Werkzeuge (2)
- collection types (2)
- continuous integration (2)
- exploratory programming (2)
- kontinuierliche Integration (2)
- live programming (2)
- memory optimization (2)
- software engineering (2)
- tools (2)
- version control (2)
- virtual machines (2)
- virtuelle Maschinen (2)
- visualization (2)
- AI Lab (1)
- Abhängigkeiten (1)
- Abschlussbericht (1)
- Algorithmen (1)
- Analog-zu-Digital-Konvertierung (1)
- Anfragesprache (1)
- Architektur (1)
- Aspect-oriented Programming (1)
- Benutzerinteraktion (1)
- Beschränkungen und Abhängigkeiten (1)
- Blockheizkraftwerke (1)
- CSCW (1)
- CoExist (1)
- Constraints (1)
- Context-oriented Programming (1)
- Context-oriented programming (1)
- ContextErlang (1)
- ContextJS (1)
- Continuous Testing (1)
- Continuous Versioning (1)
- Custom Writable Class (1)
- DSA (1)
- Data structure optimization (1)
- Datenbank (1)
- Datensatz (1)
- Datenvisualisierung (1)
- Design (1)
- Distributed debugging (1)
- Domain Objects (1)
- Dynamic Type System (1)
- Dynamic adaptation (1)
- Dynamic analysis (1)
- Dynamische Typ Systeme (1)
- Effizienz (1)
- Energiesparen (1)
- Evolution (1)
- Explore-first Programming (1)
- Extensibility (1)
- FRP (1)
- Fault Localization (1)
- Field study (1)
- Functional Lenses (1)
- Geschäftsanwendungen (1)
- GitHub (1)
- Hauptspeicherdatenbank (1)
- Heuristiken (1)
- Human Factors (1)
- Häkeln (1)
- Identifiers (1)
- Implementation (1)
- Interpreter (1)
- JCop (1)
- JIT (1)
- JIT compilers (1)
- KI-Labor (1)
- Languages (1)
- Literature review (1)
- Liveness (1)
- Measurement (1)
- Mehrfamilienhäuser (1)
- Meta-tracing (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)
- Online survey (1)
- Open implementations (1)
- Optimierungen (1)
- Pattern Matching (1)
- Patterns (1)
- Performance (1)
- Ph.D. Retreat (1)
- Ph.D. retreat (1)
- Prognosen (1)
- Programmieren (1)
- Programmiererlebnis (1)
- Programmierkonzepte (1)
- Programming Environments (1)
- Programming Languages (1)
- REST (1)
- Racket (1)
- Record and refinement (1)
- Record and replay (1)
- Regressionstests (1)
- Research School (1)
- Ruby (1)
- Sammlungsdatentypen (1)
- Schriftartgestaltung (1)
- Schriftrendering (1)
- Scope (1)
- Scrollytelling (1)
- Serialisierung (1)
- Skript-Entwicklungsumgebungen (1)
- Softwarearchitektur (1)
- Softwareproduktlinien (1)
- Softwaretests (1)
- Source Code Readability (1)
- Spaltenlayout (1)
- Speicheroptimierungen (1)
- Sprachspezifikation (1)
- StackOverflow (1)
- Synchronisation (1)
- Testergebnisse (1)
- Testpriorisierungs (1)
- Transaktionen (1)
- Travis CI (1)
- Uniform Access Principle (1)
- Unveränderlichkeit (1)
- Value classes (1)
- Virtual machines (1)
- Virtuelle Maschinen (1)
- Visualisierungskonzept-Exploration (1)
- Web applications (1)
- Web browsers (1)
- Zugriffskontrolle (1)
- access control (1)
- active layers (1)
- algorithms (1)
- analog-to-digital conversion (1)
- architecture (1)
- architecture recovery (1)
- aspect-oriented programming (1)
- ausführbare Semantiken (1)
- benutzergenerierte Inhalte (1)
- cogeneration units (1)
- comprehension (1)
- computer-aided design (1)
- context groups (1)
- contextual-variability modeling (1)
- continuous testing (1)
- contracts (1)
- crochet (1)
- data set (1)
- data visualization (1)
- debugging (1)
- demografische Informationen (1)
- demographic information (1)
- dependencies (1)
- design (1)
- digital picture archive (1)
- digitales Bildarchiv (1)
- direct manipulation (1)
- direkte Manipulation (1)
- dynamic typing (1)
- dynamic AOP (1)
- dynamic programming languages (1)
- dynamic service adaptation (1)
- dynamic typing (1)
- dynamische Programmiersprachen (1)
- dynamische Sprachen (1)
- efficiency (1)
- energy savings (1)
- entity-component-system (1)
- executable semantics (1)
- exploratives Programmieren (1)
- final report (1)
- font engineering (1)
- font rendering (1)
- forecasts (1)
- functional languages (1)
- functional lenses (1)
- functional programming (1)
- funktionale Programmierung (1)
- group-based behavior adaptation (1)
- heuristics (1)
- immutable values (1)
- implied methods (1)
- integrated development environments (1)
- integrierte Entwicklungsumgebungen (1)
- interactive media (1)
- interaktive Medien (1)
- interpreters (1)
- intuitive Benutzeroberflächen (1)
- intuitive interfaces (1)
- kontinuierliches Testen (1)
- language specification (1)
- languages (1)
- left recursion (1)
- lively groups (1)
- lively kernel (1)
- liveness (1)
- mehrdimensionale Belangtrennung (1)
- mehrsprachige Ausführungsumgebungen (1)
- modularity (1)
- morphic (1)
- multi-dimensional separation of concerns (1)
- multi-family residential buildings (1)
- object-constraint programming (1)
- object-oriented languages (1)
- object-oriented programming (1)
- objektorientiertes Programmieren (1)
- optimizations (1)
- packrat parsing (1)
- parsing expression grammars (1)
- periodic tasks (1)
- periodische Aufgaben (1)
- polyglot execution environments (1)
- predicated generic functions (1)
- program (1)
- programming (1)
- programming experience (1)
- prototyping (1)
- reactive (1)
- reactive object queries (1)
- reaktive Programmierung (1)
- rechnerunterstütztes Konstruieren (1)
- regression testing (1)
- remodularization (1)
- research school (1)
- runtime adaptations (1)
- scripting environments (1)
- scrollytelling (1)
- separation of concerns (1)
- serialization (1)
- service-oriented systems engineering (1)
- small talk (1)
- smalltalk (1)
- software architecture (1)
- software development (1)
- software product lines (1)
- software tests (1)
- squeak (1)
- synchronization (1)
- test case prioritization (1)
- test results (1)
- traceability (1)
- tracing (1)
- use-cases (1)
- user interaction (1)
- user-generated content (1)
- visual language (1)
- visual languages (1)
- visualization concept exploration (1)
- visuelle Sprache (1)
- visuelle Sprachen (1)
- web-based development (1)
- web-based development environment (1)
- web-basierte Entwicklungsumgebung (1)
- webbasierte Entwicklung (1)
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.
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.
Dynamic service adaptation
(2006)
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.
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.
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.
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.
Bei der Erstellung von Visualisierungen gibt es im Wesentlichen zwei Ansätze. Zum einen können mit geringem Aufwand schnell Standarddiagramme erstellt werden. Zum anderen gibt es die Möglichkeit, individuelle und interaktive Visualisierungen zu programmieren. Dies ist jedoch mit einem deutlich höheren Aufwand verbunden.
Flower ermöglicht eine schnelle Erstellung individueller und interaktiver Visualisierungen, indem es den Entwicklungssprozess stark vereinfacht und die Nutzer bei den einzelnen Aktivitäten wie dem Import und der Aufbereitung von Daten, deren Abbildung auf visuelle Elemente sowie der Integration von Interaktivität direkt unterstützt.
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.
There are two common approaches to implement a virtual machine (VM) for a dynamic object-oriented language. On the one hand, it can be implemented in a C-like language for best performance and maximum control over the resulting executable. On the other hand, it can be implemented in a language such as Java that allows for higher-level abstractions. These abstractions, such as proper object-oriented modularization, automatic memory management, or interfaces, are missing in C-like languages but they can simplify the implementation of prevalent but complex concepts in VMs, such as garbage collectors (GCs) or just-in-time compilers (JITs). Yet, the implementation of a dynamic object-oriented language in Java eventually results in two VMs on top of each other (double stack), which impedes performance. For statically typed languages, the Maxine VM solves this problem; it is written in Java but can be executed without a Java virtual machine (JVM). However, it is currently not possible to execute dynamic object-oriented languages in Maxine. This work presents an approach to bringing object models and execution models of dynamic object-oriented languages to the Maxine VM and the application of this approach to Squeak/Smalltalk. The representation of objects in and the execution of dynamic object-oriented languages pose certain challenges to the Maxine VM that lacks certain variation points necessary to enable an effortless and straightforward implementation of dynamic object-oriented languages' execution models. The implementation of Squeak/Smalltalk in Maxine as a feasibility study is to unveil such missing variation points.
Language 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.