Search

As a summary of past, current, and future trends in software maintenance and reengineering research, we give in this editorial a retrospective look from the past 14 years to now. We provide insight on how software maintenance has evolved and on the most important research topics presented in the series of the European Conference on Software Maintenance and Reengineering. [ABSTRACT FROM AUTHOR]

Maturity models are widely used in process improvement. The users of a maturity model should be confident that the weak points of the assessed processes can be found, and that the most valuable changes are introduced. Therefore, the evaluation of maturity models is an important activity. In this paper, a mapping study of the literature on the evaluation of maturity models is presented. Two databases are searched resulting in a set of relevant papers. The identified papers can be classified according to six categories, namely the maturity model under evaluation, type of evaluation, relation of the evaluators/authors to the maturity model, level of objectivity, main purpose of the paper, and size of study. Further, a framework of different evaluations of maturity models is developed, and the relevant papers are mapped to the framework. Finally, the relevant research on the evaluation of the maturity models in the Capability Maturity Model family is discussed in more detail. The result of this mapping study is a clear overview of how the evaluation of maturity models has been done, and some discussions are provided for further research on the evaluation of commonly used or newly developed maturity models. [ABSTRACT FROM AUTHOR]

This special issue contains a selection of distinguished papers from the 19th Working Conference on Reverse Engineering, held in Kingston, Ontario, Canada on October 15th-18th, 2012. The papers address a variety of topics related to reverse engineering, namely the analysis of execution traces, development of fast and efficient forward static slicing techniques, and mining of software repositories aiming at deriving novel patterns related to reverse engineering activities, such as the migration in Java libraries and the analysis of effects of file editing patterns on source code quality. [ABSTRACT FROM AUTHOR]

Organizations creating software commonly utilize software development lifecycles (SDLCs) to structure development activities. Secure development lifecycles (SDLs) integrate into SDLCs, adding security or compliance activities. They are widely used and have been published by industry leaders and in literature. These SDLs, however, were mostly designed before or while cloud services and other hosted solutions became popular. Such offerings widen the provider's responsibilities, as they not only deliver software but operate and decommission it as well. SDLs, however, do not always account for this change. Security maturity models (SMMs) help to assess SDLs and identify improvements by introducing a baseline to compare against. Multiple of these models were created after the advent of hosted solutions and are more recent than commonly referenced SDLs. Recent SMMs and SDLs may therefore support hosted solutions better than older proposals do. This paper compares a set of current and historic SDLs and SMMs in order to review their support for hosted solutions, including how support has changed over time. Security, privacy, and support for small or agile organizations are considered, as all are relevant to hosted solutions. The SDLs analyzed include Microsoft's SDL, McGraw's Touchpoints, the Cisco's SDL, and Stackpole and Oksendahl's SDL2. The SMMs reviewed are OWASP's Software Assurance Maturity Model 2 and DevSecOps Maturity Model. To assess the support for hosted solutions, the security and privacy activities foreseen in each SDLC phase are compared, before organizational compatibility, activity relevance, and efficiency are assessed. The paper further demonstrates how organizations may select and adjust a suitable proposal. The analyzed proposals are found to not sufficiently support hosted solutions: Important SDLC phases, such as solution retirement, are not always sufficiently supported. Agile practices, such as working in sprints, and small organizations are often not sufficiently considered as well. Efficiency is found to vary based on the application context. A clear improvement trend from before the proliferation of hosted solutions cannot be identified. Future work is therefore found to be required. [ABSTRACT FROM AUTHOR]

An introduction to the journal is presented in which the editor discusses software process improvement.

Companies often claim to follow specific software development methodologies (SDM) when performing their software development process. These methodologies are often supported by dedicated tools that keep track of work activities carried out by developers. The purpose of this paper is to provide a novel approach that integrates analytical insights from both the perceptions of SDM stakeholders and software development tools logs to provide SDM improvement recommendations. This paper develops a new process improvement approach that combines two significantly different sources of data on the same phenomenon. First, it uses a questionnaire to gather software development stakeholder SDM perceptions (managers and developers). Second, it leverages process mining to analyze software development tools logs to obtain additional information on software development activities. Finally, it develops recommendations based on concurrent analysis of both sources. Our novel process improvement approach is evaluated in three directions: Does the presented approach (RQ1) enable managers to gain additional insights into employees' performance, (RQ2) deliver additional insights into project performance, and (RQ3) enable development of additional SDM improvement recommendations? We find that integrated analysis of software development perception data and software development tools logs opens new possibilities to more precisely identify and improve specific SDM elements. The evaluation of our novel process improvement approach follows a single case study design. Our approach can only be used in enterprises in which software development tools logs are available. The study should be repeated in different cultural settings. We practically show how concurrently analyzing data about developer SDM perceptions and event log data from software development tools enables management to gain additional insights in the software development process regarding the performance of individual developers. The main theoretical contribution of our paper is a novel process improvement approach that effectively integrates data from management and developer perspectives and software development tools logs. [ABSTRACT FROM AUTHOR]

The article discusses various reports published within the issue including one on agile coaching for software development and another on systematic approach to tailoring organizational processes.

As software projects evolve and grow in size and complexity, so do their test suites. Test suite reduction (TSR) aims at reducing the size of a test suite by removing redundant and obsolete test cases based on a coverage metric while preserving its fault detection capabilities. The contributions of this paper are twofold: (1) We examine a lesser‐known coverage criterion, that is, checked coverage. Checked coverage not only investigates if a part of the code was executed but also if it was checked by a test oracle. In an empirical evaluation, we performed TSR based on different reduction algorithms, coverage metrics, and open‐source Java projects with our own TSR tool to determine the most effective and efficient combination of metric and method. (2) Given the results of the first evaluation, we further investigate the potential of parameter optimization in regard to a genetic reduction algorithm. In particular, we focus on finding a general setting for the parameters crossover rate and mutation rate such that test suites can be reduced in a reasonable time while maintaining a high fault detection power. [ABSTRACT FROM AUTHOR]

