Modern software systems require various capabilities to meet architectural and operational demands, such as the ability to scale automatically and recover from sudden failures. Self-adaptive software systems have emerged as a critical focus in software design and operation due to their capacity to autonomously adapt to changing environments. However, educating students on this topic is scarce in academia, and a survey among practitioners identified that the lack of knowledgeable individuals has hindered its adoption in the industry. In this paper, we present our experience teaching a course on selfadaptive software systems that integrates theoretical knowledge and hands-on learning with industry-relevant technologies. To close the gap between academic education and industry practices, we incorporated guest lectures from experts and showcases featuring industry professionals as judges, improving technical and communication skills for our students. Feedback based on surveys from 21 students indicates significant improvements in their understanding of self-adaptive systems. The empirical analysis of the developed course demonstrates the effectiveness of the proposed course syllabus and teaching methodology. In addition, we provide a summary of the educational challenges of running this unique course, including balancing theory and practice, addressing the diverse backgrounds and motivations of students, and integrating the industry-relevant technologies. We believe these insights can provide valuable guidance for educating students in other emerging topics within software engineering.

Tahvildari, L. and Kontogiannis, K. (2004), Improving design quality using meta-pattern transformations: a metric-based approach. J Softw Maint Evol: Res Pract, 16: 331–361. https://doi.org/10.1002/smr.299 In the online version, the corresponding author's surname was incorrect. It should read as “Tahvildari” We apologize for this error.

Nearest neighbor search is a basic and recurring proximity problem that has been studied for several decades. The goal is to preprocess a dataset of points so that we can quickly report the closet point(s) to any query point. Many recent applications of NNS involve datasets that are very large and dynamic, that is items of data items become available gradually. In this study, we propose a data structure for solving NNS for dynamic binary data where both query and dataset items are represented as binary strings. The proposed tree data structure, called the Hamming Weight Tree, is simple and as the names suggests, is based on partitioning the feature space of binary strings by exploiting the Hamming weights of the binary codes and their substrings. Given a Hamming Weight Tree of binary codes, we propose two search algorithms that accommodate nearest neighbor search for two different distance functions, the Hamming distance and the angular distance. Our empirical results show significant speedup in comparison with the best known large-scale solutions.

Hashing methods, which encode high-dimensional images with compact discrete codes, have been widely applied to enhance large-scale image retrieval. In this paper, we put forward Deep Spherical Quantization (DSQ), a novel method to make deep convolutional neural networks generate supervised and compact binary codes for efficient image search. Our approach simultaneously learns a mapping that transforms the input images into a low-dimensional discriminative space, and quantizes the transformed data points using multi-codebook quantization. To eliminate the negative effect of norm variance on codebook learning, we force the network to L2normalize the extracted features and then quantize the resulting vectors using a new supervised quantization technique specifically designed for points lying on a unit hypersphere. Furthermore, we introduce an easy-to-implement extension of our quantization technique that enforces sparsity on the codebooks. Extensive experiments demonstrate that DSQ and its sparse variant can generate semantically separable compact binary codes outperforming many state-of-the-art image retrieval methods on three benchmarks.

Given a large dataset of binary codes and a binary query point, we address how to efficiently find$K$codes in the dataset that yield the largest cosine similarities to the query. The straightforward answer to this problem is to compare the query with all items in the dataset, but this is practical only for small datasets. One potential solution to enhance the search time and achieve sublinear cost is to use a hash table populated with binary codes of the dataset and then look up the nearby buckets to the query to retrieve the nearest neighbors. However, if codes are compared in terms of cosine similarity rather than the Hamming distance, then the main issue is that the order of buckets to probe is not evident. To examine this issue, we first elaborate on the connection between the Hamming distance and the cosine similarity. Doing this allows us to systematically find the probing sequence in the hash table. However, solving the nearest neighbor search with a single table is only practical for short binary codes. To address this issue, we propose the angular multi-index hashing search algorithm which relies on building multiple hash tables on binary code substrings. The proposed search algorithm solves the exact angular$K$nearest neighbor problem in a time that is often orders of magnitude faster than the linear scan baseline and even approximation methods.

