Abstract Testing software product lines represents a challenging task mainly because there are many derivable products. To facilitate this issue, multiple solutions were developed to reduce the number of products that are tested while maintaining a good percentage of coverage. However, the order of testing products has received little consideration. The purpose of this research is twofold: first, to replicate the results of a previous study (which uses two specific metrics for prioritization, namely, Variability Coverage & Cyclomatic Complexity - VC&CC, and Coefficient of Connectivity-Density - CoC), and second, to investigate two new metrics to be used as prioritization criteria (Ratio of Variability - RoV, and Flexibility of Configuration - FoC). The APFD (Average Percentage of Faults Detected) metric is used to evaluate the results obtained. In the investigation, a set of 9 feature models with various numbers of features, grouped in three intervals, was used. The results show that the original findings are confirmed for all feature models used. Regarding the new criteria used, FoC and RoV outperformed the CoC metric in 6 out of 9 cases, and also obtained the best results in 3 out of 9 cases. In the other 6 out of 9 cases the VC&CC criterion obtained the best results.

Abstract With increasing complexity and importance in the society of software systems, testing software products becomes increasingly challenging and one of the problems that appears is determining the correct output given an input, named the test oracle problem. The aim of the paper is two fold: (1) to replicate the findings in a previous work regarding the use of various neural network models for the test oracle problem, and (2) to investigate further aspects regarding hyperparameter optimization by using the L4 Taguchi approach. Three datasets were used, two from previous studies and one created. In the execution of the experiment it is also simulated the real regression testing process by using mutation datasets. The results from the replication experiments show similar results to the ones from the original research, on the Triangle dataset, the ANN (Artificial Neural Networks) has a 0.12 MARE (Mean Absolute Relative Error) score while RBF (Radial Basis Function) 0.23; however, for both Bank Credit and Heart Risk datasets the RBF obtained the best MARE results, 0.09 and 0.12. The Taguchi L4 method does not offer a single optimal solution for a model for all datasets, but we can observe some trends in the results. Across all experiments, for the epochs parameters it seems that the best results are for 100 for all datasets and for the two models, except for the triangle dataset and ANN model. Regarding the hidden layers, best results are for the 50 nodes in the case of the ANN and 350 nodes in case of the RBF.

Software testing plays a critical role in the development workflow. Nowadays, the significance of teaching software testing principles is recognized to a greater extent than ever before. The aim of this paper is twofold: (1) to investigate the effectiveness of using a flipped classroom-based context to teach software bug advocacy, and (2) to provide the student's perspective on using flipped classroom to learn how to advocate for a bug. A seminar activity dedicated to bug reports and how to advocate for a bug is the framework for this investigation, with students being split into teams with the aim to perform two major activities: poster creation for one of the strategies from the RIMGEN mnemonics and providing advocacy strategies for a 3 years old bug. The created artifacts and the answers to a questionnaire dedicated to the learning experience are used as tools to analyze and provide answers to research questions. The results show that flipped classroom-based learning is effective in teaching how to advocate for a software bug. Around 87.75% of students agreed that the poster creation activity helped them better retain the information. A percentage of 61.22% students agreed that time was spent more effectively in class since the text was read outside the classroom, and 82.66% of students also agree that this type of learning provides them with the opportunity to communicate with other students.

Testing with proper bug investigation steps is an essential component in the development process. Teaching and learning bug investigation are nowadays performed in different contexts, with learners having different testing skills. The aim of this paper is to report on using experiential learning for discovering the bug investigation steps. Two learning settings were investigated: informal vs formal learning, in-person vs online learning, testing practitioners vs students participants. Both meetings used game-based activities to engage participants and facilitate learning. We report on the results of activities with both practitioners and students, distilling valuable lessons for reproducing this approach of experiential learning in learning bug investigation: the used games as system under test provided a fun way of learning and motivated students to participate in the activities, reflection on their actions and the reason behind their actions lead to the development of bug investigation models by the two groups. There are similarities and differences in the bug investigation steps models and in the way the groups perceived the experiential learning. Using games to experience the testing process was considered essential to the learning process, along with the experiential learning methodology.