Summary: In software development, developer turnover is among the primary reasons for project failures, leading to a great void of knowledge and strain for newcomers. Unfortunately, no established methods exist to measure how the problem domain knowledge is distributed among developers. Awareness of how this knowledge evolves and is owned by key developers in a project helps stakeholders reduce risks caused by turnover. To this end, this paper introduces a novel, realistic representation of problem domain knowledge distribution: the ConceptRealm. To construct the ConceptRealm, we employ a latent Dirichlet allocation model to represent textual features obtained from 300 K issues and 1.3 M comments from 518 open‐source projects. We analyze whether the newly emerged issues and developers share similar concepts or how aligned the individual developers' concepts are with the team over time. We also investigate the impact of leaving developers on the frequency of concepts. Finally, we also evaluate the soundness of our approach on a closed‐source software project, thus allowing the validation of the results from a practical standpoint. We find out that the ConceptRealm can represent the problem domain knowledge within a project and can be utilized to predict the alignment of developers with issues. We also observe that projects exhibit many keepers independent of project maturity and that abruptly leaving keepers correlates with a decline of their core concepts as the remaining developers cannot quickly familiarize themselves with those concepts. [ABSTRACT FROM AUTHOR]

Regression test prioritization (RTP) is an active research field, aiming at re‐ordering the tests in a test suite to maximize the rate at which faults are detected. A number of RTP strategies have been proposed, leveraging different factors to reorder tests. Some techniques include an analysis of changed source code, to assign higher priority to tests stressing modified parts of the codebase. Still, most of these change‐based solutions focus on simple text‐level comparisons among versions. We believe that measuring source code changes in a more refined way, capable of discriminating between mere textual changes (e.g., renaming of a local variable) and more structural changes (e.g., changes in the control flow), could lead to significant benefits in RTP, under the assumption that major structural changes are also more likely to introduce faults. To this end, we propose two novel RTP techniques that leverage tree kernels (TK), a class of similarity functions largely used in Natural Language Processing on tree‐structured data. In particular, we apply TKs to abstract syntax trees of source code, to more precisely quantify the extent of structural changes in the source code, and prioritize tests accordingly. We assessed the effectiveness of the proposals by conducting an empirical study on five real‐world Java projects, also used in a number of RTP‐related papers. We automatically generated, for each considered pair of software versions (i.e., old version, new version) in the evolution of the involved projects, 100 variations with artificially injected faults, leading to over 5k different software evolution scenarios overall. We compared the proposed prioritization approaches against well‐known prioritization techniques, evaluating both their effectiveness and their execution times. Our findings show that leveraging more refined code change analysis techniques to quantify the extent of changes in source code can lead to relevant improvements in prioritization effectiveness, while typically introducing negligible overheads due to their execution. [ABSTRACT FROM AUTHOR]

Summary: Concurrent software needs to be maintained over time, and the differences between continuous versions tend to be localized. The expense that simply reapplying standard model checking techniques to the new version as they evolve may be infeasible. The existing methods reuse partial state‐space to reduce the scope. However, it is obviously costly to analyze on the explosive interleaving space of the evolving concurrent programs. The conservative change‐impact analysis methods without considering the specific property and leveraging the verified result from the prior version often results in exploring redundant state‐space irrelevant to this property. Moreover, the impact of the deleted elements needs to be analyzed on old version, and their impact needs to be mapped to new version, bringing some dispensable costs. In this paper, we propose a change‐aware model checking method based on program dependence net (PDNet) for linear temporal logic (LTL). We first propose an incremental modeling method to construct a PDNet of new version by modification rules. Then, we propose a reuse checking algorithm to judge whether the verified result can be reused based on the PDNet slice. Finally, we implement change‐aware model checking tool (DAMER) and validate the advantages of our methods. [ABSTRACT FROM AUTHOR]

Requirements prioritization is giving priority to software requirements on the basis of its importance. The current research paper addresses the importance and limitations of existing research on requirements prioritization. A lot of requirements prioritization techniques are presented by authors, but these techniques have certain limitations. Not all techniques are either applied or suitable to prioritize all types of requirements. Similarly, in these techniques, only few are scalable for large size requirements. The objective of the current research is to identify all possible software requirements prioritization techniques and to show the suitability of these techniques to prioritize different types and sizes of requirements. To achieve research objectives, a systematic literature review (SLR) is carried out. In conducting SLR, planned protocol is designed, which include all the necessary steps necessary for SLR process. As a result of SLR, 60 primary studies were selected for data extraction as a result of SLR. Outcome of SLR shows that not all techniques are scalable to prioritize any size requirements. Also, there are few techniques found that are either applied on all types of requirements or not suitable to prioritize all types of requirements as these techniques are specifically designed for particular types of requirements. [ABSTRACT FROM AUTHOR]

