Refine
Year of publication
Document Type
- Monograph/Edited Volume (27)
- Article (18)
- Report (1)
Is part of the Bibliography
- yes (46)
Keywords
- 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)
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.
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.
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.
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.
Die Komplexität heutiger Geschäftsabläufe und die Menge der zu verwaltenden Daten stellen hohe Anforderungen an die Entwicklung und Wartung von Geschäftsanwendungen. Ihr Umfang entsteht unter anderem aus der Vielzahl von Modellentitäten und zugehörigen Nutzeroberflächen zur Bearbeitung und Analyse der Daten. Dieser Bericht präsentiert neuartige Konzepte und deren Umsetzung zur Vereinfachung der Entwicklung solcher umfangreichen Geschäftsanwendungen. Erstens: Wir schlagen vor, die Datenbank und die Laufzeitumgebung einer dynamischen objektorientierten Programmiersprache zu vereinen. Hierzu organisieren wir die Speicherstruktur von Objekten auf die Weise einer spaltenorientierten Hauptspeicherdatenbank und integrieren darauf aufbauend Transaktionen sowie eine deklarative Anfragesprache nahtlos in dieselbe Laufzeitumgebung. Somit können transaktionale und analytische Anfragen in derselben objektorientierten Hochsprache implementiert werden, und dennoch nah an den Daten ausgeführt werden. Zweitens: Wir beschreiben Programmiersprachkonstrukte, welche es erlauben, Nutzeroberflächen sowie Nutzerinteraktionen generisch und unabhängig von konkreten Modellentitäten zu beschreiben. Um diese abstrakte Beschreibung nutzen zu können, reichert man die Domänenmodelle um vormals implizite Informationen an. Neue Modelle müssen nur um einige Informationen erweitert werden um bereits vorhandene Nutzeroberflächen und -interaktionen auch für sie verwenden zu können. Anpassungen, die nur für ein Modell gelten sollen, können unabhängig vom Standardverhalten, inkrementell, definiert werden. Drittens: Wir ermöglichen mit einem weiteren Programmiersprachkonstrukt die zusammenhängende Beschreibung von Abläufen der Anwendung, wie z.B. Bestellprozesse. Unser Programmierkonzept kapselt Nutzerinteraktionen in synchrone Funktionsaufrufe und macht somit Prozesse als zusammenhängende Folge von Berechnungen und Interaktionen darstellbar. Viertens: Wir demonstrieren ein Konzept, wie Endnutzer komplexe analytische Anfragen intuitiver formulieren können. Es basiert auf der Idee, dass Endnutzer Anfragen als Konfiguration eines Diagramms sehen. Entsprechend beschreibt ein Nutzer eine Anfrage, indem er beschreibt, was sein Diagramm darstellen soll. Nach diesem Konzept beschriebene Diagramme enthalten ausreichend Informationen, um daraus eine Anfrage generieren zu können. Hinsichtlich der Ausführungsdauer sind die generierten Anfragen äquivalent zu Anfragen, die mit konventionellen Anfragesprachen formuliert sind. Das Anfragemodell setzen wir in einem Prototypen um, der auf den zuvor eingeführten Konzepten aufsetzt.