Software testing is an essential aspect of software development, ensuring the reliability, functionality, and overall quality of software products. Integration testing, a critical phase in the testing hierarchy, verifies interactions between software components. However, teaching integration testing presents challenges due to its complexity and abstract nature. To address these issues, this study explores the use of the VARK learning model - Visual, Auditory, Reading/Writing, and Kinesthetic - to design and implement multimodal activities that cater to diverse learning styles. A cohort of students engaged in VARK-based activities aimed at improving their understanding of integration testing concepts. The results indicated improved student engagement and comprehension, with participants demonstrating a greater ability to apply theoretical knowledge in practical testing scenarios (increase correctness from 80% to 93% and from 50% to 70% for several testing concepts). Around 60% of students agreed that VARK learning created a better understanding of how to use and apply integration testing. This paper discusses the implementation of these activities, their outcomes, and the potential of VARK-based approaches to advance technical education, especially in software engineering. These findings provide insights for educators looking for innovative methods to teach complex technical concepts effectively.

Predicting software defects is crucial for ensuring reliable systems and is a critical concern for the industry. Automating the Defect detection process in software programs can significantly reduce errors, development time, and costs. This paper has two primary aims: to generalize the findings of a previous study through replication and to provide new insights through an extension study using a different prediction model. For the replication study, three methods are used: Naive Bayes (NB), Decision Tree (DT), and Random Forest (RF) algorithm. All models used in this research were used before and after the Hybrid Feature Selection (HFS) method. This paper also provides an extension study that incorporates Support Vector Machines (SVM) that allowed a more comprehensive understanding of the impact of HFS and oversampling on classifier performance. The replicated results confirmed the original findings: the Random Forest algorithm consistently achieved the highest accuracy across datasets. In the extension study, SVM demonstrated superior performance in detecting minority class defects, as reflected in its higher Matthew’s Correlation Coefficient (MCC) scores, particularly for the PC3 dataset. This research establishes a foundation for the use of SVM along with other classifiers to address challenges in software Defect prediction.

In a world where software systems grow continuously, adding a considerable amount of features after periods of time, it is important to know that the teams can also vary, with different people leaving or joining the process. When new people join a software product, resources are spent understanding the program, a process that could use improvements. This paper proposes a software visualization plugin for object-oriented systems, CodeVestimenta, created as a new metaphor in the form of clothing. Each class of the system is drawn as a specific piece of clothing, with each piece of clothing depicted with various features depending on seven software quality metrics (Lines of Code, Number of Class Members, Number of Class Methods, Number of Child Classes, Depth of Inheritance Treen, Response for Class, and Coupling Between Objects) widely used in software applications. CodeVestimenta was created with the objective of enhancing the program comprehension and understandability of the code by the developer by finding parts of the code that are the application’s core or are more complex than others. An empirical study was conducted to validate CodeVestimenta. Participants (41 in total) had diverse backgrounds in terms of industry experience and software metrics, and were divided into two groups (Text Group and Visual Group) having different available resources for code comprehension (code, metrics values, and visual representation). The program comprehension tasks were built around four major scopes that were embedded into ten questions. The results show that CodeVestimenta helps developers to understand parts of the system that are not visible at first glance, with improvements in the speed of this process and the level of understanding.

Abstract Success in software projects is now an important challenge. The main focus of the engineering community is to predict software defects based on the history of classes and other code elements. However, these software defect prediction techniques are effective only as long as there is enough data to train the prediction model. To mitigate this problem, cross-project defect prediction is used. The purpose of this research investigation is twofold: first, to replicate the experiments in the original paper proposal, and second, to investigate other settings regarding defect prediction with the aim of providing new insights and results regarding the best approach. In this study, three composite algorithms, namely AvgVoting, MaxVoting and Bagging are used. These algorithms integrate multiple machine classifiers to improve cross-project defect prediction. The experiments use pre-processed methods (normalization and standardization) and also feature selection. The results of the replicated experiments confirm the original findings when using raw data for all three methods. When normalization is applied, better results than in the original paper are obtained. Even better results are obtained when feature selection is used. In the original paper, the MaxVoting approach shows the best performance in terms of the F-measure, and BaggingJ48 shows the best performance in terms of cost-effectiveness. The same results in terms of F-measure were obtained in the current experiments: best MaxVoting, followed by AvgVoting and then by BaggingJ48. Our results emphasize the previously obtained outcome; the original study is confirmed when using raw data. Moreover, we obtained better results when using preprocessing and feature selection.

