Search

We present Generic Refinement Types: a way to write modular higher-order specifications that abstract invariants over function contracts, while preserving automatic SMT-decidable verification. We show how generic refinements let us write a variety of modular higher-order specifications, including specifications for Rust's traits which abstract over the concrete refinements that hold for different trait implementations. We formalize generic refinements in a core calculus and show how to synthesize the generic instantiations algorithmically at usage sites via a combination of syntactic unification and constraint solving. We give semantics to generic refinements via the intuition that they correspond to ghost parameters, and we formalize this intuition via a type-preserving translation into the polymorphic contract calculus to establish the soundness of generic refinements. Finally, we evaluate generic refinements by implementing them in Flux and using it for two case studies. First, we show how generic refinements let us write modular specifications for Rust's vector indexing API that lets us statically verify the bounds safety of a variety of vector-manipulating benchmarks from the literature. Second, we use generic refinements to refine Rust's Diesel ORM library to track the semantics of the database queries issued by client applications, and hence, statically enforce data-dependent access-control policies in several database-backed web applications.

Project-based learning (PBL) is a learning technology praised for its ability to grow domain-specific and domain-general skills and related knowledge and attitudes. However, consistently designing effective PBL experiences is challenging, primarily due to the lack of instructor support and guidance for designing PBL experiences aligned with learning principles. This study designs a framework that aids software engineering instructors in designing, administering, and refining structured PBL experiences. We follow design science research to iteratively understand the problem of effective PBL experiences and design solutions for consistently creating them. We validate our intermediary designs by instantiating PBL experiences for a fourth-year undergraduate course on software design, running the experience, and reflecting on the gathered data. We repeat this process four times. Through the lens of pragmatism, we validate our final design by interviewing five software engineering instructors to examine the applicability of our framework to their courses. The resulting framework is based on the four-component instructional design model, where each instantiated PBL experience is a sequence of learning tasks. The framework is divided into four composite activities to reduce the cost of authoring PBL experiences. The paper includes heuristics and examples to aid instructors in using our framework. The designed framework has successfully created four large-scale PBL experiences, each lasting three months and including teams of 16 students. The case study results and the interviewees' perceptions indicate that the framework is useful for higher education study programs, coding boot camps, and onboarding corporate training programs. [ABSTRACT FROM AUTHOR]

Different project management processes have been used in software engineering to support managers in keeping project costs manageable. One of the essential processes in software engineering is to accurately and reliably estimate the required effort and cost to complete the projects. The domain of software cost estimation has witnessed a prominent surge in research activities in recent years and being an evolving process, it keeps opening new avenues, each with advantages and disadvantages, making it important to work out better options. This research aims to identify the factors that influence the software effort estimation using the constructive cost model (COCOMO), and artificial neural networks (ANN) model by introducing a novel cost estimation approach, COCOMO-ANN (CANN), utilizing a partially connected neural network (PCNN) with inputs derived from calibrated values of the COCOMO model. A publicly available dataset (COCOMONASA 2), various combinations of activation functions, and layer densities have been systematically explored, employing multiple evaluation metrics such as MAE, MRE, and MMRE. In the PCNN model, the ReLU activation function and a 1000-dense layer have demonstrated better performance. While layer density generally correlates with better outcomes, this correlation is not universally applicable for all activation functions and outcomes vary across different combinations. The use of the relationships between 26 key parameters of COCOMO in PCNN produced better results than FCNN by 0.59%, achieving an MRE of 6.55 and an MMRE of 7.04. The results indicated that the CANN model (COCOMO & ANN) presented better results than existing models. [ABSTRACT FROM AUTHOR]

The software engineering landscape is undergoing a significant transformation with the advent of artificial intelligence (AI). AI technologies are poised to redefine traditional software development practices, offering innovative solutions to long-standing challenges. This paper explores the integration of AI into software engineering processes, aiming to identify its impacts, benefits, and the challenges that accompany this paradigm shift. A comprehensive analysis of current AI applications in software engineering is conducted, supported by case studies and theoretical models. The study examines various phases of software development to assess where AI contributes most effectively. The integration of AI enhances productivity, improves code quality, and accelerates development cycles. Key areas of impact include automated code generation, intelligent debugging, predictive maintenance, and enhanced decision-making processes. AI is revolutionizing software engineering by introducing automation and intelligence into the development lifecycle. Embracing AI-driven tools and methodologies is essential for staying competitive in the evolving technological landscape. [ABSTRACT FROM AUTHOR]

