Search

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]

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]

Software bug prediction aims to enhance software quality and testing efficiency by constructing predictive classification models using code properties. This enables the prompt detection of fault‐prone modules. There are several machine learning‐based software bug prediction studies, which mainly focus on single view data by disregarding the natural ordering relation among the class labels in the literature. Thus, these studies cause losing each view's own intrinsic structure and the inherent order of the labels that positively affect the prediction performance. To overcome this drawback, this study focuses on integrating ordering information and a multi‐view learning strategy. This paper proposes a novel approach multi‐view ordinal classification (MVOC), which learns from different views (complexity, coupling, cohesion, inheritance and scale) of the software dataset separately and predicts software bugs taking the inherent order of class labels (non‐buggy, less buggy and more buggy) into consideration. To demonstrate its prediction performance, the MVOC approach was executed on the 40 different real‐world software datasets using six different classification algorithms as base learners. In the experiments, the MVOC approach was compared with traditional classifiers and their multi‐view implementations in terms of precision, recall, f‐measure and accuracy rate metrics. The results indicate that the MVOC approach presents better prediction performance on average than the multi‐view‐based and traditional classifiers. It is also observed from the results that the MVOC.RF model achieved the highest classification performance with an average accuracy rate of 85.65%. [ABSTRACT FROM AUTHOR]

This paper aims to identify what is currently known about Code Bad Smells using a systematic literature review. We analyzed papers published since Fowler et al. identified Code Bad Smells (2000 to June 2009). Our result suggests that there is little evidence currently available to justify using Code Bad Smells. Copyright © 2010 John Wiley & Sons, Ltd. [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]

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: In software product line engineering, feature models (FMs) represent the variability and commonality of a family of software products. The development of FMs may introduce inaccurate feature relationships. These relationships may cause various types of defects such as inconsistencies, which deteriorate the quality of software products. Several researchers have worked on the identification of defects due to inconsistency in FMs, but only a few of them have explained their causes. In this paper, FM is transformed to predicate‐based feature model ontology using Prolog. Further, first‐order logic is employed for defining rules to identify defects due to inconsistency, the explanations for their causes, and suggestions for their corrections. The proposed approach is explained using an FM available in Software Product Line Online Tools repository. It is validated using 26 FMs of discrete sizes up to 5,543 features, generated using the FeatureIDE tool and real‐world FMs. Results indicate that the proposed methodology is effective, accurate, and scalable and improves software product line. [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]

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]

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]

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]

SUMMARY In social psychology, propinquity refers to the physical (objective) or psychological (subjective) proximity between people. In this paper, we explore the psychological dimension of propinquity by examining the phenomenon of feeling distant from geographically distributed people, in the context of distributed software teams. The perceived distance is an important challenge faced by distributed teams, and it is frequently based on factors beyond the physical distance, such as communication and cultural differences. The purpose of this paper is to present a model to assess and make more visible the construct of 'perceived distance' among members of global software engineering teams. The model was applied in three real-world cases to assess its effectiveness in uncovering hidden and useful information during the project lifecycle. The practical experience lived with the quantification of perceived distance gave us good indication that this data can benefit the practice of global software engineering. In most of the projects evaluated, project managers were not expecting the results found. We present the model, details of its applications, analysis of the results, lessons learned and practical implications for the management of distributed software projects and teams. Copyright © 2010 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

This paper describes a method to recover the evolution of a software system using its software trails: information left behind by the contributors to the development process of the product, such as mailing lists, Web sites, version control logs, software releases, documentation, and the source code. This paper demonstrates the use of this method by recovering the evolution of Ximian Evolution, a mail client for Unix. By extracting useful facts stored in these software trails and correlating them, it was possible to provide a detailed view of the history of this project. This view provides interesting insight into how an open source software project evolves and some of the practices used by its software developers. Copyright © 2004 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

