As a critical and challenging research area within multi-agent systems (MAS), distributed multi-agent task allocation (D-MATA) has motivated extensive study and application across diverse domains. Although several systematic reviews exist on multi-agent task allocation (MATA), none provide an in-depth, systematic analysis of the core dimensions of D-MATA, namely applications, problems, methods, and metrics, nor explore their interrelationships. Moreover, no comprehensive repository capturing such foundational knowledge is currently available. These gaps collectively hinder the effective learning, adoption, and further development of D-MATA knowledge. To fill this gap, we conduct a systematic literature review (SLR) of 107 D-MATA studies, examining them from the perspectives of these core dimensions and discussing the potential interrelationships among these dimensions. To better support comprehensive evaluation and cross-study comparison of D-MATA methods, we propose a multi-dimensional evaluation framework based on the metrics used in the selected literature. Additionally, we provide an open knowledge repository comprising 107 problem-method-evaluation entries derived from the selected literature, supporting reproducible in-depth research. This work delivers clear guidance for both researchers and practitioners while building a systematic knowledge foundation for future investigations in the field.

Bounty programs have become a pivotal incentive mechanism in open-source software (OSS) communities, attracting contributors by offering monetary rewards for task completion. Despite their long-standing implementation, the optimal utilization of this mechanism from the perspective of backers (individuals or entities funding bounties) remains insufficiently understood, hindering its refinement and broader adoption. To bridge this gap, we conduct a mixed-methods study analyzing 10,561 bounty issues fromGitcoin, their linkedGitHubdevelopment data, and surveys from 46 bounty backers. We investigate three core decision-making dimensions: (1) why backers use bounties and the actual outcomes, (2) what issues backers prioritize, and (3) how bounty amounts are set. Our findings reveal that backers primarily seek to enhance developer engagement, project visibility, and task efficiency. However, the actual outcomes often diverge from expectations: although bounty issues have a higher resolution rate (+12%) than non-bounty issues, they also introduce systemic challenges, such as delayed resolutions (+33 days) and difficulties in engaging new developers. Notably, backers tend to prioritize feature-related, intermediate-complexity tasks with short completion timelines, while showing relatively less interest in overly simplistic or highly specialized work. Reward allocation follows a nuanced approach: lower bounties target beginner-friendly tasks, while higher rewards are reserved for advanced skills or multi-week commitments. However, backers often lack systematic methods to calibrate rewards, leading to frequent bounty adjustments. To enable data-driven decision-making, we propose a bounty recommendation predictor that uses empirical factors to predict appropriate bounty amount. By synthesizing these insights, our study offers OSS communities actionable strategies to refine bounty programs, balancing short-term productivity with long-term ecosystem sustainability.

Large language models (LLMs) have demonstrated impressive performance in code generation, particularly when augmented with chain-of-thought (CoT) prompting techniques. They break down requirements into intermediate reasoning steps, which act as design rationales to guide LLMs in writing code like human programmers. Thus, the quality of these steps is crucial for ensuring the correctness and reliability of the generated code. However, the specific factors influencing the quality of CoT generated by LLMs remain largely unexplored. To what extent can we trust the thoughts generated by LLMs? How good are they? This paper empirically explores the external and internal factors of why LLMs generate unsatisfactory CoTs by analyzing 1,023 failed code samples on two widely used code generation benchmarks. We also evaluate their impact on code generation performance by analyzing 210 CoT-code pairs and refining the unsatisfied CoTs by prompting LLMs. Our study yields the following findings: 1) Among the factors affecting CoT quality, external factors account for 53.60%, primarily including unclear requirements and lack of contextual information. Internal factors make up 40.10%, mainly due to inconsistencies between CoT and prompts caused by LLMs’ misunderstanding of the instructions. 2) Despite CoT being correct, 18.5% of the generated code still contains errors. This is primarily due to LLMs failing to follow instructions, leading to inconsistencies between CoT and the code. Additionally, we found that even when the code is correct, there is an 11.90% chance that the CoT contains errors. 3) Our further research on refining the low-quality CoTs reveals that LLMs can improve CoT, especially when providing detailed CoT problem information. Our findings shed light on the underlying issues that hinder the effectiveness of CoT in LLM-based code generation, offering valuable insights for enhancing both the reasoning process and the overall reliability of code generation.

While Large Language Models (LLMs) have significantly advanced code generation efficiency, they face inherent challenges in balancing performance and inference costs across diverse programming tasks.Dynamically selecting the optimal LLM based on task difficulty and resource constraints offers a promising approach to achieve an optimal balance between efficiency and performance.However, existing model selection methods are resource-intensive and often neglect cost efficiency.Moreover, these approaches rely on human-annotated difficulty labels that are frequently inaccessible in real-world settings and may not align with the LLM's own assessment of task difficulty.In this paper, we introduce Adaptiv-eLLM, a framework that dynamically selects optimal LLMs for a given coding task by automatically assessing task difficulty.Our framework first estimates task difficulty using Chain-of-Thought lengths generated by reasoning model, clusters these into three difficulty levels via k-means, and fine-tunes CodeBERT to embed difficulty-aware features.A trained XGBoost classifier then selects the best model for each problem, optimizing the performance-cost trade-off.Experimental results show that AdaptiveLLM achieves a 7.86% improvement in pass@1 score while reducing resource consumption by 88.9% compared to baseline method ComplexityNet.When compared to a single model, AdaptiveLLM demonstrates an approximately 15% accuracy improvement, while maintaining the same level of cost consumption.Apart from that, the difficulty assessment using CoT provides more reliable selection criteria than human evaluation.Our replication package is available at https://github.com/cjhCoder7/AdaptiveLLM.

Providing timely and personalized guidance for students’ programming assignments, particularly by indicating fine-grained error locations with explanations, offers significant practical value for helping students complete assignments and enhance their learning outcomes. In recent years, various automated Fault Localization (FL) techniques, particularly those leveraging Large Language Models (LLMs), have demonstrated promising results in identifying errors in programs. However, existing fault localization techniques face challenges when applied to educational contexts. Most approaches operate at the method level without explanatory feedback, resulting in granularity too coarse for students who need actionable insights to identify and fix their errors. While some approaches attempt line-level fault localization, they often depend on predicting line numbers directly in numerical form, which is ill-suited to LLMs. To address these challenges, we propose FLAME, a fine-grained, explainable Fault Localization method tailored for programming assignments via LLM-guided Annotation and Model Ensemble. FLAME leverages rich contextual information specific to programming assignments to guide LLMs in identifying faulty code lines. Instead of directly predicting line numbers, we prompt the LLM to annotate faulty code lines with detailed explanations, enhancing both localization accuracy and educational value. To further improve reliability, we introduce a weighted multi-model voting strategy that aggregates results from multiple LLMs to determine the suspiciousness of each code line. Extensive experimental results demonstrate that FLAME outperforms state-of-the-art fault localization baselines on programming assignments, successfully localizing 207 more faults at top-1 over the best-performing baseline. Beyond educational contexts, FLAME also generalizes effectively to general-purpose software codebases, outperforming all baselines on the Defects4J benchmark.

Large Language Models (LLMs) have demonstrated remarkable capabilities in code editing, substantially enhancing software development productivity. However, the inherent complexity of code editing tasks forces existing approaches to rely on LLMs’ autoregressive end-to-end generation, where decoding speed plays a critical role in efficiency. While inference acceleration techniques like speculative decoding are applied to improve the decoding efficiency, these methods fail to account for the unique characteristics of code editing tasks, where changes are typically localized and existing code segments are reused. To address this limitation, we propose EfficientEdit, a novel method that improves LLM-based code editing efficiency through two key mechanisms based on speculative decoding: (1) effective reuse of original code segments while identifying potential edit locations, and (2) efficient generation of edit content via high-quality drafts from edit-oriented draft models and a dynamic verification mechanism that balances quality and acceleration. Experimental results show that EfficientEdit can achieve up to 10.38× and 13.09× speedup compared to standard autoregressive decoding in CanItEdit and CodeIF-Bench, respectively, outperforming state-of-the-art inference acceleration approaches by up to 90.6%. The code and data are available at https://github.com/zhu-zhu-ding/EfficientEdit.