Smart contracts have emerged as a transformative technology within the blockchain ecosystem, facilitating the automated and trustless execution of agreements. Their adoption spans diverse sectors such as education, agriculture, healthcare, government, real estate, transportation, supply chain, and global initiatives like Central Bank Digital Currencies (CBDCs). However, the security of smart contracts has become a significant concern, as vulnerabilities in their de-sign and implementation can lead to severe consequences such as financial losses and system failures. This systematic review consolidates findings from 78 selected research articles, identifying key vulnerabilities affecting smart contracts and categorizing them into a taxonomy encompassing code-level, environment-dependent, and user-related vulnerabilities. It also examines the threats that exploit these vulnerabilities and the most effective detection techniques. The domain-based classification presented in this review aims to assist researchers, software engineers, and developers in identifying and mitigating significant security flaws related to the design, implementation, and deployment of smart con-tracts. A comprehensive understanding of these issues is essential for enhancing the security and reliability of the blockchain ecosystem, ultimately fostering the development of more secure and robust decentralized applications for end users. [ABSTRACT FROM AUTHOR]

Agile software development has been a significant methodology in software engineering for over two decades, offering enhanced adaptability to software requirement changes, improved delivery, and better quality. However, prevalent misunderstandings in Agile implementation have limited its benefits. Hence, this study investigates the challenges faced during Agile implementation. Initial analysis was carried out from cases in Indonesia, a leading country in the software industry within the Asia-Pacific region. Using Kitchenham's systematic literature review (SLR) methodology, fourteen distinct obstacles were identified from a database of research reports on Agile software development in Indonesia. Subsequent interviews with Agile experts in the country were conducted to validate the SLR findings. The results emphasize the critical need for a top-down strategic approach, the active participation of senior management, and the essential roles of competent scrum masters or Agile coaches. A comparative analysis with reports from other developing countries Saudi Arabia, India, Malaysia, Brazil and developed countries the UK, Belgium, Singapore, and the USA reveals common challenges. They highlight the imperative for proactive upper management leadership to steer successful Agile adoptions, particularly in organizations with entrenched top-down practices and complex hierarchical systems. [ABSTRACT FROM AUTHOR]

Copyright of Automatisierungstechnik is the property of De Gruyter and its content may not be copied or emailed to multiple sites or posted to a listserv without the copyright holder's express written permission. However, users may print, download, or email articles for individual use. This abstract may be abridged. No warranty is given about the accuracy of the copy. Users should refer to the original published version of the material for the full abstract. (Copyright applies to all Abstracts.)

Background: Since 2015, the Complex Reviews Synthesis Unit (CRSU) has developed a suite of web-based applications (apps) that conduct complex evidence synthesis meta-analyses through point-and-click interfaces. This has been achieved in the R programming language by combining existing R packages that conduct meta-analysis with the shiny web-application package. The CRSU apps have evolved from two short-term student projects into a suite of eight apps that are used for more than 3,000 h per month. Aim: Here, we present our experience of developing production grade web-apps from the point-of-view of individuals trained primarily as statisticians rather than software developers in the hopes of encouraging and inspiring other groups to develop valuable open-source statistical software whilst also learning from our experiences. Key challenges: We discuss how we have addressed challenges to research software development such as responding to feedback from our real-world users to improve the CRSU apps, the implementation of software engineering principles into our app development process and gaining recognition for non-traditional research work within the academic environment. Future developments: The CRSU continues to seek funding opportunities both to maintain and further develop our shiny apps. We aim to increase our user base by implementing new features within the apps and building links with other groups developing complementary evidence synthesis tools. [ABSTRACT FROM AUTHOR]