The processes used to develop software need to comply with normative requirements (e.g., standards and regulations) to align with the market and the law. Manual compliance checking is challenging because there are numerous requirements with changing nature and different purposes. Despite the importance of automated techniques, there is not any systematic study in this field. This lack may hinder organizations from moving toward automated compliance checking practices. In this paper, we characterize the methods for automatic compliance checking of software processes, including used techniques, potential impacts, and challenges. For this, we undertake a systematic literature review (SLR) of studies reporting methods in this field. As a result, we identify solutions that use different techniques (e.g., anthologies and metamodels) to represent processes and their artifacts (e.g., tasks and roles). Various languages, which have diverse capabilities for managing competing and changing norms, and agile strategies, are also used to represent normative requirements. Most solutions require tool‐support concretization and enhanced capabilities to handle processes and normative diversity. Our findings outline compelling areas for future research. In particular, there is a need to select suitable languages for consolidating a generic and normative‐agnostic solution, increase automation levels, tool support, and boost the application in practice by improving usability aspects. [ABSTRACT FROM AUTHOR]

Reverse engineering is used for extracting and understanding software architecture models from source code when the source code is the only available software product. Software module clustering is a reverse engineering method which decomposes software modules into several clusters (subsystems) by using module dependency graph. Finding the best clusters for the modules of software is a multi‐objective and NP‐hard problem; maximizing the cohesion among the modules, minimizing the coupling among different clusters, and maximizing the software modularization quality are considered as the main objectives of software module clustering. Some of these objectives, such as cohesion and coupling, are in contradiction with each other. Simultaneous improvement of all clustering objectives (cohesion, coupling, modularization quality, size, and number of clusters) is the main goal of this study. In this paper, by capitalizing on multi objective genetic algorithm and a new combination of objective functions, we proposed a homogeneous method, namely, Savalan, for clustering software modules. The proposed method generates high‐quality clusters with strong cohesion within clusters and weak connections between clusters for the input source code. The results of conducted experiments on the 14 benchmark programs indicate that simultaneous improvement of all clustering objectives is the main merit of this method. According to the experimental results, the proposed algorithm was able to outperform the previous multi objective methods. [ABSTRACT FROM AUTHOR]

Blockchain applications are gradually receiving wide acceptance as a transformative technology that could potentially bring a reformation in the industry. Blockchain handles sensitive data through cryptography, consensus mechanism, transaction immutability, and peer‐to‐peer network to manage decentralized data features. In addition to ensuring operational efficiency, blockchain development is a complex and challenging process, which warrants further exploration. In an attempt to reduce the complexity of the development, various software methodologies have been introduced to support the development of blockchain applications systematically. It has been found that those methodologies introduced structured processes that are not suitable for software models. Moreover, all models are generic and do not take into blockchain concept as first‐class entities. Hence, there is a gap in extending and transforming the current blockchain modeling and practices when developing a blockchain application. This paper introduces a new insight and innovative methodology for blockchain‐based application development through extended agent‐oriented modeling (eAOM) to discover blockchain opportunities and contribute to the growth of the technology. With eAOM, the blockchain modeling processes start with requirement elicitation, computation independent modeling, early identification of blockchain use case, platform independent modeling, and platform specific model. A walkthrough example of a blockchain application, "win a fortune games" has showcased the feasibility of eAOM in modeling blockchain enabling application development in a systematic manner. A usability analysis is conducted among novice students to test the usability of eAOM versus original AOM in modeling blockchain application development. From the findings, 44% of the students managed to capture more than 80% of blockchain requirements through eAOM. On the other hand, 51% of the students scored between 20% and 60% of the blockchain requirement, and only 5% of the students failed to model blockchain requirements through eAOM. The results reveal the usage of the eAOM to model blockchain‐enabled application comprehensively. [ABSTRACT FROM AUTHOR]

Software effort estimation is a vital process in the software industry for successfully administering 5Ds of the software development life cycle (SDLC). The 5Ds stand for demand, development, direction, deployment, and designated cost of the software. Software development effort estimation (SDEE) is an effort prediction mechanism to calculate the effort for the development of the software product in order to minimize the challenges in the software field. Academics and practitioners are striving to identify which machine learning estimation technique yields more accurate results based on evaluation metrics, datasets, and other pertinent aspects. The feature selection techniques impact accuracy by selecting the main and relevant features in the dataset and eliminating the redundant and irrelevant features in the dataset. To achieve accurate estimations, the paper utilizes feature selection algorithms, along with various machine learning techniques, which predict the desired effort and the performance of the model has been measured in terms of prediction accuracy, R2 value, relative error, and mean absolute error. The datasets China and Maxwell are trained with the relevant features by applying feature selection algorithms, and estimation techniques are applied to predict the effort. The performance is compared with the regression models and feature selection techniques utilized by many authors previously. The result of the proposed methodology significantly gives the best performance with the combination of feature selection and estimation models than all regression models when applied alone, to both datasets. From the results, it is perceptible that random forest is performing well with the feature selection techniques and obtains the highest prediction accuracy of 99.33% with the China and 89.47% with the Maxwell datasets. [ABSTRACT FROM AUTHOR]

The paper discusses structure, quality and content of the currently available agile maturity models. It presents two approaches on how to deal with such models. As a first step of the analysis, the paper contains a compilation of maturity level naming used by these agile maturity models because the variety of level naming is a sign of the variety of understanding and of definition of agile maturity. While many papers deal with agile from an inside perspective, this paper is written from the perspective of Software Process Improvement (SPI) and Capability Determination, the European Certification and Qualification Association PI Manager Certification Scheme and also the SPI Manifesto. The paper does not explicitly present its own agile maturity model. The analysis approaches presented in the paper show that the currently available agile maturity models are not fit for industrial use. The synthesis of an acceptable model seems to be feasible as the analysed models address typical organisational processes including life cycle management. Copyright © 2013 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