Among the programming languages for Programmable Logic Controllers (PLCs), Structured Text (ST) is widely adopted for industrial automation due to its expressiveness and flexibility. However, major vendors implement ST with proprietary extensions and hardware-specific libraries - Siemens’ SCL and CODESYS’ ST each differ in syntax and functionality. This fragmentation forces engineers to relearn implementation details across platforms, creating substantial productivity barriers. To address this challenge, we developed AutoPLC, a framework capable of automatically generating vendor-aware ST code directly from natural language requirements. Our solution begins by building two essential knowledge sources tailored to each vendor’s specifications: a structured API library containing platform-exclusive functions, and an annotated case database that captures real-world implementation experience. Building on these foundations, we created a four-stage generation process that combines step-wise planning (enhanced with a lightweight natural language state machine support for control logic), contextual case retrieval using LLM-based reranking, API recommendation guided by industrial data, and dynamic validation through direct interaction with vendor IDEs. Implemented for Siemens TIA Portal and the CODESYS platform, AutoPLC achieves 90%+ compilation success on our 914-task benchmark (covering general-purpose and process control functions), outperforming all selected baselines, at an average cost of only $0.13 per task. Experienced PLC engineers positively assessed the practical utility of the generated code, including cases that failed compilation.

Code generation is a latency-sensitive task that demands high timeliness. However, with the growing interest and inherent difficulty in repository-level code generation, most existing code generation studies focus on improving the correctness of generated code while overlooking the inference efficiency, which is substantially affected by the overhead during LLM generation. Although there has been work on accelerating LLM inference, these approaches are not tailored to the specific characteristics of code generation; instead, they treat code the same as natural language sequences and ignore its unique syntax and semantic characteristics, which are also crucial for improving efficiency. Consequently, these approaches exhibit limited effectiveness in code generation tasks, particularly for repository-level scenarios with considerable complexity and difficulty. To alleviate this issue, following draft-verification paradigm, we propose FastCoder, a simple yet highly efficient inference acceleration approach specifically designed for code generation, without compromising the quality of the output. FastCoder constructs a multi-source datastore, providing access to both general and project-specific knowledge, facilitating the retrieval of high-quality draft sequences. Moreover, FastCoder reduces the retrieval cost by controlling retrieval timing, and enhances efficiency through parallel retrieval and a context- and LLM preference-aware cache. Experimental results show that FastCoder can reach up to 2.53× and 2.54× speedup compared to autoregressive decoding in repository-level and standalone code generation tasks, respectively, outperforming state-of-the-art inference acceleration approaches by up to 88%. FastCoder can also be integrated with existing correctness-focused code generation approaches to accelerate the LLM generation process, and reach a speedup exceeding 2.6×.

Abstract Researchers have recently achieved significant advances in deep learning techniques, which in turn has substantially advanced other research disciplines, such as natural language processing, image processing, speech recognition, and software engineering. Various deep learning techniques have been successfully employed to facilitate software engineering tasks, including code generation, software refactoring, and fault localization. Many studies have also been presented in top conferences and journals, demonstrating the applications of deep learning techniques in resolving various software engineering tasks. However, although several surveys have provided overall pictures of the application of deep learning techniques in software engineering, they focus more on learning techniques, that is, what kind of deep learning techniques are employed and how deep models are trained or fine-tuned for software engineering tasks. We still lack surveys explaining the advances of subareas in software engineering driven by deep learning techniques, as well as challenges and opportunities in each subarea. To this end, in this study, we present the first task-oriented survey on deep learning-based software engineering. It covers twelve major software engineering subareas significantly impacted by deep learning techniques. Such subareas spread out through the whole lifecycle of software development and maintenance, including requirements engineering, software development, testing, maintenance, and developer collaboration. As we believe that deep learning may provide an opportunity to revolutionize the whole discipline of software engineering, providing one survey covering as many subareas as possible in software engineering can help future research push forward the frontier of deep learning-based software engineering more systematically. For each of the selected subareas, we highlight the major advances achieved by applying deep learning techniques with pointers to the available datasets in such a subarea. We also discuss the challenges and opportunities concerning each of the surveyed software engineering subareas.

ABSTRACT Enterprise Information System (EIS) streamlines business processes and enhances productivity by integrating various functions. However, conventional development methods are labor‐intensive, time‐consuming, and error‐prone, often necessitating a design model from requirements for implementation. Existing solutions focus on auto‐generating code from Object‐Oriented (OO) design models, but specifying the design model from a validated requirements model requires more effort due to information gaps between requirements and design. This paper introduces RM2EIS, an approach that automatically generates EIS from contract‐based requirements models, which include use case diagrams, conceptual class diagrams, and use case definitions specified by system sequence diagrams and contracts. System operation contracts are formally specified using pre‐ and post‐conditions written in OCL. We conducted nine case studies to evaluate RM2EIS. The results indicate that the time of the generation including modeling and validation by RM2EIS is at least twice as fast as the design and implementation of developers. Moreover, the generated EIS outperforms the developer‐implemented systems in functionality and is close to the non‐functional aspects like performance.

Scientific Computing Programming Languages (SCPLs), like MATLAB and R, are popular and widely used for computational mathematics. In recent years, pre-trained code language models (CLMs) have automated many code-related tasks, covering various general programming languages. SCPLs share many similarities with general programming languages, including similar syntactic structures and the semantics of identifiers. Despite the similarities, there exist many differences between them. For example, lots of numerical operations and dedicated libraries exist in SCPLs. However, there has been little comprehensive work analyzing CLMs’ capabilities in the understanding and generation of pragmatic scientific computing programs. To this end, we investigate the applicability of code language models for the SCPL analysis, especially focus on real-world code in open-source repositories. We first create a benchmark that contains programs and documentation from three widely used scientific computing programming languages, then perform an adequate evaluation of existing advanced code language models on both code understanding and generation tasks using the new benchmark, and study the relations of different training strategies, model types, and model sizes to the performance of different tasks and languages. Evaluation results confirm that, compared to general programming languages, SCPLs are more challenging to understand, and especially to generate, but the use of code language models is nevertheless feasible, and the knowledge obtained from the general languages can be transferred to SCPL analysis. A deeper analysis reveals additional challenges in generating code that incorporates API calls relevant to computational mathematics. We believe that our findings can provide guidance on improving tooling and analyses for the scientific programming language, and also inspire and motivate researchers to improve the robustness of existing code language models.

Enterprise information systems(EIS) focus on dealing with the complex business logic of collecting, filtering, processing, and distributing data for improving productivity and service in our daily life. The successful development of enterprise information system is the labor-intensive activities in software engineering, it requires the sophisticated human efforts for requirements validation, system design, implementation and verification. Our previous work RM2PT can help to achieve a validated requirements model through automatically generating prototypes from requirements models to support incremental and rapid requirements validation. In this paper, we present a tool named RM2EIS to further alleviate the problem of system development by supporting automatically generate the back-end source code of enterprise information system from the validated requirements model, which are achieved by several round requirements validation in RM2PT. We demonstrate that RM2EIS can achieve higher quality code (+8.27%) with less time cost (-61.92%) than the manual development through 9 case studies. Overall, the results were satisfactory. The proposed approach can be further extended and applied for the EIS development in the software industry. The tool can be downloaded at https://rm2pt.com/advs/rm2eis and a demo video casting its features is available at https://www.youtube.com/watch?v=5Nde-JYezg4.

