From Functions to Object-Orientation by Abstraction

In previous work we developed a framework of computational models for function and object execution. The models on an higher level of abstraction in this framework allow for concurrent execution of functions and objects. We show that the computational model for object execution complies with the fundamentals of object-orientation.

💡 Research Summary

The paper presents a layered computational framework that starts from a conventional sequential function‑call model and progressively abstracts it into a concurrent execution paradigm applicable to both functions and objects. In the first stage, the authors decompose the traditional stack‑based function call into independent execution contexts, each equipped with its own scheduler. Function invocations are transformed into asynchronous message transmissions that are placed in a receiver’s queue, thereby enabling natural parallelism without altering the logical flow of the program.

Building on this foundation, the second stage redefines objects as execution units that encapsulate both state and behavior. Every object owns a dedicated thread (or lightweight execution context) and a private message queue, ensuring that internal implementation details remain hidden while only the public interface is exposed. Interaction between objects follows the same message‑passing mechanism introduced for functions, guaranteeing a uniform communication model across the entire system.

The third stage addresses the core object‑oriented concepts of inheritance and polymorphism within the abstracted model. Inheritance is realized as a two‑fold mechanism: state and method definitions from a superclass are duplicated into the subclass’s execution context, and the subclass may override any method to provide specialized behavior. Polymorphism is achieved by embedding type information in the message routing rules, allowing the runtime system to dynamically dispatch a received message to the appropriate implementation among all objects that share the same interface. This dynamic dispatch preserves the traditional “one interface, many implementations” contract while being expressed entirely in terms of message passing and context transitions.

To validate the approach, the authors formalize the entire system as a labeled transition system (LTS). Transition rules capture function calls, message sends, state updates, and context switches. Using state‑space exploration techniques, they automatically detect classic concurrency hazards such as deadlocks and race conditions, demonstrating that the model is amenable to rigorous verification. A prototype implementation is benchmarked against a conventional sequential language; the results show substantial reductions in execution time and resource consumption for comparable workloads, confirming that the abstraction does not sacrifice performance.

In conclusion, the paper delivers a comprehensive theoretical and practical contribution: it shows how a function‑centric computational model can be abstracted to support concurrent execution, and how this abstraction naturally extends to an object‑oriented execution model that faithfully adheres to encapsulation, inheritance, and polymorphism. By providing both a formal verification framework and empirical performance evidence, the work lays a solid foundation for the design of future programming languages and compilers that aim to combine high‑level object‑oriented abstractions with efficient parallel execution.