PAINT '24: "Block-Based Platform for Defining ..."
Block-Based Platform for Defining Adaptation Rules for Automotive Systems
Luigi Altamirano, Mauricio Verano Merino, and Ion Barosan
(TU Eindhoven, Netherlands; Vrije Universiteit Amsterdam, Netherlands)
Adaptive human-machine interfaces (HMIs) enhance driver safety and comfort by tailoring information presentation. While existing research identifies key adaptation parameters, their practical application remains challenging due to the complexity of rule-based decision making and the limitations of current authoring tools. To address these issues, this paper introduces AHSL, a domain-specific language for efficiently specifying message adaptation logic. By unifying established adaptation parameters within a hierarchical structure, AHSL simplifies rule creation and improves readability. Usability testing demonstrates AHSL's effectiveness in supporting intuitive and efficient decision logic development.
Article Search
PAINT '24: "Block-Based Platform for Defining ..."
Block-Based Platform for Defining Adaptation Rules for Automotive Systems
Luigi Altamirano, Mauricio Verano Merino, and Ion Barosan
(TU Eindhoven, Netherlands; Vrije Universiteit Amsterdam, Netherlands)
Adaptive human-machine interfaces (HMIs) enhance driver safety and comfort by tailoring information presentation. While existing research identifies key adaptation parameters, their practical application remains challenging due to the complexity of rule-based decision making and the limitations of current authoring tools. To address these issues, this paper introduces AHSL, a domain-specific language for efficiently specifying message adaptation logic. By unifying established adaptation parameters within a hierarchical structure, AHSL simplifies rule creation and improves readability. Usability testing demonstrates AHSL's effectiveness in supporting intuitive and efficient decision logic development.
Article Search
PAINT '24: "Supporting Construction of ..."
Supporting Construction of Domain-Specific Representations in Textual Source Code
Tom Beckmann, Jan Reppien, Jens Lincke, and Robert Hirschfeld
(Hasso Plattner Institute, Germany; University of Potsdam, Germany)
Domain-specific replacements (DSR) allow programmers to view code in a manner better suited to the domain they are working in. Creating such DSRs, however, is not trivial as it requires knowledge of programming language internals to detect relevant patterns in the source code. In this paper, we propose a workflow that facilitates the matching of syntax tree structures and creation of DSRs without requiring expertise in programming language internals. In our workflow, authors express the patterns they want using syntax familiar to them when possible and receive immediate feedback and means for simple discovery for the other cases. We demonstrate the feasibility of our workflow through a prototypical implementation and evaluate it through three case studies. Through this workflow, we aim to further support authors in creating views on source code that support their work better than text.
Article Search
PAINT '24: "Bridging Incremental Programming ..."
Bridging Incremental Programming and Complex Software Development Environments
Max Boksem and L. Thomas van Binsbergen
(University of Amsterdam, Netherlands)
In modern software development, programmers typically choose between two main types of coding environments: Incremental Programming Environments (IPEs), such as the Read-Eval-Print-Loop (REPL) interpreter IPython and the Jupyter Computational Notebook, and Integrated (text-based) Development Environments (IDEs), such as Visual Studio Code. IPEs excel in providing immediate feedback for iterative development, testing, and debugging, making them ideal for fields like data science and AI. However, their typically linear and isolated interface struggles with managing the complexity of larger software projects. Conversely, traditional IDEs support extensive project management and debugging tools suited for complex applications but lack the interactive and incremental nature of IPEs. This paper reports on an ongoing investigation and design of a hybrid environment that combines benefits of IPEs and IDEs and the programming styles they naturally support. Central to our design is a graph structure representing code fragments as nodes and code structure as edges. By considering various types of nodes and relationships (e.g. for representing class membership, execution order, documentation, and dependencies) we can facilitate aspects of both incremental programming (in IPEs) and complexity management (in IDEs). We demonstrate our approach with a prototype, called Incremental Graph Code (IGC), by presenting its architecture and a showcase. We demonstrate IGC's functionality and discuss its potential advantages over existing environments. Key features include advanced code visualization, modular and incremental development, and complexity management. IGC aims to provide a unified, extensible, and flexible development environment that bridges the gap between different styles of programming.
Article Search
PAINT '24: "Supporting Construction of ..."
Supporting Construction of Domain-Specific Representations in Textual Source Code
Tom Beckmann, Jan Reppien, Jens Lincke, and Robert Hirschfeld
(Hasso Plattner Institute, Germany; University of Potsdam, Germany)
Domain-specific replacements (DSR) allow programmers to view code in a manner better suited to the domain they are working in. Creating such DSRs, however, is not trivial as it requires knowledge of programming language internals to detect relevant patterns in the source code. In this paper, we propose a workflow that facilitates the matching of syntax tree structures and creation of DSRs without requiring expertise in programming language internals. In our workflow, authors express the patterns they want using syntax familiar to them when possible and receive immediate feedback and means for simple discovery for the other cases. We demonstrate the feasibility of our workflow through a prototypical implementation and evaluate it through three case studies. Through this workflow, we aim to further support authors in creating views on source code that support their work better than text.
Article Search
PAINT '24: "Advanced Game Engine Wizardry ..."
Advanced Game Engine Wizardry for Visual Programming Environments
Elisabeth Kletsko and Riemer van Rozen
(University of Amsterdam, Netherlands; CWI, Netherlands)
Visual programming environments empower end-users with interactive input and feedback mechanisms that support live and exploratory programming. For creating these environments, language engineers require enabling technology. Language workbenches and meta-programming languages support rapid construction of interpreter back-ends. Game engines are specifically created for rich interactive user experiences and have the potential to augment this technology even further with maintainable front-ends. However, these technologies presently live in separate technological spaces. We aim to automate the creation of visual programming environments by integrating the two. We propose Raven, a meta-framework for rapidly prototyping visual editors that exposes key 2D features of Godot in a programmable user interface. Using Raven's declarative notation, language engineers can concisely express the structure and styling of tree-based editors. We demonstrate our approach by: 1) integrating Raven into the Rascal language workbench; and 2) creating two editors for the live state machine language.
Article Search
PAINT '24: "Supporting Construction of ..."
Supporting Construction of Domain-Specific Representations in Textual Source Code
Tom Beckmann, Jan Reppien, Jens Lincke, and Robert Hirschfeld
(Hasso Plattner Institute, Germany; University of Potsdam, Germany)
Domain-specific replacements (DSR) allow programmers to view code in a manner better suited to the domain they are working in. Creating such DSRs, however, is not trivial as it requires knowledge of programming language internals to detect relevant patterns in the source code. In this paper, we propose a workflow that facilitates the matching of syntax tree structures and creation of DSRs without requiring expertise in programming language internals. In our workflow, authors express the patterns they want using syntax familiar to them when possible and receive immediate feedback and means for simple discovery for the other cases. We demonstrate the feasibility of our workflow through a prototypical implementation and evaluate it through three case studies. Through this workflow, we aim to further support authors in creating views on source code that support their work better than text.
Article Search
PAINT '24: "Supporting Construction of ..."
Supporting Construction of Domain-Specific Representations in Textual Source Code
Tom Beckmann, Jan Reppien, Jens Lincke, and Robert Hirschfeld
(Hasso Plattner Institute, Germany; University of Potsdam, Germany)
Domain-specific replacements (DSR) allow programmers to view code in a manner better suited to the domain they are working in. Creating such DSRs, however, is not trivial as it requires knowledge of programming language internals to detect relevant patterns in the source code. In this paper, we propose a workflow that facilitates the matching of syntax tree structures and creation of DSRs without requiring expertise in programming language internals. In our workflow, authors express the patterns they want using syntax familiar to them when possible and receive immediate feedback and means for simple discovery for the other cases. We demonstrate the feasibility of our workflow through a prototypical implementation and evaluate it through three case studies. Through this workflow, we aim to further support authors in creating views on source code that support their work better than text.
Article Search
PAINT '24: "Bridging Incremental Programming ..."
Bridging Incremental Programming and Complex Software Development Environments
Max Boksem and L. Thomas van Binsbergen
(University of Amsterdam, Netherlands)
In modern software development, programmers typically choose between two main types of coding environments: Incremental Programming Environments (IPEs), such as the Read-Eval-Print-Loop (REPL) interpreter IPython and the Jupyter Computational Notebook, and Integrated (text-based) Development Environments (IDEs), such as Visual Studio Code. IPEs excel in providing immediate feedback for iterative development, testing, and debugging, making them ideal for fields like data science and AI. However, their typically linear and isolated interface struggles with managing the complexity of larger software projects. Conversely, traditional IDEs support extensive project management and debugging tools suited for complex applications but lack the interactive and incremental nature of IPEs. This paper reports on an ongoing investigation and design of a hybrid environment that combines benefits of IPEs and IDEs and the programming styles they naturally support. Central to our design is a graph structure representing code fragments as nodes and code structure as edges. By considering various types of nodes and relationships (e.g. for representing class membership, execution order, documentation, and dependencies) we can facilitate aspects of both incremental programming (in IPEs) and complexity management (in IDEs). We demonstrate our approach with a prototype, called Incremental Graph Code (IGC), by presenting its architecture and a showcase. We demonstrate IGC's functionality and discuss its potential advantages over existing environments. Key features include advanced code visualization, modular and incremental development, and complexity management. IGC aims to provide a unified, extensible, and flexible development environment that bridges the gap between different styles of programming.
Article Search
PAINT '24: "Advanced Game Engine Wizardry ..."
Advanced Game Engine Wizardry for Visual Programming Environments
Elisabeth Kletsko and Riemer van Rozen
(University of Amsterdam, Netherlands; CWI, Netherlands)
Visual programming environments empower end-users with interactive input and feedback mechanisms that support live and exploratory programming. For creating these environments, language engineers require enabling technology. Language workbenches and meta-programming languages support rapid construction of interpreter back-ends. Game engines are specifically created for rich interactive user experiences and have the potential to augment this technology even further with maintainable front-ends. However, these technologies presently live in separate technological spaces. We aim to automate the creation of visual programming environments by integrating the two. We propose Raven, a meta-framework for rapidly prototyping visual editors that exposes key 2D features of Godot in a programmable user interface. Using Raven's declarative notation, language engineers can concisely express the structure and styling of tree-based editors. We demonstrate our approach by: 1) integrating Raven into the Rascal language workbench; and 2) creating two editors for the live state machine language.
Article Search
PAINT '24: "Block-Based Platform for Defining ..."
Block-Based Platform for Defining Adaptation Rules for Automotive Systems
Luigi Altamirano, Mauricio Verano Merino, and Ion Barosan
(TU Eindhoven, Netherlands; Vrije Universiteit Amsterdam, Netherlands)
Adaptive human-machine interfaces (HMIs) enhance driver safety and comfort by tailoring information presentation. While existing research identifies key adaptation parameters, their practical application remains challenging due to the complexity of rule-based decision making and the limitations of current authoring tools. To address these issues, this paper introduces AHSL, a domain-specific language for efficiently specifying message adaptation logic. By unifying established adaptation parameters within a hierarchical structure, AHSL simplifies rule creation and improves readability. Usability testing demonstrates AHSL's effectiveness in supporting intuitive and efficient decision logic development.
Article Search