Providing personalized and timely feedback for student's programming assignments is useful for programming education. Automated program repair (APR) techniques have been used to fix the bugs in programming assignments, where the Large Language Models (LLMs) based approaches have shown promising results. Given the growing complexity of identifying and fixing bugs in advanced programming assignments, current fine-tuning strategies for APR are inadequate in guiding the LLM to identify bugs and make accurate edits during the generative repair process. Furthermore, the autoregressive decoding approach employed by the LLM could potentially impede the efficiency of the repair, thereby hindering the ability to provide timely feedback. To tackle these challenges, we propose FastFixer, an efficient and effective approach for programming assignment repair. To assist the LLM in accurately identifying and repairing bugs, we first propose a novel repair-oriented fine-tuning strategy, aiming to enhance the LLM's attention towards learning how to generate the necessary patch and its associated context. Furthermore, to speed up the patch generation, we propose an inference acceleration approach that is specifically tailored for the program repair task. The evaluation results demonstrate that FastFixer obtains an overall improvement of 20.46% in assignment fixing when compared to the state-of-the-art baseline. Considering the repair efficiency, FastFixer achieves a remarkable inference speedup of 16.67× compared to the autoregressive decoding algorithm.

Detecting and refactoring code smells is challenging, laborious, and sustaining. Although large language models have demonstrated potential in identifying various types of code smells, they also have limitations such as input-output token restrictions, difficulty in accessing repository-level knowledge, and performing dynamic source code analysis. Existing learning-based methods or commercial expert toolsets have advantages in handling complex smells. They can analyze project structures and contextual information in-depth, access global code repositories, and utilize advanced code analysis techniques. However, these toolsets are often designed for specific types and patterns of code smells and can only address fixed smells, lacking flexibility and scalability. To resolve that problem, we propose iSMELL, an ensemble approach that employs various code smell detection toolsets via Mixture of Experts (MoE) architecture for comprehensive code smell detection, and enhances the LLMs with the detection results from expert toolsets for refactoring those identified code smells. First, we train a MoE model that, based on input code vectors, outputs the most suitable expert tool for identifying each type of smell. Then, we select the recommended toolsets for code smell detection and obtain their results. Finally, we equip the prompts with the detection results from the expert toolsets, thereby enhancing the refactoring capability of LLMs for code with existing smells, enabling them to provide different solutions based on the type of smell. We evaluate our approach on detecting and refactoring three classical and complex code smells, i.e., Refused Bequest, God Class, and Feature Envy. The results show that, by adopting seven expert code smell toolsets, iSMELL achieved an average F1 score of 75.17% on code smell detection, outperforming LLMs baselines by an increase of 35.05% in F1 score. We further evaluate the code refactored by the enhanced LLM. The quantitative and human evaluation results show that iSMELL could improve code quality metrics and conduct satisfactory refactoring toward the identified code smells. We believe that our proposed solution could provide new insights into better leveraging LLMs and existing approaches to resolving complex software tasks.

Software architectures are usually meticulously designed to address multiple quality concerns and support long-term maintenance. However, there may be a lack of motivation for developers to document design rationales (i.e., the design alternatives and the underlying arguments for making or rejecting decisions) when they will not gain immediate benefit, resulting in a lack of standard capture of these rationales. With the turnover of developers, the architecture inevitably becomes eroded. This issue has motivated a number of studies to extract design knowledge from open-source communities in recent years. Unfortunately, none of the existing research has successfully extracted solutions alone with their corresponding arguments due to challenges such as the intricate semantics of online discussions and the lack of benchmarks for design rationale extraction.

Automatic Program Repair (APR) endeavors to autonomously rectify issues within specific projects, which generally encompasses three categories of tasks: bug resolution, new feature development, and feature enhancement. Despite extensive research proposing various methodologies, their efficacy in addressing real issues remains unsatisfactory. It's worth noting that, typically, engineers have design rationales (DR) on solution--- planed solutions and a set of underlying reasons---before they start patching code. In open-source projects, these DRs are frequently captured in issue logs through project management tools like Jira. This raises a compelling question: How can we leverage DR scattered across the issue logs to efficiently enhance APR?

Software requirements are the driving force behind software development. As the cornerstone of the entire software lifecycle, the efficiency of crafting requirement specifications and the quality of these requirements significantly influence the duration of software development. Despite massive research on requirements elicitation, the reality is that requirements are often painstakingly crafted manually, word by word. This manual process is not only time-consuming but also prone to issues such as the misuse of terminology. To address these challenges, we introduce ReqCompletion, an approach designed to recommend the next token in real-time for given prefix of requirements description. ReqCompletion comprises two primary components. First, we have devised and integrated a knowledge-injection module into GPT-2—which stands as the largest available GPT model that allows for fine-tuning on specialized downstream tasks. This injection imbues GPT-2 with richer domain-specific knowledge, thus improving the relevance of the suggested tokens. Additionally, we employ a pointer network to optimize the recommendation quality by utilizing completed requirements as contextual support. Empirical evaluations using two public datasets demonstrate that ReqCompletion surpasses all baselines in performance (Recall@7 gains up to 65.87% than the second-best model). Furthermore, the effectiveness of its two pivotal design elements has been substantiated through rigorous ablation studies. The utility of our work has been evaluated preliminarily through a small user study.

The challenges associated with using pre-trained models (PTMs) have not been specifically investigated, which hampers their effective utilization. To address this knowledge gap, we collected and analyzed a dataset of 5,896 PTM-related questions on Stack Overflow. We first analyze the popularity and difficulty trends of PTM-related questions. We find that PTM - related questions are becoming more and more popular over time. However, it is noteworthy that PTM-related questions not only have a lower response rate but also exhibit a longer response time compared to many well-researched topics in software engineering. This observation emphasizes the significant difficulty and complexity associated with the practical application of PTMs. To delve into the specific challenges, we manually annotate 430 PTM - related questions, categorizing them into a hierarchical taxonomy of 42 codes (i.e., leaf nodes) and three categories. This taxonomy encompasses many PTM prominent challenges such as fine-tuning, output understanding, and prompt customization, which reflects the gaps between current techniques and practical needs. We discuss the implications of our study for PTM practitioners, vendors, and educators, and suggest possible directions and solutions for future research.

Abstract Context The UML class diagram is commonly used to model functional structures and software code structures in both the preliminary and detailed design stages. And the abstraction level of UML class diagrams is usually higher than that of source code. Usually, there is a lack of trace links between these class diagrams and the source code, which may cause difficulties in understanding the source code, and affect the software evolution and maintenance. Objective The main goal of this article is to establish the trace links between highly abstracted UML class diagrams in the design phase and source code, and eventually help practitioners better understand source code. Method We propose an approach for the automated trace link establishment between UML class diagrams in the design phase and source code. To address the problem of abstraction level gap between them, we extend the UML class diagram by mining the synonymous phrases of class names and deducing the latent missing relationships between classes from multiple design documents. Then we build the trace links with a two‐phase approach including initial construction with fuzzy matching and further optimization by class relationship inference. Results Experiments on five open‐source projects show that the recalls of our approach are over 94%, and the F2‐scores are over 88%, with the gains of 30% to 60% than the four baselines. Conclusion Our work can be a reference for establishing the initial trace links between highly‐abstracted UML class diagrams and source code. Towards the higher abstraction of design diagrams, we extend UML class diagrams with the statistical analysis on multiple design documents. To guarantee the quality of trace links, we design a two‐phase approach by obtaining the “full but not good enough” trace links and filtering the “probably wrong” links. Experiments show that the main techniques of our approach behave as important role for tracing between high‐level class diagrams and source code.

Summary Detecting missing requirements during software development is crucial to avoid unexpected consequences. However, this task is challenging due to limited domain knowledge of requirements analysts and the dynamic nature of software requirements. Previous studies have shown that requirement‐oriented domain models can help identify omissions in requirements, but they are often incomplete for many domains. Meanwhile, domain models constructed from other artifacts are available online. This raises the question: Can these domain models be useful in identifying missing functional information in requirement specifications? To address this question, we conducted a study to measure the overlap between entities in domain models and requirements. We analyzed the occurrence of overlapped entities, considering four distribution characteristics: the type of entities in the domain model, the distribution of mapped entities in the domain model, the family belonging of the mapped entities in the domain model, and the distribution of mapped entities in the requirements. Based on our findings, we proposed recommendations for missing requirements. Additionally, we performed experiments, including the use of the proposed metric “ancestors of the highest level with the most mapped entities” (AHME). The results showed significant improvements with gains of 146% and 223% in the two domains, highlighting the benefits of these distribution characteristics.

