Software Design Faults Research Articles

A Novel Developed Supervised Machine Learning System For Classification And Prediction of Software Faults Using NASA Dataset

The software systems of modern computers are extremely complex and versatile. Therefore, it is essential to regularly detect and correct software design faults. In order to devote resources effectively towards the creation of trustworthy software, software companies are increasingly engaging in the practise of predicting fault-prone modules in advance of testing. These software fault prediction methods rely on the thoroughness with which prior software versions' fault as well as related code has been retrievedTime, energy, and money are all saved as a result. Increases the company's initial success and bottom line greatly by satisfying its clientele. Numerous academics have poured into this area throughout the years in an effort to raise the bar for all software. Nowadays, The most often used approaches in this field are those based on machine learning (ML). The field of ML seeks to perfect software capable of evolving as well as adapting in response to fresh data. This paper introduces a fresh approach for doing ML by bringing together a number of different expert systems. In order to reach agreement on which aspects of a software system need to be tested, the proposed multi-classifier model pools the strengths of the most effective classifiers. Several top-performing classifiers for defect prediction are put through their paces in an experiential evaluation. We test our method on 16 publicly available datasets from the NASA Metric Data Programme (MDP) repository at the promise repository. Parameters of confusion, recall, precision, recognition accuracy, etc., are evaluated and contrasted with existing schemes in a software analysis performed with the help of the python simulation tool with findings. The experimental outcomes demonstrate that by combining LGBM, XGBoost, and Voting classifiers, using a multi classifier approach, we are capable to significantly improve software fault prediction performance. The results of the investigation show that the suggested method will lead to better practical outcomes in the prediction of device failures.

FRAMEWORK FOR DEVELOPING REAL-TIME MOBILE ROBOTIC APPLICATIONS BASED ON BEHAVIOURAL MODELS

In complex real-time control systems such as autonomous mobile robotic systems, the use of development tools for the design, analysis and validation of robotic applications is highly desirable, specially to improve the robot performances and to avoid early software and hardware design faults. This paper presents a framework for developing real-time mobile robotic applications. The main feature of the environment is that it permits the integrated analysis and validation of the functional behaviour of the robot (i.e. robot carrying out its plans) and the guarantee of the temporal constraints of the system processes (i.e. reactive and deliberative process execution). The verification of the correctness of the functional requirements is supported by means of a robot simulation tool that reflects the progress of the system at the application level. Likewise, a temporal analysis tool, based on scheduling analytical techniques, guarantees the schedulability of the system load at the execution level. The usefulness of the development tool is shown through design examples applied to mobile robotic applications.

The Theory of Classification, Part 1: Perspectives on Type Compatibility .

Object oriented type theory was used to study the syntactic and semantic type compatibility. In syntactic compatibility the components provides all the expected operations. In semantic compatibility the component's operations behave in the expected way. Various examples of failure due to type-related software design faults were discussed.

Low-cost error containment and recovery for onboard guarded software upgrading and beyond

Message-driven (MDCD) error containment and recovery, a low-cost approach to mitigating the effect of software design faults in distributed embedded systems, is developed for onboard guarded software upgrading for deep-space missions. In this paper, we first describe and verify the MDCD algorithms in which we introduce the notion of confidence-driven to complement the communication-induced approach employed by a number of existing checkpointing protocols to achieve error containment and recovery efficiency. We then conduct a model-based analysis to show that the algorithms ensure low performance overhead. Finally, we discuss the advantages of the MDCD approach and its potential utility as a general-purpose, low-cost software fault tolerance technique for distributed embedded computing.

Conversational group service

The purpose of this paper is to propose a way of tolerating software (design) faults in distributed systems relying on the well-known conversation (atomic action) approach. To do this, we shall consider differences between two programming paradigms: group communication and conversations, and discuss how a group communication service can be used to provide design fault tolerance by conversations. The main characteristics and peculiarities of this new conversational group service are described.

Dependable, intelligent voting for real-time control software

