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)
Making the domain tangible
(2017)
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.
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.
Squimera
(2017)
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.
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.
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.
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.
SandBlocks
(2020)
Visuelle Programmiersprachen werden heutzutage zugunsten textueller Programmiersprachen nahezu nicht verwendet, obwohl visuelle Programmiersprachen einige Vorteile bieten. Diese reichen von der Vermeidung von Syntaxfehlern, über die Nutzung konkreter domänenspezifischer Notation bis hin zu besserer Lesbarkeit und Wartbarkeit des Programms. Trotzdem greifen professionelle Softwareentwickler nahezu ausschließlich auf textuelle Programmiersprachen zurück.
Damit Entwickler diese Vorteile visueller Programmiersprachen nutzen können, aber trotzdem nicht auf die ihnen bekannten textuellen Programmiersprachen verzichten müssen, gibt es die Idee, textuelle und visuelle Programmelemente gemeinsam in einer Programmiersprache nutzbar zu machen. Damit ist dem Entwickler überlassen wann und wie er visuelle Elemente in seinem Programmcode verwendet.
Diese Arbeit stellt das SandBlocks-Framework vor, das diese gemeinsame Nutzung visueller und textueller Programmelemente ermöglicht. Neben einer Auswertung visueller Programmiersprachen, zeigt es die technische Integration visueller Programmelemente in das Squeak/Smalltalk-System auf, gibt Einblicke in die Umsetzung und Verwendung in Live-Programmiersystemen und diskutiert ihre Verwendung in unterschiedlichen Domänen.
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.
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.
Proceedings of the HPI Research School on Service-oriented Systems Engineering 2020 Fall Retreat
(2021)
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.