Abstract Numerous academic research projects and industrial tasks related to software engineering require individual requirements as input. Unfortunately, according to our observation, several requirements may be packed in one paragraph without explicit boundaries in specification documents. To understand this problem's prevalence, we performed a preliminary study on the open requirement documents widely used in the academic community over the last 10 years, and found that 26% of them include this phenomenon. Several text segmentation approaches have been reported; however, they tend to identify topically coherent units which may contain more than one requirement. What is more, they do not take the constitutions of semantic units of requirements into consideration. Here we report a two‐phase learning‐based approach named DRIP to segment individual requirements from paragraphs. To be specific, we first propose a Requirement Segmentation Siamese framework, which models the similarity of sentences and their conjunction relations, and then detects the initial boundaries between individual requirements. Then, we optimize the boundaries heuristically based on the semantic completeness validation of the segments. Experiments with 1132 paragraphs and 6826 sentences show that DRIP outperforms the popular unsupervised and supervised text segmentation algorithms with respect to processing different documents (with accuracy gains of 57.65%–187.53%) and processing paragraphs of different complexity (with average accuracy gains of 54.46%–158.68%). We also show the importance of each component of DRIP to the segmentation.

Software developers frequently use code completion tools to accelerate software development by suggesting the following code elements. Researchers usually employ AutoRegressive (AR) decoders to complete code sequences in a left-to-right, token-by-token fashion. To improve the accuracy and efficiency of code completion, we argue that tokens within a code statement have the potential to be predicted concurrently. In this article, we first conduct an empirical study to analyze the dependency among the target tokens in line-level code completion. The results suggest that it is potentially practical to generate all statement tokens in parallel. To this end, we introduce SANAR, a simple and effective syntax-aware non-autoregressive model for line-level code completion. To further improve the quality of the generated code, we propose an adaptive and syntax-aware sampling strategy to boost the model’s performance. The experimental results obtained from two widely used datasets indicate that our model outperforms state-of-the-art code completion approaches of similar model size by a considerable margin, and is faster than these models with up to 9× speed-up. Moreover, the extensive results additionally demonstrate that the enhancements achieved by SANAR become even more pronounced with larger model sizes, highlighting their significance.

Real-time collaborative programming (RCP) entails developers working simultaneously, regardless of their geographic locations. RCP differs from traditional asynchronous online programming methods, such as Git or SVN, where developers work independently and update the codebase at separate times. Although various real-time code collaboration tools (e.g., Visual Studio Live Share , Code with Me , and Replit ) have kept emerging in recent years, none of the existing studies explicitly focus on a deep understanding of the processes or experiences associated with RCP. To this end, we combine interviews and an e-mail survey with the users of Visual Studio Live Share , aiming to understand (i) the scenarios, (ii) the requirements, and (iii) the challenges when developers participate in RCP. We find that developers participate in RCP in 18 different scenarios belonging to six categories, e.g., pair programming , group debugging , and code review . However, existing users’ attitudes toward the usefulness of the current RCP tools in these scenarios were significantly more negative than the expectations of potential users. As for the requirements, the most critical category is live editing , followed by the need for sharing terminals to enable hosts and guests to run commands and see the results, as well as focusing and following , which involves “following” the host’s edit location and “focusing” the guests’ attention on the host with a notification. Under these categories, we identify 17 requirements, but most of them are not well supported by current tools. In terms of challenges, we identify 19 challenges belonging to seven categories. The most severe category of challenges is lagging followed by permissions and conflicts . The above findings indicate that the current RCP tools and even collaborative environment need to be improved greatly and urgently. Based on these findings, we discuss the recommendations for different stakeholders, including practitioners, tool designers, and researchers.

There is growing interest in software migration as the development of software and society. Manually migrating projects between languages is error-prone and expensive. In recent years, researchers have begun to explore automatic program translation using supervised deep learning techniques by learning from large-scale parallel code corpus. However, parallel resources are scarce in the programming language domain, and it is costly to collect bilingual data manually. To address this issue, several unsupervised programming translation systems are proposed. However, these systems still rely on huge monolingual source code to train, which is very expensive. Besides, these models cannot perform well for translating the languages that are not seen during the pre-training procedure. In this paper, we propose SDA-Trans, a syntax and domain-aware model for program translation, which leverages the syntax structure and domain knowledge to enhance the cross-lingual transfer ability. SDA-Trans adopts unsupervised training on a smaller-scale corpus, including Python and Java monolingual programs. The experimental results on function translation tasks between Python, Java, and C++ show that SDA-Trans outperforms many large-scale pre-trained models, especially for unseen language translation.

Newcomers are critical for the success and continuity of open source software (OSS) projects. To attract newcomers and facilitate their onboarding, many OSS projects recommend tasks for newcomers, such as good first issues (GFIs). Previous studies have preliminarily investigated the effects of GFIs and techniques to identify suitable GFIs. However, it is still unclear whether just recommending tasks is enough and how significant mentoring is for newcomers. To better understand mentoring in OSS communities, we analyze the resolution process of 48,402 GFIs from 964 repositories through a mix-method approach. We investigate the extent, the mentorship structures, the discussed topics, and the relevance of expert involvement. We find that ~70% of GFIs have expert participation, with each GFI usually having one expert who makes two comments. Half of GFIs will receive their first expert comment within 8.5 hours after a newcomer comment. Through analysis of the collaboration networks of newcomers and experts, we observe that community mentorship presents four types of structure: centralized mentoring, decentralized mentoring, collaborative mentoring, and distributed mentoring. As for discussed topics, we identify 14 newcomer challenges and 18 expert mentoring content. By fitting the generalized linear models, we find that expert involvement positively correlates with newcomers' successful contributions but negatively correlates with newcomers' retention. Our study manifests the status and significance of mentoring in the OSS projects, which provides rich practical implications for optimizing the mentoring process and helping newcomers contribute smoothly and suecessfully,

A constant influx of newcomers is essential for the sustainability and success of open source software (OSS) projects. However, successful onboarding is always challenging because newcomers face various initial contributing barriers. To support newcomer onboarding, OSS communities widely adopt the mentoring approach. Despite its significance, previous mentoring studies tend to focus on the newcomer's perspective, leaving the mentor's perspective relatively under-studied. To better support mentoring, we study the popular Google Summer of Code (GSoC). It is a well-established global program that offers stipends and mentors to students aiming to bring more student developers into OSS development. We combine online data analysis, an email survey, and semi-structured interviews with the GSoC mentors to understand their motivations, challenges, strategies, and gains. We propose a taxonomy of GSoC mentors’ engagement with four themes, ten categories, 34 sub-categories, and 118 codes, as well as the mentors’ attitudes toward the codes. In particular, we find that mentors participating in GSoC are primarily intrinsically motivated, and some new motivators emerge adapting to the contemporary challenges, e.g., sustainability and advertisement of projects. Forty-one challenges and 52 strategies associated with the program timeline are identified, most of which are first time revealed. Although almost all the challenges are agreed upon by specific mentors, some mentors believe that several challenges are reasonable and even have a positive effect. For example, the cognitive differences between mentors and mentees can stimulate new perspectives. Most of the mentors agreed that they had adopted these strategies during the mentoring process, but a few strategies recommended by the GSoC administration were not agreed upon. Self-satisfaction, different skills, and peer recognition are the main gains of mentors to participate in GSoC. Eventually, we discuss practical implications for mentors, students, OSS communities, GSoC programs, and researchers.

