Software Reliability

The dynamic software development organizations optimize the usage of resources to deliver the products in the specified time with the fulfilled requirements. This requires prevention or repairing of the faults as quick as possible. In this paper an approach for predicting the run-time errors in java is introduced. The paper is concerned with faults due to inheritance and violation of java constraints. The proposed fault prediction model is designed to separate the faulty classes in the field of software testing. Separated faulty classes are classified according to the fault occurring in the specific class. The results are papered by clustering the faults in the class. This model can be used for predicting software reliability.

Responsibility Collaborator (CRC) Cards can be used in developing Object-Oriented models. They provide a simple and an easy to use way to explore objects in the development of a system. However, different problems might arise while adopting current CRC-Cards in identifying the system objects. In this paper, we discuss the main problems with current CRC-Cards. As a solution, we propose a new look at CRC-Cards that try to avoid most of the problems presented in traditional cards.

This paper discusses the problem of understanding and measuring quality in complex systems which include hardware and software. Using general systems concepts, a schematic model of quality is proposed and its use illustrated. The paper concludes by discussion of the problems involved with the use of the schematic model in developing the specific quality models required in the software and systems industry.

Despite the widespread adoption of software diversity in some industries, there is still controversy about its benefits for reliability, safety or security. We take the prospective of diversity as a risk reduction strategy, in face of the uncertainty about the dependability levels delivered by software development. We specifically consider the problem faced at the start of a project, when the assessment of potential benefits, however uncertain, must determine the decision whether to adopt diversity. Using probabilistic modelling, we discuss how different application areas require different measures of the effectiveness of diversity for reducing risk. Extreme values of achieved reliability, and especially, in some applications, the likelihood of delivering "effectively fault-free" programs, may be the dominant factor in this effect. Therefore, we cast our analysis in terms of the whole distribution of achieved probabilities of failure per demand, rather than averages, as usually done in past research. This analysis highlights possible and indeed frequent errors in generalizations from experiments, and identifies risk reduction effects that can be proved to derive from independent developments of diverse software versions. Last, we demonstrate that, despite the difficulty of predicting the actual advantages of specific practices for achieving diversity, the practice of "forcing" diversity by explicitly mandating diverse designs, development processes, etc., for different versions, rather than just ensuring separate development, is robust, in terms of worst-case effects, in the face of uncertainty about the reliability that the different methods will achieve in a specific project, a result with direct applicability to practice.

Since 2002, over 10% of total cyber vulnerabilities were SQL injection vulnerabilities. Since most developers are not experienced software security practitioners, a solution for correctly fixing SQL injection vulnerabilities that does not require security expertise is desirable. In this paper, we propose an automated method for removing SQL injection vulnerabilities from Java code by converting plain text SQL statements into prepared statements. Prepared statements restrict the way that input can affect the ...

We present a foundational theory of software system re-liability based on components. The theory describes how component developers can design and test their components to produce measurements that are later used by system de-signers to calculate composite system reliability — ...

This paper a rms that quanti cation of life-critical software reliability is infeasible using statistical methods whether applied to standard software or faulttolerant software. The key assumption of software fault tolerance|separately programmed versions fail independently|is shown to be problematic. This assumption cannot be justi ed by experimentation in the ultrareliability region and subjective arguments in its favor are not su ciently strong to justify it as an axiom. Also, the implications of the recent multiversion software experiments support this a rmation.

Testing software for assessing or improving reliability presents several practical challenges. Conventional operational testing is a fundamental strategy that simulates the real usage of the system in order to expose failures with the highest occurrence probability. However, practitioners find it unsuitable for assessing/delivering high reliability levels, and they do not see the adoption of a “real” usage profile estimate as a sensible idea, being it a source of non-quantifiable uncertainty. Debug testing techniques aim to expose as many failures as possible, but regardless of their impact on runtime reliability. These strategies are used either to assess or to improve reliability, but cannot improve and assess reliability in the same testing session. This article proposes Reliability Assessment and Improvement (RELAI) testing, a new technique thought to improve the delivered reliability, by an adaptive testing scheme, while providing, at the same time, a continuous assessment of reliability attained through testing and fault removal. The technique also quantifies the impact of a partial knowledge of the operational profile. RELAI is positively evaluated on four software applications compared, in separate experiments, with techniques conceived either for reliability improvement or for reliability assessment, demonstrating substantial improvements in both cases.