An introduction to the journal is presented in which the guests editors discuss source code analysis and manipulation.

Free and open source software package ecosystems have existed for a long time, but such collaborative development practice has surged in recent years. One of the oldest and most popular package ecosystems is Comprehensive R Archive Network (CRAN), the repository of packages of the statistical language R, a popular statistical computing environment. CRAN stores a large number of packages that are updated regularly and depend on many other packages in a complex graph of relations. As the repository grows, its sustainability could be threatened by that complexity or nonuniform evolution of some packages. This paper provides an empirical analysis of the evolution of the CRAN repository in the last 20 years, considering the laws of software evolution and the effect of CRAN's policies on such development. Results show how the progress of CRAN is consistent with the laws of continuous growth and change and how there seems to be a relevant increase in complexity in recent years. Significant challenges are raising related to the scale and scope of software package managers and the services they provide; understanding how they change over time and what might endanger their sustainability are key factors for their future improvement, maintenance, policies, and, eventually, sustainability of the ecosystem. This paper provides an empirical analysis of the evolution of the CRAN repository in the last 20 years, considering the laws of software evolution and the effect of CRAN's policies on such development. Results show how the progress of CRAN is consistent with the laws of continuous growth and change and how there seems to be a relevant increase in complexity in recent years. [ABSTRACT FROM AUTHOR]

Accurate prediction of software effort is important for planning, scheduling, and allocating resources. However, software effort estimation has been a challenging task. Although numerous estimation models have been proposed, few achieve anything close to accurate prediction of software development effort. To achieve optimal results, machine learning techniques have recently been employed for predicting software development effort using relatively large software repositories. However, some issues remain unresolved, and this paper aims to address the following issues. First, feature selection methods often neglected the information rich variables present in the dataset. Second, selection of important features was done through statistical methods, which lack domain knowledge. Third, missing values in the data that significantly influence the prediction outcome was not efficiently handled. Fourth, majority of the literature neglected advanced evaluation measures, which thoroughly evaluate the ability of learning models to produce accurate results. To address the above issues, a machine learning‐based model has been proposed in this paper, which not only allows effective preprocessing of data but also provides highly accurate prediction results with minimum error rate. The purpose is to best identify attributes (predictors) from large software repositories that are most influential in the estimation of effort. In addition, we apply MMRE for better performance analysis. [ABSTRACT FROM AUTHOR]

Change has been recognized as the distinguishing feature that makes software different from any other human-produced artifacts. Initial reflections on the urgent and unavoidable need to master change date back to the 1970s. However, despite the continuous progress that characterized software technology since, in practice, software change is still often handled as an afterthought, in an ad hoc and unprincipled manner. Agile development methods have been proposed and are now widely adopted to accommodate change during development. Recent extensions to also include operation-known as DevOps-are increasingly and successfully adopted by industry. Still, principled and rigorous foundations that can be taught, practiced, and replicated systematically are lacking. This paper argues that change has to become a first-class concept and that the development tools used by engineers and the runtime environment supporting software execution should be structured in a way that naturally accommodates change. It also provides a perspective along which several research approaches that were investigated by the community in the past decade might be integrated and extended to make this vision become true. Two main change categories are identified-evolution and adaptation-along with the forces that drive them. The paper discusses when and how the developed software can be designed in a way that it can self-adapt. It also discusses how the software itself can cooperate with humans in-the-loop to help them in their design and development efforts. Finally, it outlines a roadmap of future work needed to progress in the direction of supporting and automating software change that would lead to dependable adaptation and evolution. [ABSTRACT FROM AUTHOR]

ABSTRACT In earlier work, it has been suggested that processes and applications seem to share many important characteristics and seem to be amenable to similar approaches of modeling, definition, and analysis. In most of this previous work, approaches and technologies for developing applications have been applied to the development of processes, largely with positive results. This paper suggests the opposite, namely that approaches and technologies for developing processes seem likewise to be applicable to developing applications. As an example, this paper notes that resource specification, allocation, and management are central issues in the development of many processes, and suggests that although these capabilities seem to be important for growing classes of application software, the ability to support them seems curiously neglected. The paper also notes that management of rework is a central issue of virtually all creative activities. This is evidenced by the observation that facilities for supporting rework are prominent features in so many creative domains. Accordingly, the paper suggests an analogous need for facilities for supporting rework in application software as well, especially in application software aimed at supporting human creativity. The paper concludes by noting that both application and process software technologies grow through consideration of the relevance of technologies developed for one to the other. This in turn should lead to a clearer understanding of the essence of what they have in common, leading to conjectures about the nature of a more abstract class of entities, that we refer to simply as software. Copyright © 2014 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

ABSTRACT Starting from the documentation of high sprint velocity fluctuations in a Scrum project, this paper presents a thorough approach to identify the sources of issues arising in the context of Scrum implementation. Given that Scrum provides guidance on identifying process issues but not their root causes, various approaches are explored. This is of great relevance because Scrum defines project schedules relying heavily on sprint velocity and because it is the most widely used agile methodology. The findings provide a new approach to evaluate such fluctuations and establish a more realistic project assessment than what is currently defined by Scrum. In this respect, this paper contributes to improve the understanding of the software development process using this agile framework. Copyright © 2014 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

Software process improvement requires significant effort related not only to the identification of relevant issues and providing an adequate response to them, but also to the implementation and adoption of the changes. Best practices provide recommendations to software teams on how to address identified objectives in practice, based on aggregated experience and knowledge. In the paper, we present the GÉANT SPI framework based on best practices, together with the collected experience from the process of adopting the best practices. [ABSTRACT FROM AUTHOR]