Deep learning becomes the driving force behind many contemporary technologies and has been successfully applied in many fields. Through software dependencies, a multi-layer supply chain (SC) with a deep learning framework as the core and substantial down-stream projects as the periphery has gradually formed and is constantly developing. However, basic knowledge about the structure and characteristics of the SC is lacking, which hinders effective support for its sustainable development. Previous studies on software SC usually focus on the packages in different registries without paying attention to the SCs derived from a single project. We present an empirical study on two deep learning SCs: TensorFlow and PyTorch SCs. By constructing and analyzing their SCs, we aim to understand their structure, application domains, and evolutionary factors. We find that both SCs exhibit a short and sparse hierarchy structure. Overall, the relative growth of new projects increases month by month. Projects have a tendency to attract downstream projects shortly after the release of their packages, later the growth becomes faster and tends to stabilize. We propose three criteria to identify vulnerabilities and identify 51 types of packages and 26 types of projects involved in the two SCs. A comparison reveals their similarities and differences, e.g., TensorFlow SC provides a wealth of packages in experiment result analysis, while PyTorch SC contains more specific framework packages. By fitting the GAM model, we find that the number of dependent packages is significantly negatively associated with the number of downstream projects, but the relationship with the number of authors is nonlinear. Our findings can help further open the "black box" of deep learning SCs and provide insights for their healthy and sustainable development.

A software architectural tactic is a design decision for realizing quality goals at the architectural level. With the evolution of code, the designed architectural tactics might be degraded over time. In practice, the existing systems provide limited support for checking the consistency between an architectural tactic and its implementation. Kim et al. specified the generic structure and interaction behavior for a subset of architectural tactics in Role-Based Meta-modeling Language (RBML) to facilitate the design of tactics. Based on Kim et al.'s work, this paper first presents a machine learning-based method to assist users in detecting the behavior methods of the tactic structure in code, then proposes a runtime verification (RV) method for checking the behavioral consistency between the tactic specification in RBML and its implementation. We conducted experiments for the behavioral methods detection approach by comparing five machine learning models on a dataset with seventy-four open-source projects containing ten types of tactics. For each tactic, we selected an open-source project to show the effectiveness of the RV approach. Finally, we design and implement a prototype tool named ArchTacRV to help developers efficiently maintain the architectural tactics.

There are various uncertain disturbances in the actual manufacturing environment, which makes dynamic multiobjective flexible scheduling problem of flexible job shop (MDFJSP) become the research focus in the field of optimal scheduling. In this paper, MDFJSP in the environment of temporary order insertion uncertainty is studied, and a multiobjective dynamic scheduling scheme based on rescheduling index and adaptive nondominated sorting genetic algorithm (NSGA-II) is proposed. First, based on the actual manufacturing environment, the mathematical model of the traditional flexible job shop scheduling problem is improved, and the multiobjective dynamic rescheduling model of flexible work center is established. Then, the existing rescheduling mechanisms are summarized, and a rescheduling hybrid driving mechanism based on the rescheduling index is proposed to enable it to reschedule and drive according to the actual situation. Finally, the shortcomings of the traditional multiobjective scheduling algorithm NSGA-II are analyzed, the adaptive cross mutation strategy and the simplified harmonic normalized distance measure method are proposed to improve it, and an adaptive multiobjective dynamic scheduling algorithm NSGA-II (MDSA-NSGA-II) is formed. To analyze the performance of this algorithm, the performance of this algorithm is compared with five classical flexible job shop multiobjective scheduling algorithms in international general examples, and the effectiveness is verified by real aircraft production examples. The experimental results fully show that MDSA-NSGA-II has good performance in solving MDFJSP.

Design models are essential for multiple tasks in software engineering, such as consistency checking, code generation, and design-to-code tracing. Almost all of these works need a semantically analyzable model to represent the software architecture design, e.g., a UML class diagram. Unfortunately, many design models are stored as images and embedded in text-based documentations, impeding the usage and evolution of these models. Thus, identifying the semantic elements of design models from images is important. However, there are lots of design models with different elements in diverse representations, which ask for different approaches for semantic elements extraction. In order to grasp an overview of the commonly used design model types, we conduct a survey on both open-source communities and industry. We find that design model diagrams are usually embedded in documents as pictures (73.72%), and UML class diagrams are the most used type (55.43%). Considering that there are limited studies on automatically recognizing the semantic elements from class diagram images, we propose an approach, which we call ReSECDI. ReSECDI includes our customized design for extracting UML class diagram elements based on image processing technologies. We design a rectangle clustering method for class recognition, to address the challenge that the presentation of classes may vary due to the UML constraints and tools’ styles. We design a polygonal line merging method and double-recognition-approximation method for relationship recognition to deal with the impact of low resolution on the detection. We evaluate the applicability of ReSECDI on 30 images drawn by three popular UML tools and 50 diagrams collected from the open-source communities, and get promising performances. ReSECDI can recognize all types of semantic elements commonly used. It has well applicability and can be used to process the images drawn by the mainstream tools and stored in different resolutions. Editor’s note: Open Science material was validated by the Journal of Systems and Software Open Science Board.

In pull-based development process, contributors submit their code to open-source projects by pull requests, which are accepted or rejected by reviewers. Contributors may modify their code, which causes several iterations of code review process, and makes code reviews time-consuming for both contributors and reviewers. In this article, we set out to study pull request modifications in a code review process. We collect nine projects on GitHub with 104 307 pull requests, and investigate pull request modifications through analyzing added commits after pull requests’ submission. By studying four research questions, we conclude our major findings as follow. First, 34.56$\%$of collected pull requests have modifications. Pull requests with modifications have longer lifetime but higher pass rates. Second, we conclude eight modification types indicating why pull requests are modified. Third, we propose a novel method called MClassify to automatically classify pull request modifications, which achieves the accuracy of 0.807. Fourth, various modification types affect code review differently from the perspective of lifetime and pass rate. Pull requests with source control system management modifications have the longest lifetime. These findings enable developers and researchers to understand a pull-based code review process better and make improvements.

The relationships between software requirements work as the basis for several important software activities, such as change impact and developing cost analysis. Multiple types of relationships are mentioned in the RE literatures including normal (e.g., dependency) and abnormal ones (e.g., conflicts), and most of the existing work usually focus on the identification of one specific relationship. We collect and analyze the relations in the RE literatures, and find some common semantic elements of functional requirements are involved in the definition of multiple types of relations. Thus, to support automatically identifying diverse relationships, we propose our definition of the micro-level semantic constitution of functional requirement (M-FRDL), and one automatic approach for the element extraction, named by Micro-level Semantic elements Analyser of functional requirement (MISA). The experiments with three open requirement datasets show that our MISA can correctly identify about 94.93% elements of requirements on average.

Completeness is one of the most important attributes of software requirement specification. Unfortunately, incompleteness is one of the most difficult violations to detect. Some approaches have been proposed to detect missing requirements based on the requirement-oriented domain model. However, these kinds of models are actually lack for lots of domains. Fortunately, the domain models constructed for different purposes can usually be found online. This raises a question: whether or not these domain models are useful for finding the missing functional information in requirement specification? To explore this question, we design and conduct a preliminary study by computing the overlapping rate between the entities in domain models and the concepts of natural language software requirements, and then digging into four regularities of the occurrence of these entities(concepts) based on two example domains. The usefulness of these regularities, especially the one based our proposed metric AHME (with 54% and 70% of F2on the two domains), has been initially evaluated with an additional experiment.

