Incremental Analysis of Legacy Applications

• Incremental analysis of legacy applications is a methodology that localizes recomputation to affected code segments by leveraging balanced data structures and reuse of intermediate results.
• It employs formal models such as path-expression trees, knowledge graphs, and modular dependency graphs to enhance precision and scalability in system modernization.
• Empirical results demonstrate significant speedups, reduced memory usage, and near-real-time feedback, making the approach practical for evolving large-scale codebases.

Incremental analysis of legacy applications encompasses algorithms, data structures, and methodological frameworks that enable selective and high-precision program analysis in the presence of evolving, typically large-scale codebases. Historically, monolithic analysis techniques required global recomputation after every change, quickly becoming infeasible for interactive development, modernization, or maintenance of legacy systems. Incremental approaches restructure the analysis pipeline to localize recomputation, apply modularity, leverage reusable intermediate results, and support architectural workflows for systematic modernization.

1. Formal Models and Data Structures for Incremental Program Analysis

A core challenge in the incremental analysis of legacy systems is capturing program structure and semantics in forms amenable to efficient, localized updates. Several formal and data-structural paradigms have emerged:

• Path-Expression Trees in Algebraic Program Analysis (APA): In APA, control-flow graphs (CFGs) are summarized by a regular expression ρ(s,t) over edges, capturing all paths from source to sink in a method. Incremental methods represent this path expression as a balanced binary tree T, where each internal node encodes concatenation (⊗), union (⊕), or Kleene-star (⋆), and leaves correspond to edges or the empty path when marked as deleted. Node fields track subtree sizes, "marked" leaves, and modification status, enabling fast detection and efficient balancing upon CFG edits. The resulting structure supports logarithmic-time access to affected subtrees and amortized O(log n) update cost per edit (Zhou et al., 2024).
• Knowledge Graphs in Multi-Artifact, Multi-Language Repositories: For large legacy applications spanning heterogeneous languages and system artifacts, knowledge graphs (KGs) provide a flexible backbone. Artifacts (program modules, transactions, database tables, files, jobs, and logical applications) instantiate a schema in a graph database such as Neo4j, with binary relationships (e.g., CALLS, USES, HAS) expressing structural and data dependencies. Static analyses (e.g., ADDI) parse sources to populate the KG, with entities and relations indexed for scalable incremental boundary queries (Krishnan et al., 11 May 2025).
• Modular and Context-Sensitive Dependency Graphs: Modular analysis partitions a codebase into semantically self-contained modules with explicit import/export lists. Abstract interpretation over Horn-clause IR constructs module-local graphs (Gₘ) and a global interface graph (G), each tracking context-sensitive call and success patterns per predicate. Incremental updates maintain these graphs, invalidating only impacted portions and propagating boundary-level changes across module dependencies (Garcia-Contreras et al., 2018).

2. Incremental Algorithms and Update Semantics

Incremental program analysis algorithms are characterized by their capacity to reuse prior analysis output, restrict recomputation to the minimal affected scope, and efficiently propagate or contain changes:

• Incremental Path-Expression and Interpretation in APA: Edits to the CFG—addition or removal of edges—are realized as splits, insertions, or (lazily marked) deletions in the path-expression tree. Modification flags propagate upwards to ancestors, and weight-balancing triggers subtree rebuilds only when balance invariants are violated. The interpretation phase traverses only marked ("modified") nodes, recomputing semantic facts for local subtrees rather than re-evaluating the entire program, with update and interpretation both completing in O(log n) time for typical small edits (Zhou et al., 2024).
• Knowledge-Graph Increment Definition and Dependency Cut: Analysts interactively define "increments"—slices of the full system relevant for a particular modernization task—by selecting seed entities and expanding via neighborhood traversal (radius k) over dependency edges. The system computes inside-out and outside-in cuts in O(|E|), classifying cross-boundary dependencies for precise interface extraction. Adjacency metrics (coupling, dependency count, total LOC/cyclomatic complexity) guide iterative boundary refinement, enabling informed scoping of modernization efforts (Krishnan et al., 11 May 2025).
• Modular Incremental Context-Sensitive Analysis: Modular incremental analysis maintains per-module graphs and a global interface, invalidating only dirty modules upon code edits. Local recomputation within affected modules is followed by inter-module propagation, achieved through precise tracking and preloading of context-sensitive call/success patterns. Memory and time complexity scale with edited module size and interface counts, yielding order-of-magnitude speedups over flat whole-program incrementalization (Garcia-Contreras et al., 2018).
• Incremental Abstract Interpretation with Lazy Invalidation: Abstract interpretation systems such as Goblint utilize dependency-tracking fixpoint engines (TDside) that recompute only those unknowns affected by an edit, as determined by dynamic dependency graphs. Lazy invalidation and reluctant destabilization restrict recomputation to nodes where invariants have actually changed under the new code, further reducing computational effort. Selective restart strategies address flow-insensitive global summaries, and incremental postprocessing phases reuse warning diagnostics where possible (Erhard et al., 2022).