Predicting faults early in the software life cycle can be used to improve software process control and achieve high software reliability. Quality of software is increasingly important and testing related issues are becoming crucial for software. Methodologies and techniques for predicting the testing effort, monitoring process costs, and measuring results can help in increasing efficiency of software testing. Being able to measure the fault-proneness of software can be a key step towards steering the software testing and improving the effectiveness of the whole process. To estimate software faultiness before and during testing and analysis activities would greatly help software testing and analysis. Many systems are delivered to users with excessive faults. It has long been recognized that seeking out fault-prone parts of the system and targeting those parts for increased quality control and testing is an effective approach to fault reduction. Despite this it is difficult to identify a reliable approach to identifying fault-prone software components. Prediction models based on software metrics, can estimate number of faults in software modules. In this paper different machine learning algorithms and neural network techniques on two different real-time software defect datasets are evaluated. The results show that when all the prediction techniques are evaluated then best algorithm for classification of the software components into faulty/fault-free systems is found to be Generalized Regression Neural Networks.

An organizational level test strategy needs to incorporate metrics to make the testing activities visible and available to process improvements. The majority of testing measurements that are done are based on faults found in the test execution phase. In contrast, this paper investigates metrics to support software test planning and test design processes. We have assembled metrics in these two process types to support management in carrying out evidence-based test process improvements and to incorporate suitable metrics as part of an organization level test strategy. The study is composed of two steps. The first step creates a relevant context by analyzing key phases in the software testing lifecycle, while the second step identifies the attributes of software test planning and test design processes along with metric(s) support for each of the identified attributes.

In this paper we present our original approach to the model-based statistical usage testing of a class of communication protocol implementations that are based on the State design pattern and Java programming environment augmented with the class FSMSystem. The approach is based on the working environment that has been proven on a number of real-world projects. The working environment is created with the following set of tools: generic modeling environment with the operational profile model paradigm registered to it, operational profile model interpreter, generic test case generator, test case compiler, and the unit testing framework JUnit extended with the class TestBed that acts as both test driver and stub thus providing the complete test harness. In the paper we present the methodology of the model-based statistical usage testing of a class of communication protocol implementations, the tools that support this methodology, and the case study -the model based statistical usage testing of SIP INVITE client transaction, a part of the SIP protocol stack.

N-version programming has been proposed as a method of incorporating fault tolerance into software. Multiple versions of a program (i.e. ''N'') are prepared and executed in parallel. Their outputs are collected and examined by a voter,a nd, if theya re not identical, it is assumed that the majority is correct. This method depends for its reliability improvement on the assumption that programs that have been developed independently will fail independently.I nt his paper an experiment is described in which the fundamental axiom is tested. Atotal of twenty sevenversions of a program were prepared independently from the same specification at twou niversities and then subjected to one million tests. The results of the tests revealed that the programs were individually extremely reliable but that the number of tests in which more than one program failed was substantially more than expected. The results of these tests are presented along with an analysis of some of the faults that were found in the programs. Background information on the programmers used is also summarized. The conclusion from this experiment is that N-version programming must be used with care and that analysis of its reliability must include the effect of dependent errors.

Automated diagnosis of software faults can improve the efficiency of the debugging process, and is therefore an important technique for the development of dependable software. In this paper we study different similarity coefficients that are applied in the context of a program spectral approach to software fault localization (single programming mistakes). The coefficients studied are taken from the systems diagnosis / automated debugging tools Pinpoint, Tarantula, and AMPLE, and from the molecular biology domain (the Ochiai coefficient). We evaluate these coefficients on the Siemens Suite of benchmark faults, and assess their effectiveness in terms of the position of the actual fault in the probability ranking of fault candidates produced by the diagnosis technique. Our experiments indicate that the Ochiai coefficient consistently outperforms the coefficients currently used by the tools mentioned. In terms of the amount of code that needs to be inspected, this coefficient improves 5% on average over the next best technique, and up to 30% in specific cases.