This study proposes a new approach and explores how pattern recognition enhances collaboration between users and Agile teams in software development, focusing on shared resources and decision-making efficiency. Using domain-specific modeling languages (DSMLs) within a security-by-design framework, the research identifies patterns that support team selection, effort estimation, and Agile risk management for Afghanistan's ministries. These patterns align software development with governmental needs by clarifying stakeholder roles and fostering cooperation. The study builds on the p-mart-Repository-Programs (P-MARt) repository, integrating data mining, algorithms, and ETL (Extract, Transform, Load) processes to develop innovative methodologies. These approaches enable dynamic knowledge management, refine documentation, and improve project outcomes. Central to this effort is our new Pattern Shared Vision Refinement (PSVR) approach, which emphasizes robust collaboration, data security, and adaptability. By addressing challenges unique to governmental operations, PSVR strengthens Agile practices and ensures high-quality software delivery. By analyzing historical trends and introducing new strategies, the study underscores the critical role of pattern recognition in aligning development processes with organizational goals. It demonstrates how systematic pattern identification can optimize interaction and secure stakeholder consensus, ultimately enhancing software engineering outcomes in Afghanistan's governmental context. [ABSTRACT FROM AUTHOR]

Model interpretability is essential in machine learning, particularly for applications in critical fields like healthcare, where understanding model decisions is paramount. While SHAP (SHapley Additive exPlanations) has proven to be a robust tool for explaining machine learning predictions, its high computational cost limits its practicality for real-time use. To address this, we introduce C-SHAP (Clustering-Boosted SHAP), a hybrid method that combines SHAP with K-means clustering to reduce execution times significantly while preserving interpretability. C-SHAP excels across various datasets and machine learning methods, matching SHAP's accuracy in selected features while maintaining an accuracy of 0.73 for Random Forest with substantially faster performance. Notably, in the Diabetes dataset collected by the National Institute of Diabetes and Digestive and Kidney Diseases, C-SHAP reduces the execution time from nearly 2000 s to just 0.21 s, underscoring its potential for scalable, efficient interpretability in time-sensitive applications. Such advancements in interpretability and efficiency may hold value for enhancing decision-making within software-intensive systems, aligning with evolving engineering approaches. [ABSTRACT FROM AUTHOR]

In the software engineering domain, the distinction between functional (FRs) and non-functional requirements (NFRs) is paramount, as it directly influences the design and development of software systems. However, several challenges, such as dealing with limited training data, domain-specific datasets, and high computational costs, have driven the need for innovative solutions, particularly those related to classifying functional and non-functional software requirements. The limited availability of labeled data for training deep learning models and their high computational costs have hindered progress. This study proposes a novel hierarchical transfer learning (HTL) approach to address the challenges of limited training data and high computational costs associated with deep learning models. The HTL model leverages transfer learning techniques, incorporating pre-trained models such as global vectors for word representation (GloVe) for text vectorization and a bidirectional long short-term memory (BiLSTM) architecture. By harnessing knowledge from large text corpora and capturing both high-level semantic relationships and detailed syntactic patterns, the HTL model demonstrates enhanced classification performance. We have evaluated the model's performance using precision, recall, F1-score, and the area under the receiver operating characteristic curve. For FRs classification, we have observed a 26% improvement in precision, a 9% improvement in recall, and an 18% in F1-score for small datasets. Similarly, for NFRs, classification achieves a 20% improvement in precision, a 38.8% improvement in recall, and a 31.8% improvement in F1-score. For large datasets, we have observed a 25% improvement in precision, a 7% improvement in recall, and a 15% improvement in F1-score for FRs classification. For NFRs classification, it achieves a 24% improvement in precision, a 39.8% improvement in recall, and a 41.8% improvement in F1-score. Our study presents a pioneering HTL approach for FRs and NFRs classification, demonstrating superior performance compared to traditional methods. Furthermore, we identify areas for future research, including improving model interpretability, handling data biases, and fine-tuning hyperparameters, which will further enhance the capabilities and applicability of the HTL model. [ABSTRACT FROM AUTHOR]

