软件维修性的定量评估研究

首先阐述了软件维修性的概念和内涵,并对软件维修性的定量评估方法进行了理论研究,针对4个软件维修性度量模型进行了实验分析。     

软件维护性及其度量

维护性是软件的重要质量特性。介绍了Martin和McClure、Gilb、Kurt D.Walker、IEEE std 982.1_1998及ISO/IEC9126_2000标准等提出的软件维护性度量方法，指出了今后研究的发展方向，对进行软件维护性的分析与设计工作具有指导意义。     

Is software quality visible in the code

Finding and fixing software code defects is crucial to product quality. It also, however, often proves difficult and time-consuming, especially late in the development cycle. While some believe that code analysis provides a simple way to detect quality defects, the authors argue otherwise. To prove their point, they analyzed data from error reports, and their results show that code analysis detects only a small percentage of meaningful defects     

Measuring code maintainability with deep neural networks

The maintainability of source code is a key quality characteristic for software quality. Many approaches have been proposed to quantitatively measure code maintainability. Such approaches rely heavily on code metrics, e.g., the number of Lines of Code and McCabe’s Cyclomatic Complexity. The employed code metrics are essentially statistics regarding code elements, e.g., the numbers of tokens, lines, references, and branch statements. However, natural language in source code, especially identifiers, is rarely exploited by such approaches. As a result, replacing meaningful identifiers with nonsense tokens would not significantly influence their outputs, although the replacement should have significantly reduced code maintainability. To this end, in this paper, we propose a novel approach (called DeepM) to measure code maintainability by exploiting the lexical semantics of text in source code. DeepM leverages deep learning techniques (e.g., LSTM and attention mechanism) to exploit these lexical semantics in measuring code maintainability. Another key rationale of DeepM is that measuring code maintainability is complex and often far beyond the capabilities of statistics or simple heuristics. Consequently, DeepM leverages deep learning techniques to automatically select useful features from complex and lengthy inputs and to construct a complex mapping (rather than simple heuristics) from the input to the output (code maintainability index). DeepM is evaluated on a manually-assessed dataset. The evaluation results suggest that DeepM is accurate, and it generates the same rankings of code maintainability as those of experienced programmers on 87.5% of manually ranked pairs of Java classes.     

A life-cycle cost viewpoint of software maintainability

The dynamic and ever-changing characteristics of software requirements make life-cycle costs for today's software very expensive. The cost of post-operational maintenance and modification often exceeds the original development cost. Software which is easily modifiable is not built naturally; it must be carefully contracted for and the development of modifiable software, its support tools and its documentation, must be judiciously managed and tested. However, without resorting to technological innovation of R&D investment, there is much that can be done well within today's state-of-the-art to accommodate significant life-cycle cost savings provided that the acquisition agencies understand the issues and are willing to spend the required time and effort (money) during the software development phase. In this paper we propose a procedure-based approach to software engineering of modifiability by discussing a number of important issues such as contracting for modifiability; techniques for building modifiability into software; planning for post-delivery test facilities and support tools; software maintenance documentation; planning and review to assure that the product evolved support modifiability.     

An application of Bayesian network for predicting object-oriented software maintainability

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.     

Using metrics to evaluate software system maintainability

Software metrics have been much criticized in the last few years, sometimes justly but more often unjustly, because critics misunderstand the intent behind the technology. Software complexity metrics, for example, rarely measure the “inherent complexity” embedded in software systems, but they do a very good job of comparing the relative complexity of one portion of a system with another. In essence, they are good modeling tools. Whether they are also good measuring tools depends on how consistently and appropriately they are applied     

基于MIM的软件度量扩展模型对软件可维护性的度量

主要研究基于实用软件度量（PSM）的软件度量过程模型MIM，提出了一个扩展模型，给出模型的形式化描述和建模步骤。在实践中，把这种新的扩展模型应用于软件的可维护性度量中，取得了较好的效果，进一步证明了此模型提出的可行性与实用性。     

Measuring software dependability by robustness benchmarking