The quality of software systems is an important aspect, especially for embedded systems, thus strategies and actions for analyzing the trade-off between various quality attributes need to be improved. Objectives: We target firstly to determine which quality attributes are important in embedded systems, and secondly to inquire about maintainability in particular, emphasizing the practices that are associated with it, i.e., coding rules, conventions, documentation, code review, and refactoring. Method: We used interviews and surveys as means to investigate practitioners’ points of view and practices. Applying quantitative and qualitative analysis, we explored a general perspective of quality attributes in embedded systems, followed by specific practices related to the maintainability attribute. Results: At the general perspective level, we learned that the importance of security and safety is extended to all embedded systems, while maintainability remains of major importance, and there is a diversity of methods used to assure the quality of systems throughout the development cycle . At the maintainability-specific level, we learned that code review and refactoring are the most used practices and that the related activities are performed in a variety of ways. Conclusions: Our work recognizes various quality attributes as being important with different priorities, respectively analyses which maintainability-related activities are used.

Reliability is one of the most important quality attributes of a software system, addressing the system’s ability to perform the required functionalities under stated conditions, for a stated period of time. Nowadays, a system failure could threaten the safety of human life. Thus, assessing reliability became one of the software engineering‘s holy grails. Our approach wants to establish based on what project’s characteristics we obtain the best bug-oriented reliability prediction model. The pillars on which we base our approach are the metric introduced to estimate one aspect of reliability using bugs, and the Chidamber and Kemerer (CK) metrics to assess reliability in the early stages of development. The methodology used for prediction is a feed-forward neural network with back-propagation learning. Five different projects are used to validate the proposed approach for reliability prediction. The results indicate that CK metrics are promising in predicting reliability using a neural network model. The experiments also analyze if the type of project used in the development of the prediction model influences the quality of the prediction. As a result of the operated experiments using both within-project and cross-project validation, the best prediction model was obtained using PDE (PlugIn characteristic) for MY project (Task characteristic).

Abstract Software Product Lines (SPLs) make it possible to configure a single system based on features in order to create many different variants and cater to a wide range of customers with varying requirements. This configuration space is often modeled using Feature Models (FMs). However, in practice, the SPL (and consequently the FM) is often created after a set of variants has already been created manually. Automating the task of reverse engineering a feature model that describes a set of variants makes the process of adopting an SPL easier. The genetic programming pipeline is a good fit for feature models and has been shown to produce good reverse engineering results. In this paper, we replicate the results of such an existing approach with a larger set of feature models and investigate the effects of various genetic programming parameters and operators on the results. The design of our replication experiments employs three perspectives: duplicate the exact conditions using various features models, study the interaction of two parameters of the genetic programming approach, and optimize the values for the population and generation parameters and for the mutation and crossover operators. Results reinforce the previously obtained outcome, the original study being confirmed. The relations between the number of features and number of generations, respectively number of features and size of populations were also investigated and best values based on obtained results are provided. The current study also aimed to optimize various parameters of the genetic programming approach, the interpretation of those experiments discovering concrete values.

This Research to Practice Full Paper delineates the impact of using cyclic learning to obtain competences in software quality oriented design. Nowadays, the need for quality in the software systems has become more and more a concern for many researchers and industry practitioners. Developing students' appropriate competencies and skills in writing quality programs must be an important objective of any Software Engineering related course from the Computer Science Curricula. In order to attain this goal, the paper presents a new strategy for reflecting software quality models into Software Engineering related courses based on cyclic learning. The method is based on an educational strategy that integrates the cyclic learning approach and induces to the students the awareness regarding the importance of developing quality software. We focus on a set of software quality characteristics described by the ISO25010 quality model for which we analyze the level of knowledge attained by the students during the entire bachelor cycle of studies. The study is directed by a detailed analysis of three courses: Advanced Programming Methods, Parallel and Distributed Programming, and Software Systems Verification and Validation, which were chosen in order to master the analysis complexity, but at the same time to assure coverage of as many quality attributes as possible. The investigation includes qualitative and quantitative analysis, directed by the objective of establishing the efficiency and effectiveness of the approach. The results obtained confirm both students' awareness regarding the importance of learning software quality attributes, and the efficiency of using cyclic learning in teaching this subject. We also outline several insights and advantages, and we conclude by showing that the proposed strategy fulfilled the expected objectives.