An intelligent and dependable voting mechanism for use in real-time control applications is presented. Strategies proposed by current safety standards advocate N-version software to minimize the effects of undetected software design faults (bugs). This requires diversity in design but presents a problem in that truly diverse code produces diverse results; that is, differences in output values, timeliness and reliability. Reaching a consensus requires an intelligent voter, especially when non-stop operation is demanded, e.g. in aerospace applications. This paper, therefore, firstly considers the applicable safety standards and the requirements for an intelligent voter service. The use of replicated voters to improve reliability is examined and a mechanism to ensure non-stop operation is presented. The formal mathematical analysis used to verify the crucial behavioural properties of the voting service design is detailed. Finally, the use of neural nets and genetic algorithms to create N- version redundant voters, is considered.

Intelligent Voting Startegies for Dependable Real-Time Control Systems

An intelligent and dependable voting mechanism for use in real-time control applications is presented. Strategies proposed by current safety standards advocate N-version software to minimise the effects from undetected software design faults (bugs). This requires diversity in design but presents a problem that truly diverse code produces diverse results, that is, differences in output values, timeliness and reliability. To reach a consensus requires an intelligent voter, especially when non stop operation is demanded, e.g. aerospace applications. This paper, therefore, firstly considers the applicable safety standards and the requirements for an intelligent voter service. The use of replicated voters to improve reliability is examined and a mechanism to ensure non stop operation is presented. The formal mathematical analysis used to verify the crucial behavioural properties of the voting service design is detailed. Finally the creation of N-version redundant voters are considered using Neural nets and Genetic Algorithms.

Dependable flight control system by data diversity and self-checking components

This paper proposes a principle for the tolerance of software design faults in a Flight Control System. The system is considered on two levels: (i) the entire system in which N-copy programming is applied, and (ii) the individual Guidance and Navigation Computer (GNC), which is a self-checking component. The performances of data diversity ( N-copy programming) and the traditional design without diversity (multiple computation) were compared in an experiment using fault injection with a method based on mutation testing. The best performances for N-copy programming and multiple computation were 95.5% and 66.6% correct results, respectively. However, the reliability improvement introduced by the N-copy programming is application-specific. The N-copy programming alone is not likely to fulfil the safety requirements and therefore each GNC of the Flight control System is regarded as a self-checking component. A pessimistic and an optimistic analytical estimation of the enhancement introduced to each GNC by the self-checking component showed that the MTTF (Mean Time To Failure) increased by two times and nine times, respectively.

An experimental evaluation of software redundancy as a strategy for improving reliability

The strategy of using multiple versions of independently developed software as a means to tolerate residual software design faults is discussed. The effectiveness of multiversion software is studied by comparing estimates of the failure probabilities of these systems with the failure probabilities of single versions. The estimates are obtained under a model of dependent failures and compared with estimates obtained when failures are assumed to be independent. The experimental results are based on 20 versions of an aerospace application developed and independently validated by 60 programmers from 4 universities. Descriptions of the application and development process are given, together with an analysis of the 20 versions. >

Experiments in software reliability estimation

There is an urgent need for manufacturers and users of programmable electronic systems to be able to quantify the risk of system failure due to design faults in software. The reliability of the hardware components of such systems can be assessed using well-tried techniques. By contrast, software reliability is still a ‘grey area’, with no generally accepted methods of assessment. This paper describes the results of using the Littlewood Stochastic Reliability Growth Model with maximum likelihood parameter estimation to forecast the behaviour of sets of simulated failure data, generated on the assumptions of the model and using a variety of parameter values. The forecasts are long-term, such as would be made for large software products whose reliability is important from the support cost point of view, but not critical as regards safety. The data is of the ‘grouped’ variety: counts of faults found in successive intervals. The predictions are generally of low accuracy. They are particularly bad for extreme parameter values, corresponding to very many, very infrequently manifest faults, and to few frequently manifest faults. The length of the period of observation relative to the average rate of fault manifestation is also crucial. Possible reasons for this poor performance and improvements to the estimation methods are discussed.

Exception Handling and Software Fault Tolerance

Some basic concepts underlying the issue of fault-tolerant software design are investigated. Relying on these concepts, a unified point of view on programmed exception handling and default exception handling based on automatic backward recovery is constructed. The cause–effect relationship between software design faults and failure occurrences is explored and a class of faults for which default exception handling can provide effective fault tolerance is characterized. It is also shown that there exists a second class of design faults which cannot be tolerated by using default exception handling. The role that software verification methods can play in avoiding the production of such faults is discussed.