This paper investigates the integration of cognitive agents powered by Large Language Models (LLMs) within the Scaled Agile Framework (SAFe) to reinforce software project management. By deploying virtual agents in simulated software environments, this study explores their potential to fulfill fundamental roles in IT project development, thereby optimizing project outcomes through intelligent automation. Particular emphasis is placed on the adaptability of these agents to Agile methodologies and their transformative impact on decision-making, problem-solving, and collaboration dynamics. The research leverages the CogniSim ecosystem, a platform designed to simulate real-world software engineering challenges, such as aligning technical capabilities with business objectives, managing interdependencies, and maintaining project agility. Through iterative simulations, cognitive agents demonstrate advanced capabilities in task delegation, inter-agent communication, and project lifecycle management. By employing natural language processing to facilitate meaningful dialogues, these agents emulate human roles and improve the efficiency and precision of Agile practices. Key findings from this investigation highlight the ability of LLM-powered cognitive agents to deliver measurable improvements in various metrics, including task completion times, quality of deliverables, and communication coherence. These agents exhibit scalability and adaptability, ensuring their applicability across diverse and complex project environments. This study underscores the potential of integrating LLM-powered agents into Agile project management frameworks as a means of advancing software engineering practices. This integration not only refines the execution of project management tasks but also sets the stage for a paradigm shift in how teams collaborate and address emerging challenges. By integrating the capabilities of artificial intelligence with the principles of Agile, the CogniSim framework establishes a foundation for more intelligent, efficient, and adaptable software development methodologies. [ABSTRACT FROM AUTHOR]

To address the limitations of Problem-Based Learning (PBL) and to foster student initiative while enhancing teaching quality, the author suggests a novel approach: leveraging big data analysis for teaching quality evaluation and improvement. This method involves conducting diverse and dynamic evaluations, randomly and repeatedly, involving students, teachers, and supervisors. By applying an enhanced Dempster evidence synthesis formula and weights derived from the Analytic Hierarchy Process, the system dynamically calculates each teacher's rating in their respective courses, allowing for continuous improvement. Additionally, personalized feature indicators and teaching quality evaluation metrics are developed to provide a comprehensive assessment. The results indicate that in the coarse evidence set algorithm, is obtained through experience. If is used as the weight alone, the subjectivity is too heavy, and is added for fusion operation, as well as the intervention of experience factor, a balance point between subjectivity and objectivity is found. The final score of 4.2878 was obtained by combining the weights between subjects obtained through Analytic Hierarchy Process, which is consistent with the survey and the public's opinion. This method avoids the deficiency of traditional evidence theory that treats all evidence equally, enhances the ability of information fusion, and obtains more realistic conclusions. Further validated the feasibility and usability of the personalized teaching quality evaluation and improvement model for software engineering. [ABSTRACT FROM AUTHOR]

The agility of Internet of Things (IoT) software engineering is benchmarked based on its systematic insights for wide application support infrastructure developments. Such developments are focused on reducing the interfacing complexity with heterogeneous devices through applications. To handle the interfacing complexity problem, this article introduces a Semantic Interfacing Obscuration Model (SIOM) for IoT software-engineered platforms. The interfacing obscuration between heterogeneous devices and application interfaces from the testing to real-time validations is accounted for in this model. Based on the level of obscuration between the infrastructure hardware to the end-user software, the modifications through device replacement, capacity amendments, or interface bug fixes are performed. These modifications are based on the level of semantic obscurations observed during the application service intervals. The obscuration level is determined using knowledge learning as a progression from hardware to software semantics. The results reported were computed using specific metrics obtained from these experimental evaluations: an 8.94% reduction in interfacing complexity and a 15.04% improvement in integration progression. The knowledge of obscurations maps the modifications appropriately to reinstate the agility testing of the hardware/software integrations. This modification-based semantics is verified using semantics error, modification time, and complexity. [ABSTRACT FROM AUTHOR]

Requirements elicitation is a fundamental process in software engineering, essential for aligning software products with user needs and project objectives. As software projects become more complex, effective elicitation methods are vital for capturing accurate and comprehensive requirements. Despite the variety of available elicitation methods, practitioners face persistent challenges such as capturing tacit knowledge, managing diverse stakeholder needs, and addressing ambiguities in requirements. Moreover, although elicitation is recognized as a core process for gathering and analyzing system objectives, there is a lack of a unified and systematic framework to guide practitioners—especially newcomers—through the activity. To address these challenges, we provide a comprehensive analysis of existing elicitation methods, aiming to contribute to better alignment between software products and project objectives, ultimately improving software engineering practices. We do so by performing a systematic literature review identifying crosscutting steps, common techniques, tools, and approaches that define the core activities of the elicitation process. We synthesize our findings into a metamodel that structures software elicitation processes. This review uncovers various elicitation methods—such as collaborative workshops, interviews, and prototyping—each demonstrating unique strengths in different project contexts. It also highlights significant limitations, including stakeholder misalignment and incomplete requirements capture, which continue to reduce the effectiveness of elicitation processes. Finally, our study seeks to contribute to understanding requirements elicitation methods by providing a comprehensive view of their current strengths and limitations through a metamodel enabling the structuring and optimization of elicitation processes. [ABSTRACT FROM AUTHOR]