This Research to Practice Full Paper proposes a novel incremental approach in teaching a Software Engineering related course, underpinned by active-learning methods. Teaching a Software Engineering related course for undergraduate students is a challenging task due to extremely frequent changes that appeared in programming paradigms and in software process development methodologies. In this everchanging domain, which presents us with opportunities and challenges every single day, it might be difficult and almost impossible for teachers to predict what are those knowledge that will be of use to students, on the long term, maybe even for five years from now. This rapid growth in the software development evolution has led to a gap between how teachers do knowledge transfer to students and how students acquire these knowledge. To bridge this gap there is a need to change how we teach these subjects. Thus, the new theory of education suggests that learner should be in the center of the learning process and the instructors playing an advising and facilitating role. A shift in education theory to a more student-centered approach using active learning is recommended because this approach has its own role to make the students creative and competent in their study. In this respect, active learning's main drive is to put the responsibility of learning at the hands of the learners themselves and to delegate the role of facilitator to the teacher. In this paper we provide novel approaches in teaching an undergraduate Software Engineering related course at the Babeş-Bolyai University. Its contribution is threefold: firstly, we introduce a new learning process design which selects active learning methods intertwining in teaching this course; secondly, we aim to study the impact of applying active learning methods on students' grades over the three academic years. Thirdly, we investigate students perceptions, their feedback and learning experiences on the use of applying active learning methods. Also, the paper reviews challenges and constraints that we faced while trying to teach this course. The analysis results show the effectiveness of our approach. Also, our students have expressed a high level of satisfaction, and in a survey, they indicated that the skills they learned in the course are highly applicable to their careers, facilitating their interviews for the engagement within IT companies.

Regression testing is used every time a change is taking place in the source code, various approaching for the test cases to be executed focusing on different criteria: from the maximization of faults and/or code coverage to minimization of time execution. Test Case Prioritization is one of such approaches that aim to optimize the execution order of test cases according to various criteria. However, many regression testing approaches use only code coverage criteria, few considered requirements. This paper aims to propose a fuzzy clustering approach with various metrics of the considered test cases, considering several aspects: faults, execution time, requirements covered by the test cases, and requirements dependencies. An in-depth analysis will follow to determine what are the best metrics to be used in the TCP. This will have a positive impact on the research community by identifying new perspectives to be considered for the TCP.

This Research to Practice Ful1 Paper presents a study regarding applying cyclic learning strategy with a special focus on object-oriented programming and states our findings, emphasizing both the advantages and disadvantages.The research considers as a use-case the teaching activity in the Faculty of Computer Science of Babeş-Bolyai University. The analysis takes into consideration several disciplines that compass a set of interconnected teaching objectives and aspects: (1) fundamental concepts and mechanisms (F) defined by object-orientated programming paradigm, (2) design principles, heuristics, and rules (D) that act as strategies implied in object-oriented design, and (3) functional and nonfunctional requirements related to software architecture (A).The study is directed by a statistical analysis of the grades obtained by the students at different courses that treat the (F, D, A) aspects, and also the results obtained at the Bachelor's final exam that evaluates the level of the acquired fundamental knowledge. Their evolution and correlation during a period of several years are analyzed, and together with an analysis of the degree of absorption of the students in the IT industry form the base of the study.

Component selection is a crucial problem in Component Based Software Engineering (CBSE). CBSE is concerned with the assembly of pre-existing software components that leads to a software system that responds to client-specific requirements. This work deals with the component selection problem which we formulate as multiobjective optimization, involving four objectives: the number of used components, the number of new requirements, the number of provided interfaces and the number of the initial requirements that are not in solution. We use the Pareto dominance principle to deal with the multiobjective optimization problem. Needles to say the last two objectives should be zero. Afterwards, we investigate the problem in an dynamic or changing environment for which two practical scenarios are envisaged: the repository containing the components varies over time and the system requirements change over time. The algorithm employed uses a combination of evolutionary algorithms and repair mechanism. The idea behind this was to avoid restarting the algorithm from randomly generated solutions and to make use of the ones found at the previous step.