In this paper, we critically examine the current "humanoid hype" in robotics, questioning its alignment with responsible robotics principles. While technical challenges drive internal fascination, the pervasive public image of humanoids demands deeper HRI engagement. We explore how responsible robotics concepts, such as privacy, dignity, and trust, are uniquely challenged or overlooked in the pursuit of anthropomorphic robot forms. By dissecting this hype, and mapping the main findings of the recently-published Roadmap for Responsible Robotics to the humanoids field, we aim to move beyond technical form-factor obsessions to understand the true societal implications and identify potential blind spots for the HRI community.

The specification and validation of robotics applications require bridging the gap between formulating requirements and systematic testing. This often involves manual and error-prone tasks that become more complex as requirements, design, and implementation evolve. To address this challenge systematically, we propose extending behaviour-driven development (BDD) to define and verify acceptance criteria for robotic systems. In this context, we use domain-specific modelling and represent composable BDD models as knowledge graphs for robust querying and manipulation, facilitating the generation of executable testing models. A domain-specific language helps to efficiently specify robotic acceptance criteria. We explore the potential for automated generation and execution of acceptance tests through a software architecture that integrates a BDD framework, Isaac Sim, and model transformations, focusing on acceptance criteria for pick-and-place applications. We tested this architecture with an existing pick-and-place implementation and evaluated the execution results, which shows how this application behaves and fails differently when tested against variations of the agent and environment. This research advances the rigorous and automated evaluation of robotic systems, contributing to their reliability and trustworthiness.

An object handover between a robot and a human is a coordinated action which is prone to failure for reasons such as miscommunication, incorrect actions and unexpected object properties. Existing works on handover failure detection and prevention focus on preventing failures due to object slip or external disturbances. However, there is a lack of datasets and evaluation methods that consider unpreventable failures caused by the human participant. To address this deficit, we present the multimodal Handover Failure Detection dataset, which consists of failures induced by the human participant, such as ignoring the robot or not releasing the object. We also present two baseline methods for handover failure detection: (i) a video classification method using 3D CNNs and (ii) a temporal action segmentation approach which jointly classifies the human action, robot action and overall outcome of the action. The results show that video is an important modality, but using force-torque data and gripper position help improve failure detection and action segmentation accuracy.

Safety is paramount for robots used in environments they share with humans. In such scenarios, security is also growing in importance. However, conventional approaches to analysing safety requirements are aimed at identifying hazards only. Security-related aspects such as cyber threats, cyber attacks and vulnerabilities have hardly been integrated into analysis and design methods to date. The methods available so far for the joint analysis of safety and security are based on established methods of safety engineering, where the amount of information is very large and usually stored in text- and table-based documents. This makes it challenging for engineers to systematically assess and maintain safety and security information. Thus, adequate tool support for robot engineers is required to cope with the increased complexity and to manage the safety and security risks. In this paper, we demonstrate that robot's safety and security information can be expressed, stored, analysed and queried in a knowledge graph representation paving the way to automated analysis. More specifically, we apply an integrated, systems-oriented safety and security co-analysis approach, namely STPA-Safesec, to a robot performing disinfection tasks in domestic environments. By querying the resulting graph of safety and security artefacts, we automatically retrieve hazardous scenarios, identify gaps in the analysis and increase our understanding of the overall risks of the robot.

The Unified Robot Description Format (URDF) and, to a lesser extent, the COLLAborative Design Activity (COLLADA) format are two of the most popular domain-specific languages (DSLs) to represent kinematic chains in robotics with support in many tools including Gazebo, MoveIt!, KDL or IKFast. In this paper we analyse both DSLs with respect to their structure and semantics as seen by tools that produce or consume such representations. For the former, we notice a tight coupling of various unrelated domains like kinematics and dynamics with visualisation, control or even specific simulators. For the latter, a key insight is that both DSLs target human developers and leave important design decisions like the choice of joint attachment frames implicit or hidden in the documentation. The lessons learned from this analysis guide us to an improved interchange format by designing composable, loosely coupled models with complete metamodels that unambiguously define the model semantics. We substantiate our findings with concrete examples. Furthermore, we compose solver algorithms on top of the kinematic chain representation. As a consequence of the above analysis and decomposition we can systematically apply structure- and semantics-conserving model-to-code transformations to those algorithms.