3. Performance, Complexity, and Scalability

Rigorous empirical and theoretical analyses have demonstrated the efficacy of incremental analysis by comparing baseline, monolithic, and incremental scenarios:

Approach	Update Complexity	Typical Speedup	Memory Usage	Scope of Reuse
Path-Expression Tree APA	O(log n)	160×–4761×	O(n)	Affected subtrees only
Modular Incremental Analysis	O(	Δₘ	+ Eₘ)	1.5×–10×
Interactive Abstract Int.	<< from-scratch	3.7×–4.7×	Reuses previous solutions	Downstream dependency
Knowledge-Graph Increment	O(#entities+edges)	20 s/increment	Efficient via indexing	Boundary-local changes

Incremental APA achieves per-edit cost of O(log n), with worst-case degradation to O(n) only for edits impacting the majority of the program, and experimental speedups of up to 4761× on large Java codebases (Zhou et al., 2024). Modular approaches demonstrate 1.5×–10× speedups with 0.4–0.8× memory consumption compared to monolithic, even outperforming non-incremental modular analysis due to staged reuse (Garcia-Contreras et al., 2018). Interactive incremental frameworks sustain sub-second update times on real-world multi-threaded C programs, retaining 96–98% solution precision and exhibiting only minimal loss on rare, pathological changes (Erhard et al., 2022). Knowledge-graph driven increment processing scales to thousands of artifacts with second-level latency, supporting responsive iterative analysis in modernization settings (Krishnan et al., 11 May 2025).

4. Modernization, Maintenance, and Interactive Workflows

Incremental analysis significantly advances workflows in legacy application modernization and ongoing maintenance:

• Boundary-Driven Modernization: The definition and iterative refinement of logical increments around business functions or data domains isolates modernization efforts to strictly necessary artifacts. The knowledge-graph approach supports SME-guided scoping, cut edge extraction, and metric-based tradeoff analysis without overwhelming stakeholders with the complexity of the whole system (Krishnan et al., 11 May 2025).
• Interactive, Visual Feedback: Fine-grained update mechanisms, particularly those integrating with IDEs or live analysis environments, enable near-real-time propagation and visualization of analysis results. For example, Goblint leverages MagpieBridge and the Language Server Protocol to translate incremental re-analysis events into IDE bar diagnostics, facilitating rapid developer feedback (Erhard et al., 2022).
• Selective, Persisted State Management: Practical implementations maintain persistent analysis state (e.g., path-expression trees in APA, modular graphs in context-sensitive analysis) and support undo/versioning through lazily revokable deletions and historical checkpointing. Strategic design of module boundaries, interface policies, and artifact mapping are crucial for maximize reuse and minimize spurious recomputation (Zhou et al., 2024, Garcia-Contreras et al., 2018).

5. Methodological Guidelines and Best Practices

Research in incremental analysis distills several architectural and operational lessons applicable to legacy system contexts:

• Balance Locality and Modularity: Maintain analysis structures (e.g., balanced trees, modular graphs) that tightly localize impact while retaining expressiveness for cross-cutting dependencies. Avoid degenerate structures by enforcing balancing invariants and minimizing interface exposure (Zhou et al., 2024, Garcia-Contreras et al., 2018).
• Ontology and Schema Extensibility: Employ a compact, language-agnostic ontology for artifact representation, allowing for domain-driven extensions as new business domains or platform peculiarities are encountered. SME-driven groupings enable bootstrapped seed selection and iterative knowledge refinement (Krishnan et al., 11 May 2025).
• Efficient State Propagation: Rigorously track dependencies and leverage lazy invalidation, reluctant propagation, and selective restart to avoid unnecessary recomputation, especially in concurrent or dataflow-intensive settings (Erhard et al., 2022).
• Metrics-Driven Scoping: Use aggregate metrics such as coupling degree, dependency counts, LOC, and cyclomatic complexity to quantitatively steer refinement and modernization boundaries, guiding rational tradeoffs between size, coupling, and feasibility (Krishnan et al., 11 May 2025).
• Persistent, Versioned Analysis State: Support undo, rollback, and persistent versioning of analysis state, especially in CI/CD or collaborative maintenance environments. Strategies include lazy marking, ancestor-flagging, and historical delta replay (Zhou et al., 2024).

Adherence to these principles ensures robust, high-performance incremental analysis for legacy applications, providing tractable, accurate, and responsive support for both large-scale modernization and day-to-day evolution. These approaches form the backbone of scalable static analysis, optimization, and migration pipelines in modern software engineering research and practice.