[Paper Review] Towards Live Programming in ROS with PhaROS and LRP

Pablo Estefó, Miguel Campusano+4 more|arXiv (Cornell University)|Dec 15, 2014

Robotics and Automated Systems2 references3 citations

TL;DR

This paper proposes a live programming approach for ROS robots using the LRP language and PhaROS, enabling real-time code changes, dynamic node management, and runtime parameter and connection updates. The solution fulfills four key live programming requirements in ROS, demonstrating immediate behavioral feedback during robot development through iterative code tuning in a Pharo-based environment.

ABSTRACT

In traditional robot behavior programming, the edit-compile-simulate-deploy-run cycle creates a large mental disconnect between program creation and eventual robot behavior. This significantly slows down behavior development because there is no immediate mental connection between the program and the resulting behavior. With live programming the development cycle is made extremely tight, realizing such an immediate connection. In our work on programming of ROS robots in a more dynamic fashion through PhaROS, we have experimented with the use of the Live Robot Programming language. This has given rise to a number of requirements for such live programming of robots. In this text we introduce these requirements and illustrate them using an example robot behavior.

Motivation & Objective

• To address the cognitive disconnect in traditional ROS development caused by the static edit-compile-simulate-deploy-run cycle.
• To enable immediate feedback between code edits and robot behavior through live programming in ROS.
• To identify and fulfill core requirements for live programming in ROS, including runtime node control and dynamic configuration.
• To evaluate the feasibility and effectiveness of integrating live programming via LRP and PhaROS in a real robot application.
• To demonstrate that live programming in ROS improves development efficiency and reduces mental overhead in robot behavior development.

Proposed method

• Leveraged PhaROS, a ROS client for the Pharo dynamic language, to represent ROS nodes as first-class objects with runtime lifecycle control.
• Integrated the Live Robot Programming (LRP) domain-specific language, which uses nested state machines and supports live code updates.
• Used Pharo’s dynamic environment to enable hot code swapping, allowing code changes without stopping execution.
• Implemented runtime parameter modification via accessible node fields, enabling dynamic configuration during execution.
• Enabled dynamic topic subscription and publishing by creating ROS connections at runtime, allowing runtime reconfiguration of node connections.
• Utilized the RobulabBridge API to abstract robot-specific hardware interactions, simplifying LRP code development.

Experimental results

Research questions

• RQ1 How can live programming be effectively integrated into the ROS ecosystem, which traditionally enforces static configurations?
• RQ2 What core requirements must be met to support live programming of robot behaviors in ROS?
• RQ3 To what extent can runtime node management, parameter updates, code swapping, and connection changes be achieved in ROS using a dynamic language environment?
• RQ4 How does the combination of LRP and PhaROS improve the development workflow for robot behaviors compared to traditional ROS development?
• RQ5 Can real-time behavioral feedback be achieved during robot programming through live code integration in ROS?

Key findings

• The proposed LRP+PhaROS solution successfully fulfills all four key requirements for live programming in ROS: dynamic node start/stop, runtime parameter changes, hot code swapping, and dynamic connection updates.
• PhaROS nodes can be restarted multiple times, reconnecting to topics and resuming communication automatically, satisfying Requirement 1.
• Node parameters in PhaROS are accessible as fields, enabling runtime modification via Smalltalk code or command-line arguments, fulfilling Requirement 2.
• The robot’s obstacle avoidance behavior was iteratively refined in real time by modifying code while the system was running, demonstrating effective hot code swapping (Requirement 3).
• Topic subscriptions and publications were dynamically managed at runtime, allowing changes to node connections without restarting the application, satisfying Requirement 4.
• The integration of LRP with PhaROS enabled a seamless, interactive development experience with immediate behavioral feedback, significantly reducing the cognitive gap between code and execution.