We revisit the K Nearest Neighbors (KNN) problem in large binary datasets which is of major importance in several applied areas. The goal is to find the K nearest items in a dataset to a query point where both the query and the items lie in the Hamming cube. The problem is addressed in its online setting, that is, data items are inserted sequentially into the dataset. To accommodate efficient similarity search and fast insertion of new items, we propose a data structure that partitions the feature space based on the Hamming weights of the binary codes and their substrings. Empirical evaluations on a large-scale dataset show significant speedup over the linear scan baseline.

Test case prioritization aims at ordering test cases to increase the rate of fault detection, which quantifies how fast faults are detected during the testing phase. A common approach for test case prioritization is to use the information of previously executed test cases, such as coverage information, resulting in an iterative (greedy) prioritization algorithm. Current research in this area validates the fact that using coverage information can improve the rate of fault detection in prioritization algorithms. The performance of such iterative prioritization schemes degrade as the number of ties encountered in prioritization steps increases. In this paper, using the notion of lexicographical ordering, we propose a new heuristic for breaking ties in coverage based techniques. Performance of the proposed technique in terms of the rate of fault detection is empirically evaluated using a wide range of programs. Results indicate that the proposed technique can resolve ties and in turn noticeably increases the rate of fault detection.

The main quest for cloud stakeholders is to find an optimal deployment architecture for cloud applications that maximizes availability, minimizes cost, and addresses portability and scalability. Unfortunately, the lack of a unified definition and adequate modeling language and methodologies that address the cloud domain specific characteristics makes architecting efficient cloud applications a daunting task. This paper introduces Stratus ML: a technology agnostic integrated modeling framework for cloud applications. Stratus ML provides an intuitive user interface that allows the cloud stakeholders (i.e., providers, developers, administrators, and financial decision makers) to define their application services, configure them, specify the applications' behaviour at runtime through a set of adaptation rules, and estimate cost under diverse cloud platforms and configurations. Moreover, through a set of model transformation templates, Stratus ML maintains consistency between the various artifacts of cloud applications. This paper presents Stratus ML and illustrates its usefulness and practical applicability from different stakeholder perspectives. A demo video, usage scenario and other relevant information can be found at the Stratus ML webpage.

Defect prioritization is a decision making process wherein stakeholders determine the temporal order of open defects to be fixed. It is critical to the software development lifecycle as the decisions made during this process directly affect release planning, resource management, and maintenance costs. In fact, defect prioritization is complex as many factors need to be taken into consideration and the decisions made can be subjective or incorporate inherent knowledge and intuition of decision makers. We believe that managing the complexities of the decision making process can provide valuable support and help in uncovering any inconsistencies in the interpretation of criteria to prioritize defects. In this paper, we explore the defect triaging process in Research In Motion to gain a better understanding of the shortcomings and challenges of the current practices. Based on our findings, we sketch some research directions to improve industrial software defect prioritization.

Duplicate defects put extra overheads on software organizations, as the cost and effort of managing duplicate defects are mainly redundant. Due to the use of natural language and various ways to describe a defect, it is usually hard to investigate duplicate defects automatically. This problem is more severe in large software organizations with huge defect repositories and massive number of defect reporters. Ideally, an efficient tool should prevent duplicate reports from reaching developers by automatically detecting and/or filtering duplicates. It also should be able to offer defect triagers a list of top-N similar bug reports and allow them to compare the similarity of incoming bug reports with the suggested duplicates. This demand has motivated us to design and develop a search-based duplicate bug detection framework at BlackBerry. The approach follows a generalized process model to evaluate and tune the performance of the system in a systematic way. We have applied the framework on software projects at BlackBerry, in addition to the Mozilla defect repository. The experimental results exhibit the performance of the developed framework and highlight the high impact of parameter tuning on its performance.