Inability to identify weaknesses or to quantify advancements in software system robustness frequently hinders the development of robust software systems. Efforts have been made to develop benchmarks of software robustness to address this problem, but they all suffer from significant shortcomings. The paper presents the various features that are desirable in a benchmark of system robustness, and evaluates some existing benchmarks according to these features. A new hierarchically structured approach to building robustness benchmarks, which overcomes many deficiencies of past efforts, is also presented. This approach has been applied to building a hierarchically structured benchmark that tests part of the Unix file and virtual memory systems. The resultant benchmark has successfully been used to identify new response class structures that were not detected in a similar situation by other less organized techniques     

Using software architecture for code testing

Our research deals with the use of software architecture (SA) as a reference model for testing the conformance of an implemented system with respect to its architectural specification. We exploit the specification of SA dynamics to identify useful schemes of interactions between system components and to select test classes corresponding to relevant architectural behaviors. The SA dynamics is modeled by labeled transition systems (LTSs). The approach consists of deriving suitable LTS abstractions called ALTSs. ALTSs offer specific views of SA dynamics by concentrating on relevant features and abstracting away from uninteresting ones. Intuitively, deriving an adequate set of test classes entails deriving a set of paths that appropriately cover the ALTS. Next, a relation between these abstract SA tests and more concrete, executable tests needs to be established so that the architectural tests derived can be refined into code-level tests. We use the TRMCS case study to illustrate our hands-on experience. We discuss the insights gained and highlight some issues, problems, and solutions of general interest in architecture-based testing.     

Evaluating inheritance depth on the maintainability of object-oriented software

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.     

An approach to feature‐based software construction for enhancing maintainability

While the way we build software affects significantly its maintenance in terms of the effort and cost, the experience level of the maintainer in a software acquirers' organization is also one of concern. In this context, often the maintainer is the user of the system. Unfortunately, it is quite possible to lose the trustworthiness of the software due to the inexperience of the maintainer, especially when the maintainer is without the help of the original developers. One remedy for providing security against the effects of the maintainer's software modifications is to restrict the access to software parts (modules) relative to the experience level of the maintainers. For such a remedy to be successful, the software should be constructed in such a way that its parts under maintenance affect others as little as possible. We propose an approach to software construction aligning the dependencies among software parts in one direction so that they are allocated to maintainers based on their experience level. Our approach decomposes the software into parts based on functionality and orders the parts by essentiality, which indicates how difficult it is to change each part. Then, we align the dependencies in such a way that the less essential functionality is dependent on the more essential functionality. Consequently, any modification on less essential functionality does not affect the essential functionalities. To demonstrate the feasibility of our proposed approach, we applied it to a military application and found that the constructed software enables us to confine maintainers' activity within a limited working area, and thus the software is safer against maintainers' modification. Copyright © 2006 John Wiley & Sons, Ltd.     

An empirical analysis of the impact of software development problem factors on software maintainability

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.     

Development,evaluation and benchmarking of simulation software for biomolecule-based computing

Simulators for biomolecular computing, (both in vitro and in silico), have come to play an important role in experimentation, analysis, and evaluation of the efficiency and scalability of DNA and biomolecule based computing. Simulation in silico of DNA computing is useful to support DNA-computing algorithm design and to reduce the cost and effort of lab experiments. Although many simulations have now been developed, there exists no standard for simulation software in this area. Reliability, performance benchmarks, user interfaces, and accessibility are arguably the most important criteria for development and wide spread use of simulation software for BMC. The requirements and evaluation of such software packages for DNA computing software are discussed, particularly questions about software development, appropriate user environments, standardization of benchmark data sets, and centrally available common repositories for software and/or data.     

An empirical study on predictability of software maintainability using imbalanced data

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...     

Best practices in code inspection for safety-critical software

One of the most important issues in analyzing safety-critical systems is code verification through an inspection checklist, whose items must be applied to the source code. The attention given to this list will help ensure obedience to good coding rules and represents an important factor in the design of safety-critical systems. This list also helps in the development of non-safety-critical systems, improving their quality and correctness.     

Developing a software system for automata-based code generation

This paper is devoted to the development of the State Machine Generator system meant for automatic code generation based on the principles of automata-based programming. This system models program logic in terms of the finite-state automaton transition graph and generates program code on its basis. Basic functions of the developed software system and the mechanism of their implementation are described. This paper also proposes a new pattern for designing automaton programs. As an example, State Machine Generator is used to develop a bug tracker system for software testing.