1 views collected around this technical thread.
This article explores how a multi‑agent AI system dramatically improves 0‑day vulnerability detection by automating code audit, reducing false positives, and outperforming traditional static analysis tools in large‑scale real‑world benchmarks.
The article introduces an AI‑driven automated testing system that streamlines code self‑testing, improves impact assessment, and generates comprehensive test reports, detailing its modular architecture, workflow, AI test engine, and future enhancements such as UI simulation and AI‑generated unit tests.
This article presents a comprehensive overview of the security challenges in HarmonyOS native ArkTS applications and describes the design and implementation of a specialized static analysis framework—including source extraction, data‑flow and inter‑function analysis, knowledge‑graph construction, and risk inference engine—while also outlining integration into development pipelines and future research directions.
This article explains how to analyse the impact range of code changes in large frontend projects, describes the architecture and core techniques—including project dependency‑tree building, AST parsing, GitLab diff extraction, and change propagation—provides concrete JavaScript/TypeScript examples, and discusses visualization of the results.
This article introduces JavaParser, an open‑source library for parsing Java source code into an AST, and walks through practical cases covering dependency setup, basic parsing, class and method extraction, code modification, class generation, and comprehensive analysis with code snippets and output screenshots.
This article examines how Kuaishou’s internal Mulan universal code analysis service tackled pipeline quality challenges by introducing on‑demand triggering, incremental checking, and unified rule infrastructure, resulting in dramatically faster static checks, lower rule‑development costs, comprehensive monitoring, and a rapid increase in rule coverage.
This article explains how to detect missing or unused Python packages, install the tach tool, configure it to analyze a project’s source root, and use its built‑in commands to list and verify external dependencies against the declared requirements, ensuring a clean and reproducible environment.
The latest GitStats release adds JSON report generation, extensive code refactoring with argparse replacing getopt, and full testing on Linux, Windows, and macOS, while outlining upcoming dark‑mode theming and a goal of 100% unit‑test coverage.
The Precise Testing Platform combines a recommendation engine—featuring a link analyzer, diff analyzer, and knowledge base—to automatically construct detailed method‑call graphs from source code, extract HTTP and Dubbo APIs, handle reflections and inheritance, and store billions of nodes in Nebula Graph, thereby eliminating blind, missed, and redundant tests while boosting coverage and reducing testing costs.
This article introduces Python's Abstract Syntax Tree (AST), explains its purpose for code analysis and transformation, and provides ten detailed examples that demonstrate building, inspecting, modifying, and generating code using the ast module in a standard Python environment.
This article describes how to construct a code‑analysis platform for Java micro‑services that builds a knowledge base through static, semi‑dynamic and dynamic analysis, enabling precise test‑case selection and safe removal of dead code to improve iteration efficiency and system maintainability.
A precise testing platform built on AST analysis and a recommendation engine was deployed across four core applications, enabling automated test execution with 100% pass rates, at least 75% service coverage, around 80% precision, early defect interception, and up to one hour per‑iteration time savings while planning further expansion and precision improvements.
This article explains the internal workings of HashMap traversal in Java, showing why using keySet() results in two passes—first converting to an iterator and then fetching values—and details the underlying iterator, KeyIterator, and HashIterator implementations with code examples.
This article explores the fundamentals of code understanding, including static, dynamic, and non‑code analysis, presents a three‑layer architecture for scalable code comprehension, and demonstrates practical AI‑enhanced applications such as intelligent unit testing, dead‑code detection, and AI‑based static analysis within CI/CD pipelines.
This article explains PHP's reflection capabilities, detailing how developers can inspect classes, interfaces, methods, and properties at runtime, and demonstrates practical uses such as dynamic object creation, method invocation, property manipulation, and annotation parsing with code examples.
Baidu’s white‑box code understanding platform combines static, dynamic, non‑code and LLM‑based analyses in a three‑layer architecture that accelerates C/C++ processing ninefold, supports multiple languages, and powers applications such as intelligent unit testing, orphan‑function cleanup and AI‑driven risk detection, while future integration with models like GPT‑4 aims to enable multi‑turn code Q&A, automated refactoring and predictive testing.
To accurately trim iOS app binaries, the article discards low‑precision Mach‑O/LinkMap methods and instead builds a custom compilation pipeline using libtooling and the Swift compiler to analyze full abstract syntax trees, enabling reliable detection of unused methods across complex language features and inheritance hierarchies.
This article explains how to convert TypeScript source code into an AST, traverse it to collect import statements, distinguish various import forms, and use the TypeScript compiler API to locate identifier symbols, enabling accurate counting of API calls and line numbers for a given dependency.
The article explains how Baidu App reduces its iOS package size by analyzing Link Map files and applying six code‑optimization techniques—unused class and module slimming, unused method pruning with LLVM, duplicate‑code detection, utility‑method consolidation, and A/B‑test hardening—yielding up to 8 MB of savings.
This article presents a comprehensive approach to building an Android code impact analysis tool that leverages Git diff to locate modified lines, employs ASM-based class and method visitors to construct upward and downward call chains, extracts Javadoc and custom tags, and visualizes the results for developers and testers.