Artifacts including Modernized Code

These artifacts illustrate the structural and behavioral understanding required to safely sustain and modernize high-consequence legacy systems.

Reconstructed directly from source code, data interfaces, and shared record layouts, they replace undocumented behavior with verified system knowledge and reveal how the system actually operates in production.

Together, these models expose operational coupling, hidden risk boundaries, and modernization constraints, enabling safe evolution without unintended mission impact.

System Execution Flow

COBOL Tax Extension Engine: Reconstructed execution flow and processing phases derived from source code and file dependencies. This model reveals how the system operates in production and establishes the sequencing foundation required for safe sustainment and modernization. View the execution flow.

Runtime Execution Flow: Reconstructed batch execution sequencing derived from file dependencies and processing stages. View execution order.

System Architecture Models

These reconstructed architectural views reveal system structure, data movement, program dependencies, and shared record layouts, exposing coupling and change-risk boundaries.

Copybook Relationship Diagram: Identifies shared COBOL copybooks and their usage across programs, exposing structural coupling clusters. View the diagram.

Data Flow Diagram: Traces end-to-end data movement from inputs through batch pipelines to final outputs. See the data flow.

Program Dependency Diagram: Maps dependencies using CALL relationships and file-mediated handoffs. View dependencies.

System Context Diagram: Defines system boundaries, external inputs, actors, and processing phases. See the system context.

Program Domain Catalog

This domain-organized inventory documents program purpose, interfaces, dependencies, and processing roles to support impact analysis and modernization planning. Browse the catalog.

Domain Processing Groups:

ASCOE – Certificate of Error processing (View our documentation)

ASHMA – Homestead & Senior Freeze processing (View our documentation)

ASREA – Core assessment & valuation processing (View our documentation)

ASSRQ – Service request & mixed-class processing (View our documentation)

CLREB – Equalization factor validation (View our documentation)

CLRTM – Tax rate & valuation aggregation (View our documentation)

Business & Regulatory Logic

These artifacts reconstruct implemented rules and regulatory logic directly from program behavior to preserve compliance and operational correctness.

Requirements overview organized by valuation, exemption, equalization, and corrections. View requirements.

Extracted formulas, thresholds, and decision logic. See business rules.

Embedded constants and date thresholds with modernization risk implications. View hardcoded values.

Mapping of implemented logic to governing statutes and regulatory frameworks. See regulatory mappings.

Code Modernization Examples

This demonstration shows how a single monolithic COBOL program can be translated into a modular Java class ecosystem while preserving functional behavior.

The objective is not a line-by-line conversion. The objective is to make legacy logic understandable, testable, and evolvable by decomposing monolithic structure into clear responsibilities and stable interfaces.

Original Monolithic COBOL Component

CLREB020.cbl: Single program containing input parsing, validation, computation, and reporting logic.

Modern Modular Java Ecosystem

The same operational behavior is preserved, but responsibilities are separated into focused components.

Each class has a single responsibility and can be verified independently, enabling unit testing, deterministic behavior validation, and automated regression protection.

This structure supports traceability from requirements through implementation and provides a clear foundation for independent verification, validation, and certification activities.

ClerkRealEstateBoardEqualizationFactorProgram.java: Orchestration and high-level processing flow

CardRecord.java: Input record model and validation

FactorRecord.java: Equalization factor domain model

CardFileReadResult.java: File read handling and control logic

RecordProcessingStatistics.java: Processing metrics and counters

PrintReportFile.java: Report formatting and output generation

We provide a complete, repeatable test framework for the refactored codebase that runs automatically in the client’s DevSecOps pipeline. The linked materials include well documented unit tests that verify each component and confirm deterministic behavior and error handling. Unit tests form the baseline, but we always deliver integration tests to validate data flow and component interactions, along with end-to-end system tests that exercise the full operational workflow. This layered approach prevents regressions and provides objective evidence to support verification, certification, and long term sustainment confidence.

Why These Artifacts Matter

Together, these models transform an undocumented legacy system into a verified operational architecture.

They enable:

Safe modernization sequencing
Preservation of compliance and operational behavior
Identification of high-risk coupling zones
Reduction of change uncertainty
Restoration of engineering confidence

This structural clarity is what makes even million-line legacy systems tractable to human understanding.

Connect with Us