Is mobile robot navigation a solved problem? We asked this question to 14 professional robot software engineers who work with navigation stacks of mobile, wheeled robots on a daily basis. They unanimously report that it remains challenging to ensure the performance of their mobile robots. We find that the method of choice to verify a robot's performance is to expose it to different environments under varying conditions. Unfortunately, these field tests are costly to set up and often too risky to execute. Therefore, robot software engineers want to replicate real-world environments in simulated sceneries (i) to test their navigation stack or parts of it prior to deployment; and (ii) to reproduce erroneous behaviour observed in the real world. Motivated by these insights, we have developed a domain-specific language and associated tooling which enables engineers (i) to specify sceneries of indoor environments; and (ii) to automatically generate variants thereof that resemble changes in the real world. We demonstrate how our approach enables the simulation-based replication of real-world environments and allows us to recreate erroneous robot behaviour as reported in the interviews. While performing simulation-based tests, we discovered an 8-year dormant bug in the ROS navigation stack.

Service robots are mobile autonomous robots, often operating in uncertain and difficult environments. While being increasingly popular, engineering service robots is challenging. Especially, evolving them from prototype to deployable product requires effective validation and verification, assuring the robot's correct and safe operation in the target environment. While testing is the most common validation and verification technique used in practice, surprisingly little is known about the actual testing practices and technologies used in the service robotics domain. We present an experience report on field testing of an industrial-strength service robot, as it transitions from lab experiments to an operational environment. We report challenges and solutions, and reflect on their effectiveness. Our long-term goal is to establish empirically-validated testing techniques for service robots. This experience report constitutes a necessary, but self-contained first step, exploring field testing practices in detail. Our data sources are detailed test artifacts and developer interviews. We model the field testing process and describe test-case design practices. We discuss experiences from performing these field tests over a 10-month test campaign.

Autonomous robots are already being used, for example, as tour guides, receptionists, or office-assistants. The proximity to humans and the possibility to physically interact with them highlights the importance of developing secure robot applications. It is crucial to consider security implications to be an important part of the robot application's development process. Adding security later in the application's life-cycle usually leads to high costs, or is not possible due to earlier design decisions. In this work, we present the Robot Application Security Process (RASP) as a lightweight process that enables the development of secure robot applications. Together with RASP we introduce the role of a Security Engineer (SecEng) as an important stakeholder in any robot application development process. RASP enables the SecEng to verify the completeness of his work and allows him to argue about the application's security with other stakeholders. Furthermore, we demonstrate how the RASP supports the SecEng and also other developers in their daily work.

Exploring of software architectures with software visualization in Augmented Reality (AR) is possible with different interaction methods, such gesture, gaze, and speech. For interaction with speech (i.e., natural language), we present an architecture and an implementation of conversational interfaces for the Microsoft HoloLens device. We aim to remedy some peculiarities of AR devices, but also enhancing the exploration task at hand. To implement the conversational interface different natural language processing (NLP) components such as natural language generation and intent recognition are typically required. Our proposed architecture integrates conversational components with the AR-based software visualization. We describe its implementation based on different user utterances, where the system provides information about the to-be-explored component-based software architecture in the form of adjusted visualizations and speech-based results. We apply out tool to explore OSGi-based software architectures.

Software systems and components are increasingly based on machine learning methods, such as Convolutional Neural Networks (CNNs). Thus, there is a growing need for common programmers and machine learning newcomers to understand the general functioning of these algorithms. However, as neural networks are complex in nature, novel presentation means are required to enable rapid access to the functionality. For that purpose, this paper examines how CNNs can be visualized in Virtual Reality. A first exploratory study has confirmed that our visualization approach is both intuitive to use and conductive to learning.

The successes of teleoperation scenarios for mobile robots depends on a stable and reliable communication link. The environment information collected by the robot - represented by 2D or 3D images - has to be provided with a high resolution and a low delay to ensure a fast and precise system response. But in most realistic applications, the communication parameters fluctuate strongly over time. It is necessary to monitor the communication link continuously to react in case of reduced bandwidth and increased delay. But which environment information and correspondingly which bandwidth is necessary to control a robot safely? Due to a missing reliable rule set we investigated this question for a UAV scenario based on two different environment representations (camera images, gridmaps). We designed a simulator based study and evaluated the capability of the participants to control a robot in case of delayed or coarsely rasterized information. Although our study involved only non-experts, we found some interesting first results. While the performance of our participants depends strongly on the delay, it is nearly independent on the image resolution, which suggests downsampling as a valid response for bandwidth decrease. We also found that participants generally struggle with using grid map for controlling the robot. However, this type of interfaces requires far less bandwidth than images. They also excel in situations with higher delays, which makes them the tool of choice when there are really bad channel conditions.