SUMMARY Self‐adaptive software is a closed‐loop system, since it continuously monitors its context (i.e. environment) and/or self (i.e. software entities) in order to adapt itself properly to changes. We believe that representing adaptation goals explicitly and tracing them at run‐time are helpful in decision making for adaptation. While goal‐driven models are used in requirements engineering, they have not been utilized systematically yet for run‐time adaptation. To address this research gap, this article focuses on the deciding process in self‐adaptive software, and proposes the Goal‐Action‐Attribute Model (GAAM). An action selection mechanism, based on cooperative decision making, is also proposed that uses GAAM to select the appropriate adaptation action(s). The emphasis is on building a light‐weight and scalable run‐time model which needs less design and tuning effort comparing with a typical rule‐based approach. The GAAM and action selection mechanism are evaluated using a set of experiments on a simulated multi‐tier enterprise application, and two sample ordinal and cardinal action preference lists. The evaluation is accomplished based on a systematic design of experiment and a detailed statistical analysis in order to investigate several research questions. The findings are promising, considering the obtained results, and other impacts of the approach on engineering self‐adaptive software. Although, one case study is not enough to generalize the findings, and the proposed mechanism does not always outperform a typical rule‐based approach, less effort, scalability, and flexibility of GAAM are remarkable. Copyright © 2011 John Wiley & Sons, Ltd.

To ensure that a modified software system has not regressed, one approach is to rerun existing test cases. However, this is a potentially costly task. To mitigate the costs, the testing effort can be optimized by executing only a selected subset of the test cases that are believed to have a better chance of revealing faults. This paper proposes a novel approach for selecting and ordering a predetermined number of test cases from an existing test suite. Our approach forms an Integer Linear Programming problem using two different coverage-based criteria, and uses constraint relaxation to find many close-to-optimal solution points. These points are then combined to obtain a final solution using a voting mechanism. The selected subset of test cases is then prioritized using a greedy algorithm that maximizes minimum coverage in an iterative manner. The proposed approach has been empirically evaluated and the results show significant improvements over existing approaches for some cases and comparable results for the rest. Moreover, our approach provides more consistency compared to existing approaches.

To modernize legacy software into adaptable software, a program understanding procedure is needed to study software for identifying the mechanisms that support adaptability. Though the procedure can benefit from modeling techniques, current software meta-models do not fully support particular aspects of software adaptability. The goal of this research is to develop a meta-model, which facilitate comprehending applications for adaptability by annotating a set of pre-determined adaptability factors in software models. To this end, we investigate application-level sensing and effecting mechanisms, identify the core adaptability factors, and propose a meta-model for adaptability.

Regression testing is an expensive process used to validate modified software. Test case prioritization techniques improve the cost-effectiveness of regression testing by ordering test cases such that those that are more important are run earlier in the testing process. Many prioritization techniques have been proposed and evidence shows that they can be beneficial. It has been suggested, however, that the time constraints that can be imposed on regression testing by various software development processes can strongly affect the behavior of prioritization techniques. If this is correct, a better understanding of the effects of time constraints could lead to improved prioritization techniques and improved maintenance and testing processes. We therefore conducted a series of experiments to assess the effects of time constraints on the costs and benefits of prioritization techniques. Our first experiment manipulates time constraint levels and shows that time constraints do play a significant role in determining both the cost-effectiveness of prioritization and the relative cost-benefit trade-offs among techniques. Our second experiment replicates the first experiment, controlling for several threats to validity including numbers of faults present, and shows that the results generalize to this wider context. Our third experiment manipulates the number of faults present in programs to examine the effects of faultiness levels on prioritization and shows that faultiness level affects the relative cost-effectiveness of prioritization techniques. Taken together, these results have several implications for test engineers wishing to cost-effectively regression test their software systems. These include suggestions about when and when not to prioritize, what techniques to employ, and how differences in testing processes may relate to prioritization cost--effectiveness.

The testing activities of the Software Verification and Validation (SV&V) team at Research In Motion (RIM) are requirements-based, which is commonly known as requirements-based testing (RBT). This paper proposes a novel approach to enhance the current RBT process at RIM, by utilizing historical testing data from previous releases, static analysis of the modified source code, and real-time execution data. The main focus is on the test case generation phase and the objective is to increase the effectiveness and efficiency of test cases in such a way that overall testing is improved. The enhanced process not only automatically generates effective test cases but also seeks to achieve high test coverage and low defect escape rate.

