Software system evolution analysis method based on algebraic topology

Chun Shan, Liyuan Liu, Jingfeng Xue, Changzhen Hu, Hongjin ZhuTsinghua 2018 · DOI

Abstract

The analysis of software system evolution is highly significant in software research as the evolution runs throughout the lifecycle of a software system. Considering a software system as an algebraic engineering system, we propose a software system evolution analysis method based on algebraic topology. First, from a complex network perspective, we abstract a software system into the software structural topology diagram. Then, based on the algebraic topology principle, we abstract each node in the software structural topology diagram into an algebraic component represented by a 6-tuple. We propose three kinds of operation relationships between two algebraic components, so that the software system can be abstracted into an algebraic expression of components. In addition, we propose three forms of software system evolution, which help to analyze the structure and evolution of system software and facilitate its maintenance and reconfiguration.

Introduction

Software systems are dynamic entities, constantly evolving to meet shifting user requirements and technological advancements. This evolution is typically categorized as either static (offline) or dynamic (runtime). However, as systems grow in scale, manually tracking how changes in one module ripple through a complex network of dependencies becomes increasingly error-prone. There is a critical need for a unified theoretical framework that provides both mathematical rigor and practical utility for system maintenance and reconfiguration.

This paper addresses this challenge by treating software systems as mathematical structures. By applying principles of algebraic topology, software modules are represented as "algebraic components" and their interactions as formal mathematical operations. This allows complex system changes—such as feature additions or deletions—to be calculated and managed through precise algebraic expressions.

Methodology

The proposed framework consists of three primary stages: structural mapping, algebraic abstraction, and the definition of operational relationships.

1. Structural Topology Mapping

Using a complex network perspective, the software is first abstracted into a structural topology diagram. In this representation, nodes represent information resources (modules), while edges represent behaviors or interactions between them. This abstraction simplifies the software's physical architecture into a form suitable for topological analysis.

Abstraction of a software system into a structural topology diagram of algebraic components.

2. Algebraic Abstraction

Each node in the topology is defined as an algebraic component (PM). To capture both the logic and the connectivity of a module, each PM is represented by a 6-tuple: $PM = (X, Y, D, C, \tau, \eta)$.

This tuple accounts for:

  • Logical behaviors ($X$): The core functions of the module.
  • Connection relations ($Y$): How the module links to others.
  • Internal data ($D$): The state maintained within the module.
  • Controllers ($C$): Logic governing the execution flow.
  • Aggregation operations ($\tau$): Methods for combining data or functions.
  • Detectors ($\eta$): Interfaces for monitoring module status.
Internal structure of an algebraic component showing the connection and function parts.

3. Operation Relationships

To describe how these components interact, the authors define three specific mathematical operations:

  • Calling ($\oplus$): One component utilizes the services of another.
  • Nesting ($\otimes$): Components are nested to perform a specific, unified function.
  • Including ($\odot$): The execution of one component is dependent on the output of another.

By combining these operations, any software system can be represented as a single, complex algebraic expression. Evolution is then treated as a transformation of this expression.

Validation and Results

The researchers validated this method using JeeSite, an open-source JavaEE rapid development platform. They focused on four primary modules: System Management (SYS), Content Management (CMS), Online Office (OA), and Code Generation (GEN).

Key Findings

  • Mathematical Stability: The authors proved that the proposed operations ($\oplus, \otimes, \odot$) satisfy 10 specific properties, such as the union law on calling operations, forming a stable algebraic system.
  • Dynamic Evolution: In the JeeSite experiment, adding a new "Job Group" management module was handled by updating the algebraic expression. This change was automatically reflected in the system's XML configuration, enabling dynamic evolution without manual structural re-coding.
  • Top Component Criticality: The analysis identified that every system has a "top algebraic component" acting as the entry point. The framework ensures that if this component is deleted, a new entrance is mathematically introduced to prevent system collapse.

Conclusion

By shifting software architecture from manual diagrams to formal algebraic systems, this method reduces the risks associated with manual dependency analysis and streamlines system reconfiguration. Future work will focus on automating the extraction of 6-tuple components from raw source code and addressing the complexities of state migration during dynamic evolution.

Summary updated

Abstract

The analysis of software system evolution is highly significant in software research as the evolution runs throughout the lifecycle of a software system. Considering a software system as an algebraic engineering system, we propose a software system evolution analysis method based on algebraic topology. First, from a complex network perspective, we abstract a software system into the software structural topology diagram. Then, based on the algebraic topology principle, we abstract each node in the software structural topology diagram into an algebraic component represented by a 6-tuple. We propose three kinds of operation relationships between two algebraic components, so that the software system can be abstracted into an algebraic expression of components. In addition, we propose three forms of software system evolution, which help to analyze the structure and evolution of system software and facilitate its maintenance and reconfiguration.
BibTeX
@inproceedings{shan2018software,
  author = {Chun Shan and Liyuan Liu and Jingfeng Xue and Changzhen Hu and Hongjin Zhu},
  title = {{Software system evolution analysis method based on algebraic topology}},
  booktitle = {Tsinghua},
  year = {2018},
  doi = {10.26599/tst.2018.9010027},
}

Loading related content...

Figure