Predictive models in software engineering

Cross-project defect prediction (CPDP) aims to predict software defects in a target project domain by leveraging information from different source project domains, allowing testers to identify defective modules quickly. However, CPDP models often underperform due to different data distributions between source and target domains, class imbalances, and the presence of noisy and irrelevant instances in both source and target projects. Additionally, standard features often fail to capture sufficient semantic and contextual information from the source project, leading to poor prediction performance in the target project. To address these challenges, this research proposes Smote Correlation and Attention Gated recurrent unit based Long Short-Term Memory optimization (SCAG-LSTM), which first employs a novel hybrid technique that extends the synthetic minority over-sampling technique (SMOTE) with edited nearest neighbors (ENN) to rebalance class distributions and mitigate the issues caused by noisy and irrelevant instances in both source and target domains. Furthermore, correlation-based feature selection (CFS) with best-first search (BFS) is utilized to identify and select the most important features, aiming to reduce the differences in data distribution among projects. Additionally, SCAG-LSTM integrates bidirectional gated recurrent unit (Bi-GRU) and bidirectional long short-term memory (Bi-LSTM) networks to enhance the effectiveness of the long short-term memory (LSTM) model. These components efficiently capture semantic and contextual information as well as dependencies within the data, leading to more accurate predictions. Moreover, an attention mechanism is incorporated into the model to focus on key features, further improving prediction performance. Experiments are conducted on apache_lucene, equinox, eclipse_jdt_core, eclipse_pde_ui, and mylyn (AEEEM) and predictor models in software engineering (PROMISE) datasets and compared with active learning-based method (ALTRA), multi-source-based cross-project defect prediction method (MSCPDP), the two-phase feature importance amplification method (TFIA) on AEEEM and the two-phase transfer learning method (TPTL), domain adaptive kernel twin support vector machines method (DA-KTSVMO), and generative adversarial long-short term memory neural networks method (GB-CPDP) on PROMISE datasets. The results demonstrate that the proposed SCAG-LSTM model enhances the baseline models by 33.03%, 29.15% and 1.48% in terms of F1-measure and by 16.32%, 34.41% and 3.59% in terms of Area Under the Curve (AUC) on the AEEEM dataset, while on the PROMISE dataset it enhances the baseline models’ F1-measure by 42.60%, 32.00% and 25.10% and AUC by 34.90%, 27.80% and 12.96%. These findings suggest that the proposed model exhibits strong predictive performance.

The Modeling in Software Engineering (MiSE) workshops are a collaboration between the ICSE and MoDELS research communities, with a focus on using models to facilitate software development.

Scientific discovery related to software is based on a centuries-old paradigm common to all fields of science: setting up hypotheses and testing them through experiments. Repeatedly confirmed hypotheses become models that can describe and predict real-world phenomena. The best-known models in software engineering describe relationships between development processes, cost and schedule, defects, and numerous software -ilities such as reliability, maintainability, and availability. But, compared to other disciplines, the science of software is relatively new. It's not surprising that most software models have proponents and opponents among software engineers. This introduction to the special issue discusses the power of modeling, the promise of data repositories, and the workshop devoted to this topic.

With the tremendous growth in the complexity of software development in the last 1015 years, the management of risks in software engineering activities is becoming an important and non-trivial issue from three perspectives: project, process and product. Therefore, researchers and practitioners are continually trying to find effective risk management approaches. In this paper, we briefly discuss the principles of risk management in software engineering, review some of the process models popular in the software engineering community, and finally discuss some of the important works conducted recently in this area in the last five years. While writing the paper, we have focused mostly on project, and process-based risks and not on product risks.

