共查询到20条相似文献,搜索用时 15 毫秒
1.
Jie-Cherng Chen Author Vitae Author Vitae 《Journal of Systems and Software》2009,82(6):981-992
Many problem factors in the software development phase affect the maintainability of the delivered software systems. Therefore, understanding software development problem factors can help in not only reducing the incidence of project failure but can also ensure software maintainability. This study focuses on those software development problem factors which may possibly affect software maintainability. Twenty-five problem factors were classified into five dimensions; a questionnaire was designed and 137 software projects were surveyed. A K-means cluster analysis was performed to classify the projects into three groups of low, medium and high maintainability projects. For projects which had a higher level of severity of problem factors, the influence on software maintainability becomes more obvious. The influence of software process improvement (SPI) on project problems and the associated software maintainability was also examined in this study. Results suggest that SPI can help reduce the level of severity of the documentation quality and process management problems, and is only likely to enhance software maintainability to a medium level. Finally, the top 10 list of higher-severity software development problem factors was identified, and implications were discussed. 相似文献
2.
Software Quality Journal - In software engineering predictive modeling, early prediction of software modules or classes that possess high maintainability effort is a challenging task. Many... 相似文献
3.
In this paper, we investigate the impact of team size on the software development effort. Using field data of over 200 software
projects from various industries, we empirically test the impact of team size and other variables—such as software size in
function points, ICASE tool and programming language type—on software development effort. Our results indicate that software
size in function points significantly impacts the software development effort. The two-way interactions between function points
and use of ICASE tool, and function points and language type are significant as well. Additionally, the interactions between
team size and programming language type, and team size and use of ICASE tool were all significant.
相似文献
James A. RodgerEmail: |
4.
5.
Shane McIntosh Yasutaka Kamei Bram Adams Ahmed E. Hassan 《Empirical Software Engineering》2016,21(5):2146-2189
Software code review, i.e., the practice of having other team members critique changes to a software system, is a well-established best practice in both open source and proprietary software domains. Prior work has shown that formal code inspections tend to improve the quality of delivered software. However, the formal code inspection process mandates strict review criteria (e.g., in-person meetings and reviewer checklists) to ensure a base level of review quality, while the modern, lightweight code reviewing process does not. Although recent work explores the modern code review process, little is known about the relationship between modern code review practices and long-term software quality. Hence, in this paper, we study the relationship between post-release defects (a popular proxy for long-term software quality) and: (1) code review coverage, i.e., the proportion of changes that have been code reviewed, (2) code review participation, i.e., the degree of reviewer involvement in the code review process, and (3) code reviewer expertise, i.e., the level of domain-specific expertise of the code reviewers. Through a case study of the Qt, VTK, and ITK projects, we find that code review coverage, participation, and expertise share a significant link with software quality. Hence, our results empirically confirm the intuition that poorly-reviewed code has a negative impact on software quality in large systems using modern reviewing tools. 相似文献
6.
Context
Code smells are manifestations of design flaws that can degrade code maintainability. So far, no research has investigated if these indicators are useful for conducting system-level maintainability evaluations.Aim
The research in this paper investigates the potential of code smells to reflect system-level indicators of maintainability.Method
We evaluated four medium-sized Java systems using code smells and compared the results against previous evaluations on the same systems based on expert judgment and the Chidamber and Kemerer suite of metrics. The systems were maintained over a period of up to 4 weeks. During maintenance, effort (person-hours) and number of defects were measured to validate the different evaluation approaches.Results
Most code smells are strongly influenced by size; consequently code smells are not good indicators for comparing the maintainability of systems differing greatly in size. Also, from the comparison of the different evaluation approaches, expert judgment was found as the most accurate and flexible since it considered effects due to the system's size and complexity and could adapt to different maintenance scenarios.Conclusion
Code smell approaches show promise as indicators of the need for maintenance in a way that other purely metric-based approaches lack. 相似文献7.
8.
Release notes are an important source of information about a new software release. Such notes contain information regarding what is new, changed, and/or got fixed in a release. Despite the importance of release notes, they are rarely explored in the research literature. Little is known about the contained information, e.g., contents and structure, in release notes. To better understand the types of contained information in release notes, we manually analyzed 85 release notes across 15 different software systems. In our manual analysis, we identify six different types of information (e.g., caveats and addressed issues) that are contained in release notes. Addressed issues refer to new features, bugs, and improvements that were integrated in that particular release. We observe that most release notes list only a selected number of addressed issues (i.e., 6-26 % of all addressed issues in a release). We investigated nine different factors (e.g., issue priority and type) to better understand the likelihood of an issue being listed in release notes. The investigation is conducted on eight release notes of three software systems using four machine learning techniques. Results show that certain factors, e.g., issue type, have higher influence on the likelihood of an issue to be listed in release notes. We use machine learning techniques to automatically suggest the issues to be listed in release notes. Our results show that issues listed in all release notes can be automatically determined with an average precision of 84 % and an average recall of 90 %. To train and build the classification models, we also explored three scenarios: (a) having the user label some issues for a release and automatically suggest the remaining issues for that particular release, (b) using the previous release notes for the same software system, and (c) using prior releases for the current software system and the rest of the studied software systems. Our results show that the content of release notes vary between software systems and across the versions of the same software system. Nevertheless, automated techniques can provide reasonable support to the writers of such notes with little training data. Our study provides developers with empirically-supported advice about release notes instead of simply relying on adhoc advice from on-line inquiries. 相似文献
9.
Daniel M. German 《Empirical Software Engineering》2006,11(3):369-393
Software is typically improved and modified in small increments (we refer to each of these increments as a modification record—MR).
MRs are usually stored in a configuration management or version control system and can be retrieved for analysis. In this
study we retrieved the MRs from several mature open software projects. We then concentrated our analysis on those MRs that
fix defects and provided heuristics to automatically classify them. We used the information in the MRs to visualize what files
are changed at the same time, and who are the people who tend to modify certain files. We argue that these visualizations
can be used to understand the development stage of in which a project is at a given time (new features are added, or defects
are being fixed), the level of modularization of a project, and how developers might interact between each other and the source
code of a system. 相似文献
10.
Miyoshi T. Azuma M. 《IEEE transactions on pattern analysis and machine intelligence》1993,19(5):425-435
A study that evaluates new-paradigm-oriented software development environments which have been developed in the five-year formal approach to software environment technology (FASET) project is reviewed. For this study, a software environment evaluation technology based on a software quality evaluation process model defined in ISO/IEC 9126 has been developed. The evaluation technology has been applied to the R&D project at the middle and final phase of development. The evaluation results provide useful information to develop a widely acceptable evaluation technology and to improve the new-paradigm-oriented software development environments that are based on various specification methods: the algebraic specification method, function-oriented specification method, declarative specification method, natural-language-oriented specification method, diagrammatic specification method, state-transition-oriented specification method, and model-based specification method 相似文献
11.
As the complexity of software systems is increasing; software maintenance is becoming a challenge for software practitioners. The prediction of classes that require high maintainability effort is of utmost necessity to develop cost-effective and high-quality software. In research of software engineering predictive modeling, various software maintainability prediction (SMP) models are evolved to forecast maintainability. To develop a maintainability prediction model, software practitioners may come across situations in which classes or modules requiring high maintainability effort are far less than those requiring low maintainability effort. This condition gives rise to a class imbalance problem (CIP). In this situation, the minority classes’ prediction, i.e., the classes demanding high maintainability effort, is a challenge. Therefore, in this direction, this study investigates three techniques for handling the CIP on ten open-source software to predict software maintainability. This empirical investigation supports the use of resampling with replacement technique (RR) for treating CIP and develop useful models for SMP. 相似文献
12.
13.
《Information and Software Technology》2006,48(1):59-67
As the number of object-oriented software systems increases, it becomes more important for organizations to maintain those systems effectively. However, currently only a small number of maintainability prediction models are available for object-oriented systems. This paper presents a Bayesian network maintainability prediction model for an object-oriented software system. The model is constructed using object-oriented metric data in Li and Henry's datasets, which were collected from two different object-oriented systems. Prediction accuracy of the model is evaluated and compared with commonly used regression-based models. The results suggest that the Bayesian network model can predict maintainability more accurately than the regression-based models for one system, and almost as accurately as the best regression-based model for the other system. 相似文献
14.
《Information and Software Technology》2000,42(1):47-65
In software engineering there is a need for technologies that will significantly decrease effort in developing software products, increase quality of software products and decrease time-to-markets. The software development industry can be improved by utilizing and managing software reuse with an “empirically validated reference model” that can be customized for different kinds of software development enterprises. Our research thesis is that software development based on a software reuse reference model improves the competitive edge and time-to-market of many software development enterprises. The definition and study of such a model has been carried out using four steps. First, the reference model developed here is based on the existing software reuse concepts. Second, this reference model is an empirical study which uses both legacy studies and lessons learned studies. Third, the impact of the reference model on software development effort, quality, and time-to-market is empirically derived. Fourth, an initial set of successful cases, which are based on the software reuse reference model utilization, are identified. The main contribution of this paper is a reference model for the practice of software reuse. A secondary contribution is an initial set of cases from software development enterprises which are successful in the practice of reuse in terms of decreased effort, increased quality and a high correlation in their application of our software reuse reference model activities. 相似文献
15.
Paulson J.W. Succi G. Eberlein A. 《IEEE transactions on pattern analysis and machine intelligence》2004,30(4):246-256
We describe an empirical study of open-source and closed-source software projects. The motivation for this research is to quantitatively investigate common perceptions about open-source projects, and to validate these perceptions through an empirical study. We investigate the hypothesis that open-source software grows more quickly, but does not find evidence to support this. The project growth is similar for all the projects in the analysis, indicating that other factors may limit growth. The hypothesis that creativity is more prevalent in open-source software is also examined, and evidence to support this hypothesis is found using the metric of functions added over time. The concept of open-source projects succeeding because of their simplicity is not supported by the analysis, nor is the hypothesis of open-source projects being more modular. However, the belief that defects are found and fixed more rapidly in open-source projects is supported by an analysis of the functions modified. We find support for two of the five common beliefs and conclude that, when implementing or switching to the open-source development model, practitioners should ensure that an appropriate metrics collection strategy is in place to verify the perceived benefits. 相似文献
16.
17.
John Daly Andrew Brooks James Miller Marc Roper Murray Wood 《Empirical Software Engineering》1996,1(2):109-132
This empirical research was undertaken as part of a multi-method programme of research to investigate unsupported claims made of object-oriented technology. A series of subject-based laboratory experiments, including an internal replication, tested the effect of inheritance depth on the maintainability of object-oriented software. Subjects were timed performing identical maintenance tasks on object-oriented software with a hierarchy of three levels of inheritance depth and equivalent object-based software with no inheritance. This was then replicated with more experienced subjects. In a second experiment of similar design, subjects were timed performing identical maintenance tasks on object-oriented software with a hierarchy of five levels of inheritance depth and the equivalent object-based software.The collected data showed that subjects maintaining object-oriented software with three levels of inheritance depth performed the maintenance tasks significantly quicker than those maintaining equivalent object-based software with no inheritance. In contrast, subjects maintaining the object-oriented software with five levels of inheritance depth took longer, on average, than the subjects maintaining the equivalent object-based software (although statistical significance was not obtained). Subjects' source code solutions and debriefing questionnaires provided some evidence suggesting subjects began to experience difficulties with the deeper inheritance hierarchy.It is not at all obvious that object-oriented software is going to be more maintainable in the long run. These findings are sufficiently important that attempts to verify the results should be made by independent researchers. 相似文献
18.
《Information and Software Technology》2008,50(5):361-374
Software systems must continually evolve to adapt to new functional requirements or quality requirements to remain competitive in the marketplace. However, different software systems follow different strategies to evolve, affecting both the release plan and the quality of these systems. In this paper, software evolution is considered as a self-organization process and the difference between closed-source software and open-source software is discussed in terms of self-organization. In particular, an empirical study of the evolution of Linux from version 2.4.0 to version 2.6.13 is reported. The study shows how open-source software systems self-organize to adapt to functional requirements and quality requirements. 相似文献
19.
The resources allocated for software quality assurance and improvement have not increased with the ever-increasing need for
better software quality. A targeted software quality inspection can detect faulty modules and reduce the number of faults
occurring during operations. We present a software fault prediction modeling approach with case-based reasoning (CBR), a part
of the computational intelligence field focusing on automated reasoning processes. A CBR system functions as a software fault
prediction model by quantifying, for a module under development, the expected number of faults based on similar modules that
were previously developed. Such a system is composed of a similarity function, the number of nearest neighbor cases used for
fault prediction, and a solution algorithm. The selection of a particular similarity function and solution algorithm may affect
the performance accuracy of a CBR-based software fault prediction system. This paper presents an empirical study investigating
the effects of using three different similarity functions and two different solution algorithms on the prediction accuracy
of our CBR system. The influence of varying the number of nearest neighbor cases on the performance accuracy is also explored.
Moreover, the benefits of using metric-selection procedures for our CBR system is also evaluated. Case studies of a large
legacy telecommunications system are used for our analysis. It is observed that the CBR system using the Mahalanobis distance
similarity function and the inverse distance weighted solution algorithm yielded the best fault prediction. In addition, the
CBR models have better performance than models based on multiple linear regression.
Taghi M. Khoshgoftaar is a professor of the Department of Computer Science and Engineering, Florida Atlantic University and the Director of the
Empirical Software Engineering Laboratory. His research interests are in software engineering, software metrics, software
reliability and quality engineering, computational intelligence, computer performance evaluation, data mining, and statistical
modeling. He has published more than 200 refereed papers in these areas. He has been a principal investigator and project
leader in a number of projects with industry, government, and other research-sponsoring agencies. He is a member of the Association
for Computing Machinery, the IEEE Computer Society, and IEEE Reliability Society. He served as the general chair of the 1999
International Symposium on Software Reliability Engineering (ISSRE’99), and the general chair of the 2001 International Conference
on Engineering of Computer Based Systems. Also, he has served on technical program committees of various international conferences,
symposia, and workshops. He has served as North American editor of the Software Quality Journal, and is on the editorial boards
of the journals Empirical Software Engineering, Software Quality, and Fuzzy Systems.
Naeem Seliya received the M.S. degree in Computer Science from Florida Atlantic University, Boca Raton, FL, USA, in 2001. He is currently
a Ph.D. candidate in the Department of Computer Science and Engineering at Florida Atlantic University. His research interests
include software engineering, computational intelligence, data mining, software measurement, software reliability and quality
engineering, software architecture, computer data security, and network intrusion detection. He is a student member of the
IEEE Computer Society and the Association for Computing Machinery. 相似文献