Predicting changes in software entities (e.g. source files) that are more likely to change can help in the efficient allocation of the project resources. A powerful change prediction tool can improve maintenance and evolution tasks in software projects in terms of cost and time factors. The vast majority of research works have focused on determining "where" the most change-prone entities are, and "how" the change will be propagated through a system. This article suggests that knowing "when" changes are likely to happen can also provide another consideration for managers and developers to plan their maintenance activities more efficiently. To address this issue, a Neural Network-based Temporal Change Prediction (NNTCP) framework is proposed. This novel framework indicates "where" the changes are likely to happen (i.e. hot spots), and then adds the time dimension to predict "when" it may occur. In proving this concept, the NNTCP framework is applied in two large-scale open source software projects, Mozilla and Eclipse. The results obtained indicate NNTCP can predict the occurrence of several future revisions with reasonable performance.

Software systems dealing with distributed applications in changing environments normally require human supervision to continue operation in all conditions. These (re-)configuring, troubleshooting, and in general maintenance tasks lead to costly and time-consuming procedures during the operating phase. These problems are primarily due to the open-loop structure often followed in software development. Therefore, there is a high demand for management complexity reduction, management automation, robustness, and achieving all of the desired quality requirements within a reasonable cost and time range during operation. Self-adaptive software is a response to these demands; it is a closed-loop system with a feedback loop aiming to adjust itself to changes during its operation. These changes may stem from the software system'sself(internal causes, e.g., failure) orcontext(external events, e.g., increasing requests from users). Such a system is required tomonitoritself and its context,detectsignificant changes,decidehow to react, andactto execute such decisions. These processes depend on adaptation properties (called self-* properties), domain characteristics (context information or models), and preferences of stakeholders. Noting these requirements, it is widely believed that new models and frameworks are needed to design self-adaptive software. This survey article presents a taxonomy, based on concerns of adaptation, that is,how,what,whenandwhere, towards providing a unified view of this emerging area. Moreover, as adaptive systems are encountered in many disciplines, it is imperative to learn from the theories and models developed in these other areas. This survey article presents a landscape of research in self-adaptive software by highlighting relevant disciplines and some prominent research projects. This landscape helps to identify the underlying research gaps and elaborates on the corresponding challenges.

The two papers in this special section are extended and enhanced versions of ones presented at the International Conference on Software Maintenance (ICSM), held in Paris, France, on 2-5 October 2007.

A cost effective approach to regression testing is to prioritize test cases from a previous version of a software system for the current release. We have previously introduced a new approach for test case prioritization using Bayesian Networks (BN) which integrates different types of information to estimate the probability of each test case finding bugs. In this paper, we enhance our BN-based approach in two ways. First, we introduce a feedback mechanism and a new change information gathering strategy. Second, a comprehensive empirical study is performed to evaluate the performance of the approach and to identify the effects of using different parameters included in the technique. The study is performed on five open source Java objects. The obtained results show relative advantage of using feedback mechanism for some objects in terms of early fault detection. They also provide insight into costs and benefits of the various parameters used in the approach.

Regression testing is an expensive process used to validate modified software. Test case prioritization techniques improve the cost-effectiveness of regression testing by ordering test cases such that those that are more important are run earlier in the testing process. Many prioritization techniques have been proposed and evidence shows that they can be beneficial. It has been suggested, however, that the time constraints that can be imposed on regression testing by various software development processes can strongly affect the behavior of prioritization techniques. Therefore, we conducted an experiment to assess the effects of time constraints on the costs and benefits of prioritization techniques. Our results show that time constraints can indeed play a significant role in determining both the cost-effectiveness of prioritization, and the relative cost-benefit tradeoffs among techniques, with important implications for the use of prioritization in practice.

During software evolution, developers modify various modules to handle new requirements or to fix existing bugs. Such changes usually propagate to related modules throughout the system. Program comprehension techniques are able to predict this change propagation phenomenon. In this paper, we introduce a novel approach that predicts the possible affected system modules, given a change in the system. We use Bayesian Belief Networks as a probabilistic tool to make such predictions in a systematic way. This novel technique mainly relies on two sources of information: dependency metrics (calculated using static analysis) and change history extracted from a version control repository. We evaluate our approach by examining all significant revisions of Azureusl, an open-source Java system. The results show that the predicted change probabilities reflect actual module changes even in the early stages of the software development.

Program componentization has been proved to be an effective way to increase the speed and cost-effectiveness of reusing, maintaining, and understanding existing software systems. JComp is a componentization framework that supports semi-automatically extracting reusable components from an existing Java system and automatically transforming the existing system into a component-based system. Based on the automated class dominance analysis and domain knowledge, JComp introduces a novel technique to incrementally identify reusable components in a low cost but high precision way. Also, JComp provides a methodology to automate the transformation of existing object-oriented systems into component-based systems.

