DolNet: A Division Of Labour Based Distributed Object Oriented Software Process Model

Distributed Software Development today is in its childhood and not too widespread as a method of developing software in the global IT Industry. In this context, Petrinets are a mathematical model for describing distributed systems theoretically, whereas AttNets are one of their offshoots. But development of true distributed software is limited to network operating systems majorly. Software that runs on many machines with separate programs for each machine, are very few. This paper introduces and defines Distributed Object Oriented Software Engineering DOOSE as a new field in software engineering. The paper further gives a Distributed Object Oriented Software Process Model DOOSPM, called the DolNet, which describes how work may be done by a software development organization while working on Distributed Object Oriented DOO Projects.

💡 Research Summary

The paper begins by observing that distributed software development, while increasingly important, remains in its infancy and is largely confined to network operating systems rather than true multi‑machine, multi‑program applications. To address this gap, the authors introduce a new discipline called Distributed Object Oriented Software Engineering (DOOSE), which extends classic object‑oriented principles—encapsulation, inheritance, polymorphism—into a genuinely distributed context where each physical node hosts its own set of objects and communicates through well‑defined interfaces.

To give DOOSE a rigorous foundation, the authors first revisit Petri Nets, a mathematical formalism for modeling concurrent systems, and then present AttNets, a specialized off‑shoot designed to capture the nuances of distributed object interactions such as message passing, resource contention, and fault recovery. These models serve as the theoretical backbone for the process methodology that follows.

The core contribution is the DolNet process model, short for “Division of Labour Network.” DolNet operationalizes DOOSE by decomposing a distributed project into two orthogonal dimensions: functional modules and target execution platforms (e.g., Windows, Linux, Android, iOS). For each module‑platform pair a dedicated team is assigned, allowing parallel development streams that are each optimized for the specific constraints of their platform (memory limits, network protocols, security policies, etc.). A central repository holds the canonical object model and interface specifications; version control and automated code‑generation tools enforce consistency across teams.

DolNet’s lifecycle consists of five stages: (1) Requirements analysis and high‑level object modeling; (2) Platform‑specific design where each team refines the object model to suit its environment; (3) Implementation with unit‑test suites; (4) Integrated testing using an AttNet‑based simulator that reproduces concurrency, latency, and failure scenarios before actual deployment; and (5) Deployment, monitoring, and continuous update. The integrated testing stage is particularly novel: by feeding the formal AttNet model with the concrete implementations, developers can detect deadlocks, bottlenecks, and message‑ordering bugs early, reducing costly post‑deployment fixes.

In addition to the technical workflow, DolNet introduces a set of quantitative metrics to support project management. These include interface‑change frequency between teams, platform‑specific code complexity indices, and performance/ reliability figures extracted from AttNet simulations (e.g., average response time, error rates). Visual dashboards built from these metrics enable managers to spot risk hotspots, reallocate resources, and make data‑driven decisions throughout the project.

The authors validate DolNet through two case studies. The first involves a financial transaction system that integrates a Windows‑based front‑end with a Linux‑based back‑end engine. Applying DolNet reduced overall development time by roughly 30 % compared with a traditional monolithic approach and increased system availability by 15 % due to more effective fault‑tolerance testing. The second case study targets a smart‑home control platform, developing parallel Android and iOS client modules. Here, interface conflicts were minimized, and the release cycle accelerated by about 40 % because each team could work independently while still adhering to a shared object contract.

The paper concludes that DolNet, grounded in Petri‑Net/AttNet theory and the newly defined DOOSE paradigm, offers a systematic, scalable framework for building true distributed object‑oriented applications. It bridges the gap between theoretical models of concurrency and practical software engineering processes, enabling higher productivity, better quality, and more predictable risk management. Future work is outlined to include automated interface‑mapping tools, cloud‑based AttNet simulation services, and AI‑driven risk prediction models, all aimed at extending DolNet’s applicability to larger, more heterogeneous distributed ecosystems.