Code‑Level Quality Techniques: Architecture, Understanding, Probes, and Applications

Background – Code‑level quality technology aims to improve service quality by operating directly on source code, not limited to static scans or unit tests. It addresses challenges such as code coverage performance, risk‑driven testing, hidden defects, and the need for robust, maintainable code.

Architecture

Layer 1 – Code Understanding (CodeC) : provides low‑level analysis (AST, call‑graph, dependencies) via storage, analysis, model, and API layers.

Layer 2 – Code‑Level Quality Applications (Codeπ) : includes four sub‑categories: CodeQ – problem recall (smart UT, rule‑based defect detection, flame graphs, ASAN, etc.) CodeP – dynamic instrumentation (coverage, runtime data collection) CodeH – code health assessment (e.g., SonarQube‑style metrics) CodeDL – defect location.

Code Understanding Layer

Static analysis: lexical, syntactic, control‑flow and data‑flow analysis without executing code.

Dynamic analysis: runtime behavior observation (performance, functional testing).

Non‑code analysis: correlating configuration or data files with source changes.

The C++ compilation process is described as four stages – preprocessing, compilation (producing AST), assembly, and linking (static or dynamic).

Code Probe (CodeP) – probes are inserted into the program to collect execution data, enabling coverage collection, method‑execution timing, and data‑flow tracing. Techniques include source‑level instrumentation and bytecode‑level instrumentation.

Coverage types covered are line, branch, path, and changed‑line coverage, with typical usage scenarios such as RD self‑test, QA release, precise testing, integration testing, and gray‑release evaluation.

Smart Unit Testing (Intelligent UT) – automatically generates exception‑driven unit tests by analyzing functions, constructing test data, and producing test code, reducing manual effort and improving early defect detection.

Static Analysis (SA) – rule‑based code scanning without compilation, detecting issues like null‑pointer dereference, array out‑of‑bounds, division‑by‑zero, etc. Advantages: low resource consumption, high automation; disadvantages: reliance on predefined rules and limited recall.

Isolated Function Identification – detects functions that are never called (orphan functions). Methods include: Static analysis of call graphs (fast, low cost, but language‑specific challenges). Dynamic analysis via runtime probes (higher accuracy, but incurs overhead). Hybrid static‑dynamic approaches for complementary strengths. Identifying orphan functions helps reduce technical debt, improve maintainability, and streamline debugging.

The article concludes that the presented background, architecture, and layer concepts provide a foundation for future deep‑dive posts on each aspect of code‑level quality technology.