Abstract Stack Overflow is a very popular programming question and answer community. Some questions become hot, and receive high views, which are of widespread concern to developers. Finding hot questions early can give priority to recommend potential hot questions to answers, thereby shortening the response time. Besides, the hot question prediction is also helpful for making advertising plan, planning advertising campaigns and estimating costs. Therefore, it is important to predict hot questions. The authors propose the VSAF method which analyses the V iew amount changes, A nswer amount changes and S core changes soon after questions' creation based on F ully convolutional neural network. The performance of the VSAF method based on a training set and two different test sets has been evaluated. The training set has 1600 hot questions and 1600 cold questions. The random test set has 381 hot questions and 2819 cold questions, while the balanced test set has 400 hot questions and 400 cold questions. The experimental results show that using the balanced test set, VSAF achieves Accuracy, F 1 hot and F 1 cold of 80%, 77.77% and 81.81%, which outperforms the baseline approach by 25.59%, 21.52% and 29.04%, respectively. Using the random test set for evaluation, VSAF achieves Accuracy , F 1 hot and F 1 cold of 84.91%, 53.96% and 90.97%, which outperforms the baseline approach by 31.83%, 84.16% and 19.35%, respectively. The VSAF method significantly outperforms the state‐of‐the‐art approach on hot question prediction.

Abstract The microservice application programming interface (API) becomes a growing concern in the IT industry, as a result of the increasing usage of microservice architecture style. There exist many successful practices among companies, communities, and so on. In contrast, the related academic research is still at an early stage, where lacks an overview of technologies for the design, implementation and operation of microservice APIs, as well as a general picture of concerns. In this article, we try to fill this gap by eliciting the technologies and concerns on microservice APIs and establishing a microservice API description model, with the intention of aiding researchers to gain an overview of this field and find possible research directions, and helping practitioners to better understand microservice APIs and be aware of the existing approaches for daily work. Twelve academic papers and 38 gray literatures are selected and analyzed following the systematic literature review approach. Besides, we give our observations from this study. For researchers, our findings show the most cared concerns of practitioners, and our description model can be used as a reference for new theories, experiments, and future research dimensions. For practitioners, our study can be used as a guideline for microservices experimentation and a starting point for practice.

In daily software development, inconsistencies between architecture and code inevitably occur with the continuous contribution, even under model-driven development which can trace between design and code. Many methods have been proposed for consistency checking, but most require huge human efforts on establishing the mappings between architectural and code elements. Besides, the multi-layered architecture and code increases the difficulties in inconsistency detection, while existing algorithms do not handle this well. Thus, we propose an improved mapping method for automated consistency check between software architecture and Java implementation, with the premises that initial tracing between architecture and code are established. To be specific, during software evolution, our method can automatically re-establish the mappings between architecture and code using initial tracing information. Then, with detailed inconsistency check rules, we detect the inconsistencies heuristically. Experiments with two projects show our method's high effectiveness with more than 98% of recall and 96% of precision.

Stack Overflow is a popular question and answer website based on the software programming. Different users often ask the same questions in different ways, resulting in a large number of duplicate questions in Stack Overflow. Generally, the users with high reputation manually analyze and mark duplicate questions, which is time consuming and low efficiency. Therefore, the automatic duplicate question detection approach is demanded. We first investigate the application of deep learning models to software engineering task. Then, three deep learning models (i.e., CNN, RNN and LSTM) are applied to demonstrate whether they are effective to duplicate question detection task in Stack Overflow. In this paper, we explore three deep learning approaches DQ-CNN, DQ-RNN and DQ-LSTM based on CNN, RNN and LSTM to detect duplicate questions. The effectiveness of DQ-CNN, DQ-RNN and DQ-LSTM is evaluated by six different question groups. The experimental results show that DQ-LSTM outperforms DupPredictor, Dupe, DupePredictorRep-T and DupeRep in terms of recall-rate@5, recall-rate@10 and recall-rate@20 except for Ruby question group.

In GitHub, integrators inspect submitted code changes, make evaluation decision, and close pull requests. However, some pull requests may get reopened for further modification and code review. It is important to predict reopened pull requests immediately after pull requests' first close, and help integrators reopen pull requests in time. If pull requests are reopened a long time after their close, they may cause conflicts with newly submitted pull requests, add software maintenance cost, and increase burden for already busy developers. To the best of our knowledge, we present the first look at predicting reopened pull requests in GitHub. We propose an approach DTPre which is an automatic predictor of reopened pull requests based on Decision Tree classifier. DTPre mainly analyzes code features of modified changes, review features during evaluation, and developer feature of contributors. We evaluate the effectiveness of DTPre on 7 Open Source projects containing 100,622 pull requests. Experimental results show that DTPre has high performances by achieving a precision of 95.53%, recall of 99.01% and F1-measure of 97.23% on average. In comparison with predictors based on neural network, naïve Bayes, logistic regression and SVM, DTPre based on decision tree improves F-1 measures by 41.76%, 59.45%, 42.25% and 9.98% on average across 7 projects.

The timing requirements of real-time systems can be guaranteed by the well-designed scheduling.The analysis of such scheduling inputs an abstract task model of the system and outputs a diagnostic regarding the practicability of the timing requirements.Task models have evolved from periodic models to more sophisticated graph-based ones, among which the digraph real-time (DRT) task model is the most applicable because of its good expressiveness and analysis efficiency.However, the DRT model can't support the precedence constraints within or between tasks.In this paper, we propose a new task model, called the DRTPC model, that extends the DRT model to support the precedence constraint.Further, based on our model, we present a uniprocessor schedulability analysis algorithm for the static priority scheduling, and introduce an optimization technique to improve the analysis efficiency.Our experiments show that, despite the high computational complexity of the problem, our approach scales very well for large sets of tasks with precedence constraints.

Currently, more and more application-specific operating systems (ASOS) are applied in real-time embedded systems.With the development of microkernel technique, the ASOS is usually customized based on the microkernel using the configurable policy, which has various alternatives.In the design of the real-time embedded system (RTES) based on such ASOS, evaluating its timing performance at the early design stage is helpful to guide the designer towards choosing the most appropriate policy.However, the existing works lack a uniform approach to support analyzing the various alternatives of the configured policy.To solve this problem, this paper presents a general-purpose timing analysis approach for the ASOS-based RTES.In the analysis, a timing analysis tree is proposed to characterize the tasks and the ASOS in the RTES.Then, each of the alternative policies in the ASOS is refined by the uniform execution rules in the tree.Finally, the task's response time under the various alternative policies is analyzed by a traversal of the timing analysis tree using a uniform way.In the case study, we take the scheduling policy as an example to show the use of our approach on a real-life robot controller system.

The timing requirements of real-time systems can be guaranteed by well-designed scheduling policies. The analysis of such scheduling uses an abstract task model of the system to diagnose the practicability of timing requirements. The task models have evolved from periodic models to more sophisticated graph-based ones, among which digraph real-time (DRT) task model is the most applicable because of its good expressiveness and analysis efficiency. However, the DRT model cannot support the commonly used precedence constraints within or between tasks. In this paper, we propose a new task model that extends the DRT model to support precedence constraints. Based on our model, we present two methods of uniprocessor schedulability analysis for static priority scheduling policy and earliest deadline first (EDF) scheduling policy. We also introduce an optimization technique to improve the efficiency of model analysis. Our experiments show that, despite a high computational complexity of the problem, our approach scales very well for large sets of tasks with precedence constraints.

A typical way to improve the quality of requirements is to assign them to suitable stakeholders for reviewing. Due to different characteristics of requirements and diverse background of stakeholders, it is needed to find an optimal solution for requirements assignment. Existing search-based requirements assignment solutions focus on maximizing stakeholders' familiarities to assigned requirements and balancing the overall workload of each stakeholder. However, a cost-effective requirements assignment solution should also take into account another two optimization objectives: 1) minimizing required time for reviewing requirements, and 2) minimizing the monetary cost required for performing reviewing tasks. We formulated the requirements assignment problem as a search problem and defined a fitness function considering all the five optimization objectives. We conducted an empirical evaluation to assess the fitness function together with six search algorithms using a real-world case study and 120 artificial problems to assess the scalability of the proposed fitness function. Results show that overall, our optimization problem is complex and further justifies the use for multi-objective search algorithms, and the Speed-constrained Multi-Objective Particle Swarm Optimization (SMPSO) algorithm performed the best among all the search algorithms.