Software change‐proneness prediction can help reduce software maintenance costs. Thus, it has drawn the attention of many researchers. In this paper, we propose a CNN (convolutional neural network)‐based method for software change‐proneness prediction, aiming to utilize the powerful prediction ability to make score of the performance measure higher than other baseline methods. Moreover, to alleviate the effect of the class imbalance problem, resampling methods are employed with the CNN. To validate the performance of the proposed CNN‐based method, an empirical study was conducted. The experimental results show that the CNN‐based method together with the resampling method performs better than the baseline methods, and the scores of performance measure of CNN with the ROS (random oversampling) method are higher than other method, especially the important performance measure. [ABSTRACT FROM AUTHOR]

ABSTRACT This paper describes a case study on using the Eclipse Process Framework in a medical software development organization to consolidate existing process descriptions. Although on nonmedical fields the Eclipse Process Framework was successfully used for process modeling and aiding process improvement efforts, the complex nature of the regulatory and process standard requirements on the medical software field needs special attention. In this environment, compliance to the regulatory is more important than improvement, so the process modeling has to implement these requirements in a very strict way, while supporting the business goals of the organization and enabling the improvement of the processes. Copyright © 2013 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

Context The advances in information and communication technologies have revolutionized the software development environment from local to global software development (GSD). This revolution also created challenges for vendor organizations. Vendors face challenges in integrating the components developed independently by GSD teams into a final working product. Objective The objectives of the current study is to find out those critical barriers/challenges that hinder the integration process at any stage in the GSD environment for different types and size of projects. Methodology For achieving the objectives we initially conducted a comprehensive systematic literature review (SLR). We searched 6 digital libraries and also followed the snowballing technique. The data was extracted from a total of 88 finally selected papers. Findings of the SLR study were then empirically validated through a questionnaire survey in GSD industry. A total of 96 experts from 22 different countries participated in the survey. Results We have found a total of 16 barriers/challenges among which ten barriers are ranked as critical barriers/challenges. Some of the top ranked barriers are 'lack of communication,' 'lack of proper documentation,' 'lack of compatibility,' and 'architecture mismatch.' The findings of our industrial survey are mostly coherent with the SLR findings. However, there is a difference in ranks of the various barriers/challenges across the 2 data sets (SLR and industrial survey). The identified challenges need to be properly addressed by software vendors to reduce the complexity of the integration process in GSD projects. Conclusion We found that the severity of these barriers increases in large size projects. On the other hand, bespoke products are more affected by 'lack of communication,' while off-the-shelf-based projects face integration problems due to 'lack of compatibility,' 'architecture mismatch,' and 'wrong off the shelf product selection and customization'. [ABSTRACT FROM AUTHOR]

It is difficult to manage complex software systems. Thus, many research initiatives focus on how to improve software development efficiency and maintainability. However, the trend in the industry is still alarming, software development projects fail, and maintenance is becoming more and more expensive. One problem could be that research has been focusing on the wrong things. Most research publications address either process improvements or architectural improvements. There are few known approaches that consider how architectural changes affect processes and vice versa. One method proposed, called the Business-Architecture-Process method, takes these aspects into consideration. In 2007 the method was tested in one case study. Findings in the 2007 case study show that the method is useful, but in need of improvements and further validation. The present paper employs the method in a second case study. The contribution in this paper is thus a second test and validation of the proposed method, and useful method improvements for future use of the method. [ABSTRACT FROM AUTHOR]

Detection of code clones -- similar or identical source code fragments -- is of concern both to researchers and to practitioners. An analysis of the clone detection results for a single source code version provides a developer with information about a discrete state in the evolution of the software system. However, tracing clones across multiple source code versions permits a clone analysis to consider a temporal dimension. Such an analysis of clone evolution can be used to uncover the patterns and characteristics exhibited by clones as they evolve within a system. Developers can use the results of this analysis to understand the clones more completely, which may help them to manage the clones more effectively. Thus, studies of clone evolution serve a key role in understanding and addressing issues of cloning in software. In this paper, we present a systematic review of the literature on clone evolution. In particular, we present a detailed analysis of 30 relevant papers that we identified in accordance with our review protocol. The review results were organized to address three research questions. Through our answers to these questions, we present the methods that researchers have used to study clone evolution, the patterns that researchers have found evolving clones to exhibit, and the evidence that researchers have established regarding the extent of inconsistent change undergone by clones during software evolution. Overall, the review results indicate that whereas researchers have conducted several empirical studies of clone evolution, there are contradictions among the reported findings, particularly regarding the lifetimes of clone lineages and the consistency with which clones are changed during software evolution. We identify human-based empirical studies and classification of clone evolution patterns as two areas that are in particular need of further work. [ABSTRACT FROM AUTHOR]

Abstract: Evolvability of software lies in intersection of 3 factors: evolving system properties, human factors present in the developer team, and evolution demands. The paper presents 5 recommendations that enhance software evolvability: defined processes of software change, distinction between evolving and stabilized part of the code, analyzable code segments, significant concept encapsulation, and avoidance of wrapping. [ABSTRACT FROM AUTHOR]