One of the important activities in re-engineering process is detecting design flaws. Such design flaws prevent an efficient maintenance, and further development of a system. This research proposes a novel metric-based heuristic framework to detect and locate object-oriented design flaws from the source code. It is accomplished by evaluating design quality of an object-oriented system through quantifying deviations from good design heuristics and principles. While design flaws can occur at any level, the proposed approach assesses the design quality of internal and external structure of a system at the class level which is the most fundamental level of a system. In a nutshell, design flaws are detected and located systematically in two phases using a generic OO design knowledge-base. In the first phase, hotspots are detected by primitive classifiers via measuring metrics indicating a design feature (e.g. complexity). In the second phase, individual design flaws will be detected by composite classifiers using a proper set of metrics. We have chosen JBoss Application Server as the case study, due to its pure OO large size structure, and its success as an open source J2EE platform among developers.

This work presents a framework for providing quality based re-engineering of object-oriented systems (Tahvildari, 2003). The framework allows for specific design and quality requirements (performance and maintainability) of the target migrant system to be considered during the reengineering process. Quality requirements for the migrant system can be encoded using soft-goal interdependency graphs and be associated with specific software transformations that need to be carried out for the specific target quality requirement to be achieved. These transformations can be applied as a series of the iterative and incremental steps to the source code. An evaluation procedure can be used at each transformation step to determine whether specific goals have been achieved.

Our previous work on improving the quality of object-oriented legacy systems through re-engineering proposed a software transformation framework based on soft-goal inter-dependency graphs (Tahvildari and Kontogiannis, 2002). We considered a class of transformations where a program is transformed into another program in the same language (source-to-source transformations) and that the two programs may differ in specific qualities such as performance and maintainability. This paper defines a decision making process that determines a list of source-code improving transformations among several applicable transformations. The decision-making process is developed on a multi-objective decision analysis technique. This type of technique is necessary as there are a number of different, and sometimes conflicting, criterion among nonfunctional requirements. For the migrant system, the proposed approach uses heuristic estimates to guide the discovery process.

Abstract Improving the design quality of large object‐oriented systems during maintenance and evolution is widely regarded as a high‐priority objective. Furthermore, for such systems that are subject to frequent modifications, detection and correction of design defects may easily become a very complex task that is even not tractable for manual handling. Therefore, the use of automatic or semi‐automatic detection and correction techniques and tools can assist reengineering activities. This paper proposes a framework whereby object‐oriented metrics can be used as indicators for automatically detecting situations for particular transformations to be applied in order to improve specific design quality characteristics. The process is based both on modeling the dependencies between design qualities and source code features, and on analyzing the impact that various transformations have on software metrics that quantify the design qualities being improved. Copyright © 2004 John Wiley & Sons, Ltd.

In re-engineering object-oriented legacy code, it is frequently useful to introduce a design pattern in order to improve specific nonfunctional requirements (e.g., maintainability enhancement). This paper presents a methodology for the development of a quality-driven re-engineering framework for object-oriented systems. First, a catalogue of design motifs (primitive design pattern transformations) is presented Then, the transformations for the design patterns in the GoF book are defined as a composition of these primitive transformations. Nonfunctional requirements for the migrant system can be encoded using soft-goal interdependency graphs and can be associated with design pattern transformations that are applied for the migration of an object-oriented legacy system.

One of the characteristics of large software systems is that they evolve over time. Evolution patterns include modifications related to the implementation, interfaces and the overall system structure. Consequently, system understanding and maintainability tend to degrade over time unless particular attention is paid to measure, assess and evaluate the effects of the evolution activities. Traditionally, the assessment of evolution activities has focused on the architectural level. However, in many cases it is easier to extract low-level program information from the Abstract Syntax Tree rather than to discover the full architecture of a large legacy system. This paper presents techniques for analyzing the evolution of large systems even in cases where no complete architectural views of the system exist, from information obtained solely from the AST. It presents experimental results by analyzing the evolution patterns across different versions of two popular systems, the Apache Web server and the Bash shell.