When Does the Dependency Graph Help Code-to-Architecture Mapping?
Architectural drift is expensive to detect when the mapping between source files and architectural modules is missing or outdated. This paper frames code-to-architecture mapping as semi-supervised node classification over a directed multi-relational dependency graph, expanding a small labeled seed via iterative self-training. By holding features, training loops, and classifier heads fixed across GCN, GAT, and a graph-free MLP, the authors isolate whether dependency structure genuinely improves mapping accuracy.
The paper offers a cautiously optimistic empirical assessment: GAT achieves the highest average system-level median macro- and micro-$F_1$ (83.5 and 92.2), yet the authors explicitly warn that "average advantages should therefore not be read as guarantees for an individual labeled set or training run." The graph advantage is striking on Chrome---the sole large-scale system---but largely absent or reversed on smaller, sparser systems such as HDF, so the overall conclusion is qualified by substantial system-level variance.
The experimental protocol is praiseworthy for its controlled isolation of the graph contribution: all neural models share the same Word2Vec-derived node features, classification head, and self-training loop, differing only in whether and how they aggregate neighbors. The multi-relational design is also convincingly validated, with separate per-type adjacency matrices significantly outperforming a merged homogeneous graph on every benchmark system for both GCN and GAT.
Despite the controlled design, the comparison between MLP and the GNNs is confounded by differences in encoder depth, dropout, and parameter count---GAT introduces attention parameters that the other encoders lack, so the observed gaps cannot be attributed solely to dependency information. The authors acknowledge this in Section 2, noting that "Differences in encoder depth, dropout, and parameter count remain potential confounders," and the data bear this out: MLP significantly outperforms both GNNs on HDF, while sparse Bash nevertheless favors GAT, undermining any simple rule based on connectivity or homophily.
A second limitation is the restricted benchmark scale. With only one industrial-scale system (Chrome at 18,343 files), scalability claims rest on a single observation. Moreover, directory paths are included as node features, and because "in several benchmark systems the folder hierarchy closely reflects the reference module decomposition," performance may be inflated when path features leak ground-truth module information.
The core evidence supports the claim that dependency graphs reduce persistent file-level errors on large systems: on Chrome, MLP misclassifies 10.4% of files in nearly every run versus roughly 1.1% for GAT. Yet comparisons to prior work are weakened by the use of a Python re-implementation of Naive Bayes that the authors admit is "not a claim of numerical equivalence to the original Java/Weka implementation." Furthermore, the deterministic seed-sensitivity follow-up shows that several model rankings---including GAT versus MLP on SH-3D and T.Mates---flip depending on initialization, so the reported median advantages are less stable than the aggregate tables suggest.
The authors provide source code, split identities, and software version details in a public GitHub repository, which supports independent reproduction. Reproducing the exact reported numbers is nevertheless hindered by the primary experiment's lack of deterministic GPU enforcement: "Same-seed controls exposed a numerical discrepancy on A.UML that was amplified during training and pseudo-label selection." Although deterministic execution was later added, the seed-sensitivity analysis was exploratory and covered only ten splits with five seeds each, leaving unanswered how many other conclusions might shift under repeated trials.
Architectural technical debt arises when a system's implementation drifts from its inten ded modular decomposition, while the mapping between source files and architectural modu les is missing, incomplete, or costly to maintain manually. We formulate code-to-archite cture mapping as semi-supervised node classification over a directed multi-relational de pendency graph, with files as nodes, typed dependencies as edges, and lexical features d erived from code identifiers and directory layout. Starting from a small labeled sample, an iterative self-training procedure expands the mapping to the remaining files. We com pare a graph convolutional network (GCN), a graph attention network (GAT), and a graph-f ree multi-layer perceptron (MLP), using identical features and training procedures for t he learned models, against a Naive Bayes reference. Across 100 runs on ten open-source J ava and C/C++ systems, all three neural models outperform the reference on both F1 metri cs. GAT achieves the highest averages of system-level median macro and micro F1, at 83.5 and 92.2, respectively, whereas MLP remains competitive or superior on several systems. On Chrome, the largest system with 18,343 files, GAT and GCN exceed MLP by 22 and 19 ma cro-F1 points, respectively, and have substantially fewer persistently misclassified fil es. Connectivity and homophily are associated with where neural message passing helps, w hile multi-relational aggregation outperforms a single merged edge type on every system for both GCN and GAT. A follow-up study finds that several model rankings depend on the training seed, qualifying smaller advantages without removing the large graph benefit ob served on Chrome.
Pick a starting point or write your own. Challenges run in the background, so you can keep reading while the AI investigates.
No challenges yet. Disagree with the review? Ask the AI to revisit a specific claim.