BACKGROUND: The laws of software evolution were formulated to describe time series trends in software over time. OBJECTIVE: Building on econometrics, the paper relates the laws theoretically to the concept of stationarity. The theoretical argumentation builds on the fact that in a stationary time series, the mean and variance remain constant. The concept is further elaborated with different statistical types of time series trends. These provide the objective for the empirical experiment that evaluates whether software size measures in a typical software evolution dataset are stationary. METHOD: The time series analysis is based on conventional statistical tests for the evaluation of stationarity. RESULTS: The empirical dataset contains time series extracted from the version control systems used in Vaadin and Tomcat between circa 2006 and 2013. The results establish that the observed time series are neither stationary nor follow simple mathematical functions that would translate into stationarity. CONCLUSION: The testing framework presented in the paper allows evaluating the stationarity of software evolution time series. The results can be interpreted theoretically against the laws of software evolution. These methodological and theoretical contributions improve the foundations of predictive time series modeling of software evolution problems. [ABSTRACT FROM AUTHOR]

ABSTRACT Despite the fact that software is mostly a team endeavor, the software engineering (SE) literature has not tapped into organizational psychology's conceptual and empirical writings on teams. This paper presents a model of team dynamics adapted to the specificities of SE project teams. The taxonomy is composed of nine episodes that are likely to be found in any software team process. Each episode is described in terms of the input-process-output cycle and illustrated with examples. The measurability of the episodes is validated on a capstone student project carried out with an industrial partner. The team activities are recorded by each developer, throughout the project's duration, in the form of work tokens. These work tokens are then associated with episodes by two independent coders. The results show that all the episodes of the proposed taxonomy are measurable, and very few (less than 5% in this field study) remain ambiguous. Most of the ambiguities arise from short episodes that alternate during team process activities. This paper's contribution to software team process research is to synthesize the team literature and draw up a theoretically driven taxonomy of team dynamics specific to SE teams and to provide initial evidence of measurability of the taxonomy. Copyright © 2014 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

ABSTRACT Software process improvement (SPI) initiatives are facing complex environments where stakeholders need to integrate different reference models in their organizations. There are several approaches to multimodel environments defining some steps or activities that should be carried out for implementing it efficiently inside organizations. This paper presents a report on the use of a multimodel framework integrating three quality reference models in 47 SPI initiatives. Basically, this report is based on statistical data extracted from industrial assessments. Copyright © 2014 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

Abstract: Cloud computing has emerged as a new powerful service delivery model to cope with resource challenges and to offer various on‐demand services (eg, software, storage, network, etc.). Software as a Service (SaaS) is one of the most popular service models. To meet the increasing demands of users, SaaS can be offered in a composite form. Although this approach offers some advantages like flexibility and reusability, it raises a question about how to manage composite SaaS in the distributed and the highly dynamic cloud environment. In this paper, we address one of the major SaaS resource management issues referred to as SaaS placement problem. As existing efforts only focus on SaaS placement problem from the perspective of resources utilization to optimize SaaS performance and minimize resource usage, in this paper, we also incorporate security concerns in SaaS placement strategy. In fact, security risk is one of the major factors influencing the efficiency of the composite SaaS. We adopt a multi‐swarm variant of particle swarm optimization to propose a security‐aware SaaS placement method. Also, a cooperative learning strategy is hybridized to the placement algorithm, which makes information of best candidate servers be used more effectively to generate better placement plan. Experiments show that our solution outperforms existing SaaS placement approaches. [ABSTRACT FROM AUTHOR]

In recent years, the evolution of software ecosystems and the detection of technical debt received significant attention by researchers from both industry and academia. While a few studies that analyze various aspects of technical debt evolution already exist, to the best of our knowledge, there is no large‐scale study that focuses on the remediation of technical debt over time in Python projects—that is, one of the most popular programming languages at the moment. In this paper, we analyze the evolution of technical debt in 44 Python open‐source software projects belonging to the Apache Software Foundation. We focus on the type and amount of technical debt that is paid back. The study required the mining of over 60K commits, detailed code analysis on 3.7K system versions, and the analysis of almost 43K fixed issues. The findings show that most of the repayment effort goes into testing, documentation, complexity, and duplication removal. Moreover, more than half of the Python technical debt is short term being repaid in less than 2 months. In particular, the observations that a minority of rules account for the majority of issues fixed and spent effort suggest that addressing those kinds of debt in the future is important for research and practice. [ABSTRACT FROM AUTHOR]

Software project defect prediction can help developers allocate debugging resources. Existing software defect prediction models are usually based on machine learning methods, especially deep learning. Deep learning‐based methods tend to build end‐to‐end models that directly use source code‐based abstract syntax trees (ASTs) as input. They do not pay enough attention to the front‐end data representation. In this paper, we propose a new framework to represent source code called multiperspective tree embedding (MPT‐embedding), which is an unsupervised representation learning method. MPT‐embedding parses the nodes of ASTs from multiple perspectives and encodes the structural information of a tree into a vector sequence. Experiments on both cross‐project defect prediction (CPDP) and within‐project defect prediction (WPDP) show that, on average, MPT‐embedding provides improvements over the state‐of‐the‐art method. [ABSTRACT FROM AUTHOR]

ABSTRACT Software Process Improvement (SPI) activities aim at driving change in information technology development towards increased quality and productivity levels. The SPI Manifesto describes the key values and principles for a successful implementation of SPI. About two-thirds of its principles relate to human, social, and organizational aspects and one-third to technical aspects. This raises the question if these aspects have a relationship with 'social responsibility' principles. The new ISO 26000:2010 standard provides guidance about social responsibility (SR), describing the core subjects and issues an organization has to consider when implementing SR. In this paper, we describe how the values and principles of the SPI Manifesto have a relationship with the SR issues described in the ISO 26000. In addition, this paper describes about the steps taken in an industry group to exchange best practices about how social strategies can be used to achieve higher acceptance and sustainability of SPI initiatives. Copyright © 2013 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