To perform a wide range of tasks service robots need to robustly extract knowledge about the world from the data perceived through the robot's sensors even in the presence of varying context-conditions. This makes the design and development of robot perception architectures a challenging exercise. In this paper we propose a robot perception architecture which enables to select and execute at runtime different perception graphs based on monitored context changes. To achieve this the architecture is structured as a feedback loop and contains a repository of different perception graph configurations suitable for various context conditions.

We present the design and development of a benchmarking testbed for the Factory of the Future. The testbed as a physical installation enables to study, compare and assess robotics scenarios involving the integration of mobile robots and manipulators with automation equipment, large-scale integration of service robots and industrial robots, cohabitation of robots and humans, and cooperation of multiple robots and/or humans. We also report on the lessons learned of using the testbed in recent robotic competitions.

In this paper we present our ongoing work on Robotics Run-time Adaptation (RRA). RRA is a model-driven approach that addresses robotics runtime adaptation by modeling and resolving run-time variability of robotic applications.

This paper presents a distributed world model that is able to adapt to changes in the Quality of Service (QoS) of the communication layer by online reconfiguration of perception algorithms. The approach consists of (a) a mechanism for storage, exchange and processing of world model data and (b) a feedback loop that incorporates reasoning techniques to adapt to QoS changes immediately. The latter introduces a Level of Detail (LoD) metric based on a spatial resolution in order to infer an upper bound for the amount of data that can be transmitted without violating an application specific transmission delay. Experiments have been performed with Octree-based subsampling techniques applied to data originating from a RGB-D camera using simulated and real-world data sets for timevarying bandwidth values as employed QoS measure.

Robotics applications are characterized by a huge amount of variability. Their design requires the developers to choose between several variants, which relate to both functionalities and hardware. Some of these choices can be taken at deployment-time, however others should be taken at run-time, when more information about the context is known. To make this possible, a software system needs to be able to reason about its current state and to adapt its architecture to provide the configuration that best suites the context. This paper presents a model-based approach for run-time adaptation of robotic systems. It defines a set of orthogonal models that represent the system architecture, its variability, and the state of the context. Additionally it introduces a set of algorithms that reason about the knowledge represented in our models to resolve the run-time variability and to adapt the system architecture. The paper discusses and evaluates the approach by means of two case studies.

Grasping objects and using them in a task-oriented manner is challenging for a robot. It requires an understanding of the object, the robot's capabilities, and the task to be executed. We argue that an explicit representation of these domains increases reusability and robustness of the resulting system. We present the declarative Grasp Domain Definition Language (GDDL) which enables the explicit grasp-planner-independent specification of grasping problems. The formal model underlying GDDL enables the definition of formal constraints that are validated during design time and run time. Our approach has been realized on two real robots.

Deploying a complex robot software architecture on real robot systems and getting it to run reliably is a challenging task. We argue that software deployment decisions should be separated as much as possible from the core development of software functionalities. This will make the developed software more independent of a particular hardware architecture (and thus more reusable) and allow it to be deployed more flexibly on a wider variety of robot platforms. This paper presents a domain-specific language (DSL) which supports this idea and demonstrates how the DSL is used in a model-driven engineering-based development process. A practical example of applying the DSL to the development of an application for the KUKA youBot platform is given.

Most of the recent robot software frameworks follow a component-oriented development approach. They allow developers to compose a distributed application from a set of interacting components. Though these frameworks provide rich functionality, often they fail to cope with non-functional aspects (e.g., network scalability, predictability of system behavior) involved in system design, especially in distributed settings. This research sets out to address aforementioned quality attributes by introducing a pragmatic model, Protocol Stack View (PSV), for the analysis of distributed robotic software. The model relies on the fact that a distributed software can be viewed in terms of three main elements: components, ports and connectors. It specifically focuses on structure and semantics of software connectors on the implementation level. To prove effectiveness and usefulness of PSV a set of experiments were conducted to analyze scalability and to determine the configurable elements that affect it. The experiments are based on the comparison of communication infrastructure provided by two existing software packages, namely ROS and ZeroMQ.