The Design and Evaluation of an Application Programming Interface for Programming Social Robots

Abstract

Despite there being much work bringing the vision of socially interactive robots to life, it is still a challenge to program them. There are two key reasons for this. First, many robot programming tools express primitives for programming social-interaction at low abstraction levels. Second, the usability of methods used to combine primitives, regardless of their abstraction levels, into social-interactions are not well understood. To address these problems, this thesis presents the iterative design and evaluation of application programming interfaces (APIs) for programming socially interactive robots. An iterative design-based research method was used throughout this thesis. During each research iteration, an API was designed with user-centred design principles to address particular aspects of the social robot programming research problem. Each API was then evaluated with a user study and the data analysed with the Cognitive Dimensions of Notations. The first API iteration began exploring what abstraction level is appropriate for programming social robot applications, through an evaluation of an API with high-level, domain-specific primitives. The results of the evaluation showed that the chosen abstraction level had positive effects on usability, however, a stakeholder interview suggested that finer control of social-interaction was needed. This evaluation also explored how primitives, regardless of their abstraction level, should be orchestrated to create higher level social-interaction. This was done by evaluating an imperative finite state machine API for authoring robot dialogue; the results showed that they have poor usability when used in this context. This is important because imperative finite state machines are a common means of orchestrating robot behaviour in the robotics community. The second API iteration further refined what abstraction level is appropriate for programming social robot applications. Based on the results of a stakeholder interview of the previous API, its primitives were refactored into a slightly lower abstraction level, providing finer control of social-interaction. A user evaluation demonstrated the benefits of the refactoring which retained the key advantages from the previous API and also the trade-offs inherent in having a higher abstraction level. The positive effects include hiding of lower level implementation details, primitives having a close mapping to the socialinteraction domain and a structure that enables programmers to use their domain knowledge to understand the API. The main trade-off occurs when implementation details are hidden, this can make progressive evaluation difficult because programmers are suddenly exposed to lower level implementation details when debugging errors. Parallel to the iterative API design, I derived an expanded implementation independent taxonomy of the primitives required for programming robot social-interaction. The taxonomy defines robot actions, perceptions and the objects with which a social robot interacts. This is important for stakeholders who help create socially interactive robots. The last stage of the research was the design and implementation of an extensible, vendor agnostic architecture to support the API. The architecture enables API users to define new entities (objects, people and robots) and create relationships between them. It also enables the API to interface with multiple social robot platforms through its vendor agnostic action and perception interfaces. In summary, this thesis makes five main contributions. First, the implementation of an API with high-level, domain-specific primitives for programming socially interactive robots. Second, an in depth understanding of what abstraction level is appropriate for programming social robot applications and the effects that different abstraction levels have on the APIs usability. Third, an exploration of how primitives should be orchestrated into higher level social-interaction, in particular, the effects that imperative finite state machines have on usability when used to author robot dialogue. Fourth, a taxonomy of primitives that are set at an appropriate abstraction level for programming robot socialinteraction. Fifth, the design and implementation of an extensible, vendor agnostic architecture to support social robot programming APIs with primitives at an appropriate abstraction level.