Context:Deep learning (DL) techniques have gained significant popularity among software engineering (SE) researchers in recent years. This is because they can often solve many SE challenges without enormous manual feature engineering effort and complex domain knowledge.Objective:Although many DL studies have reported substantial advantages over other state-of-the-art models on effectiveness, they often ignore two factors:(1) reproducibility—whether the reported experimental results can be obtained by other researchers using authors’ artifacts (i.e., source code and datasets) with the same experimental setup; and(2) replicability—whether the reported experimental result can be obtained by other researchers using their re-implemented artifacts with a different experimental setup. We observed that DL studies commonly overlook these two factors and declare them as minor threats or leave them for future work. This is mainly due to high model complexity with many manually set parameters and the time-consuming optimization process, unlike classical supervised machine learning (ML) methods (e.g., random forest). This study aims to investigate the urgency and importance of reproducibility and replicability for DL studies on SE tasks.Method:In this study, we conducted a literature review on 147 DL studies recently published in 20 SE venues and 20 AI (Artificial Intelligence) venues to investigate these issues. We also re-ran four representative DL models in SE to investigate important factors that may strongly affect the reproducibility and replicability of a study.Results:Our statistics show the urgency of investigating these two factors in SE, where only 10.2% of the studies investigate any research question to show that their models can address at least one issue of replicability and/or reproducibility. More than 62.6% of the studies do not even share high-quality source code or complete data to support the reproducibility of their complex models. Meanwhile, our experimental results show the importance of reproducibility and replicability, where the reported performance of a DL model could not be reproduced for an unstable optimization process. Replicability could be substantially compromised if the model training is not convergent, or if performance is sensitive to the size of vocabulary and testing data.Conclusion:It is urgent for the SE community to provide a long-lasting link to a high-quality reproduction package, enhance DL-based solution stability and convergence, and avoid performance sensitivity on different sampled data.

A large number of research works have addressed the importance of models in software engineering. However, the adoption of model-based techniques in software organizations is limited since these models are perceived to be expensive and not necessarily cost-effective. Focusing on model-based testing, this paper reports on a series of controlled experiments. It investigates the impact of state machine testing on fault detection in class clusters and its cost when compared with structural testing. Based on previous work showing this is a good compromise in terms of cost and effectiveness, this paper focuses on a specific state-based technique: the round-trip paths coverage criterion. Round-trip paths testing is compared to structural testing, and it is investigated whether they are complementary. Results show that even when a state machine models the behavior of the cluster under test as accurately as possible, no significant difference between the fault detection effectiveness of the two test strategies is observed, while the two test strategies are significantly more effective when combined by augmenting state machine testing with structural testing. A qualitative analysis also investigates the reasons why test techniques do not detect certain faults and how the cost of state machine testing can be brought down.

Recent research on software development environments (SDE) and computer-aided software engineering (CASE) have not addressed the issue of multiple environments. This paper presents an approach for developing an integrated modelling environment (IME) that supports the maintenance of software environment models in software engineering. The approach uses the notion of a composite software development environment maintaining multiple software development environments. The composite is specified by analysing and identifying common features from other environments. These other environments include various government-supported efforts. The idea of a common software development environment may be supported in part by several different international standards or technical approaches (e.g. CAIS, CAIS-A, PCTE, ALMA/metasystems, object-oriented systems, and so forth). Some of these ways are outlined in the paper. An analysis of them in case study form is presented.

This paper conducts a comprehensive analysis based on the typical research of the traditional project-driven teaching model of software programming practice courses. According to the software programming course's own software engineering discipline attributes and the typical development model in enterprise software development, a life cycle model theory based on the software engineering discipline is proposed. As a basis, we can flexibly choose different software development models according to the different scales of project cases used in the classroom, and design teaching links scientifically and rationally according to the typical development process of different models of software engineering. Thereby, a teaching process design plan for software programming courses is formed, which meets the actual needs of the company's position and can reflect the dominant position of students, which is conducive to the cultivation of applied talents with soft engineer qualities in universities.

Towards understanding the impact of data bugs on deep learning models in software engineering

UML and OCL descriptions may be regarded as one fundamental way of formulating models in software engineering. Here, an approach for determining the complexity of OCL expressions based on metrics is studied. Well-chosen metrics, in general, offer support for a developer in ordering, classifying and focusing model elements in terms of importance during the development process for taking decisions. For OCL, fine-grained metrics are known. We develop and validate a new metric for OCL expressions and show how to realize the new and the known metrics. The development was accompanied by a comparative study with modeling experts that gave crucial feedback and influenced overall decisions. We also show how through considering OCL constraints with high metric complexity values, the model validation and verification process can be enhanced.