Nowadays more and more business activities are operated through web and the web plays a vital role in the interests of both businesses and their shareholders. However, the very good features of web such as its popularity, accessibility and openness, has provided more opportunities for security breaches by malicious users. That is why the rate of successful attacks on web and web applications are increasing. Many approaches have been introduced so far to reduce the rate of successful attacks of many kinds. Any technique that can detect these vulnerabilities and mitigate the security problems of web applications is useful to organizations seeking for more reliability from the security viewpoint. In this paper we first introduce the control flow tampering attack, which is one of the notable attacks against web applications, and present our approach for countering this attack using web application firewall.

Regression testing in continuous integration environment is bounded by tight time constraints. To satisfy time constraints and achieve testing goals, test cases must be efficiently ordered in execution. Prioritization techniques are commonly used to order test cases to reflect their importance according to one or more criteria. Reduced time to test or high fault detection rate are such important criteria. In this paper, we present a case study of a test prioritization approach ROCKET (Prioritization for Continuous Regression Testing) to improve the efficiency of continuous regression testing of industrial video conferencing software. ROCKET orders test cases based on historical failure data, test execution time and domain-specific heuristics. It uses a weighted function to compute test priority. The weights are higher if tests uncover regression faults in recent iterations of software testing and reduce time to detection of faults. The results of the study show that the test cases prioritized using ROCKET (1) provide faster fault detection, and (2) increase regression fault detection rate, revealing 30% more faults for 20% of the test suite executed, comparing to manually prioritized test cases.

Safety critical software requires integrating verification techniques in software development methods. Software architectures must guarantee that developed systems will meet safety requirements and safety analyses are frequently used in the assessment. Safety engineers and software architects must reach a common understanding on an optimal architecture from both perspectives. Currently both groups of engineers apply different modelling techniques and languages: safety analysis models and software modelling languages. The solutions proposed seek to integrate both domains coupling the languages of each domain. It constitutes a sound example of the use of language engineering to improve efficiency in a software-related domain. A model-driven development approach and the use of a platform-independent language are used to bridge the gap between safety analyses (failure mode effects and criticality analysis and fault tree analysis) and software development languages (e.g. unified modelling language). Language abstract syntaxes (metamodels), profiles, language mappings (model transformations) and language refinements, support the direct application of safety analysis to software architectures for the verification of safety requirements. Model consistency and the possibility of automation are found among the benefits.