Whatever be the nature of underlying software, the impact of the software development process that was used to create it would remain vital. The objective of this paper is to provide a process selection framework for the software development firm's engineers and managers, looking to identify the proper way to build software to run on a mobile, web, or desktop. The motivation behind this work comes from the fact that the applications that fall in one of the above three categories can be significantly different in terms of scale, UI, and memory requirements, time to market, and other characteristics. Software development that needs to be completed in a challenging timeframe has to resort to principles and values as declared in Agile Manifesto. The availability of various agile methodologies has made the project managers often stuck when selecting the most suitable one. The proposed agile process identification system addresses this dilemma of engineering fraternity using a fuzzy variant of a popular multiple‐criteria decision‐making (MCDM) technique called the analytic hierarchy process (AHP). The proposed system is validated through a primary dataset generated as a result of the development of 20 software projects. The results are encouraging enough with a probability of true identification close to 88%. [ABSTRACT FROM AUTHOR]

Many software systems today provide support for adaptation and reconfiguration at runtime, in response to changes in their environment. Such adaptive systems are designed to run continuously and may not be shut down for reconfiguration or maintenance tasks. The variability of such systems has to be explicitly managed, together with mechanisms that control their runtime adaptation and reconfiguration. Dynamic software product lines (DSPLs) can help to achieve this. However, dealing with evolution is particularly challenging in a DSPL, as changes made at runtime can easily lead to inconsistencies. This paper describes the challenges of evolving DSPLs using an example cyber‐physical system for home automation. We discuss the shortcomings of existing work and present a reference architecture to support DSPL evolution. To demonstrate its feasibility and flexibility, we implemented the proposed reference architecture for two different DSPLs: the aforementioned cyber‐physical system, which uses feature models to describe its variability, and a runtime monitoring infrastructure, which is based on decision models. To assess the industrial applicability of our approach, we also implemented the reference architecture for a real‐world DSPL, an automation software system for injection molding machines. Our results provide evidence on the flexibility, performance, and industrial applicability of our approach. [ABSTRACT FROM AUTHOR]

The Software Process Improvement (SPI) Manifesto is based on three basic values: people, business focus and organisational change underpinning the philosophy of SPI. In turn, these values bring up to date certain SPI principles serving as a foundation for action in software development. The authors of this paper carried out a pilot expert validation of the sociocultural dimension of the sociocultural, technical, economic, environmental, political, legal, ethical and demographic analysis of the SPI Manifesto. Further, the authors report on the rationale and results of the pilot validation of both the survey instrument and the qualitative responses generated by the field experts, targeting to enlighten and reinforce the importance of the sociocultural dimension of the SPI Manifesto in research and development. The related literature review findings and the pilot research study strengthen this target. The pilot study with experts in particular provided stronger indications that the sociocultural dimension is considered of high importance by between 62% and 88% of the respondents, who were IT and computing professionals and software practitioners from academia and industry. [ABSTRACT FROM AUTHOR]

Traditional portfolio management tools and methods are challenging for software companies that use agile and lean approaches, because of the complex pre-planning activities required. In this paper, traditional portfolio management tools and methods that have been conventionally used in industry and presented in literature are reviewed. Findings concerning their use in agile and lean software companies are investigated, on the basis of the literature review and semi-structured interviews conducted in 7 agile and lean software companies in Finland. The findings indicate that the studied companies do not use traditional portfolio management tools and methods in their entirety. The software companies adapted suitable components from traditional portfolio management tools and methods into their practices. They also apply new tools and methods to manage their portfolios of offerings, to cope with the dynamics required by agile and lean methods. The companies' emphasis is on using tools to facilitate immediate feedback from customers, to assess the value of offerings in their portfolio. The results showed a growing interest in using Kanban at the portfolio level to provide a visual overview of offerings. [ABSTRACT FROM AUTHOR]

Practically all information retrieval based approaches developed to date for automatic bug localization are based on the bag-of-words assumption that ignores any positional and ordering relationships between the terms in a query. In this paper, we argue that bug reports are ill-served by this assumption because such reports frequently contain various types of structural information whose terms must obey certain positional and ordering constraints. It therefore stands to reason that the quality of retrieval for bug localization would improve if these constraints could be taken into account when searching for the most relevant files. In this paper, we demonstrate that such is indeed the case. We show how the well-known Markov Random Field based retrieval framework can be used for taking into account the term-term proximity and ordering relationships in a query vis-à-vis the same relationships in the files of a source-code library to greatly improve the quality of retrieval of the most relevant source files. We have carried out our experimental evaluations on popular large software projects using over 4000 bug reports. The results we present demonstrate unequivocally that the new proposed approach is far superior to the widely used bag-of-words based approaches. Copyright © 2016 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

In software intensive products such as cars or telecom systems, software has traditionally been associated with cost, and there has been no real perception of its value in relation to the entire product offering. How-ever, because software is becoming a larger part of the main competitive advantage, driving innovation and product differentiation, hardware is becoming more standardized, thus the valuation of software is becoming critical. In existing literature, several value constructs and corresponding valuation/measurement solutions needed for making decisions about software product development are presented. However, the contributions are often isolated with respect to a certain perspective such as focusing on product's internal or external quality aspects only. Consequently, a complete view of value constructs relevant from different perspectives required for making decisions about software product development is missing. This paper presents a consolidated view of the software value concept utilizing the major perspectives and introduces a software value map. The created value map was evaluated through an industry case study through the development of impact evaluation patterns, which were subsequently used by professionals in industry, and experiences gathered. During industry evaluation, practitioners found substantial benefits of having a consolidated, vastly improved, and extended value aspect's view of software. [ABSTRACT FROM AUTHOR]