Background: In model-driven development, model transformation transforms one model to another between different phases of software engineering. In model transformation, metamodel plays a vital role which defines the abstract syntax of models and the interrelationship between their elements. A unified metamodel defines an abstract syntax for both source and target models when they share core elements. Theoretical approaches define language and platform independent representation of models in software engineering. This paper investigates the theoretical foundation to this unified meta-modelling for their consistent transformation. Objective: This paper aims to define the formal foundations to the unified metamodel for generating implementation from design specifications and model reusability. Method: In this paper, the study considers transformation from design to implementation and vice versa using theoretical foundations to build a verified software system. Results: The related tools provide a formal representation of the design phase for verification purpose. Our approach provides a set-theoretical foundation to the unified metamodel for model transformation from USE (UML/OCL) to Spec#. In other words, our approach defines the formal foundation to define a model which consists of all the required properties for verification at the design and implementation phase. Conclusion: This paper introduced a new set of the theoretical framework which acts as an interface between the design and implementation to generate verified software systems.

Model driven development (MDD) aims to promote the role of modeling in software engineering. Enterprise systems and architectures are often modeled via multiple representations. For example UML models are widely used by the designers to capture various viewpoint of the system; while formal models using languages such as CSP, Z and Petri nets are suitable for the analysis. Model transformation techniques developed as a part of MDD can be applied to generate one model from another model automatically. This allows benefiting from the tools and techniques developed and used in multiple languages. This paper presents a method of applying MDD model transformation from UML 2.0 sequence diagrams to Petri nets. The paper shows that the model transformation results in free choice Petri nets. As a result, the low complexity of analysis and the synthesis techniques can be applied to the models of enterprise systems which are captured in UML sequence diagrams.

There exist two ongoing large repositories of software projects in the software engineering community: the repository of the International Software Benchmarking Standards Group (ISBSG) and the Repository referred to as PROMISE (PRedictOr Models In Software Engineering). Researchers interested in using the datasets have to conduct their own analysis of the datasets within these repositories that figure out what contents are suitable for their purposes. Repositories designed without users (researchers and Industrial) needs in mind greatly are more challenging to use. This paper present an analysis of both repositories and provide users with additional information on these datasets by identifying the topics addressed, highlighting their descriptiveness, and their availability, and by indicating whether or not further details are available in order to enhance their reusability in further empirical studies. Recommendations to both PROMISE managers and datasets owners are also suggested to improve the usefulness of the data provided.

The University of Southern California (USC) teaches a two-semester real-client project course as a core course in USC's MSCS-SE (Master of Science in Computer Science and Software Engineering) degree program. The course has evolved rapidly, each year introducing many changes in order to satisfy the course stakeholder's win conditions. The course has also been our primary experimental testbed for evolving our MBASE (Model-Based Architecting and Software Engineering) model integration framework. In turn, this framework, along with the CRESST (Center for Research on Evaluation, Standards and Student Testing) cognitive demands analysis has served as an effective means of managing the course's rapid evolution. A further test of the framework has been its application to undergraduate software engineering project courses at other institutions. This paper provides a description and examples of USC's experience in constructing and evolving a family of software engineering project courses based on the MBASE software engineering model integration framework. A discussion of course needs, use of software engineering models, a description of MBASE, use of the CRESST model of learning objectives, course development and experiences are presented. The approach has been used successfully at Columbia University and to a lesser degree at other institutions. Much of the current and historical materials and resources described in this paper are freely available for educational use.

Summary form only given. Since its adoption in 1997, the unified modeling language (UML) has proved very popular with software engineers and has become the de facto standard as a visual modeling language for software engineers. However, this software focus of UML has discouraged many systems engineers from adopting it in earnest. Those who did adopt UML developed strategies to cope with its shortcomings. A common approach was to model additional systems engineering concepts in other modeling tools. This made it difficult to integrate the different viewpoints and achieve traceability. Fortunately, with the release of UML 2.0 and the ensuing extensions to it in SysML - the soon-to-be adopted systems modeling language - the systems engineering community has a real alternative to systems modeling that provides a more integrated approach to systems and software engineering. Since its inception in 1997, ARTiSAN has endeavored to bridge the gap between systems and software engineering modeling by adding systems engineering extensions to the UML and, as a key member of the SysML initiative, is well poised to support these emerging standards for systems and software modeling. This presentation will provide a brief overview of the major extensions proposed by SysML, and will summarize how ARTiSAN's latest release of its flagship product Studio (version 6.0) takes the lead in supporting these concepts.