Summary: Software architecture assists developers in addressing non‐functional requirements and in maintaining, debugging, and upgrading their software systems. Consequently, consistency between the designed architecture and the implemented software system itself is important; without this consistency the non‐functional requirements targeted may not be addressed and architectural documentation may mis‐direct maintenance efforts that target the associated code‐base. But often, when software is initially implemented or subsequently evolved, the designed architecture and software architecture become inconsistent, with the implemented structure degraded due to issues like developer time‐pressures, or ambiguous communication of the designed architecture. In such cases, Software Architecture Recovery (SAR) or consistency approaches can be applied to reconstruct the architecture of the software system and possibly to compare it to/re‐align it with the designed architecture. Many SAR approaches have been proposed in the research. However, choosing an appropriate architecture recovery approach for software systems is still an open issue. Consequently, this research aims to conduct a tertiary‐mapping study based on available secondary studies of architecture recovery approaches, to uncover important characteristics, towards the selection of appropriate SAR approaches. This research has aggregated 13 secondary studies and 10 primary studies beyond 2020 from 5 databases and, in doing so, identified 111 architecture recovery approaches. Based on these approaches, a taxonomy, containing nine main SAR‐selection categories is proposed and a framework (in the form of a supporting tool to help developers select an appropriate SAR approach) has been developed. Finally, this research identifies six potential open research gaps related to the underlying research that could be helpful for guiding research in the future. [ABSTRACT FROM AUTHOR]

Performance is arguably the most crucial attribute that reflects the quality of a configurable software system. However, given the increasing scale and complexity of modern software, modeling and predicting how various configurations can impact performance becomes one of the major challenges in software maintenance. As such, performance is often modeled without having a thorough knowledge of the software system, but relying mainly on data, which fits precisely with the purpose of deep learning. In this article, we conduct a comprehensive review exclusively on the topic of deep learning for performance learning of configurable software, covering 1,206 searched papers spanning six indexing services, based on which 99 primary papers were extracted and analyzed. Our results outline key statistics, taxonomy, strengths, weaknesses, and optimal usage scenarios for techniques related to the preparation of configuration data, the construction of deep learning performance models, the evaluation of these models, and their utilization in various software configuration-related tasks. We also identify the good practices and potentially problematic phenomena from the studies surveyed, together with a comprehensive summary of actionable suggestions and insights into future opportunities within the field. To promote open science, all the raw results of this survey can be accessed at our repository: https://github.com/ideas-labo/DCPL-SLR. [ABSTRACT FROM AUTHOR]

Infrastructure as Code (IaC) automates IT infrastructure deployment, which is particularly beneficial for continuous releases, for instance, in the context of microservices and cloud systems. Despite its flexibility in application architecture, neglecting security can lead to vulnerabilities. The lack of comprehensive architectural security guidelines for IaC poses challenges in adhering to best practices. We studied how developers interpret IaC scripts (source code) in two IaC technologies, Ansible and Terraform, compared to semi-formal IaC deployment architecture models and metrics regarding design-level security understanding. In a controlled experiment involving ninety-four participants, we assessed the understandability of IaC-based deployment architectures through source code inspection compared to semi-formal representations in models and metrics. We hypothesized that providing semi-formal IaC deployment architecture models and metrics as supplementary material would significantly improve the comprehension of IaC security-related practices, as measured by task correctness. Our findings suggest that semi-formal IaC deployment architecture models and metrics as supplementary material enhance the understandability of IaC security-related practices without significantly increasing duration. We also observed a significant correlation between task correctness and duration when models and metrics were provided. [ABSTRACT FROM AUTHOR]

