PAINT '24: Proceedings of the 3rd ACM SIGPLAN International Workshop on Programming Abstractions and Interactive Notations, Tools, and Environments

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.

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.

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.

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.