Synergistic Static and Dynamic Program Analysis

198 concepts153 papers1 proposal

Software analysis has traditionally been divided into two camps: static analysis, which examines code without executing it, and dynamic analysis, which observes software during runtime. Static analysis offers broad coverage and formal soundness but is plagued by "false positive" noise—warnings about bugs that cannot actually occur. Dynamic analysis provides ground-truth precision but suffers from the "state explosion" problem, where it is computationally impossible to execute every possible path.

Ji et al. observe that neither approach alone fully captures the nuances of software vulnerabilities. Modern research focuses on bridging this gap through hybrid frameworks that use the strengths of one method to mitigate the weaknesses of the other.

Static Analysis as a Roadmap for Execution

One of the most effective synergies involves using lightweight static analysis to guide expensive dynamic exploration. In this configuration, the static analyzer acts as a scout, identifying "danger zones" or potential vulnerabilities that a dynamic tool should prioritize.

For example, Chen et al. propose a "bug-driven" approach in the SAVIOR framework, which prioritizes execution seeds likely to reach potential vulnerabilities identified by static analysis. Similarly, Nassirzadeh et al. demonstrate that sequencing static analysis before dynamic verification can mitigate state explosion in smart contracts by narrowing the search space through control flow analysis.

This guidance can also be compositional. Fang et al. introduce an algorithm that uses over-approximate path summaries from static analysis to direct local symbolic exploration, allowing the search to "jump" directly to deep program states that appear buggy.

Dynamic Grounding for Static Precision

Conversely, dynamic information can be fed back into static engines to resolve ambiguities that occur when code is too complex to analyze in the abstract. This is particularly vital for highly dynamic languages like Python or complex environments like smart contracts.

Yin et al. show that grounding a symbolic engine in a concretely initialized state—using actual execution to set up the environment—prevents the false positives that arise when treating all variables as unconstrained. In the realm of pointer analysis, Ana L. Milanova argues that integrating concrete evaluation into static points-to analysis allows for the resolution of external library calls that are typically opaque to static tools.

Neural Networks as Semantic Filters

A burgeoning direction in hybrid analysis involves using machine learning, particularly Large Language Models (LLMs), as a "semantic layer" to filter the noise generated by rule-based static analyzers. Static tools are excellent at finding syntactic violations but often lack the context to understand if a violation is exploitable.

Kharkar et al. and the authors of the SAVIOR framework demonstrate that Transformer-based models can act as secondary filters, validating static warnings to boost precision. Dolcetti et al. and Eleonora Iotti suggest that this pairing allows for a "dual perspective" where the model provides semantic intuition while the static analyzer provides the rigorous proof required for security validation.

Efficiency through Instrumentation and Pruning

Hybridization also serves to make runtime monitoring more efficient. If a program is monitored for every possible security violation, the performance overhead becomes prohibitive. Sokolsky et al. and Grigore Roşu highlight how static analysis can be used to prune unnecessary runtime checks, ensuring that monitors only trigger when a program enters a state that hasn't been formally proven safe at compile-time.

This integration extends to specialized environments like computational notebooks. Shankar et al. show that combining Abstract Syntax Tree (AST) analysis with runtime instrumentation creates more accurate "program slices," capturing data dependencies that are invisible to static analysis alone due to the non-linear execution of notebook cells.

The Complementary Nature of Fault Detection

The necessity of this hybrid approach is perhaps best illustrated by the types of bugs each method finds. Luo et al. found that static and dynamic techniques often identify distinct sets of defects with low overlap. By fusing design-time syntax with runtime events, researchers like Meimei Pan and Sunny S. J. Lin argue that we can create a holistic view of software behavior, capturing complex relationships that remain hidden when using either method in isolation.

History & citationVersion 1 · 2026-10-04

Current · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_combined_static_and_dynamic_analysis_eca9659c,
  title = {combined static and dynamic analysis},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/combined-static-and-dynamic-analysis/rdr_eca9659cfdcf422280e892a30231272e},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-20},
}

This exact version (version 1, frozen text):

@misc{lacuna_combined_static_and_dynamic_analysis_eca9659c_v1,
  title = {combined static and dynamic analysis},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/combined-static-and-dynamic-analysis/rdr_eca9659cfdcf422280e892a30231272e/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-20},
}
About

These directions overlap with this one through shared papers.

See something wrong? Report a mistake