Effective model management is crucial for ensuring performance and reliability in Machine Learning (ML) systems, given the dynamic nature of data and operational environments. However, standard practices are lacking, often resulting in ad hoc approaches. To address this, our research provides a clear definition of ML model management activities, processes, and techniques. Analyzing 227 ML repositories, we propose a taxonomy of 16 model management activities and identify 12 unique challenges. We find that 57.9% of the identified activities belong to the maintenance category, with activities like refactoring (20.5%) and documentation (18.3%) dominating. Our findings also reveal significant challenges in documentation maintenance (15.3%) and bug management (14.9%), emphasizing the need for robust versioning tools and practices in the ML pipeline. Additionally, we conducted a survey that underscores a shift toward automation, particularly in data, model, and documentation versioning, as key to managing ML models effectively. Our contributions include a detailed taxonomy of model management activities, a mapping of challenges to these activities, practitioner-informed solutions for challenge mitigation, and a publicly available dataset of model management activities and challenges. This work aims to equip ML developers with knowledge and best practices essential for the robust management of ML models. [ABSTRACT FROM AUTHOR]

Code based adversarial attacks play a crucial role in revealing vulnerabilities of software system. Recently, pre-trained programming language models (PLMs) have demonstrated remarkable success in various significant software engineering tasks, progressively transforming the paradigm of software development. Despite their impressive capabilities, these powerful models are vulnerable to adversarial attacks. Therefore, it is necessary to carefully investigate the robustness and vulnerabilities of the PLMs by means of adversarial attacks. Adversarial attacks entail imperceptible input modifications that cause target models to make incorrect predictions. Existing approaches for attacking PLMs often employ either identifier renaming or the greedy algorithm, which may yield sub-optimal performance or lead to high inference times. In response to these limitations, we propose CARL, an unsupervised black-box attack model that leverages reinforcement learning to generate imperceptible adversarial examples. Specifically, CARL comprises a programming language encoder and a perturbation prediction layer. In order to achieve more effective and efficient attack, we cast the task as a sequence decision-making process, optimizing through policy gradient with a suite of reward functions. We conduct extensive experiments to validate the effectiveness of CARL on code summarization, code translation, and code refinement tasks, covering various programming languages and PLMs. The experimental results demonstrate that CARL surpasses state-of-the-art code attack models, achieving the highest attack success rate across multiple tasks and PLMs while maintaining high attack efficiency, imperceptibility, consistency, and fluency. [ABSTRACT FROM AUTHOR]

Quantum annealers are specialized quantum computers for solving combinatorial optimization problems with special quantum computing characteristics, e.g., superposition and entanglement. Theoretically, quantum annealers can outperform classic computers. However, current quantum annealers are constrained by a limited number of qubits and cannot demonstrate quantum advantages. Nonetheless, research is needed to develop novel mechanisms to formulate combinatorial optimization problems for quantum annealing (QA). However, QA applications in software engineering remain unexplored. Thus, we propose BootQA, the very first effort at solving test case minimization (TCM) problems on classical software with QA. We provide a novel TCM formulation for QA and utilize bootstrap sampling to optimize the qubit usage. We also implemented our TCM formulation in three other optimization processes: simulated annealing (SA), QA without problem decomposition, and QA with an existing D-Wave problem decomposition strategy, and conducted an empirical evaluation with three real-world TCM datasets. Results show that BootQA outperforms QA without problem decomposition and QA with the existing decomposition strategy regarding effectiveness. Moreover, BootQA's effectiveness is similar to SA. Finally, BootQA has higher efficiency in terms of time when solving large TCM problems than the other three optimization processes. [ABSTRACT FROM AUTHOR]

Bindings for machine learning frameworks (such as TensorFlow and PyTorch) allow developers to integrate a framework's functionality using a programming language different from the framework's default language (usually Python). In this article, we study the impact of using TensorFlow and PyTorch bindings in C#, Rust, Python and JavaScript on the software quality in terms of correctness (training and test accuracy) and time cost (training and inference time) when training and performing inference on five widely used deep learning models. Our experiments show that a model can be trained in one binding and used for inference in another binding for the same framework without losing accuracy. Our study is the first to show that using a non-default binding can help improve machine learning software quality from the time cost perspective compared to the default Python binding while still achieving the same level of correctness. [ABSTRACT FROM AUTHOR]

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 FROM AUTHOR]