To ensure the quality of requirements, a common practice, especially in critical domains, is to review requirements within a limited time and monetary budgets. A requirement with higher importance, larger number of dependencies with other requirements, and higher implementation cost should be reviewed with the highest priority. However, requirements are inherently uncertain in terms of their impact on the requirements implementation cost. Such cost is typically estimated by stakeholders as an interval, though an exact value is often used in the literature for requirements optimization (e.g., prioritization). Such a practice, therefore, ignores uncertainty inherent in the estimation of requirements implementation cost. This paper explicitly takes into account such uncertainty for requirement prioritization and formulates four objectives for uncertainty-wise requirements prioritization with the aim of maximizing 1) the importance of requirements, 2) requirements dependencies, 3) the implementation cost of requirements, and 4) cost over-run probability. We evaluated the multi-objective search algorithm NSGA-II together with Random Search (RS) using the RALIC dataset and 19 artificial problems. Results show that NSGA-II can solve the requirements prioritization problem with a significantly better performance than RS. Moreover, NSGA-II can prioritize requirements with higher priority earlier in the prioritization sequence. For example, in the case of the RALIC dataset, the first 10% of prioritized requirements in the prioritization sequence are on average 50% better than RS in terms of prioritization effectiveness.

The cost and effort of developing software systems in a new technical area can be extensive. An organization must perform a domain analysis to discover competing products, analyze their architectures and features, and ultimately discover and specify product requirements. However, delivering high quality products, depends not only on gaining an understanding of functional requirements, but also of qualities such as performance, reliability, security, and usability. Discovering such concerns early in the requirements process drives architectural design decisions. This paper extends our prior work on mining functional requirements from large collections of domain documents, by proposing and evaluating a new technique for discovering and specifying quality concerns related to specific functional components. We evaluate our approach against three domains of Positive Train Control, Electronic Health Records, and Medical Infusion Pumps, and show that it significantly outperforms a basic information retrieval approach. Finally we classified the forms of retrieved information, discussed the utility of different types, and conducted a small study with an experienced engineer to investigate the quality of requirements produced using our approach.

In the context of large-scale system product line engineering, manual configuration is often mandatory and therefore inevitably introduces nonconformities: violating pre-defined constraints for conformance checking. Resolving nonconformities without proper tool support is more or less random, as there are usually hundreds and thousands of configurable parameters and conformance constraints, in the context of configuring a large-scale and directly deployable system. Moreover, inter-connections among constraints and configurable parameters worsen the feasibility of manual resolving nonconformities without proper tool support. In this paper, we present an automatic approach (named as Zen-FIX) to optimally recommend solutions to resolve nonconformities using multi-objective search. Solutions recommended by Zen-FIX conform to all pre-defined constraints and are optimized in terms of maximizing the overall efficiency of an interactive product configuration process. We evaluated Zen-FIX with a real-world case study containing 52454 optimization problems, with which we evaluated seven multi-objective search algorithms. Results show that MoCell outperformed all others: CellDE, IBEA, NSGA-II, PESA2, Random, SPEA2, for most of the problems, in terms of Efficiency (a combined metric of finding optimized solutions and time performance).

When organizations enter domains that are entirely new to them, they need to invest significant time and effort to acquire domain knowledge. This typically involves searching through a broad set of domain documents, retrieving relevant ones, and analyzing the textual content in order to discover and specify pertinent requirements. Depending on the nature of the domain and the availability of documentation, this task can be extremely time-consuming and may require non-trivial human effort. Furthermore, the task must often be performed repeatedly throughout early phases of the project. In this paper we first explore the effort needed to manually build a high-level domain model capturing the functional components. We then present MaRK (Mining Requirements Knowledge), which identifies and retrieves the documents containing descriptions of functional components in the domain model. Domain analysts can use this information to to specify requirements. We introduce and evaluate an algorithm which ranks domain documents according to their relevance to a component and then highlights sections of text which are likely to contain requirements-related information. We describe our process within the context of the Positive Train Control (PTC) domain with a repository of of 523 documents, representing 852MB of data. We empirically evaluate the MaRK relevance algorithm and its ability to retrieve relevant requirements knowledge for requirements related to PTC's On-Board Unit.

In open source software (OSS) projects, integrators are given high-level access to repositories so that they could maintain and manage projects.Although integrators play a critical role in evaluating code changes for OSS projects, they may be short-term active.Long-term active integrators keep in evaluating code update submission and managing responses from contributors.In order to survive and succeed, OSS projects need to attract and retain long-term active integrators.To assist OSS projects to retain active integrators, we propose a method called LTAPredict to predict whether integrators will be longterm active in the evaluation of code contributions.LTAPredict collects activity data of integrators, extracts a rich set of features, and makes prediction via machine learning techniques.We perform experiments on 37 popular projects, containing a total of 1,073 integrators.Results show that based on the Decision Tree, LTAPredict achieves the accuracy as 0.829, the precision as 0.81, the recall as 0.827 and the F1 as 0.818.Meanwhile, we evaluate the feature importance to identify the most significant indicators of long-term active integrators.We observe that whether integrators becoming long-term active is associated with the number of active months and social distance with contributors in their first year as integrators.These findings assist OSS projects to identify potential long-term active integrators and adopt better strategies to retain them in the evaluation of code contributions.

Process models are becoming more and more widespread in contemporary organizations. For the purpose of reducing cost and improve model quality, the ability to rapidly tailor a reference process to satisfy the changing of business requirements is necessary for organizations. In this context, how to provide a suitable reference process model for a specific domain becomes a challenging question. This paper proposes a method to automatically generate a hierarchical reference process model using fragments clustering from existing process variants. Similar fragments in process variants are detected and clustered firstly. Then an improved reference sub-process is discovered for each cluster of fragments based on a heuristic search. After fragments are replaced by reference sub-processes hierarchically, the refactored process variants are merged into the final reference process model. The quality and usability of the generated reference model are demonstrated by a case study and user experiment from a real industry scenario.

As an important research issue in software product line, feature selection is extensively studied. Besides the basic functional requirements (FRs), the non-functional requirements (NFRs) are also critical during feature selection. Some NFRs have numerical constraints, while some have not. Without clear criteria, the latter are always expected to be the best possible. However, most existing selection methods ignore the combination of constrained and unconstrained NFRs and FRs. Meanwhile, the complex constraints and dependencies among features are perpetual challenges for feature selection. To this end, this paper proposes a multi-objective optimization algorithm IVEA to optimize the selection of features with NFRs and FRs by considering the relations among these features. Particularly, we first propose a two-dimensional fitness function. One dimension is to optimize the NFRs without quantitative constraints. The other one is to assure the selected features satisfy the FRs, and conform to the relations among features. Second, we propose a violation-dominance principle, which guides the optimization under FRs and the relations among features. We conducted comprehensive experiments on two feature models with different sizes to evaluate IVEA with state-of-the-art multi-objective optimization algorithms, including IBEAHD, IBEAε+, NSGA-II and SPEA2. The results showed that the IVEA significantly outperforms the above baselines in the NFRs optimization. Meanwhile, our algorithm needs less time to generate a solution that meets the FRs and the constraints on NFRs and fully conforms to the feature model.

In safety-critical systems (e.g. Ship control system, avionics system), various reliability tactics are applied for guaranteeing the safe operation of the system. Therefore, much more attentions during the testing process are expected to be paid on these tactics. However, since developers cannot identify the reliability tactics from the system design effectively, the traditional testing approaches cannot obtain the test scenarios associated with reliability tactics directly. Based on our previous works about the aspect specifications of reliability tactics, we propose an approach for generating the test scenarios associated with reliability tactics from Sequence Diagram of Unified Modeling Language (UML). Owing to the separation of reliability tactics from the base model, the Label Transition Systems (LTSs) of the base and tactic aspect model can be obtained as intermediate models of generation process respectively. Then the action sequences of above LTSs are generated. Following the proposed principles, we can acquire the test scenarios associated with reliability tactics through integrating the action sequences of tactic aspect models with the ones of the base model. An avionics system is used to evaluate the availability of our approach. The results show that 1) our approach can effectively identify the test scenarios associated with reliability tactics from all possible test scenarios of system design, 2) the aspect specifications of reliability tactics can alleviate the input effort of test scenario generation for different functional fragments. We also exemplify the advantage of our approach for supporting the model changes.

