competitive teardown

Traditional reverse engineering (RE) research relies on manual data collection and subjective analysis, suffering from low efficiency, poor scalability, and insufficient objectivity. To address these limitations, this paper proposes reAnalyst—a tool-agnostic, multimodal RE behavior acquisition and semi-automatic annotation framework. reAnalyst synchronously captures heterogeneous data—including screen screenshots, keyboard inputs, and process information—and leverages computer vision–driven activity recognition, heuristic behavioral modeling, and semi-supervised learning to accurately identify and semantically annotate RE operations. Experimental results demonstrate high recognition accuracy across diverse and complex screenshots. Empirical evaluation confirms the framework’s effectiveness and practical utility, with broad endorsement from professional reverse engineers. This work significantly advances the automation, reproducibility, and large-scale analytical capability of RE research.

This work addresses the lack of dedicated datasets and systematic evaluation methodologies for automatically generating software architectures from requirements documents. It introduces R2ABench, a benchmark that comprises a novel dataset of real-world requirements documents paired with expert-annotated PlantUML architecture diagrams, along with a hybrid evaluation framework integrating structural diagram metrics, multidimensional human assessments, and architectural anti-pattern detection. Experimental results demonstrate that while large language models can generate syntactically valid architectures containing key entities, they exhibit significant limitations in relational reasoning. Code-specialized models show modest improvements, whereas agent-based workflows do not consistently enhance performance. This study establishes a standardized benchmark and a multifaceted evaluation suite for the requirements-to-architecture generation task.

Existing benchmarking methodologies rely on static datasets and struggle to support architectural trade-off analysis and evolutionary assessment of heterogeneous information systems in multi-model environments. This work proposes the TransforMMer framework, which reconceptualizes benchmark engineering as a systematic design tool by introducing a unified representation model that explicitly captures schema semantics and cross-model mappings. From a single source dataset, TransforMMer automatically generates semantically consistent yet structurally diverse variants across relational, document, and graph database models. The framework supports structural redesign operations—including embedding, augmentation, and hybrid partitioning—to enable reproducible cross-representation transformations. Experimental results demonstrate that query performance disparities primarily stem from interactions between workload characteristics and data representations, thereby validating the framework’s efficacy in guiding the evolution of heterogeneous systems.

This work addresses the limited reusability and evolvability of existing software product line (SPL) engineering approaches, which are typically tied to specific technology stacks and integrated development environments (IDEs). To overcome this constraint, the authors propose a workspace-agnostic protocol that incrementally extracts feature models from lightweight dependency units called “atoms.” The approach introduces a configuration and generation architecture comprising a generic SPL server and pluggable clients—each combining a universal frontend with a specialized backend. This design decouples SPL engineering from underlying technical spaces, enabling flexible, cross-language and cross-IDE component substitution. A prototype implementation, with a Go/Prolog-based server, a Java backend, and a JavaScript frontend, was validated on Neverlang language artifacts, demonstrating the protocol’s generality, reusability, and independence from specific development workspaces.

Inconsistent definitions of “feature” across software engineering domains—particularly requirements engineering (RE) and software product lines (SPL)—impede communication, trigger rework, and reduce cross-team collaboration efficiency. Method: We conducted an empirical study across 27 mainstream open-source projects, integrating repository mining, branch behavior analysis, qualitative coding, and pattern induction to derive a data-driven, cross-disciplinary definition of feature. Contribution/Results: This work introduces the first empirically grounded, unified feature definition framework bridging RE and SPL. It identifies recurring collaboration patterns and critical bottlenecks in feature description, implementation, and management, and proposes a roadmap linking academic theory with industrial practice. The findings yield actionable guidelines for project planning, resource allocation, and inter-team coordination, advancing feature conceptual standardization and engineering practice optimization.

This study addresses the persistent challenges of version control in modern computer-aided design (CAD), where data complexity and strong interdependencies hinder effective implementation, thereby limiting design traceability, variant management, and team collaboration. Through qualitative content analysis, the authors systematically coded and synthesized insights from 170 online forum posts, revealing recurring sociotechnical challenges that CAD users face in version management, continuity, scoping, and distribution. The work introduces “infrastructural reflexivity” as a novel design principle for CAD tools, emphasizing support for coordinated work and cross-boundary collaboration. This concept offers actionable guidance for software developers and opens new research avenues for reimagining version control systems in complex design environments.

Software architecture documentation (SAD) is frequently missing, outdated, or inconsistent with implementation, leading to high comprehension costs and maintenance challenges. To address this, we propose a semi-automated approach integrating reverse engineering with large language models (LLMs). Our method first extracts component structure via static analysis, then leverages prompt engineering and few-shot learning to guide LLMs in generating architectural artifacts—specifically, static views (component diagrams) and dynamic views (state machine diagrams). Crucially, it requires minimal expert annotation, substantially reducing manual effort while enabling scalable, abstraction-aware documentation. Evaluated on an industrial C++ system, our approach accurately reconstructs complex component structures and behavioral logic. Results demonstrate significant improvements in both the accuracy of generated architecture documentation and the efficiency of its maintenance, thereby enhancing system comprehensibility and long-term maintainability.

This study addresses the lack of effective validation methods for semi-formal blueprints in early-stage software product line engineering, which often leads to undetected structural and constraint-related errors in feature models. For the first time, it systematically evaluates the capability of large language models (LLMs) in feature model analysis tasks by leveraging twelve state-of-the-art LLMs and sixteen standard analytical operations that integrate structural parsing with constraint reasoning. Performance is benchmarked against the solver-based tool FLAMA. Results demonstrate that reasoning-optimized models—such as Grok 4 Fast Reasoning and Gemini 2.5 Pro—achieve average accuracies of 88–89%, approaching the performance of formal solvers. These findings substantiate the feasibility and practical potential of LLMs as lightweight, early-stage validation tools for feature model verification.

This work addresses the challenge of high evolutionary risk in legacy systems, where implicit business rules and architectural decisions are difficult for AI agents to reliably interpret. To mitigate this, the authors propose a multi-agent pipeline that transforms legacy code into traceable, unit-level specifications through structural mapping, modular analysis, implicit rule extraction, and architectural synthesis. The approach innovatively incorporates code-to-specification traceability, explicit confidence annotations, and knowledge gap identification to ensure the safety of AI-driven evolution. Implemented as a Node.js CLI tool integrated with a multi-agent engine, the system tracks changes via SHA-256 hashes and outputs Gherkin scenarios alongside structured declarative specifications. Evaluated on a COBOL-to-Go ATM migration case study, it generated 517 confidence-annotated statements, 53 Gherkin scenarios, identified 10 knowledge gaps, and successfully completed 9 out of 11 targeted refactorings.

This work addresses the heavy reliance on manual effort in software requirements engineering and the lack of efficient, cross-domain automated approaches for requirements extraction. The authors propose a multi-large language model (LLM) ensemble system based on the PEGS framework, which orchestrates models such as GPT, Claude, and Groq through a structured prompting mechanism. By integrating consensus-based decision-making and a fault-tolerant architecture, the system automatically extracts and classifies both functional and non-functional requirements from diverse document types. Evaluated on 18 real-world documents, the approach achieves an F1 score of 0.88—representing a 24% improvement over generic prompting—and demonstrates a 78% gain in analysis efficiency across 1,050 requirement instances, significantly outperforming manual methods in accuracy. The solution proves effective across academic, industrial, and tendering contexts.