It's Alive! What a Live Object Environment Changes in Software Engineering Practice

2026-03-03

AI Summary

Traditional development tools struggle to provide direct interaction with runtime objects, limiting developers’ intuitive understanding of program state. This work explores novel development practices within the live object programming paradigm, leveraging the Pharo Smalltalk environment. It introduces several innovative mechanisms—including customizable inspector views, micro-commits, in-debugger coding, automatic rewriting of deprecated APIs at runtime, and object-centric breakpoints. By integrating dynamic object inspection, real-time debugging, incremental version control, and automated refactoring, the approach significantly enhances developers’ ability to observe and manipulate program state. This not only streamlines debugging and refactoring workflows but also offers a new paradigm for the design of modern integrated development environments.

Technology Category

• Reasoning under Uncertainty: Probabilistic Programming
• Natural Language Processing: Code Generation / Program Synthesis from Natural Language
• Knowledge Representation and Reasoning: Logic Programming

Application Category

• Systems and Infrastructure for Web, Mobile and WoT: Web performance, measurement, and characterization
• Graph Algorithms and Modeling for the Web: Efficient manipulation of static and dynamic Web-related graphs
• User Modeling, Personalization and Recommendation: On-Device user modeling, personalization, and recommendation

Abstract

Tools shape our mind. This is why it is important to have extensible and flexible tools for developers to adapt to their needs. Reasoning about programs in the abstract -- by imagining what objects should look like -- can make it harder to grasp the underlying model. In Smalltalk environments like Pharo, developers work closely with their objects, gaining immediate feedback -- not guessing how they will look like but directly interacting with them. This article presents some tools developers use in Pharo: Inspector custom views for defining specific views and navigation for objects, Microcommits for reverting changes without the need to commit and pull, Xtreme TDD that allows developers to code in the debugger, On the Fly Rewriting Deprecations that support API evolution through automated rewriting of deprecated calls, and Object-Centric Breakpoints -- when a problem cannot be efficiently solved with a dummy trace, developers can use break points that will only halt for a given instance. By showcasing these features that evolved alongside Smalltalk, we invite reflection on how other IDEs could rethink some of their features and improve developers' workflows.

Problem

• Live Object Environment
• Software Engineering Practice
• Developer Tools
• Object Interaction
• IDE Limitations

Innovation

• Live Object Environment
• Inspector Custom Views
• Microcommits
• Xtreme TDD
• Object-Centric Breakpoints