Function-point analysis was introduced to help measure the functionality of software systems. For more than a decade, function points have been widely used to measure the size of information systems, often as a part of estimating the effort required for software development and maintenance processes. Limiting the use of function point measurement have been concerns about variable judgements on the part of the personnel doing the measurement, yielding differences in function-point measures for the same software product even in the same organization. Also, if an organization tries to introduce function-point analysis, the process normally starts with measurements from the organization's own past software products--a time consuming task with start-up costs. In this paper, we propose detailed function-point analysis measurement rules using design specifications based on the Unified Modelling Language and describe a function-point measurement tool, whose inputs are design specifications developed on Rational Rose ®. Then in this paper, we report tool validation work on software involved in software evolution at an organization where we have applied the tool to actual design specifications and examined the differences between the function point values obtained by the tool and those of an experienced function point measurement specialist at the organization. [ABSTRACT FROM AUTHOR]

The past two decades have seen increasing sophistication in software work. Now and in the future, the work of both practitioners and researchers would be helped by a more objective and finer granularity recognition of types of software evolution and software maintenance activities as actually done. To these ends, this paper proposes a clarifying redefinition of the types of software evolution and software maintenance. The paper bases the proposed classification not on people's intentions but upon objective evidence of maintainers' activities ascertainable from observation of activities and artifacts, and/or a before and after comparison of the software documentation. The classification includes taking into account in a semi-hierarchical manner evidence of the change or lack thereof in: (1) the software, (2) the documentation, (3) the properties of the software, and (4) the customer-experienced functionality. A comparison is made with other classifications and typologies. The paper provides a classified list of maintenance activities and a condensed decision tree as a summary guide to the proposed evidence-based classification of the types of software evolution and software maintenance. [ABSTRACT FROM AUTHOR]

Requirements Engineering (RE) includes processes intended to elicit, analyse, specify and validate systems and software requirements throughout the software life cycle. Mastering the principles of RE is key to achieving the goals of better, cheaper and quicker systems and software development projects. It is also important to be prepared to work with remote teammates, as distributed and global projects are becoming more common. This paper presents an experiment with a total of 31 students from two universities in Spain and Morocco who were assigned to either a co-located or a distributed team. Both traditional and reuse-based requirements specification techniques were applied by the participants to produce requirements documents. Their outcomes were then analysed, and the approaches were compared from the point of view of their effect on a set of performance-based and perception-based variables in co-located and distributed settings. We found significant differences in only productivity (Z =-2.320, p = 0.020) and difficulty (Z =-2.124, p = 0.034) as regards the scores attained for non-reuse and reuse conditions, both in the co-located modality. Our findings show that, in general, the participants attained similar results for requirements specification when using the two strategies in both distributed and non-distributed environments. [ABSTRACT FROM AUTHOR]

This paper considers the software which is used discretely with regard to time, such as the usual software for numerical computation, and proposes a model for the reliability analysis in the development stage. Also, the ease of the software test is considered in which two debuggers attempt to detect the bugs in the software. A discussion is made from the viewpoint of Bayes' theory. The case of two debuggers is as follows. Two software engineers execute the test independently for the same software. The detected bugs are compared later, including their overlaps, to acquire a larger amount of information. Based on the model for analysis proposed in this paper, a formulation is presented for the determination of the release of the software, i.e., the time to terminate the test. Numerical examples are presented, providing discussions on the features of the model considered in this study as well as on its usefulness. [ABSTRACT FROM AUTHOR]