Business process simulation is the procedure of planning, modeling and simulating enterprise process to analyze the features varying with time which guides the users to make decisions or important means of process improvement. In the existing simulation methods, they considered little about dynamic resource, which may lead to a large deviation. To solve the problem above, a business process simulation method supporting resource evolution that mainly focuses on human resource is proposed. Individual differences and personnel composition are analyzed to represent the dynamic feature of resources. Evolution of human capacity and personnel changes are described to meet the simulation requirements of human resource model. And then, process simulation mechanism and algorithm are realized. An experiment is conducted by simulating the software development process of a real-world software project using the system prototype we developed, and it shows that our method is closer to the practical project situation, thus the method effectiveness can be demonstrated to a certain extent. The main contribution of our work is a novel process simulation approach based on a dynamic resource model with configurable evolution rules.

In the context of product line engineering (PLE), providing immediate feedback on the correctness of a manual configuration step to users has a practical impact on whether a configuration process with tool support can be successfully adopted in practice. Model-based PLE has brought opportunities to enable automated product configuration and derivation for large-scale systems/software, in which models are used as the abstract specification of commonalities and variabilities of products of a product line. In our previous work, we have proposed a UML-based variability modeling methodology and an interactive configuration process. Based on these work, in this paper, we propose an automated and incremental conformance checking approach to ensure that the manual configuration to each variation point conforms to a set of pre-defined conformance rules specified in OCL. The proposed approach, called Zen-CC is implemented as a component of our product configuration and derivation tool, named as Zen-Configurator. The proposed approach is evaluated with two real-world case studies and results showed that the performance of Zen-CC is significantly better than a baseline algorithm checking all the conformance rules at each configuration step. Moreover, the performance of Zen-CC rarely varies during the configuration process, suggesting that our approach is scalable for configuring products with a large number of configuration points.

There are various approaches for QoS-based web service composition. However, most of them are concerned about the algorithms of service compositions while ignoring the flexibility and expressiveness of users to set QoS constraints. Most of them assume that users could specify accurate QoS constraints easily. In reality, it is often not true especially for non-expert users. Users may not know the exact ranges or values of QoS requirements for their tasks. They may just want service composition solutions based on current QoS technical levels or want composition solutions in cost priority or quality priority. To deal with this non-clarity and variety of QoS requirements, in this paper, we propose a multi-strategic approach of service composition. This approach provides four strategies and aids to help users complete their QoS constraints and find optimization web service composition solutions.

Feature location is the activity of identifying an initial location in the source code that implements special functionality in a software system. Existing techniques for feature location broadly fall into three categories, based on the type of information they use: text, static, and dynamic. The techniques based on dynamic may generate large amount of data and is difficult to utilize. This paper presents a method combing the text and static techniques. A feature location technique based on topic modeling is introduced, and the topic cohesion and coupling is computed by software dependency network to improve the effects of feature location. When the topic cohesion degree is low and topic coupling degree is high, software dependency network is used to find additional candidate program elements. This method is empirically evaluated through several experiments. Experimental results show that the topic modeling based feature location improves the effectiveness of feature location when compared with other techniques.

There are three types of web service QoS criterion weight: subjective weight decided by user's preference of QoS criterion, objective weight affected by QoS criterion value and synthetic weight synthesized with the two. Considering the uncertainty of conversion from qualitative value, which is used to describe user's preference, to quantitative value, the uncertainty of subjective weight is described by cloud model and the weight is calculated using normalization method and least square method. Objective weight is obtained using entropy method. For synthetic weight, Cobb-Douglas method is used to synthesize subjective and objective weight. Lastly, a case is studied and sensibility analysis of weight based on uncertain weight is discussed.

In recent years, many graphs have turned out to be complex networks. This paper presents a novel method to study Linux kernel evolution - using complex networks to understand how Linux kernel modules evolve over time. After studying the node degree distribution and average path length of the call graphs corresponding to the kernel modules of 223 different versions (V1.1.0 to V2.4.35), we found that the call graphs of the file system and drivers module are scale-free small-world complex networks. In addition, both of the file system and drivers module exhibit very strong preferential attachment tendency. Finally, we proposed a generic method that could be used to find major structural changes that occur during the evolution of software systems.

Requirement engineering (RE) is emerging as an increasingly important discipline for supporting Web application development, as these are designed to satisfy diverse stakeholder needs, additional functional, information, multimedia and usability requirements as compared to traditional software applications. Moreover, when considering innovative e-commerce applications, value-based RE is an extremely relevant methodology which exploits the concept of economic value during the RE activity. In contrast, most of the methodologies proposed for the development of Web applications, primarily focus on the system design, and paying less attention to the RE, and specifically to value-based RE. Focusing this aspect, the paper presents integration of value-based RE models to WebML models using our recently proposed VIP Business Modeling Framework [1]. We also analyze the framework's potential in linking other modeling approaches, and argue about its significant integration potential with various E-R/OO-based, process aware Web modeling approaches.

During the rapid growth of World Wide Web in the recent past, ‘usability’ and ‘navigation’ have emerged as problems of concern to the research community. Large web systems are being made so complex that often the users have to make excessive amount of ‘navigational efforts’ to complete their tasks. We identify certain aspects which aggravate the ‘navigational burden’ of a user. Vital amongst them are, complex navigational structure of web, unfamiliarity of users with the website, and disagreement between the research community and practitioners. This paper is based on the empirical analysis of an experimental data obtained from the prospective students who were invited to interact with the websites of few world class educational institutions from four different countries. The data allows us to determine that despite active research in the area of usability engineering, the users still experience heavy ‘navigational burden’ while performing same task using similar systems. The users do not observe any improvement in their ‘familiarity’ with these web systems even when they interact with more than one such systems which serve similar functions. This leads us to propose a solution with a different approach that is; to resort to ‘Generic User Interface’ as a ‘standard’ for organizations serving similar functions such as universities, hospitals etc. We then present some convincing arguments to support our proposal and answer some of the opponent’s voices, followed by a brief discussion on the future work to be done in this direction.

During the rapid growth of World Wide Web in the recent past, ‘usability’ and ‘navigation’ have emerged as problems of concern to the research community. Large web systems are being made so complex that often the users have to make excessive amount of ‘navigational efforts’ to complete their tasks. This inflicts a heavy ‘navigational burden’ upon the users. Current collection of usability guidelines and principles has on the order of thousand rules to follow but none of them directly and specifically addresses the problem of ‘navigational burden’. Thus there exists no tool/validator that can measure the ‘navigational burden’ a user experiences while performing some task on a website. Some usability and accessibility guidelines do exist which are validated by current tools just by analyzing the HTML pages, CSS (cascading style sheets) and other contents that can be retrieved from a website. However, the implementation of checks for these guidelines often suffers from the problem that no model is available, i.e. no abstract description of certain properties of the web page (or its parts). This way, the validators either fail to find certain usability problems in the pages or it outputs too many general warning messages. For instance, it is straightforward to check given HTML code for the use of a limited number of different font faces, but it is not possible to do this reliably for measuring the ‘navigational burden’ a user experiences, unless a model or a mechanism provides information regarding the aspects that aggravate the ‘navigational burden’. In this paper we identify certain aspects which aggravate the ‘navigational burden’ of users. We then present a mechanism how to measure ‘navigational burden’, followed by a discussion to integrate this mechanism into currently available automated usability validators.