Strokes are a leading cause of disability, with many survivors experiencing significant mobility impairments. While robot-assisted rehabilitation offers a promising solution, its adoption seems challenged by high upfront costs, low flexibility and complex configuration workflows. To address these challenges, this study conducts an interaction analysis to identify key requirements for empowering therapists to self-configure and adapt a flexible, cost-effective robot during gait rehabilitation tasks. Our analysis is based on 20 training sequences from a 60-hour video dataset collected across three experimental setups, involving young adults with motor impairments training with the assistance of the robot. Drawing methods from Ethnomethodology and Conversation Analysis (EMCA), we examined the sequential organization of actions between technology, therapist and participant, identifying three main stages: setup, training, and completion. During setup, coordinated actions prepare the participant and the robot for the main training task; during training, participant and robot engage in movement while the therapist iterates adjustments; and in completion, coordinated actions prepare the participant for transitioning back to their conventional support system. Our analysis highlights some requirements and strategies for developing End-User Development (EUD) environments for robot-assisted physiotherapy, emphasizing user-driven workflows, multimodal transitions between robot’s assistance modes, and real-time robotic feedback that maintains coherence with therapists’ practices. • Robot-assisted physical training follows a structured sequence with 3 main phases. • The gaze, speech, and touch of the therapists indicate transitions between phases. • Robot control modes adapt across phases to support evolving therapeutic goals. • Software engagement varies with each phase of therapy and the patient’s condition. • Therapists can adjust assistance settings before, during, and after active therapy.

Programming robots presents significant challenges, including high costs, extensive time commitments and steep learning curves, particularly for individuals lacking technical background in engineering. These barriers have been partially mitigated by the emergence of end-user development methodologies. Yet existing approaches often fall short in equipping users with the necessary software engineering competencies to develop comprehensive robot behaviors or to effectively maintain and re-purpose their creations. In this paper, we introduce a novel end-user development approach designed to empower physical therapists to independently specify robot-assisted physical training exercises, eliminating the need for robotics experts' intervention. Our approach is based on a set of design goals obtained through a participatory design study with experts in the field. It utilizes a textual domain-specific language (DSL) that enables users to define expected robot behaviors through Behaviour-Driven Development (BDD) scenarios. This paper discusses key themes, design objectives, and the evolution of requirements that emerged from an evaluative workshop.

This paper introduces an approach for translating Behaviour-Driven Development (BDD) scenarios written under a domain-specific language (DSL) into Timed Automata (TA) to al-low for formal verification of real-time systems. A set of mapping rules is presented to facilitate the translation. We demonstrate the feasibility of our approach through an illustrative example of a vending machine that operates under a particular set of time constraints. Our proof-of-concept indicates that this approach is an important step towards ensuring compatibility between high-level software specifications (BDD scenarios) and formal models (TA models). We also discuss the current limitations of such work along with recommendations on how these might be addressed.

Programming robots has long been an expensive and time-consuming task with a high barrier to entry for non-experts. The emergence of end-user development approaches for robotics has allowed to lower this barrier. Existing approaches, however, still lack proper software engineering techniques to allow the programming of fully functional robot behaviours and facilitate further maintenance and reuse of the programs developed by end users. In this work, we introduce a low-code approach for allowing physical trainers to program robot-assisted physical training activities without the assistance of a robotics engineer. The approach relies on a textual domain-specific language (DSL) to allow end users to specify the expected robot behaviour through Behaviour-Driven Development (BDD) scenarios.

This paper introduces a high-level domain-specific language (DSL) and its rich editing environment to allow the specification of consistent and testable Behaviour-Driven Development (BDD) scenarios as user requirements at different levels of abstraction. We preliminary evaluated our approach by looking at its potential to support the writing of BDD scenarios in five open-source projects on GitHub. Results have shown the language was able to fully support, with minor adaptations, the specification of consistent user requirements, allowing also a complete mapping between domain and interactive behaviours through BDD scenarios.

Behaviour-Driven Development (BDD) stories have gained considerable attention in recent years as an effective way to specify and test user requirements in agile software development projects. External testing frameworks also allow developers to automate the execution of BDD stories and check whether a fully functional software system behaves as expected. However, other software artifacts may quite often lose synchronization with the stories, and many inconsistencies can arise with respect to requirements representation. This paper reports on preliminary empirical findings regarding the performance of two existing approaches in the literature intended to support consistency assurance between BDD stories and software artifacts. The first approach involves the parsing of BDD stories in order to identify conceptual elements to automatically generate consistent class diagrams, while the second approach seeks to identify interaction elements to automatically assess the consistency of task models and GUI prototypes. We report on the precision of these approaches when applied to a study with BDD stories previously written by Product Owners (POs). Based on the results, we also identify a set of challenges and opportunities for BDD stories in the consistency assurance of such artifacts.

Evaluating and ensuring the consistency between user requirements and modeling artifacts is a long-time issue for model-based software design. Conflicts in requirements specifications can lead to many design errors and have a decisive impact on the quality of systems under development. This article presents an approach based on Behavior-Driven Development (BDD) to provide automated assessment for task models, which are intended to model the flow of user and system tasks in an interactive system. The approach has been evaluated by exploiting user requirements described by a group of experts in the domain of business trips. Such requirements gave rise to a set of BDD stories that have been used to automatically assess scenarios extracted from task models that were reengineered from an existing web system for booking business trips. The results have shown our approach, by performing a static analysis of the source files, was able to identify different types of inconsistencies between the user requirements and the set of task models analyzed.

This paper presents a scenario-based approach to specify requirements and tests by extending Behavior-Driven Development (BDD) with the aim of ensuring the consistency between user requirements and user interface design artifacts.The approach has been evaluated by exploiting user requirements specified by a group of potential Product Owners (POs) for a web system to book business trips.Such requirements gave rise to a set of User Stories that have been refined and used to automatically check the consistency of task models, user interface (UI) prototypes, and final UIs of the system.The results have shown our approach was able to identify different types of inconsistencies in the set of analyzed artifacts and consistently keep the semantic traces between them.

In a user-centered development process, artifacts are aimed to evolve in iterative cycles until they meet users' requirements and then become the final product. Every cycle gives the opportunity to revise the design and to introduce new requirements which might affect the specification of artifacts that have been set in former development phases. Testing the consistency of multiple artifacts used to develop interactive systems every time that a new requirement is introduced it is a cumbersome and time consuming activity, especially if it should be done manually. For that we propose an approach based on Behavior-Driven Development (BDD) to support the automated assessment of artifacts along the development process of interactive systems. In order to prevent that test should be written to every type of artifact, we investigate the use of ontologies for specifying the test once and then run it in all artifacts sharing the ontological concepts.