Activities - Program Graphs for Code Analysis

Activities in Program Graphs for Code Analysis

All activities across workflows in this playbook

Activities 19

Name	Abbrev.	Workflow	Phase	Actions
Scrape target repositories	CSE-1	Collect and Compile Source	Data Preparation
Filter compilable projects	CSE-1	Collect and Compile Source	Data Preparation
Extract variable usage slots	CSE-1	Collect and Compile Source	Data Preparation	Read the 'CSE-1 Extract variable usage slots' activity from playbook 'Program Graphs for Code Analysis' (workflow 'Collect and Compile Source'). Follow its guidance when assisting me. For each variable usage location (excluding declarations), check that at least one other type-compatible variable is in scope. Each such location becomes a training slot. Record the ground-truth variable at each slot.
Split dataset by file	CSE-1	Collect and Compile Source	Data Preparation	Read the 'CSE-1 Split dataset by file' activity from playbook 'Program Graphs for Code Analysis' (workflow 'Collect and Compile Source'). Follow its guidance when assisting me. Partition into train/validation/test splits along source file boundaries — all examples from one file must go to the same split. Reserve held-out projects (no files in training) for UNSEENPROJTEST evaluation. Suggested split: 60-10-30.
Parse source to AST	BGS-1	Build Program Graphs	Data Preparation	Read the 'BGS-1 Parse source to AST' activity from playbook 'Program Graphs for Code Analysis' (workflow 'Build Program Graphs'). Follow its guidance when assisting me. Parse each source file to its Abstract Syntax Tree. Label syntax nodes with nonterminal names and syntax tokens with their string representation. Add Child edges connecting parent-child AST relationships and NextToken edges connecting consecutive tokens.
Add data flow edges	BGS-1	Build Program Graphs	Data Preparation	Read the 'BGS-1 Add data flow edges' activity from playbook 'Program Graphs for Code Analysis' (workflow 'Build Program Graphs'). Follow its guidance when assisting me. For each variable token v, compute DR(v) (last read locations) and DW(v) (last write locations). Add LastRead and LastWrite edges accordingly — these may span non-sequential locations including across loop boundaries. Add ComputedFrom edges connecting assignment targets to all variable tokens in the right-hand side expression.
Add semantic shortcut edges	BGS-1	Build Program Graphs	Data Preparation	Read the 'BGS-1 Add semantic shortcut edges' activity from playbook 'Program Graphs for Code Analysis' (workflow 'Build Program Graphs'). Follow its guidance when assisting me. Add LastLexicalUse edges chaining all occurrences of the same variable (independent of data flow). Add ReturnsTo edges connecting return tokens to their method declaration. Add FormalArgName edges connecting call-site arguments to the formal parameter names they map to.
Add backward edges	BGS-1	Build Program Graphs	Data Preparation	Read the 'BGS-1 Add backward edges' activity from playbook 'Program Graphs for Code Analysis' (workflow 'Build Program Graphs'). Follow its guidance when assisting me. For every edge type added (Child, NextToken, LastRead, LastWrite, ComputedFrom, LastLexicalUse, ReturnsTo, FormalArgName), add the corresponding backward edge by transposing the adjacency matrix. This doubles edge count and types, aids information propagation, and increases model expressiveness.
Compute subtoken embeddings	CRS-1	Compute Node Representations	Data Preparation	Read the 'CRS-1 Compute subtoken embeddings' activity from playbook 'Program Graphs for Code Analysis' (workflow 'Compute Node Representations'). Follow its guidance when assisting me. Split each node name on camelCase and pascal_case boundaries into subtokens (e.g. classTypes → [class, types]). Learn an embedding for each subtoken. Compute the node name embedding as the average of its subtoken embeddings.
Compute type hierarchy embeddings	CRS-1	Compute Node Representations	Data Preparation	Read the 'CRS-1 Compute type hierarchy embeddings' activity from playbook 'Program Graphs for Code Analysis' (workflow 'Compute Node Representations'). Follow its guidance when assisting me. For each variable, collect the full set of its supertypes (type lattice τ(v)). Learn an embedding r(τ) for each known type; use "UNKTYPE" for unseen types. Compute the variable's type representation as the element-wise maximum over {r(τ) : τ ∈ τ(v)}. During training, randomly sample a non-empty subset of τ*(v) as regularization.
Assemble initial node state	CRS-1	Compute Node Representations	Data Preparation
Configure task-specific graph	TGN-1	Train GGNN	Model Training	Read the 'TGN-1 Configure task-specific graph' activity from playbook 'Program Graphs for Code Analysis' (workflow 'Train GGNN'). Follow its guidance when assisting me. For VARNAMING: replace all tokens of the target variable with a special SLOT token. For VARMISUSE: insert a v_SLOT node at the target location connected via all non-variable edges; insert candidate nodes v_t,v for each type-compatible variable connected via LastUse, LastWrite, LastLexicalUse edges. Set an extra bit to 1 for candidate nodes.
Batch graphs as disconnected components	TGN-1	Train GGNN	Model Training	Read the 'TGN-1 Batch graphs as disconnected components' activity from playbook 'Program Graphs for Code Analysis' (workflow 'Train GGNN'). Follow its guidance when assisting me. Represent each graph as a sparse adjacency list to minimize memory. Combine a minibatch into one large graph with disconnected components by making node IDs unique per batch. Prepare minibatches on a separate CPU thread to avoid GPU stalls during training.
Run GGNN propagation	TGN-1	Train GGNN	Model Training	Read the 'TGN-1 Run GGNN propagation' activity from playbook 'Program Graphs for Code Analysis' (workflow 'Train GGNN'). Follow its guidance when assisting me. For each step: compute messages m(v)_k = linear(h(v)) per edge type. Aggregate incoming messages via elementwise summation. Update node state via GRU: h'(v) = GRU(aggregated_messages, h(v)). Repeat for exactly 8 steps — fewer is insufficient; more does not help.
Train with maximum likelihood	TGN-1	Train GGNN	Model Training	Read the 'TGN-1 Train with maximum likelihood' activity from playbook 'Program Graphs for Code Analysis' (workflow 'Train GGNN'). Follow its guidance when assisting me. VARNAMING: average final SLOT node states; use as GRU initial state to predict variable name as subtoken sequence via MLE. VARMISUSE: compute context c(t)=h(v_SLOT) and usage u(t,v)=h(v_t,v); train argmax of c(t)^T u(t,v) via MLE. Report accuracy (exact match) and F1 (subtoken match) for VARNAMING; accuracy and PR-AUC for VARMISUSE.
Evaluate on seen and unseen projects	EAE-1	Evaluate and Analyze	Evaluation	Read the 'EAE-1 Evaluate on seen and unseen projects' activity from playbook 'Program Graphs for Code Analysis' (workflow 'Evaluate and Analyze'). Follow its guidance when assisting me. Run evaluation on SEENPROJTEST (projects with files in training) and UNSEENPROJTEST (completely held-out projects). Report accuracy and PR-AUC for VARMISUSE; accuracy and F1 for VARNAMING. Expect lower performance on unseen projects due to unknown type lattices and different vocabularies.
Compare against baselines	EAE-1	Evaluate and Analyze	Evaluation	Read the 'EAE-1 Compare against baselines' activity from playbook 'Program Graphs for Code Analysis' (workflow 'Evaluate and Analyze'). Follow its guidance when assisting me. Compare GGNN against: LOC (local bidirectional GRU, no usage context), AVGBIRNN (bidirectional RNN averaged over all usages). For VARNAMING also compare against AVGLBL (log-bilinear model over 4-token context windows). All baselines use same variable selection objective: argmax of c(t)^T u(t,v).
Run ablation study	EAE-1	Evaluate and Analyze	Evaluation	Read the 'EAE-1 Run ablation study' activity from playbook 'Program Graphs for Code Analysis' (workflow 'Evaluate and Analyze'). Follow its guidance when assisting me. Systematically vary: (1) edge types used — syntax only, semantic only, combined; (2) node label representation — subtokens vs full tokens vs disabled. Measure impact on both VARNAMING and VARMISUSE accuracy to attribute performance gains to specific design choices.
Discover real-world bugs	EAE-1	Evaluate and Analyze	Evaluation	Read the 'EAE-1 Discover real-world bugs' activity from playbook 'Program Graphs for Code Analysis' (workflow 'Evaluate and Analyze'). Follow its guidance when assisting me. Rank variable usage locations by model confidence that a different variable should be used. Inspect the top-N locations (top 500 in the paper) where the model strongly disagrees with the ground truth. Classify findings as true bugs vs. valid alternatives (e.g. aliases). Report confirmed bugs with code snippets.