Feature location is the activity of identifying an initial location in the source code that implements functionality in a software system. Many feature location techniques have been introduced that automate some or all of this process, and a comprehensive overview of this large body of work would be beneficial to researchers and practitioners. This paper presents a systematic literature survey of feature location techniques. Eighty-nine articles from 25 venues have been reviewed and classified within the taxonomy in order to organize and structure existing work in the field of feature location. The paper also discusses open issues and defines future directions in the field of feature location. [ABSTRACT FROM AUTHOR]

Design patterns play a significant role in reverse engineering by providing information not only on how but also on why a solution has been implemented in a specific way because of their semantics. The application of design patterns leads to their personalization to a specific context, hence to the generation of variants. This makes their recognition a challenging task, which may be addressed through the understanding and detection of the micro-structures design patterns are made of. This is very useful for the detection as well as for the application of design patterns. The principal aim of this paper is to present a survey on these micro-structures and a comparison among them in the perspective of reverse engineering. Because of their less complex structure and behavior, as well as closer link to the source code, the recognition of these micro-structures may be automated, which can be considered a step towards the automatic recognition of the more complex design patterns. In this paper, we consider four of the most significant types of micro-structures: elemental design patterns, clues, sub-patterns, and micro patterns. To analyze the role of the micro-structures in the design pattern detection process, we make a comparison among these four types of micro-structures and among the micro-structures of various types in order to identify the relations among them. [ABSTRACT FROM AUTHOR]

Software process modeling and simulation have become effective tools for support of software process management and improvement over the past two decades. They have recently been integrated into the Trustworthy Process Management Framework (TPMF) as the infrastructural components to facilitate the delivery of trustworthy software products. This paper proposes the concept of Trustworthy Software Process Models as inputs to TPMF and introduces transformable process modeling for supporting effective and productive development of trustworthy process models. Furthermore, this paper undertakes an exploratory study on process model transformation by investigating and comparing process modeling semantics between quantitative (e.g., System Dynamics, SD) and qualitative forms of modeling and simulation. By following the model transformation scheme, a quantitative continuous (SD) software evolution process model is successfully transformed into its qualitative form for simulation. The results present the different capabilities and performance between these two modeling paradigms, as well as the possible benefits and interesting perspectives of transformable process modeling. [ABSTRACT FROM AUTHOR]

Distributed software development (DSD) has intensified over the past few years, and DSD project management is more complex than collocated project management. However, no systematic research effort has focused on aggregating evidence from the scientific literature to build models to support project management on DSD context. For these reasons, the goal of this paper is to build an evidence-based model of DSD project management from the research findings about challenges of DSD and the practices, models and tools proposed and used to overcome these challenges. We based the construction of this model on the evidence collected and synthesized by a comprehensive systematic mapping study of 70 research papers published between 1997 and 2009. We believe that our results can help practitioners and researchers to better understand the challenges and implement more effective solutions to improve project management within distributed project management teams. These results also provide a mapping of the research about DSD project management, identifying areas where further research is needed. [ABSTRACT FROM AUTHOR]

Globalization has influenced the way software is developed today, and many software organizations have started to actively utilize resources from around the world. However, these endeavors are recognized as very challenging, and they have attracted a lot of attention in software research in the past decade. Unlike many other research initiatives, which explore the complexities of distributed software development activities, the focus of this paper is on software transfers. Software transfers refer to activities that are moved from one location to another. The authors draw attention to the lessons learned from an empirical investigation of two transfer projects conducted at Ericsson. Both transfers were performed between a site in Sweden and a site in India. The observations outline a set of generic practices that have been found useful for transferring software development within a company. It also highlights a number of challenges to be addressed and a set of corresponding recommendations. Finally, the paper emphasizes the need to identify software products that are suitable for transfers and the need to monitor the long-term effects of transfer. [ABSTRACT FROM AUTHOR]

SUMMARY While the payback from technical training is largely undisputed, and a cost that many organizations are prepared to incur, the benefits of socialization training on global software development projects remains an area of debate. This paper begins to explore whether getting to know those you are working with really matters when it comes to the quality of the software that is produced in global settings. The paper describes how five student teams were put in competition to develop software for a Cambodian client. Each extended team comprised students distributed across a minimum of three locations, drawn from the US, India, Thailand, and Cambodia. Two exercises were conducted with these students during the project, to examine their awareness of the countries of their collaborators and competitors, and to assess their knowledge of their own extended team members. On a weekly basis, the stress levels of the students, along with the communication patterns of each development team, were also recorded. The quality of each team's eventual software product was measured through a final product selection process. The paper reports on the results of these two exercises, examined in conjunction with these additional data, and implications for practice and future studies are discussed. Copyright © 2010 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

Large software development organizations manage reusable software components through a reusable software repository in order to reduce development time and cost and to improve software quality and productivity. This paper presents a hybrid DevOps process with a systematic reuse‐based software development and management process to reduce the effort and cost required for the rework and to increase productivity. The proposed approach promotes the systematic reuse of software components based on both information retrieval and ontology‐based retrieval techniques. The reusable assets are presented in different styles to ease and support the reuse process with fine‐grained reusable artifacts. To evaluate our proposed process, a pilot project, aiming to monitor the health of a patient, was developed and monitored the reuse activities throughout the whole experiment. The results revealed that our proposed process got an average gain of 35.2% in terms of developed function points by reusing 30.63% of reusable artifacts available in the reuse repository. [ABSTRACT FROM AUTHOR]