programming fundamentals

To address the challenges of simultaneously generating semantically consistent yet stylistically diverse multi-artifact programming exercises—namely source code, test specifications, and natural language descriptions—this paper proposes a compositional generation framework grounded in abstract syntax building blocks. The framework defines reusable syntactic abstractions and integrates templated mapping with multi-objective instantiation to ensure intent preservation and cross-modal co-generation. Its key innovations include: (i) enabling style-controllable, diverse outputs while guaranteeing semantic consistency; and (ii) providing a highly configurable generation interface that substantially reduces customization effort for new tasks. Experimental evaluation demonstrates that the approach outperforms existing baselines across three critical dimensions: generation quality, output diversity, and system extensibility.

Novice programmers commonly rely on syntax-oriented, test-driven trial-and-error programming, exhibiting weak systematic reasoning abilities; AI-assisted coding tools exacerbate this issue by frequently generating syntactically correct yet semantically flawed code. To address this, we propose BOOP—the first pedagogical framework enforcing a rigorous four-stage structured programming process: formal specification → language-agnostic algorithm design → implementation → correctness proof. Implemented as a VS Code extension with an OCaml preprocessor, BOOP integrates specification verification and anti-pattern detection. Empirical evaluation demonstrates that BOOP significantly enhances beginners’ algorithmic thinking, boundary-case analysis, and problem decomposition skills. Preliminary results indicate superior performance over conventional instruction in both depth of algorithmic reasoning and foundational competency development. Educator feedback confirms its pedagogical efficacy and usability.

Current AI programming evaluations predominantly emphasize behavioral correctness while neglecting code maintainability—particularly aspects such as modularity and testability. This work proposes the NITR framework, which for the first time translates software engineering best practices into quantifiable, diagnosable structural probes. By embedding these probes into small multi-file codebases and combining functional tests with structural oracles, the study systematically evaluates the maintainability performance of leading large language models (GPT, Claude, Gemini, Qwen) and their agent-based variants. Experiments reveal that across 23 configurations, models solve only 36.2% of cases on average (57.1% at best), with 13.3% of functionally correct solutions failing structurally. Although agent modes improve performance to 45.0%, they still struggle with architectural-level flaws, exposing a fundamental limitation in current AI coding systems regarding structural design.

This study addresses the lack of systematic empirical evidence on how Rust design patterns influence code quality and compile-time invariant guarantees. For the first time in Rust backend systems, we construct an evaluation framework grounded in the SQuaRE quality model by applying the typestate and newtype patterns—combined with the “Parse, don’t validate” principle—across three representative components. Our assessment integrates benchmarking, static analysis, and expert interviews. Results demonstrate that typestate significantly enhances fault tolerance and testability, albeit potentially at the cost of readability, while newtype effectively eliminates invalid runtime states with negligible overhead, substantially improving overall software quality. This work provides the first empirical foundation for the engineering application of Rust design patterns.

Existing benchmarks predominantly evaluate end-to-end tasks like code generation, lacking fine-grained assessment of large language models’ (LLMs) semantic reasoning capabilities for program analysis. Method: We introduce CoRe, the first benchmark targeting foundational static analysis competencies—covering data dependencies, control dependencies, and information flow in C/C++, Java, and Python. It comprises 12,553 human-verified tasks. Our novel semantic-aware diversity sampling strategy selects targets based on structural coverage and dependency depth, enhancing both semantic diversity and reasoning complexity. Contribution/Results: Evaluating 10 mainstream LLMs reveals competent performance on basic dependency identification but sharp degradation on multi-step reasoning, reverse dependencies, and complex control structures—exposing critical bottlenecks in current LLMs’ code understanding. CoRe thus provides a rigorous, semantics-oriented evaluation framework to advance program reasoning research.

This work addresses the inherent limitations of individual program analysis techniques—particularly their constrained precision, coverage, and insight—which hinder comprehensive software reliability assurance. Through a systematic mapping study of 248 relevant publications, the paper presents the first taxonomy of combined program analysis approaches explicitly centered on synergistic effects and interaction patterns. The proposed multidimensional classification framework is structured around three core dimensions: collaboration objectives, workflow architectures, and types of mapping functions. This framework systematically uncovers commonalities and distinctions in the design of existing methods, offering a clear conceptual foundation for understanding, comparing, and developing novel combined analysis techniques. Furthermore, it delineates current research trends and identifies promising directions for future investigation.

This work proposes a novel software construction paradigm that fundamentally departs from the core assumptions of object-oriented programming. By decoupling problem-domain entities from functional modules, the approach enables independent organization and reuse of functionality, thereby addressing the fragmentation of features and entanglement of responsibilities commonly induced by binding system behavior to individual domain objects. The proposed paradigm adopts a non-object-oriented modular design that substantially mitigates architectural coupling stemming from rigid object boundaries. As a result, it offers a clearer, more flexible, and maintainable pathway for modeling complex systems, overcoming key limitations inherent in traditional object-oriented approaches.

This study addresses the persistent occurrence of software defects after release, particularly in C/C++ and Java systems, whose underlying causes remain poorly understood. Through a large-scale empirical analysis of over 14,000 open-source projects, the work systematically compares pre-release and post-release defect characteristics using multidimensional metrics—including code complexity, size, change frequency, and development history—and employs statistical modeling to uncover key patterns. It reveals for the first time that post-release defects are significantly concentrated in legacy modules that undergo frequent modifications, with their root causes primarily stemming from dynamic evolutionary pressures rather than static code structure. Furthermore, such defects exhibit longer repair cycles and higher complexity, offering empirical grounding for targeted testing strategies and improved reliability assurance.

This study investigates whether code generated by AI coding agents is more difficult to maintain than human-written code, with a particular focus on compounding challenges that arise when agents develop upon code previously generated by themselves or others. To address this, we introduce the CodeThread framework and conduct controlled experiments with four state-of-the-art coding agents across four repository-scale benchmarks, systematically evaluating their task-completion performance through regression analysis and behavioral code comparison. Our work reveals, for the first time, that agents experience up to a 13.1% drop in task success rate when building upon their own prior outputs—a significant degradation in downstream development efficiency. This phenomenon cannot be explained by conventional maintainability metrics but stems instead from subtle behavioral discrepancies in aspects such as input validation and error handling, underscoring the critical role of code behavior characteristics in software maintainability.

本文解决了细粒度代码重构自动化问题，通过形式化五种Move Statement重构方法，并结合现有技术实现更细粒度的表达式移动。