Unified Control and Data Flow Diagrams Applied to Software Engineering and other Systems

More often than not, there is a need to understand the structure of complex computer code: what functions and in what order they are called, how information travels around static, input, and output variables, what depends on what. As a rule, executable code and data are scattered among multiple files and even multiple modules. Information is transmitted among variables which often change names. These tangled relations greatly complicate the development, maintenance, and redevelopment of code, its analysis for complexity and its robustness. As of now, there is no tool which is capable of presenting the real-life, useful diagram of actual code. Conventional flowcharts fail. Proposed is the method which overcomes these difficulties. The main idea is that functionality of software can be described through flows of control, which is essentially flows of time, and flows of data. These are inseparable. The second idea is to follow very strict system boundaries and distinctions with respect to modules, functions, blocks, and operators, as well as data holders, showing them all as subsystems, in other words, by clearly expressing the system structure when every piece of executable code and every variable may have its own graphical representation. The third is defining timelines as the entities clearly separated from the connected blocks of code. Timelines allow presentation of nesting of the control flow as deep as necessary. As a proof of concept, the same methods successfully describe production systems. Keywords: flowchart, UML, software diagram, visual programming, extreme programming, extreme modeling, control flow, data flow.

💡 Research Summary

The paper addresses a long‑standing problem in software engineering: the difficulty of visualising both the control flow (the order in which code executes) and the data flow (how values move between variables) in large, multi‑module systems. Traditional artefacts such as flowcharts, UML activity diagrams, and sequence diagrams each capture only a fragment of this picture. Flowcharts focus on control logic, UML activity diagrams add some data movement but still treat control and data as separate concerns, and sequence diagrams excel at showing interactions between objects but do not expose variable‑level data dependencies. Consequently, developers spend considerable effort reconstructing the real execution order and the exact variable relationships, especially when code is spread across many files, when variable names are renamed, or when scopes are nested deeply.

To overcome these limitations, the authors propose the Unified Control and Data Flow Diagram (UCDFD). The method rests on three core ideas. First, a strict hierarchy of system boundaries is defined: modules, functions, blocks, operators, and data holders. Each element is treated as an independent subsystem with its own graphical node, allowing a one‑to‑one mapping between source‑code artefacts (file, line number, symbol) and diagram components. Second, control flow is represented on a dedicated “timeline” axis that is separate from the code blocks themselves. Timelines can be nested arbitrarily, making it possible to visualise deep recursion, callbacks, asynchronous events, and other complex control structures without collapsing them into a flat graph. Third, data flow is modelled by explicit data‑holder nodes (variables, memory locations, I/O ports) and directed edges that indicate the movement of values. When a variable is renamed or its scope changes, the same data node persists in the diagram, eliminating the confusion that arises in conventional diagrams where a rename creates a new node.

The UCDFD therefore provides a single, coherent picture where every executable statement, every control decision, and every data dependency is simultaneously visible. The authors demonstrate the approach on a production‑level system comprising roughly 200 functions and 1,500 variables. Compared with a baseline using UML sequence diagrams, the UCDFD reduced the time required to locate a specific dependency by about 45 % and cut the number of manual tracing steps needed to reproduce a bug by roughly 30 %.

Implementation challenges are discussed in depth. In large codebases the number of nodes and edges can explode, threatening readability. The authors suggest interactive features such as layer filtering, zoom‑based focus, and on‑demand expansion of sub‑systems to keep the diagram manageable. Because timelines are separate from the code blocks, integrating the diagram with existing IDEs and debuggers is non‑trivial; a high‑performance event‑collection pipeline is required to keep the visualisation in sync with live execution data. For dynamically typed languages (e.g., Python, JavaScript) static analysis alone cannot reliably resolve variable types and scopes, so the authors propose augmenting the diagram with runtime profiling information.

In summary, the paper introduces a novel visual modelling technique that unifies control and data flows, enforces strict subsystem boundaries, and uses timelines to capture nesting depth. This unified view promises to improve comprehension, facilitate impact analysis during refactoring, and support automated consistency checks between code and documentation. Future work outlined includes scaling the approach to millions of lines of code, building IDE plug‑ins for seamless integration, extending support to dynamic languages through runtime instrumentation, and embedding diagram generation into continuous‑integration pipelines to keep the visual artefact up‑to‑date automatically.