Developers might follow different file editing patterns when handling change requests. Existing research has warned the community about the potential negative impacts of some file editing patterns on software quality. However, very few studies have provided quantitative evidence to support these claims. In this paper, we propose four metrics to identify four file editing patterns: concurrent editing pattern, parallel editing pattern, extended editing pattern, and interrupted editing pattern. Our empirical study on three open source projects shows that 90% (i.e. 1935 out of 2140) of files exhibit at least one file editing pattern. More specifically (1) files that are edited concurrently by many developers are 1.8 times more likely to experience future bugs than files that are not concurrently edited; (2) files edited in parallel with too many other files by the same developer are 2.9 times more likely to exhibit future bugs than files individually edited; (3) files edited over an extended period of time are 1.9 times more likely to experience future bugs than other files; and (4) files edited with long interruptions have 2.0 times more future bugs than other files. We also observe that the likelihood of future bugs in files experiencing all the four file editing patterns is 3.9 times higher than in files that are never involved in any of the four patterns. We further investigate factors impacting the occurrence of these file editing patterns along three dimensions: the ownership of files, the type of change requests in which the files were involved, and the initial code quality of the files. Results show that a file with a major owner is 0.6 times less likely to exhibit the concurrent editing pattern than files without major owners. Files with bad code quality (e.g. highMcCabe's complexity, high coupling between objects, and lack of cohesion) are more likely to experience the four editing patterns. By ensuring a clear ownership and improving code quality, the negative impact of the four patterns could be reduced. Overall, our findings could be used by software development teams to warn developers about risky file editing patterns. [ABSTRACT FROM AUTHOR]

ABSTRACT Rework is inherent in product development, but estimation of the duration and required resources for rework cycles is inhibited by task size variation, process capacity variation, and the process characteristics of dynamism and concurrency. This difficulty is especially evident in testing of software-intensive systems. Dynamic modeling of test-and-fix cycles has addressed this problem by providing good forecasting of test phase durations and by providing good results in supporting resource allocation and process improvement decisions. A generalized model of test-and-fix phases has been produced from an analysis of commonality and variation in six project models. The generalized model can be configured to support test phase planning of duration and resources. This paper extends the work reported in ICSSP 2012 by reporting results of experiments on managing test-and-fix projects through work-in-process limits and through test case prioritization. Copyright © 2014 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

SUMMARY Software process improvement in software development organizations is a complex task that can be solved using knowledge management strategies. The definition and use of process patterns is a proven approach to apply knowledge management strategies in software engineering organizations. One of the main problems for the effective application of process patterns is the difficulty of formalizing the knowledge about the development process using these approaches. In this paper, a framework to manage software project patterns is presented. This framework is composed of a model called reusable project pattern (RPP) and a tool called sdpReuser. It is able to formalize the knowledge on software development projects from software development methodologies, reference frameworks, best practices and also tacit knowledge, useful to software engineers. The authors carried out a case study at the University Carlos III of Madrid, where junior software engineers used RPP. This study shows that the quality of pattern formalization correlates with experience in specific software engineering methods, the quality of the references in software engineering practices and the collaboration among software engineers to develop an RPP. It also analyzed the usefulness of RPP information elements to help software engineers to identify the most appropriate RPP and how to adapt it to project restrictions. Copyright © 2013 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

Looking at normal test activities such as test preparation or test execution, setting up a Process Reference Model or a Process Assessment Model seems to be quite easy, but when discussion focuses on technical issues, it becomes really challenging. This paper describes the current handling of those issues in the TestSPICE approach and also some potential pitfalls. Copyright © 2013 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

ABSTRACT This paper proposes a methodology to identify and prevent/control noncompliances and conflicts arisingout of requirement attribute values during requirements management. It is intended to provide a cost-effective approach for managing noncompliances in projects that employ the requirements based engineering approach. The method involves continuous checking and monitoring of requirement attribute values using a rule-based engine concept. This methodology can serve as an enhanced feature for any commercial requirement management application software available today (such as IBM DOORS© and Seimens TcSE©).The methodology offers the following advantages: It enables standardization in the development and management of requirement modules., It decreases development and maintenance cost for requirement modules by reducing the effort needed for audits, compliance checks, rework and others., Copyright © 2013 John Wiley & Sons, Ltd. [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]

ABSTRACT Spectrum-based fault localization is a promising approach to automatically locate root causes of failures quickly. Two well-known spectrum-based fault localization techniques, Tarantula and Ochiai, measure how likely a program element is a root cause of failures based on profiles of correct and failed program executions. These techniques are conceptually similar to association measures that have been proposed in statistics, data mining, and have been utilized to quantify the relationship strength between two variables of interest (e.g., the use of a medicine and the cure rate of a disease). In this paper, we view fault localization as a measurement of the relationship strength between the execution of program elements and program failures. We investigate the effectiveness of 40 association measures from the literature on locating bugs. Our empirical evaluations involve single-bug and multiple-bug programs. We find there is no best single measure for all cases. Klosgen and Ochiai outperform other measures for localizing single-bug programs. Although localizing multiple-bug programs, Added Value could localize the bugs with on average smallest percentage of inspected code, whereas a number of other measures have similar performance. The accuracies of the measures in localizing multi-bug programs are lower than single-bug programs, which provokes future research. Copyright © 2013 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

The software engineering literature reports empirical evidence on the relation between various characteristics of a software system and its quality. Among other factors, recent studies have shown that a proper choice of identifiers influences understandability and maintainability. Indeed, identifiers are developers' main source of information and guide their cognitive processes during program comprehension when high-level documentation is scarce or outdated and when source code is not sufficiently commented. This paper proposes a novel approach to recognize words composing source code identifiers. The approach is based on an adaptation of Dynamic Time Warping used to recognize words in continuous speech. The approach overcomes the limitations of existing identifier-splitting approaches when naming conventions (e.g., Camel Case) are not used or when identifiers contain abbreviations. We apply the approach on a sample of more than 1000 identifiers extracted from 340 C programs and compare its results with a simple Camel Case splitter and with an implementation of an alternative identifier splitting approach, Samurai. Results indicate the capability of the novel approach: (i) to outperform the alternative ones, when using a dictionary augmented with domain knowledge or a contextual dictionary and (ii) to expand 48% of a set of selected abbreviations into dictionary words. [ABSTRACT FROM AUTHOR]

Research and practice in software engineering have led to an extensive set of metrics for the evaluation of almost every aspect of software development. One of the major challenges for any quality model is the combination of metrics, which are complementary to each other. In this paper, we propose the use of Data Envelopment Analysis (DEA), a non-parametric technique employed in economics, as a means of providing a unified view of selected design metrics. The proposed application of DEA aims at assessing the overall trend of quality during the evolution of software systems, by considering releases of a project as units to be ranked. An important benefit derived from the use of DEA is the ability to "normalize" the evaluation over the size characteristics of the examined systems, which is vital when comparing projects of different scale. Results are presented for successive versions of two open-source, one industrial and one research project, whereas validation, whereas validation is performed by comparing the findings with the results obtained by Analytic Hierarchy Process, which is an acknowledged multi-criteria decision analysis approach. According to the results, DEA enables the perception of global trends in qualitative characteristics, which would be otherwise difficult to recognize and interpret. [ABSTRACT FROM AUTHOR]

This paper introduces a new process for a rigorous component-centered development of trustworthy systems. The rationale for our perspective of the process is two-fold. The activities prescribed in a conventional software engineering development process are neither suitable nor sufficient for developing component-based systems. Component-based development methods that are currently practised do not support the explicit specification of trustworthiness properties, and are not based on rigorous principles. Hence they are not suitable for developing trustworthy systems. Trustworthiness is regarded as a composite nonfunctional property comprising the four attributes safety, security, availability, and reliability. They must be rigorously defined for components and systems composed from them. It is essential that the process enforces a direct evidence of trustworthiness in the systems that are developed following the process. Consequently, the development process, in addition to being reuse-oriented, component-oriented, and rigorous in all phases of the system lifecycle, should maintain the chain of evidence that the trustworthiness properties are preserved in every activity of every phase of system development. The proposed process includes several parallel interrelated tracks including component development, component assessment, component reuse, and component-based system development and prescribes specific activities and tools for ensuring trustworthiness in all activities. [ABSTRACT FROM AUTHOR]

Software development organizations are increasingly recognizing the need for flexibility in almost every project they execute. At the same time, development teams are under ever-increasing pressure to deliver software products in shorter cycles and with higher levels of quality. The current software development projects face conflicting demands: improving process predictability to deliver trustworthy software products, and improving process flexibility to adapt to the dynamic context. Although the importance of process tailoring is well recognized, the current literature and industry standards fail to provide theoretically and empirically grounded guidelines on how to tailor the development process to suit the needs of developing trustworthy software in the current dynamic environment. This paper examines how software development teams achieve dynamic capabilities to pursue conflicting demands on trustworthiness and flexibility through a case study of a large military software development project. [ABSTRACT FROM AUTHOR]

Automated negotiation is widely applied in various domains. However, the development of such systems is a complex knowledge and software engineering task. So, a methodology there will be helpful. Unfortunately, none of existing methodologies can offer sufficient, detailed support for such system development. To remove this limitation, this paper develops a new methodology made up of (1) a generic framework (architectural pattern) for the main task, and (2) a library of modular and reusable design pattern (templates) of subtasks. Thus, it is much easier to build a negotiating agent by assembling these standardized components rather than reinventing the wheel each time. Moreover, because these patterns are identified from a wide variety of existing negotiating agents (especially high impact ones), they can also improve the quality of the final systems developed. In addition, our methodology reveals what types of domain knowledge need to be input into the negotiating agents. This in turn provides a basis for developing techniques to acquire the domain knowledge from human users. This is important because negotiation agents act faithfully on the behalf of their human users and thus the relevant domain knowledge must be acquired from the human users. Finally, our methodology is validated with one high impact system. [ABSTRACT FROM AUTHOR]

SUMMARY As software evolution organizations (SEOs) formalize their activities into standard repeatable processes, capability maturity models suggest that they gather and analyze data to quantitatively manage their activities. This study examines the use of a time-series cross-section (TSCS) modeling approach to inform the quantitative management of the testing activities within a mature SEO. This paper describes the TSCS modeling approach and provides an exemplar case study that details its use. Data for the case study come from readily available, commonly gathered production and testing defect reports in the quantitative measurement efforts of ait CMMI-DEV Level 3 assessed software development and evolution organization. Covering six independent projects for 43 months, the case study defines quality in terms of reported defects in the production code base. The predictors are the six projects and defect data identified in the unit, system, and regression testing activities logs. The case study also details how results from the TSCS analysis triggered causal analysis to improve the testing activities. The study provides evidence that TSCS models can be used as a quantitative problem identification tool for the mature ( SM mm Level 3 or higher) SEO's testing activities. Copyright © 2011 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

Current practices in the industry are moving towards the market-driven development of software intensive products compared to customer-specific system development. Consequently, product management is faced with several challenges that have to be addressed as a part of the market-driven requirements engineering process. One of the important challenges is how to select the right mix of requirements, balancing short-term and long-term gains. One way to address this challenge is to utilize product strategies for selecting requirements. However, in order to do this the internal success-critical stakeholders (SCS) involved in strategies creation and requirements selection need to be aligned with respect to a product's strategic goals and objectives. This paper presents a method to enable the evaluation of degree of alignment between SCS with respect to the understanding and interpretation of a product's strategy. Further, the method not only enables the evaluation of alignment, but also specifically shows misalignment, and enables the identification of leading causes. The method has been developed in collaboration with the industry and its application is shown through a case study at Ericsson AB. Copyright © 2011 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

There are many tools and techniques readily available to support the work in requirements activities of software development processes. As a consequence, the high frequency of errors still occurring in requirements activities suggests that the misunderstanding of the relationships among key decisions is the probable reason for this. The present work presents a system dynamics model constructed to make it possible for users to better understand the relations among key decision variables in requirements activities. The model was parameterized with data taken from previous studies and from a software development company so as to run two sets of simulations with three scenarios each. Optimistic, baseline and pessimistic scenarios are created on the basis of different assumptions regarding risk factors related to requirements volatility and people turnover. We used our simulation results to foresee the effects of these risk factors on the quality and cost of work in requirements activities. Up-to-date results from the software engineering literature strongly support the simulation outcomes obtained in our research. Copyright © 2010 John Wiley & Sons, Ltd. In this paper we present a system dynamics model constructed to make it possible for users to better understand the relations among key decision variables in requirements activities. The model was parameterized with data taken from previous studies and from a software development company to run scenarios simulations. We used our simulation results to foresee the effects of risk factors related to requirements volatility and people turnover on the quality and cost of work in requirements activities. Copyright © 2010 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

Grammar inference is a family of machine learning techniques that aim to infer grammars from a sample of sentences in some (unknown) language. Dynamic analysis is a family of techniques in the domain of software engineering that attempts to infer rules that govern the behaviour of software systems from a sample of executions. Despite their disparate domains, both fields have broadly similar aims; they try to infer rules that govern the behaviour of some unknown system from a sample of observations. Deriving general rules about program behaviour from dynamic analysis is difficult because it is virtually impossible to identify and supply a complete sample of necessary program executions. The problems that arise with incomplete input samples have been extensively investigated in the grammar inference community. This has resulted in a number of advances that have produced increasingly sophisticated solutions that are more successful at accurately inferring grammars from (potentially) sparse information about the underlying system. This paper investigates the similarities and shows how many of these advances can be applied with similar effect to dynamic analysis problems by a series of small experiments on random state machines. Copyright © 2008 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

Sequence diagrams can be valuable aids to software understanding. However, they can be extremely large and hard to understand in spite of using modern tool support. Consequently, providing the right set of tool features is important if the tools are to help rather than hinder the user. This paper surveys research and commercial sequence diagram tools to determine the features they provide to support program understanding. Although there has been significant effort in developing these tools, many of them have not been evaluated using human subjects. To begin to address this gap, a preliminary study was performed with a specially designed sequence diagram tool that implements the features found during the survey. On the basis of an analysis of the study results, we discuss the features that were found to be useful and relate these to the tasks performed. It concludes by proposing how future tools can be improved to better support the exploration of large sequence diagrams. Copyright © 2008 Crown in the right of Canada. Published by John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

One approach to measuring and managing the complexity of software, as it evolves over time, is to exploit software metrics. Metrics have been used to estimate the complexity of the maintenance effort, to facilitate change impact analysis, and as an indicator for automatic detection of a transformation that can improve the quality of a system. However, there has been little effort directed at applying software metrics to the maintenance of grammar-based software applications, such as compilers, editors, program comprehension tools and embedded systems. In this paper, we adapt the software metrics that are commonly used to measure program complexity and apply them to the measurement of the complexity of grammar-based software applications. Since the behaviour of a grammar-based application is typically choreographed by the grammar rules, the measure of complexity that our metrics provide can guide maintainers in locating problematic areas in grammar-based applications. Copyright © 2004 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

Gaining higher-level evolutionary information about large software systems is a key challenge in dealing with increasing complexity and architectural deterioration. Modification reports and problem reports (PRs) taken from systems such as the concurrent versions system (CVS) and Bugzilla contain an overwhelming amount of information about the reasons and effects of particular changes. Such reports can be analyzed to provide a clearer picture about the problems concerning a particular feature or a set of features. Hidden dependencies of structurally unrelated but over time logically coupled files exhibit a good potential to illustrate feature evolution and possible architectural deterioration. In this paper, we describe the visualization of feature evolution by taking advantage of this logical coupling introduced by changes required to fix a reported problem. We compute the proximity of PRs by applying a standard technique called multidimensional scaling (MDS). The visualization of these data enables us to depict feature evolution by projecting PR dependence onto (a) feature-connected files and (b) the project directory structure of the software system. These two different views show how PRs, features and the directory tree structure relate. As a result, our approach uncovers hidden dependencies between features and presents them in an easy-to-assess visual form. A visualization of interwoven features can indicate locations of design erosion in the architectural evolution of a software system. As a case study, we used Mozilla and its CVS and Bugzilla data to show the applicability and effectiveness of our approach. Copyright © 2004 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

This paper presents a probabilistic model for evaluating the reliability of software having modular structure. In particular, it proposes a new reliability-evaluating model based on the structure of software by integrating the Jelinski-Moranda model, which is the most basic black box model, and the Littlewood model, which is a representative white box model. The performance of the proposed model is compared and studied in reference to the benchmark model of Cheung and the dependency of the architecture and the reliability growth in software reliability evaluation is discussed. [ABSTRACT FROM AUTHOR]

Software visualization is concerned with the static visualization as well as the animation of software artifacts, such as source code, executable programs, and the data they manipulate, and their attributes, such as size, complexity, or dependencies. Software visualization techniques are widely used in the areas of software maintenance, reverse engineering, and re-engineering, where typically large amounts of complex data need to be understood and a high degree of interaction between software engineers and automatic analyses is required. This paper reports the results of a survey on the perspectives of 82 researchers in software maintenance, reverse engineering, and re-engineering on software visualization. It describes to which degree the researchers are involved in software visualization themselves, what is visualized and how, whether animation is frequently used, whether the researchers believe animation is useful at all, which automatic graph layouts are used if at all, whether the layout algorithms have deficiencies, and--last but not least--where the medium-term and long-term research in software visualization should be directed. The results of this survey help to ascertain the current role of software visualization in software engineering from the perspective of researchers in these domains and give hints on future research avenues. [ABSTRACT FROM AUTHOR]

Since the proposal for the six object-oriented metrics by Chidamber and Kemerer (1994), several studies have been conducted to validate their metrics and have discovered some deficiencies. Consequently, many new metrics for object-oriented systems have been proposed. Among the various measurements of object-oriented characteristics, we focus on the metrics of class inheritance hierarchies in design and maintenance. As such, we propose two simple and heuristic metrics for the class inheritance hierarchy for the maintenance of object-oriented software. In this paper we investigate the work of Chidamber and Kemerer (1994) and Li (1998), and extend their work to apply specifically to the maintenance of a class inheritance hierarchy. In doing so, we suggest new metrics for understandability and modifiability of a class inheritance hierarchy. The main contribution here includes the various comparisons that we have made. We discuss the advantages over Chidamber and Kemerer's (1994) metrics and Henderson-Sellers's (1996) metrics in the context of maintaining class inheritance hierarchies. [ABSTRACT FROM AUTHOR]

Testing of software systems involves many complex problems for test managers. Important issues to be considered include how to quantify reliability, how to design tests, which tests should be performed given time, cost and resource constraints, what are the implications of test failures, what tests should be re-run following corrections to rectify faults, and so forth. All of these issues are related to the uncertainties involved in the quality of the software and the process of testing. In a continuing collaboration, the use of Bayesian graphical models has been explored to model these uncertainties and to support software testers and test managers with their complex tasks. This paper discusses some features of Bayesian graphical models which are pertinent to modelling software testing problems, and in particular the kind of support they can provide to test managers and the use of such models in a practical environment. Details of the modelling process are presented elsewhere. Copyright © 2001 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

Domain knowledge is the soul of software systems. After decades of software development, domain knowledge has reached a certain degree of saturation. The recovery of domain knowledge from source code is beneficial to many software engineering activities, in particular, software evolution. In the real world, the ambiguous appearance of domain knowledge embedded in source code constitutes the biggest barrier to recovering reliable domain knowledge. In this paper, we introduce an innovative approach to recovering domain knowledge with enhanced reliability from source code. In particular, we divide domain knowledge into interconnected knowledge slices and match these knowledge slices against the source code. Each knowledge slice has its own authenticity evaluation function which takes the belief of the evidence it needs as input and the authenticity of the knowledge slice as output. Moreover, the knowledge slices are arranged to exchange beliefs with each other through interconnections, i.e. concepts, so that a better evaluation of the authenticity of these knowledge slices can be obtained. The decision on acknowledging recovered knowledge slices can therefore be made more easily. Our approach, rooted as it is in cognitive science and social psychology, is also widely applicable to other knowledge recovery tasks. [ABSTRACT FROM AUTHOR]

This paper describes a new effort estimation model based on use case reuse, called the use case reusability (UCR), intended for the projects that are reusing artifacts previously developed in past projects with similar scope. Analysis of the widely spread effort estimation techniques for software development projects shows that these techniques were primarily intended for the development of new software solutions. The baseline for the new effort estimation model is the use case points model. The UCR model introduces new classification of use cases based on their reusability, and it includes only those technical and environmental factors that according to the effort estimation experts have significant impact on effort for the target projects. This paper also presents a study which validates the usage of UCR model. The study is conducted within industry and academic environments using industry project teams and postgraduate students as subjects. The analysis results show that UCR model can be applied in different project environments and that according to the observed mean magnitude relative error, it produced very promising effort estimates. This paper describes a new effort estimation model based on use case reuse, called the use case reusability (UCR), intended for the projects that are reusing artifacts previously developed in past projects with similar scope. The baseline for the new effort estimation model is the use case points model. The UCR model introduces new classification of use cases based on their reusability, and it includes only those technical and environmental factors that according to the effort estimation experts have significant impact on effort for the target projects. [ABSTRACT FROM AUTHOR]

Analogy‐based estimation is one of the most widely used techniques for effort prediction in software engineering. However, existing analogy‐based techniques suffer from an inability to correctly handle nonquantitative data. To deal with this limitation, a new technique called 2FA‐kprototypes was proposed and evaluated. 2FA‐kprototypes is based on the use of the fuzzy k‐prototypes clustering technique. Although fuzzy k‐prototypes algorithms are well known for their efficiency in clustering numerical and categorical data, they are sensitive to the selection of initial cluster centers. In this paper, the impact of cluster center initialization on improving the prediction accuracy of 2FA‐kprototypes was analyzed and discussed using two cluster initialization techniques: centrality‐based initialization and density‐based initialization. The performance of 2FA‐kprototypes using these two initialization techniques was evaluated and compared with that of 2FA‐kprototypes using random initialization over four datasets: ISBSG, COCOMO81, USP05‐FT, and USP05‐RQ. The results showed an improvement in the performance of 2FA‐kprototypes in terms of estimation accuracy when the all‐in method is used. [ABSTRACT FROM AUTHOR]

Context Since last more than one‐decade software process improvement, widely known as SPI has received the attention of the software engineering community. Objective: The objective of the paper is to empirically examine and develop a framework to model structural dependences among inhibitors that impact SPI initiatives in software SMEs. Methods: Authors used mixed method approach (empirical analysis and interpretive structural modeling, ISM) to evaluate, model, and analyze the association between SPI inhibitors in software SMEs. Results: The results from empirical analysis and ISM show that lack of management commitment, lack of resources, and lack of communication and information sharing are the key SPI inhibitors. The association of various inhibitors with SPI implementation is found statistically significant with effect size (0.42 < Ø < 0.75, P < 0.05). Also, Spearman's coefficient of correlation for rankings of SPI inhibitors is found to be moderate to high, ie, 0.601 (P = 0.01 < 0.05) for SLR and interviews; 0.794 (P = 0.00) for SLR and empirical analysis; and 0.711 (P = 0.002 < 0.01) for interviews and empirical analysis. Conclusions: Analysis of SPI inhibitors through the proposed triangulation approach and development of software process improvement inhibitors model highlights the importance of structural dependencies among the inhibitors. [ABSTRACT FROM AUTHOR]

Today's world economic situation is ruled by issues such as reducing cost, improving quality, maximizing profit, and improving and optimizing processes at organizations. In this context, business process management can be an essential strategy, but it is not usually consolidated at software organizations because software process properties involve a complex business process management application on software lifecycle. Consequently, software organizations often focus on Software Process Modeling (SPM), and each involved role performs process execution and orchestration independently and manually. This fact makes software processes maintenance, monitoring, and measurement become difficult tasks. This paper proposes a model‐based approach for SPM taking into account concepts related to process execution, orchestration, and monitoring. It is framed into a model‐driven engineering‐based and tool‐based framework: Process Lifecycle Management for Business Software (PLM4BS). We present a SPM metamodel and its concrete syntax (through Unified Modeling Language profiles) that lays the foundation for extending PLM4BS. Its underlying metamodel allows managing processes automatically. Furthermore, PLM4BS improves current state‐of‐the‐art proposals in 6 dimensions: expressiveness, understandability, granularity, measurability, orchestrability, and business variables and rules. Also, PLM4BS has been evaluated in a multiple‐case study, in which the 6 mentioned dimensions were already validated. [ABSTRACT FROM AUTHOR]

Abstract: Unreadable code could compromise program comprehension, and it could cause the introduction of bugs. Code consists of mostly natural language text, both in identifiers and comments, and it is a particular form of text. Nevertheless, the models proposed to estimate code readability take into account only structural aspects and visual nuances of source code, such as line length and alignment of characters. In this paper, we extend our previous work in which we use textual features to improve code readability models. We introduce 2 new textual features, and we reassess the readability prediction power of readability models on more than 600 code snippets manually evaluated, in terms of readability, by 5K+ people. We also replicate a study by Buse and Weimer on the correlation between readability and FindBugs warnings, evaluating different models on 20 software systems, for a total of 3M lines of code. The results demonstrate that (1) textual features complement other features and (2) a model containing all the features achieves a significantly higher accuracy as compared with all the other state‐of‐the‐art models. Also, readability estimation resulting from a more accurate model, ie, the combined model, is able to predict more accurately FindBugs warnings. [ABSTRACT FROM AUTHOR]