One of the most important current software issues is re- liability, and accordingly, a major criterion of program- ming language design must be that the language contribute to the production of reliable programs. Although there are other important aspects of software reliability (eg, ...

Both the M.Sc. and Ph.D. degrees are in the area of computer science. Until February 1983, he was DP Manager of a bank in Greece. During the Spring term of 1983 he was a Visiting Associate Professor at the Michigan Technological University, Houghton. He is now Professor at the National Techni-Michael Hatzopoulos was born in Athens, Greece. He received the cal University of Athens. His research interests include physical data-B.S. degree inn mathematics from the University of Athens, Athens, in base design, distributed databases, and spatial processing. 1971, and the M.Sc. and Ph.D. degrees in computer science from the Dr. Kollias is a member of the Association for Computing Machinery

The introduction of Incentive Based Regulation as the tariff framework in Malaysia's Electricity Supply Industry calls for efficiency in the creation of a new asset while meeting the required reliability. In line with the new regulatory framework, Tenaga Nasional Berhad took the opportunity to enhance its planning methods and approaches by adopting value-based approach to achieve optimum total cost of ownership. This paper presents an actual case study of detailed analysis on the connection schemes and substation configuration for a newly proposed 275/132kV substation. The outcome of the study results in a significant cost saving as compared to traditional approach.

This paper suggests a new model for reliability demonstration of safety-critical systems, based on the TRW Software Reliability Theory. The paper describes the model; the test equipment required and test strategies based on the various constraints occurring during software development. The paper also compares a new testing method, Single Risk Sequential Testing (SRST), with the standard Probability Ratio Sequential Testing

A variety of Software Reliability Growth Models (SRGM) have been presented in literature. These models suffer many problems when handling various types of project. The reason is; the nature of each project makes it difficult to build a model which can generalize. In this paper we propose the use of Genetic Programming (GP) as an evolutionary computation approach to handle the software reliability modeling problem. GP deals with one of the key issues in computer science which is called automatic programming. The goal of automatic programming is to create, in an automated way, a computer program that enables a computer to solve problems. GP will be used to build a SRGM which can predict accumulated faults during the software testing process. We evaluate the GP developed model and compare its performance with other common growth models from the literature. Our experiments results show that the proposed GP model is superior compared to Yamada S-Shaped, Generalized Poisson, NHPP and Schneidewind reliability models.

Understanding vulnerability trends is a key component of the risk management process. The focus of this research is to analyze the trends of Common Vulnerabilities and Exposures (CVE) from the National Vulnerability Database (NVD) from 2007 to 2010. We extracted 22,521 CVEs through the four years, also collected their Common Vulnerability Scoring System (CVSS) scores from the NVD, then we analyzed the overall frequency, severity, and CVSS base metrics trends. Our finding shows that the frequency of all vulnerabilities decreased by 28% from 2007 to 2010; also, the percentage of high severity incidents decreased for that period. Over 80% of the total vulnerabilities were exploitable by network access without authentication. We further studied the trends of the select fifteen (15) vulnerability types which contain 18,427 vulnerabilities by analyzing their changes in frequency, severity, and CVSS base metrics. This research findings can help information security professionals focus their efforts in preventing and mitigating the impact of the attacks, and influence the development of security strategies developed by IS professionals as well.

Standards concerned with the development of safety-critical systems, and the software in such systems in particular, abound today as the software crisis increasingly affects the world of embedded computer-based systems. The use of formal methods is often advocated as a way of increasing confidence in such systems. This paper examines the industrial use of these techniques, the recommendations concerning formal methods in a number of current and draft standards, and comments on the applicability and problems of using formal methods for the development of safety-critical systems of an industrial scale. Some possible future directions are suggested.

Winner of the IEE Charles Babbage Premium award, 1994. Other versions issued as a Oxford University Computing Laboratory Technical Report PRG-TR-5-92, and Chapter 1 in Towards Verified Systems.

Several tools have been developed for the estimation of software reliability. However, they are highly specialized in the approaches they implement and the particular phase of the software life-cycle in which they are applicable. There is an increasing need for a tool that can be used to track the quality of a software product during the software development process, right from the architectural phase all the way up to the operational phase of the software. Also the conventional techniques for software reliability evaluation, which treat the software as a monolithic entity are inadequate to assess the reliability of heterogeneous systems, which consist of a large number of globally distributed components. Architecture-based approaches are essential to predict the reliability and performance of such systems. This paper presents the high-level design of a Software Reliability Estimation and Prediction Tool (SREPT), that offers a unified framework containing techniques (including the architecture-based approach) to assist in the evaluation of software reliability at all phases of the software life-cycle.

A neural network based software reliability model to predict the cumulative number of failures based on Feed Forward architecture is proposed in this paper. Depending upon the available software failure count data, the execution time is encoded using Exponential and Logarithmic function in order to provide the encoded value as the input to the neural network. The effect of encoding and the effect of different encoding parameter on prediction accuracy have been studied. The effect of architecture of the neural network in terms of hidden nodes has also been studied. The performance of the proposed approach has been tested using eighteen software failure data sets. Numerical results show that the proposed approach is giving acceptable results across different software projects. The performance of the approach has been compared with some statistical models and statistical models with change point considering three datasets. The comparison results show that the proposed model has a good prediction capability.

—We introduce covrel, an adaptive software testing approach based on the combined use of operational profile and coverage spectrum, with the ultimate goal of improving the delivered reliability of the program under test. Operational profile-based testing is a black-box technique that selects test cases having the largest impact on failure probability in operation; as such, it is considered well suited when reliability is a major concern. Program spectrum is a characterization of a program's behavior in terms of the code entities (e.g., branches, statements, functions) that are covered as the program executes. The driving idea of covrel is to complement operational profile information with white-box coverage measures based on count spectra, so as to dynamically select the most effective test cases for reliability improvement. In particular, we bias operational profile-based test selection towards those entities covered less frequently. We assess the approach by experiments with 18 versions from 4 subjects commonly used in software testing research, comparing results with traditional operational and coverage testing. Results show that exploiting operational and coverage data in a combined adaptive way actually pays in terms of reliability improvement, with covrel overcoming conventional operational testing in more than 80% of the cases.

Many studies have been performed on the subject of software reliability but few have explicitly considered the impact of software testing on the reliability process. This paper presents two important issues on software reliability modeling and software reliability economics: testing effort and efficiency. First, we discuss on how to extend the logistic testing-effort function into a general form. The generalized logistic testing-effort function has the advantage of relating the work profile more directly to the natural flow of software development. Therefore, it can be used to describe the actual consumption of resources during the software development process and to obtain a conspicuous improvement in modeling testing-effort expenditures. Furthermore, we incorporate the generalized logistic testing-effort function into software reliability modeling and its fault-prediction capability is evaluated through four numerical experiments on real data. Then, we address the effects of automated techniques or tools on increasing the efficiency of software testing. New testing techniques usually increase test coverage. We propose a modified software reliability cost model to reflect these effects. From the simulation results, we obtain a powerful software economic policy which clearly indicates the benefits of applying new automated testing techniques and tools during the software development process

In software development life cycle, the most important activity is software maintenance, in order to get a reliable and quality product. Huge amount of time, cost and effort is involved in it. Maintenance of software encompasses various activities like
prediction, detection, prevention and correction of fault. Due to refined and multifaceted applications, clustered architecture, artificial intelligence and commercial hardware are in use. Hence, in this research work a review is conducted in the field of software fault detection and correction. There are a lot of software reliability growth models and techniques which help in software fault detection and correction, nevertheless, the room for more models and processes is vacant to detect and correct faults.

Any software generally goes roughly through following phases in its life 1. Birth 2. Learning 3. Earning 4. Retiring From the business perspective, the software that stays in earning phase for longer time, can roughly be considered as a successful software (well, there can be some exceptions). Keeping this in mind, everyone who works with the software at any point of time in the life of software (irrespective of the role and responsibilities) should focus on working in such a way that software will stay in earning phase as long as possible. Even though we accept the fact that no software can stay in earning phase forever, it can certainly be tried to manage to provide optimum result. Everyone who works with the software at any point of time in any role leaves a mark on the software and contributes to increase or decrease in the overall life expectancy of the software. Therefore, this paper tries to study the software life expectancy, factors affecting it, its relation with different software quality attributes and processes to improve the software life.

Software test-coverage measures" quantify the degree of thoroughness of testing. Tools are now available that measure test-coverage in terms of blocks, branches, computation-uses, predicate-uses, etc. that are covered. This paper models the relations among testing time, coverage, and reliability. An LE (logarithmic-exponential) model is presented that relates testing effort to test coverage (block, branch, computation-use, or predicate-use). The model is based on the hypothesis that the enumerable elements (like branches or blocks) for any coverage measure have various probabilities of being exercised; just like defects have various probabilities of being encountered. This model allows relating a test-coverage measure directly with defect-coverage. The model is fitted to 4 data-sets for programs with real defects. In the model, defect coverage can predict the time to next failure.

The flight control system must meet extremely high levels of functional integrity and availability. The control algorithm is processed by onboard computer (OBC). To meet the reliability requirements for onboard computers, various type of redundancy must be employed. In this paper, we concerned with the triple modular redundancy (TMR) for an onboard computer with aerospace application. In the proposed architecture, control inputs and system states are measured using designated sensors. According to the acquired data, mission scenario and control algorithm are processed by the processing unit. Thereafter, the results are applied to the system by actuators.TMR technology in component level is used to improve the reliability of OBC according to the system requirements. All of the constituent modules of OBC, comprising processing unit, bus interface, sensor, actuators, and IO devices, benefits from triple redundancy. The case study shows that the similar architecture is used for high reliable flight computer of passenger airplanes except that our architecture is based on the available multicore microcontrollers. The reliability of the designed onboard computer is evaluated analytically, which indicates that the proposed OBC can meet the reliability requirements.

Software problems are the main causes of system failures today. There are many well-known cases of the tragic consequences of software failures. In critical systems, very high reliability is naturally expected. Software packages used everyday also need to be highly reliable, because the enormous investment of the software developer is at stake. Studies have shown that reliability is regarded as the most important attribute by potential customers. All software developed will have a significant number of defects. All programs must be ...

Computational Fluid Dynamics (CFD) analysis has become a useful research and design instrument albeit with errors and uncertainties. Appropriate standards and protocols for increasing confidence and reliability need to be identified and applied. These requirements become more relevant as improvements in hardware, software and user competence increase. Advances in these sectors have led to the increased use of CFD codes in the applied research industry.

Which Software Reliability Engineering (SRE) methods should be applied during the various phases of the lifecycle of a product? The answer given here centres on learning from errors. The classification and evaluation of methods is strictly based on causal analyses of disasters, accidents and incidents with undesired outcome. The lifecycle model of IEC Standard 61508 has been adopted as a classification scheme. A couple of examples are given. The SRE methods considered here are those of IEC 61508. These methods are dealing with software reliability as well as with the production of highly reliable software. As an example of some more recent proposals Extreme Programming (XP) has been included.

Software quality engineering is concerned with building software products with required quality and assessing the level of quality. Software processes are important assets in achieving and assessing the software quality. Furthermore the adherence to defined processes is a key issue to having the software engineering under control and to enable process improvement. In this paper, the Software Quality Assurance (SQA) key process area in the Capability Maturity Model (CMM) is elaborated, i.e. activities for monitoring adherence to the processes. The term SQA creates some misconceptions and confusions with the general quality management concept. The SQA concept is compared to quality management and the differences and similarities are elaborated in order to eliminate the misconceptions. Furthermore, some experiences from supporting the implementation of the SQA concepts in two different software companies are briefly reported.

In this author's opinion, following are the most important software quality attributes - Reliability, Usability, Performance and Availability. As said wisely, "Things that count most, can not be counted mostly." This paper tries to suggest how 'Reliability' can be measured from end user's perspective.
For any software system, end user is the most important actor. Measuring ‘Reliability’ is a way to quantify the usefulness of the software for and end user. Therefore, measuring Reliability from an end user's perspective is very important. Unfortunately, there doesn't seem to be much discussion about how much reliable the software is for end user

In this paper using the main feature of our proposed Model in its inflection point, we propose a software reliability growth model, which relatively early in the testing and debugging phase, provides accurate parameters estimation, gives a very good failure behavior prediction and enable software developers to predict when to conclude testing, release the software and avoid over testing in order to cut the cost during the development and the maintenance of the software. Two real world experimental data previously analyzed have been used to compare our proposed Early Estimation Logistic Model effectiveness with several pre-existing models.

A variety of Software Reliability Growth Models (SRGM) have been presented in literature. These models suffer many problems when handling various types of project. The reason is; the nature of each project makes it difficult to build a model which can generalize. In this paper we propose the use of Genetic Programming (GP) as an evolutionary computation approach to handle the software reliability modeling problem. GP deals with one of the key issues in computer science which is called automatic programming. The ...