Eliminating Software Failures - A Literature Survey

[1]  Jehad Al Dallal,et al.  Dynamic data flow analysis for Java programs , 2000, Inf. Softw. Technol..

[2]  Nancy G. Leveson,et al.  An empirical evaluation of the MC/DC coverage criterion on the HETE-2 satellite software , 2000, 19th DASC. 19th Digital Avionics Systems Conference. Proceedings (Cat. No.00CH37126).

[3]  R. J. Rubey,et al.  Quantitative aspects of software validation , 1975 .

[4]  A. Avizienis.  Dependable computing depends on structured fault tolerance , 1995, Proceedings of Sixth International Symposium on Software Reliability Engineering. ISSRE'95.

[5]  Francesco Bergadano,et al.  Testing by means of inductive program learning , 1996, TSEM.

[6]  Ana Gabriela Maguitman,et al.  Logical models of argument , 2000, CSUR.

[7]  John C. Shepherdson,et al.  Computability of Recursive Functions , 1963, JACM.

[8]  Szu Hui Ng,et al.  A model for correlated failures in N-version programming , 2004 .

[9]  Paul Klint,et al.  Term rewriting with traversal functions , 2003, TSEM.

[10]  Sarfraz Khurshid,et al.  An Evaluation of Exhaustive Testing for Data Structures , 2003 .

[11]  A. Jefferson Offutt,et al.  An Approach to Fault Modeling and Fault Seeding Using the Program Dependence Graph , 1997, J. Syst. Softw..

[12]  Ken-ichi Matsumoto,et al.  A Study on the Failure Intensity of Different Software Faults , 1997, Proceedings of the (19th) International Conference on Software Engineering.

[13]  Neelam Gupta,et al.  Improving Fault Detection Capability by Selectively Retaining Test Cases during Test Suite Reduction , 2007, IEEE Transactions on Software Engineering.

[14]  Leon J. Osterweil,et al.  On Two Problems in the Generation of Program Test Paths , 1976, IEEE Transactions on Software Engineering.

[15]  Patrick van Bommel,et al.  Combining boolean logic and linguistic structure , 2001, Inf. Softw. Technol..

[16]  Man F. Lau,et al.  An extended fault class hierarchy for specification-based testing , 2005, TSEM.

[17]  Janche Sang,et al.  An empirical analysis of debugging performance - differences between iterative and recursive constructs , 2000, J. Syst. Softw..

[18]  Samantha Jenkins,et al.  Information theory-based software metrics and obfuscation , 2004, J. Syst. Softw..

[19]  Insup Lee,et al.  Data flow testing as model checking , 2003, 25th International Conference on Software Engineering, 2003. Proceedings..

[20]  J. B. Dugan,et al.  Sensitivity analysis of modular dynamic fault trees , 2000, Proceedings IEEE International Computer Performance and Dependability Symposium. IPDS 2000.

[21]  Arthur H. M. ter Hofstede,et al.  How to formalize it?: Formalization principles for information system development methods , 1997, Inf. Softw. Technol..

[22]  Leslie Hatton,et al.  EC--a measurement based safer subset of ISO C suitable for embedded system development , 2005, Inf. Softw. Technol..

[23]  Daniela Cruzes,et al.  Simulating families of studies to build confidence in defect hypotheses , 2005, Inf. Softw. Technol..

[24]  Doron A. Peled,et al.  Combining Software and Hardware Verification Techniques , 2002, Formal Methods Syst. Des..

[25]  Miroslaw Malek,et al.  Survey of software tools for evaluating reliability, availability, and serviceability , 1988, CSUR.

[26]  Ram Chillarege,et al.  Defect type and its impact on the growth curve (software development) , 1991, [1991 Proceedings] 13th International Conference on Software Engineering.

[27]  Mark Weiser,et al.  Program Slicing , 1981, IEEE Transactions on Software Engineering.

[28]  L. Alvisi,et al.  A Survey of Rollback-Recovery Protocols , 2002 .

[29]  Paul I. Barton,et al.  Modeling, simulation and sensitivity analysis of hybrid systems , 2000, CACSD. Conference Proceedings. IEEE International Symposium on Computer-Aided Control System Design (Cat. No.00TH8537).

[30]  J. Keith Townsend,et al.  The theory of direct probability redistribution and its application to rare event simulation , 1999, TOMC.

[31]  Dino Pedreschi,et al.  On logic programs that always succeed , 2003, Sci. Comput. Program..

[32]  Arie van Deursen,et al.  Identifying Crosscutting Concerns Using Fan-In Analysis , 2006, TSEM.

[33]  Amit M. Paradkar.  Case studies on fault detection effectiveness of model based test generation techniques , 2005, ACM SIGSOFT Softw. Eng. Notes.

[34]  Gustavo Ribeiro Alves,et al.  A Framework for Fault Tolerant Real Time Systems Based on Reconfigurable FPGAs , 2006, 2006 IEEE Conference on Emerging Technologies and Factory Automation.

[35]  István Forgács.  Double iterative framework for flow-sensitive interprocedural data flow analysis , 1994, TSEM.

[36]  BaesensBart,et al.  Benchmarking Classification Models for Software Defect Prediction , 2008 .

[37]  Mauro Ferrari,et al.  On the complexity of the disjunction property in intuitionistic and modal logics , 2005, TOCL.

[38]  Ana Regina Cavalcanti da Rocha,et al.  Domain-oriented software development environment , 2004, J. Syst. Softw..

[39]  Hong Xu,et al.  Combining dynamic fault trees and event trees for probabilistic risk assessment , 2004, Annual Symposium Reliability and Maintainability, 2004 - RAMS.

[40]  Paul A. Fishwick,et al.  OOPM/RT: a multimodeling methodology for real-time simulation , 1999, TOMC.

[41]  Barbara G. Ryder,et al.  An efficient hybrid algorithm for incremental data flow analysis , 1989, POPL '90.

[42]  Robyn R. Lutz,et al.  Contributions of SFMEA to requirements analysis , 1996, Proceedings of the Second International Conference on Requirements Engineering.

[43]  Norman F. Schneidewind,et al.  Software quality control and prediction model for maintenance , 2000, Ann. Softw. Eng..

[44]  Norman E. Fenton,et al.  Quantitative Analysis of Faults and Failures in a Complex Software System , 2000, IEEE Trans. Software Eng..

[45]  Vadim Okun,et al.  Comparison of fault classes in specification-based testing , 2004, Inf. Softw. Technol..

[46]  Joxan Jaffar,et al.  A decision procedure for a class of set constraints , 1990, [1990] Proceedings. Fifth Annual IEEE Symposium on Logic in Computer Science.

[47]  Barry W. Boehm,et al.  Bridging models across the software lifecycle , 2003, J. Syst. Softw..

[48]  Ram Chillarege.  Self-testing software probe system for failure detection and diagnosis , 1994, CASCON.

[49]  G. Frege.  On Sense and Reference , 1948 .

[50]  Martin Fränzle,et al.  Model-checking dense-time Duration Calculus , 2004, Formal Aspects of Computing.

[51]  Tim Menzies,et al.  Data Mining Static Code Attributes to Learn Defect Predictors , 2007 .

[52]  Aloysius K. Mok,et al.  Simulation-Verification: Biting at the State Explosion Problem , 2001, IEEE Trans. Software Eng..

[53]  Michal Walicki,et al.  Algebraic approaches to nondeterminism—an overview , 1997, CSUR.

[54]  Mark Harman,et al.  Analysis and visualization of predicate dependence on formal parameters and global variables , 2004, IEEE Transactions on Software Engineering.

[55]  A. Prasad Sistla,et al.  Employing symmetry reductions in model checking , 2004, Comput. Lang. Syst. Struct..

[56]  David L. Dill,et al.  State reduction using reversible rules , 1996, DAC '96.

[57]  Claes Wohlin,et al.  Towards integration of use case modelling and usage-based testing , 2000, J. Syst. Softw..

[58]  Yuan-Shun Dai,et al.  A model for availability analysis of distributed software/hardware systems , 2002, Inf. Softw. Technol..

[59]  Witold Pedrycz,et al.  Practical assessment of the models for identification of defect-prone classes in object-oriented commercial systems using design metrics , 2003, J. Syst. Softw..

[60]  Claes Wohlin,et al.  Software faults: spreading, detection and costs , 1990, Softw. Eng. J..

[61]  Richard Han,et al.  A decentralized fault diagnosis system for wireless sensor networks , 2005, IEEE International Conference on Mobile Adhoc and Sensor Systems Conference, 2005..

[62]  Linda Badri,et al.  Supporting predictive change impact analysis: a control call graph based technique , 2005, 12th Asia-Pacific Software Engineering Conference (APSEC'05).

[63]  Jeff Tian,et al.  Better Reliability Assessment and Prediction through Data Clustering , 2002, IEEE Trans. Software Eng..

[64]  Jun Han,et al.  Using role-based coordination to achieve software adaptability , 2007, Sci. Comput. Program..

[65]  Victor F. Nicola,et al.  Comparative Analysis of Different Models of Checkpointing and Recovery , 1990, IEEE Trans. Software Eng..

[66]  Robert L. Glass,et al.  Persistent Software Errors , 1981, IEEE Transactions on Software Engineering.

[67]  Jeffrey M. Voas,et al.  Estimating the Probability of Failure When Testing Reveals No Failures , 1992, IEEE Trans. Software Eng..

[68]  Ilkka Tervonen,et al.  Towards deeper co-understanding of software quality , 1998, Inf. Softw. Technol..

[69]  In-Jeong Chung,et al.  Improved control strategy for parallel logic programming , 1989, [Proceedings 1989] IEEE International Workshop on Tools for Artificial Intelligence.

[70]  Andreas Zeller,et al.  Simplifying and Isolating Failure-Inducing Input , 2002, IEEE Trans. Software Eng..

[71]  David F. McAllister,et al.  An Experimental Evaluation of Software Redundancy as a Strategy For Improving Reliability , 1991, IEEE Trans. Software Eng..

[72]  Martin P. Robillard,et al.  Topology analysis of software dependencies , 2008, TSEM.

[73]  Hitoshi Kume,et al.  A Case History Analysis of Software Error Cause-Effect Relationships , 1991, IEEE Trans. Software Eng..

[74]  James A. Whittaker.  Software's Invisible Users , 2001, IEEE Softw..

[75]  Robert F. Stärk,et al.  Information Algebras and Consequence Operators , 2007, Logica Universalis.

[76]  R. J. Mulvihill.  Design-safety enhancement through the use of hazard and risk analysis , 1988 .

[77]  James M. Armstrong,et al.  The Deconstruction of Safety Arguments Through Adversarial Counter-Argument , 2004, SAFECOMP.

[78]  Akif Günes Koru,et al.  An empirical comparison and characterization of high defect and high complexity modules , 2003, J. Syst. Softw..

[79]  Paul C. Jorgensen,et al.  Object-oriented integration testing , 1994, CACM.

[80]  George S. Avrunin,et al.  Data flow analysis for checking properties of concurrent Java programs , 1999, Proceedings of the 1999 International Conference on Software Engineering (IEEE Cat. No.99CB37002).

[81]  David Leon,et al.  Tree-based methods for classifying software failures , 2004, 15th International Symposium on Software Reliability Engineering.

[82]  Mark Sullivan,et al.  Software defects and their impact on system availability-a study of field failures in operating systems , 1991, [1991] Digest of Papers. Fault-Tolerant Computing: The Twenty-First International Symposium.

[83]  Eduardo B. Fernández,et al.  Design and Modeling of Hybrid Fault-Tolerant Software With Cost Constraints , 1996, J. Syst. Softw..

[84]  Joël Ouaknine,et al.  Domain theory, testing and simulation for labelled Markov processes , 2005, Theor. Comput. Sci..

[85]  Takeshi Chusho,et al.  Test Data Selection and Quality Estimation Based on the Concept of Essential Branches for Path Testing , 1987, IEEE Transactions on Software Engineering.

[86]  D. Richard Kuhn,et al.  FAILURE MODES IN MEDICAL DEVICE SOFTWARE: AN ANALYSIS OF 15 YEARS OF RECALL DATA , 2001 .

[87]  Z. Hocenski,et al.  Influence of software on fault-tolerant microprocessor control system dependability , 1999, ISIE '99. Proceedings of the IEEE International Symposium on Industrial Electronics (Cat. No.99TH8465).

[88]  Carlos Urias Munoz.  An Approach to Software Product Testing , 1988, IEEE Trans. Software Eng..

[89]  Soheil Khajenoori,et al.  Knowledge centered assessment pattern: an effective tool for assessing safety concerns in software architecture , 2004, J. Syst. Softw..

[90]  Francesca Rossi,et al.  Semiring-based constraint satisfaction and optimization , 1997, JACM.

[91]  Ali R. Hurson,et al.  Transaction Processing in Mobile, Heterogeneous Database Systems , 2002, IEEE Trans. Knowl. Data Eng..

[92]  Victor R. Basili,et al.  A Comparative Analysis of Functional Correctness , 1982, CSUR.

[93]  Harvey P. Siy,et al.  Predicting Fault Incidence Using Software Change History , 2000, IEEE Trans. Software Eng..

[94]  V. Rajaraman,et al.  An Algorithm to Decide Feasibility of Linear Integer Constraints Occurrng in Decision Tables , 1987, IEEE Transactions on Software Engineering.

[95]  David S. Rosenblum.  A Practical Approach to Programming With Assertions , 1995, IEEE Trans. Software Eng..

[96]  Deepinder P. Sidhu,et al.  Undetected faults in protocol testing , 1995, IEEE Trans. Commun..

[97]  Pankaj Jalote,et al.  Testing the Completeness of Specifications , 1989, IEEE Trans. Software Eng..

[98]  John A. McDermid,et al.  Software fault trees and weakest preconditions: a comparison and analysis , 1993, Softw. Eng. J..

[99]  Leon J. Osterweil,et al.  Interprocedural static analysis of sequencing constraints , 1992, TSEM.

[100]  Robert E. Mullen,et al.  The lognormal distribution of software failure rates: origin and evidence , 1998, Proceedings Ninth International Symposium on Software Reliability Engineering (Cat. No.98TB100257).

[101]  Massimiliano Di Penta,et al.  Assessing and improving state-based class testing: a series of experiments , 2004, IEEE Transactions on Software Engineering.

[102]  Rajeev Alur,et al.  Parametric temporal logic for “model measuring” , 2001, TOCL.

[103]  Ferhat Khendek,et al.  Test Selection Based on Finite State Models , 1991, IEEE Trans. Software Eng..

[104]  Richard J. Lipton,et al.  Reduction: a method of proving properties of parallel programs , 1975, CACM.

[105]  Stefano Crespi-Reghizzi,et al.  Software Prototyping by Relational Techniques: Experiences with Program Construction Systems , 1988, IEEE Trans. Software Eng..

[106]  Alan R. Hevner,et al.  The impacts of quality and productivity perceptions on the use of software process improvement innovations , 2005, Inf. Softw. Technol..

[107]  Boumediene Belkhouche,et al.  A formally specified prototyping system , 1996, J. Syst. Softw..

[108]  Dolores R. Wallace,et al.  Software Error Analysis , 1995 .

[109]  Emil Sekerinski,et al.  Exploring Tabular Verification and Refinement , 2003, Formal Aspects of Computing.

[110]  Elaine J. Weyuker,et al.  The evaluation of program-based software test data adequacy criteria , 1988, CACM.

[111]  Elaine J. Weyuker,et al.  Experience with Performance Testing of Software Systems: Issues, an Approach, and Case Study , 2000, IEEE Trans. Software Eng..

[112]  Gerard J. Holzmann,et al.  The Model Checker SPIN , 1997, IEEE Trans. Software Eng..

[113]  David Gay,et al.  Memory management with explicit regions , 1998, PLDI.

[114]  H. Dieter Rombach.  Proceedings of the 18th international conference on Software engineering , 1996, ICSE 1996.

[115]  Robyn R. Lutz,et al.  Operational anomalies as a cause of safety-critical requirements evolution , 2003, J. Syst. Softw..

[116]  Hany H. Ammar,et al.  Architectural-Level Risk Analysis Using UML , 2003, IEEE Trans. Software Eng..

[117]  Charles B. Dunham.  Test for (IN) equality, subtraction, proof of correctness , 1986, SGNM.

[118]  Thomas Lukasiewicz,et al.  Probabilistic logic programming with conditional constraints , 2001, TOCL.

[119]  He Jifeng,et al.  Towards a refinement calculus for object systems , 2002 .

[120]  Paul Grünbacher,et al.  System dynamics modelling and simulation of collaborative requirements engineering , 2001, J. Syst. Softw..

[121]  James M. Bieman,et al.  Measuring Design-Level Cohesion , 1998, IEEE Trans. Software Eng..

[122]  Barton P. Miller,et al.  Fuzz Revisited: A Re-examination of the Reliability of UNIX Utilities and Services , 1995 .

[123]  Tony Moynihan.  Coping with 'requirements-uncertainty': the theories-of-action of experienced IS/software project managers , 2000, J. Syst. Softw..

[124]  Silvana Castano,et al.  Using Patterns to Design Rules in Workflows , 2000, IEEE Trans. Software Eng..

[125]  Tsong Yueh Chen,et al.  A Choice Relation Framework for Supporting Category-Partition Test Case Generation , 2003, IEEE Trans. Software Eng..

[126]  Jeffrey S. Lavell,et al.  Report on the Loss of the Mars Polar Lander and Deep Space 2 Missions , 2000 .

[127]  Chan-Gun Lee,et al.  Specifying timing constraints and composite events: an application in the design of electronic brokerages , 2004, IEEE Transactions on Software Engineering.

[128]  J. Martonchik.  MISR Multi-Angle Imaging SpectroRadiometer , 2003 .

[129]  Johnette Hassell,et al.  A relational database model of program execution and software components , 2000, ACM-SE 38.

[130]  Jeff Tian,et al.  A comparison of measurement and defect characteristics of new and legacy software systems , 1998, J. Syst. Softw..

[131]  David Harel,et al.  Statecharts: A Visual Formalism for Complex Systems , 1987, Sci. Comput. Program..

[132]  Matthew B. Dwyer,et al.  Carving and Replaying Differential Unit Test Cases from System Test Cases , 2009, IEEE Transactions on Software Engineering.

[133]  Benjamin Livshits,et al.  Finding application errors and security flaws using PQL: a program query language , 2005, OOPSLA '05.

[134]  Ramanath Subramanyam,et al.  Empirical Analysis of CK Metrics for Object-Oriented Design Complexity: Implications for Software Defects , 2003, IEEE Trans. Software Eng..

[135]  Marvin V. Zelkowitz,et al.  Defect evolution in a product line environment , 2004, J. Syst. Softw..

[136]  Elaine J. Weyuker,et al.  The distribution of faults in a large industrial software system , 2002, ISSTA '02.

[137]  Georg Gottlob,et al.  Complexity and expressive power of logic programming , 2001, CSUR.

[138]  Joseph A. Gallian.  Error detection methods , 1996, CSUR.

[139]  Jon Damon Reese,et al.  Analyzing Software Specifications for Mode Confusion Potential , 1998 .

[140]  Kishor S. Trivedi,et al.  Fighting bugs: remove, retry, replicate, and rejuvenate , 2007, Computer.

[141]  David Lorge Parnas,et al.  Using information about functions in selecting test cases , 2005, ACM SIGSOFT Softw. Eng. Notes.

[142]  Arthur Charlesworth,et al.  The undecidability of associativity and commutativity analysis , 2002, TOPL.

[143]  Martin Große-Rhode,et al.  Compositional Comparison of Formal Software Specifications Using Transformation Systems , 2002, Formal Aspects of Computing.

[144]  Antonia Bertolino,et al.  Using Spanning Sets for Coverage Testing , 2003, IEEE Trans. Software Eng..

[145]  Carol S. Smidts,et al.  Software reliability models: an approach to early reliability prediction , 1996, Proceedings of ISSRE '96: 7th International Symposium on Software Reliability Engineering.

[146]  Hoang Pham,et al.  An analysis of factors affecting software reliability , 2000, J. Syst. Softw..

[147]  Martin C. Rinard,et al.  Goal-Directed Reasoning for Specification-Based Data Structure Repair , 2006, IEEE Transactions on Software Engineering.

[148]  Takeshi Nakajo,et al.  A Case History Development of a Foolproofing Interface Documentation System , 1993, IEEE Trans. Software Eng..

[149]  Elaine J. Weyuker,et al.  An Extended Domain-Bases Model of Software Reliability , 1988, IEEE Trans. Software Eng..

[150]  I. S. Alkadi,et al.  Algorithms that compute test drivers in object oriented testing , 2001, 2001 IEEE Aerospace Conference Proceedings (Cat. No.01TH8542).

[151]  Richard J. Fateman,et al.  Advances and trends in the design and construction of algebraic manipulation systems , 1990, ISSAC '90.

[152]  Stuart H. Zweben,et al.  Analysis and Refinement of Software Test Data Adequacy Properties , 1991, IEEE Trans. Software Eng..

[153]  Elaine J. Weyuker,et al.  An analytical comparison of the fault-detecting ability of data flow testing techniques , 1993, Proceedings of 1993 15th International Conference on Software Engineering.

[154]  Brian Randell,et al.  Software fault tolerance: t/(n-1)-variant programming , 1992 .

[155]  Zhe Yang,et al.  Software validation via scalable path-sensitive value flow analysis , 2004, ISSTA '04.

[156]  Brian Marick,et al.  Classic Testing Mistakes , 1997 .

[157]  Alexander Pretschner,et al.  Model based testing in incremental system development , 2004, J. Syst. Softw..

[158]  Richard J. Lipton,et al.  Theoretical and empirical studies on using program mutation to test the functional correctness of programs , 1980, POPL '80.

[159]  Nancy G. Leveson.  Intent Specifications: An Approach to Building Human-Centered Specifications , 2000, IEEE Trans. Software Eng..

[160]  Lee J. White,et al.  Complexity of testing iterated borders for structured programs , 1988, [1988] Proceedings. Second Workshop on Software Testing, Verification, and Analysis.

[161]  Hermann Kopetz,et al.  Software engineering for real-time: a roadmap , 2000, ICSE '00.

[162]  Oliver Laitenberger,et al.  Perspective-based reading of code documents at Robert Bosch GmbH , 1997, Inf. Softw. Technol..

[163]  Philip Koopman,et al.  Representing Embedded System Sequence Diagrams as a Formal Language , 2001, UML.

[164]  T. B. Dinesh,et al.  Centrum Voor Wiskunde En Informatica Reportrapport a Slicing-based Approach for Locating Type Errors a Slicing-based Approach for Locating Type Errors , 2022 .

[165]  Shaoying Liu,et al.  A Model-Oriented Approach to Safety Analysis Using Fault Trees and a Support System , 1996, J. Syst. Softw..

[166]  Michael R. Lyu.  Software Fault Tolerance , 1995 .

[167]  Kevin Knight,et al.  Unification: a multidisciplinary survey , 1989, CSUR.

[168]  Carl H. Smith,et al.  A Recursion Theoretic Approach to Program Testing , 1987, IEEE Transactions on Software Engineering.

[169]  Bingchiang Jeng,et al.  An automatic approach of domain test data generation , 1999, J. Syst. Softw..

[170]  James Miller,et al.  An empirical evaluation of defect detection techniques , 1997, Inf. Softw. Technol..

[171]  H. D. Chu,et al.  An evaluation scheme of software testing techniques , 1997 .

[172]  Sarfraz Khurshid,et al.  Software assurance by bounded exhaustive testing , 2004, IEEE Transactions on Software Engineering.

[173]  Stuart Bennett,et al.  A taxonomy for software voting algorithms used in safety-critical systems , 2004, IEEE Transactions on Reliability.

[174]  Ron Weber,et al.  An Ontological Model of an Information System , 1990, IEEE Trans. Software Eng..

[175]  Zhibin Tan.  Estimation of exponential component reliability from uncertain life data in series and parallel systems , 2007, Reliab. Eng. Syst. Saf..

[176]  Joanne M. Atlee,et al.  Feasibility of model checking software requirements: a case study , 1996, Proceedings of 11th Annual Conference on Computer Assurance. COMPASS '96.

[177]  Alain Abran,et al.  The Guide to the Software Engineering Body of Knowledge , 1999, IEEE Softw..

[178]  Franck Xia,et al.  Look before you leap: on some fundamental issues in software engineering research , 1999, Inf. Softw. Technol..

[179]  Michael Pecht,et al.  Reliability of a k-out-of-n warm-standby system , 1992 .

[180]  Ryszard Janicki,et al.  On a formal semantics of tabular expressions , 2001, Sci. Comput. Program..

[181]  J. M. Voas,et al.  Examining fault-tolerance using unlikely inputs: turning the test distribution up-side down , 1995, COMPASS '95 Proceedings of the Tenth Annual Conference on Computer Assurance Systems Integrity, Software Safety and Process Security'.

[182]  Jehad Al Dallal,et al.  Anomaly detection in concurrent Java programs using dynamic data flow analysis , 2001, Inf. Softw. Technol..

[183]  J. V. Tucker,et al.  Abstract computability and algebraic specification , 2002, TOCL.

[184]  Stephen G. MacDonell,et al.  A comparison of techniques for developing predictive models of software metrics , 1997, Inf. Softw. Technol..

[185]  Taghi M. Khoshgoftaar,et al.  Predicting fault-prone modules with case-based reasoning , 1997, Proceedings The Eighth International Symposium on Software Reliability Engineering.

[186]  Ioannis Stamelos.  Detecting associative shift faults in predicate testing , 2003, J. Syst. Softw..

[187]  Nancy G. Leveson,et al.  Analysis of Faults in an N-Version Software Experiment , 1990, IEEE Trans. Software Eng..

[188]  G. Frege.  Über Sinn und Bedeutung , 1892 .

[189]  Lee J. White,et al.  A Domain Strategy for Computer Program Testing , 1980, IEEE Transactions on Software Engineering.

[190]  R. C. Jones,et al.  On the uniformity of error propagation in software , 1997, Proceedings of COMPASS '97: 12th Annual Conference on Computer Assurance.

[191]  Nancy J. Wahl.  An overview of regression testing , 1999, SOEN.

[192]  Torres Wilfredo,et al.  Software Fault Tolerance: A Tutorial , 2000 .

[193]  Lori A. Clarke,et al.  A Formal Model of Program Dependences and Its Implications for Software Testing, Debugging, and Maintenance , 1990, IEEE Trans. Software Eng..

[194]  Barry W. Boehm,et al.  A spiral model of software development and enhancement , 1986, Computer.

[195]  Cem Kaner.  Teaching domain testing: a status report , 2004, 17th Conference on Software Engineering Education and Training, 2004. Proceedings..

[196]  Sandro Morasca,et al.  A hybrid approach to analyze empirical software engineering data and its application to predict module fault-proneness in maintenance , 2000, J. Syst. Softw..

[197]  Peter G. Bishop,et al.  An exploration of software faults and failure behaviour in a large population of programs , 2004, 15th International Symposium on Software Reliability Engineering.

[198]  Axel van Lamsweerde,et al.  Managing Conflicts in Goal-Driven Requirements Engineering , 1998, IEEE Trans. Software Eng..

[199]  Nicos Malevris.  A path generation method for testing LCSAJs that restrains infeasible paths , 1995, Inf. Softw. Technol..

[200]  Gwangil Jeon,et al.  A partitioning method for efficient system-level diagnosis , 2002, J. Syst. Softw..

[201]  Neil A. M. Maiden,et al.  The Domain Theory for Requirements Engineering , 1998, IEEE Trans. Software Eng..

[202]  Gregor Snelting,et al.  Efficient path conditions in dependence graphs for software safety analysis , 2006, TSEM.

[203]  Paul Lander,et al.  Optimizing signal averaging methods , 1989, Images of the Twenty-First Century. Proceedings of the Annual International Engineering in Medicine and Biology Society,.

[204]  Daniel Jackson,et al.  Alloy: a lightweight object modelling notation , 2002, TSEM.

[205]  G. Becker,et al.  Two-stage Bayesian models - application to ZEDB project , 2005, Reliab. Eng. Syst. Saf..

[206]  J. A. Makowsky.  Model theory and computer science: an appetizer , 1993, LICS 1993.

[207]  Sara Jones,et al.  Formal methods and requirements engineering: Challenges and synergies , 1998, J. Syst. Softw..

[208]  Marc J. Balcer,et al.  The category-partition method for specifying and generating fuctional tests , 1988, CACM.

[209]  David A. Schmidt.  Data flow analysis is model checking of abstract interpretations , 1998, POPL '98.

[210]  Kishor S. Trivedi,et al.  A workload-based analysis of software aging, and rejuvenation , 2005, IEEE Transactions on Reliability.

[211]  Brian Mitchell,et al.  A reliability model combining representative and directed testing , 1996, Proceedings of IEEE 18th International Conference on Software Engineering.

[212]  Poong-Hyun Seong,et al.  Quantitative evaluation of safety critical software testability based on fault tree analysis and entropy , 2004, J. Syst. Softw..

[213]  William E. Howden,et al.  Reliability of the Path Analysis Testing Strategy , 1976, IEEE Transactions on Software Engineering.

[214]  Alfred V. Aho,et al.  Data Structures and Algorithms , 1983 .

[215]  Peter G. Bishop,et al.  Rescaling reliability bounds for a new operational profile , 2002, ISSTA '02.

[216]  Pierfrancesco Bellini,et al.  Temporal logics for real-time system specification , 2000, CSUR.

[217]  A. Jefferson Offutt,et al.  An analysis tool for coupling-based integration testing , 2000, Proceedings Sixth IEEE International Conference on Engineering of Complex Computer Systems. ICECCS 2000.

[218]  Farokh B. Bastani,et al.  A Class of Inherently Fault Tolerant Distributed Programs , 1988, IEEE Trans. Software Eng..

[219]  S. Munson.  Assessment of accident investigation methods for wildland firefighting incidents by case study method , 2000 .

[220]  Issa Traoré,et al.  Enhancing structured review with model-based verification , 2004, IEEE Transactions on Software Engineering.

[221]  Jeff Tian,et al.  An Integrated Approach to Test Tracking and Analysis , 1996, J. Syst. Softw..

[222]  Bernard M. E. Moret,et al.  Decision Trees and Diagrams , 1982, CSUR.

[223]  Sukhamay Kundu.  Note on a Constrained-Path Problem in Program Testing , 1978, IEEE Transactions on Software Engineering.

[224]  Phyllis G. Frankl,et al.  The ASTOOT approach to testing object-oriented programs , 1994, TSEM.

[225]  Purnendu Sinha,et al.  A novel approach for component-based fault-tolerant software development , 2005, Inf. Softw. Technol..

[226]  Taghi M. Khoshgoftaar,et al.  The Detection of Fault-Prone Programs , 1992, IEEE Trans. Software Eng..

[227]  Taghi M. Khoshgoftaar,et al.  Early Quality Prediction: A Case Study in Telecommunications , 1996, IEEE Softw..

[228]  Jon Doyle,et al.  A Truth Maintenance System , 1979, Artif. Intell..

[229]  James C. Corbett,et al.  Identical tasks and counter variables in an integer programming-based approach to verification , 1993, Proceedings of 1993 IEEE 7th International Workshop on Software Specification and Design.

[230]  Farokh B. Bastani,et al.  Systematic reliability analysis of a class of application-specific embedded software framework , 2004, IEEE Transactions on Software Engineering.

[231]  Lee J. White,et al.  Sufficient test sets for path analysis testing strategies , 1981, ICSE '81.

[232]  Janusz W. Laski,et al.  A Data Flow Oriented Program Testing Strategy , 1983, IEEE Transactions on Software Engineering.

[233]  Helmut Veith,et al.  Counterexample-guided abstraction refinement for symbolic model checking , 2003, JACM.

[234]  Steven J. Zeil,et al.  Testing for Perturbations of Program Statements , 1983, IEEE Transactions on Software Engineering.

[235]  Tharam S. Dillon,et al.  Software Complexity and Its Impact on Software Reliability , 1988, IEEE Trans. Software Eng..

[236]  Martin Glinz,et al.  Improving the Quality of Requirements with Scenarios , 2000 .

[237]  R. Burchfield.  Oxford English dictionary , 1982 .

[238]  Luqi,et al.  Documentation driven development for complex real-time systems , 2004, IEEE Transactions on Software Engineering.

[239]  Bev Littlewood,et al.  Evaluating Testing Methods by Delivered Reliability , 1998, IEEE Trans. Software Eng..

[240]  David A. McAllester,et al.  On the complexity of set-based analysis , 1997, ICFP '97.

[241]  James H. Andrews,et al.  General Test Result Checking with Log File Analysis , 2003, IEEE Trans. Software Eng..

[242]  J. Paul Myers,et al.  The Path Prefix Software Testing Strategy , 1987, IEEE Transactions on Software Engineering.

[243]  Donald Sannella,et al.  Completeness of Proof Systems for Equational Specifications , 1985, IEEE Transactions on Software Engineering.

[244]  Radha Jagadeesan,et al.  Computing with Continuous Change , 1998, Sci. Comput. Program..

[245]  Lionel C. Briand,et al.  Exploring the relationships between design measures and software quality in object-oriented systems , 2000, J. Syst. Softw..

[246]  Lorin Hochstein,et al.  Combating architectural degeneration: a survey , 2005, Inf. Softw. Technol..

[247]  B. A. Sheil,et al.  The Psychological Study of Programming , 1981, CSUR.

[248]  Onur Demirörs,et al.  Functional size measurement revisited , 2008, TSEM.

[249]  Bo Yang,et al.  Modeling software for accurate data flow representation , 1993, Proceedings of 1993 15th International Conference on Software Engineering.

[250]  Agostino Dovier,et al.  Sets and constraint logic programming , 2000, TOPL.

[251]  Hong Zhu,et al.  Software unit test coverage and adequacy , 1997, ACM Comput. Surv..

[252]  Timothy G. Trucano,et al.  Verification and validation. , 2005 .

[253]  Marvin D. Troutt,et al.  Software quality assurance: An analytical survey and research prioritization , 1999, J. Syst. Softw..

[254]  Bojan Cukic,et al.  Robust prediction of fault-proneness by random forests , 2004, 15th International Symposium on Software Reliability Engineering.

[255]  Steve Easterbrook,et al.  Formal methods for verification and validation of partial specifications: A case study , 1998, J. Syst. Softw..

[256]  Thomas Ragg,et al.  Using machine learning for estimating the defect content after an inspection , 2004, IEEE Transactions on Software Engineering.

[257]  W. Eric Wong,et al.  Reducing the cost of mutation testing: An empirical study , 1995, J. Syst. Softw..

[258]  Wen-Kui Chang,et al.  Impartial evaluation in software reliability practice , 2005, J. Syst. Softw..

[259]  Adam A. Porter,et al.  Comparing Detection Methods for Software Requirements Inspections: A Replicated Experiment , 1995, IEEE Trans. Software Eng..

[260]  Neil Walkinshaw,et al.  Identifying State Transitions and their Functions in Source Code , 2006, Testing: Academic & Industrial Conference - Practice And Research Techniques (TAIC PART'06).

[261]  David A. Schmidt.  A calculus of logical relations for over- and underapproximating static analyses , 2007, Sci. Comput. Program..

[262]  Robyn R. Lutz,et al.  Analyzing software requirements errors in safety-critical, embedded systems , 1993, [1993] Proceedings of the IEEE International Symposium on Requirements Engineering.

[263]  Ann Q. Gates,et al.  A taxonomy and catalog of runtime software-fault monitoring tools , 2004, IEEE Transactions on Software Engineering.

[264]  Les Hatton,et al.  Safer language subsets: an overview and a case history, MISRA C , 2004, Inf. Softw. Technol..

[265]  G. B. Finelli,et al.  The Infeasibility of Quantifying the Reliability of Life-Critical Real-Time Software , 1993, IEEE Trans. Software Eng..

[266]  Alistair G. Sutcliffe,et al.  Scenario-based assessment of nonfunctional requirements , 2005, IEEE Transactions on Software Engineering.

[267]  Robert S. Lubarsky.  CZF and Second Order Arithmetic , 2006, Ann. Pure Appl. Log..

[268]  Lorenzo Strigini,et al.  Backward error recovery via conversations in Ada , 1995, Softw. Eng. J..

[269]  Neil C. Rowe,et al.  Absolute Bounds on Set Intersection and Union Sizes from Distribution Information , 1988, IEEE Trans. Software Eng..

[270]  Shoichi Noguchi,et al.  A User Friendly Software Environment for Protocol Synthesis , 1991, IEEE Trans. Computers.

[271]  Mitsuari Hakuta,et al.  A study of software portability evaluation , 1997, J. Syst. Softw..

[272]  Yan Georget,et al.  Encoding global constraints in semiring-based constraint solving , 1998, Proceedings Tenth IEEE International Conference on Tools with Artificial Intelligence (Cat. No.98CH36294).

[273]  Qian Cui,et al.  Data-Oriented Exception Handling , 1992, IEEE Trans. Software Eng..

[274]  Andrea Masini,et al.  An Analysis of (Linear) Exponentials Based on Extended Sequents , 1998, Log. J. IGPL.

[275]  Marc Roper.  Software testing - searching for the missing link , 1999, Inf. Softw. Technol..

[276]  Jeffrey W. Vincoli.  System Safety Program Requirements , 2005 .

[277]  Lorenzo Strigini,et al.  On the Use of Testability Measures for Dependability Assessment , 1996, IEEE Trans. Software Eng..

[278]  Kai-Yuan Cai,et al.  An efficient defect estimation method for software defect curves , 2003, Proceedings 27th Annual International Computer Software and Applications Conference. COMPAC 2003.

[279]  Jim Gray,et al.  Why Do Computers Stop and What Can Be Done About It? , 1986, Symposium on Reliability in Distributed Software and Database Systems.

[280]  Richard Gerber,et al.  Composite model-checking: verification with type-specific symbolic representations , 1999, TSEM.

[281]  Michael Stonebraker,et al.  The POSTGRES Rule Manager , 1988, IEEE Trans. Software Eng..

[282]  Franck Xia,et al.  On the concept of coupling, its modeling and measurement , 2000, J. Syst. Softw..

[283]  Vadlamani Ravi,et al.  Software reliability prediction by soft computing techniques , 2008, J. Syst. Softw..

[284]  M. E. Staknis.  A formal investigation of checking the input to critical systems , 1993 .

[285]  Mats Per Erik Heimdahl,et al.  On the analysis needs when verifying state-based software requirements: an experience report , 2000, Sci. Comput. Program..

[286]  Ehud Shapiro,et al.  Algorithmic Program Debugging , 1983 .

[287]  Gaetano Borriello,et al.  An Algorithm for Exact Bounds on the Time Separation of Events in Concurrent Systems , 1995, IEEE Trans. Computers.

[288]  Kishor S. Trivedi,et al.  Transient analysis of Markov regenerative stochastic Petri nets: a comparison of approaches , 1995, Proceedings 6th International Workshop on Petri Nets and Performance Models.

[289]  Dov M. Gabbay,et al.  Background : computational structures , 1992 .

[290]  Susan L. Gerhart,et al.  Application of axiomatic methods to a specification analyser , 1984, ICSE '84.

[291]  Petrus H. Potgieter,et al.  Zeno machines and hypercomputation , 2004, Theor. Comput. Sci..

[292]  Gregg Rothermel,et al.  An experimental determination of sufficient mutant operators , 1996, TSEM.

[293]  GERNOT METZE,et al.  On the Connection Assignment Problem of Diagnosable Systems , 1967, IEEE Trans. Electron. Comput..

[294]  Jeremy E. Dawson.  Formalising General Correctness , 2004, Electron. Notes Theor. Comput. Sci..

[295]  Joseph A. Goguen,et al.  Institutions: abstract model theory for specification and programming , 1992, JACM.

[296]  T. Kikuno,et al.  Fault analysis based on fault reporting in JSP software development , 1991, [1991] Proceedings The Fifteenth Annual International Computer Software & Applications Conference.

[297]  D. Shepherd.  Using HOL To Produce Custom Verification Tools , 1991, 1991., International Workshop on the HOL Theorem Proving System and Its Applications.

[298]  George S. Avrunin,et al.  Improving the precision of INCA by preventing spurious cycles , 2000, ISSTA '00.

[299]  James Miller,et al.  Towards a benchmark for the evaluation of software testing techniques , 1995, Inf. Softw. Technol..

[300]  Tsong Yueh Chen,et al.  On the maximin algorithms for test allocations in partition testing , 2001, Inf. Softw. Technol..

[301]  Chih-Ping Chu,et al.  Integrating in-process software defect prediction with association mining to discover defect pattern , 2009, Inf. Softw. Technol..

[302]  Mogens Nielsen,et al.  Models for Concurrency , 1992 .

[303]  Pascal Van Hentenryck,et al.  Newton - Constraint Programming over Nonlinear Constraints , 1998, Sci. Comput. Program..

[304]  Anish Arora,et al.  Designing Masking Fault-Tolerance via Nonmasking Fault-Tolerance , 1998, IEEE Trans. Software Eng..

[305]  Margaret M. Burnett,et al.  Sharing reasoning about faults in spreadsheets: An empirical study , 2006, Visual Languages and Human-Centric Computing (VL/HCC'06).

[306]  Yong Rae Kwon,et al.  Empirical evaluation of orthogonality of class mutation operators , 2004, 11th Asia-Pacific Software Engineering Conference.

[307]  Roy A. Maxion,et al.  Eliminating Exception Handling Errors with Dependability Cases: A Comparative, Empirical Study , 2000, IEEE Trans. Software Eng..

[308]  C. V. Ramamoorthy,et al.  Software Reliability—Status and Perspectives , 1982, IEEE Transactions on Software Engineering.

[309]  Gary Klein,et al.  System analysts' orientations and perceptions of system failure , 1999, Inf. Softw. Technol..

[310]  Randal E. Bryant,et al.  Symbolic Boolean manipulation with ordered binary-decision diagrams , 1992, CSUR.

[311]  Alexander Bunkenburg,et al.  A source of inconsistency in theories of nondeterministic functions , 2002, Sci. Comput. Program..

[312]  Claes Wohlin,et al.  Applying sampling to improve software inspections , 2004, J. Syst. Softw..

[313]  R. Blute,et al.  Category theory for linear logicians , 2004 .

[314]  Attila Csenki.  Reliability analysis of recovery blocks with nested clusters of failure points , 1993 .

[315]  Atul Prakash,et al.  Programming in the large , 1986, IEEE Transactions on Software Engineering.

[316]  Jan Gerben Wijnstra.  From problem to solution with quality attributes and design aspects , 2003, J. Syst. Softw..

[317]  Alfonso F. Cardenas,et al.  An Approach and Mechanism for Auditable and Testable Advanced Transaction Processing Systems , 1987, IEEE Transactions on Software Engineering.

[318]  Anna H. Hać,et al.  A new cell loss recovery method using forward error correction in ATM networks , 1998 .

[319]  Key-Sun Choi,et al.  Two-Dimensional Specification of Universal Quantification in a Graphical Database Query Language , 1992, IEEE Trans. Software Eng..

[320]  Carol S. Smidts,et al.  HOTTest: A model-based test design technique for enhanced testing of domain-specific applications , 2006, TSEM.

[321]  Elaine J. Weyuker,et al.  A Formal Analysis of the Fault-Detecting Ability of Testing Methods , 1993, IEEE Trans. Software Eng..

[322]  Seiki Akama.  Three-valued constructive logic and logic programs , 1995, Proceedings 25th International Symposium on Multiple-Valued Logic.

[323]  Diane Kelly,et al.  A case study in the use of defect classification in inspections , 2001, CASCON.

[324]  Debra J. Richardson,et al.  An Analysis of Test Data Selection Criteria Using the RELAY Model of Fault Detection , 1993, IEEE Trans. Software Eng..

[325]  Aniello Cimitile,et al.  An Extensible System for Source Code Analysis , 1998, IEEE Trans. Software Eng..

[326]  Mana Taghdiri,et al.  Inferring specifications to detect errors in code , 2004, Proceedings. 19th International Conference on Automated Software Engineering, 2004..

[327]  George S. Avrunin,et al.  Analyzing Partially-Implemented Real-Time Systems , 1997, Proceedings of the (19th) International Conference on Software Engineering.

[328]  Myra B. Cohen,et al.  Covering Arrays for Efficient Fault Characterization in Complex Configuration Spaces , 2006, IEEE Trans. Software Eng..

[329]  Douglas Stott Parker,et al.  Partial order programming (extended abstract) , 1989, POPL '89.

[330]  Stephen N. Freund,et al.  Atomizer: A Dynamic Atomicity Checker for Multithreaded Programs (Summary) , 2004, IPDPS.

[331]  Mark Harman,et al.  ConSUS: a light-weight program conditioner , 2005, J. Syst. Softw..

[332]  J. Christopher Westland,et al.  The cost of errors in software development: evidence from industry , 2002, J. Syst. Softw..

[333]  Farn Wang,et al.  Symbolic parametric safety analysis of linear hybrid systems with BDD-like data-structures , 2004, IEEE Transactions on Software Engineering.

[334]  Anders P. Ravn,et al.  From Safety Analysis to Software Requirements , 1998, IEEE Trans. Software Eng..

[335]  Robert M. Hierons.  Avoiding coincidental correctness in boundary value analysis , 2006, TSEM.

[336]  David Lorge Parnas,et al.  Predicate Logic for Software Engineering , 1993, IEEE Trans. Software Eng..

[337]  Toufik Taibi,et al.  Formal Specification of Design Patterns and Their Instances , 2006, IEEE International Conference on Computer Systems and Applications, 2006..

[338]  Leigh A. Davis,et al.  Patterns of conflict among software components , 2006, J. Syst. Softw..

[339]  Harvey P. Siy,et al.  An Experiment ot Assess the Cost-Benefits of Code Inspections in Large Scale Software Development , 1997, IEEE Trans. Software Eng..

[340]  Richard H. Carver,et al.  Debugging Concurrent Ada Programs by Deterministic Execution , 1991, IEEE Trans. Software Eng..

[341]  Michael I. Jordan,et al.  Statistical debugging: simultaneous identification of multiple bugs , 2006, ICML.

[342]  A. Jefferson Offutt,et al.  Evaluation of three specification-based testing criteria , 2000, Proceedings Sixth IEEE International Conference on Engineering of Complex Computer Systems. ICECCS 2000.

[343]  Richard G. Hamlet.  Theoretical comparison of testing methods , 1989 .

[344]  Siddhartha R. Dalal,et al.  When to Stop Testing for Large Software Systems with Changing Code , 1994, IEEE Trans. Software Eng..

[345]  Holger Hermanns,et al.  QoS modelling and analysis with UML-statecharts: the StoCharts approach , 2005, PERV.

[346]  Bharat K. Bhargava,et al.  An open and safe nested transaction model: concurrency and recovery , 2000, J. Syst. Softw..

[347]  Bedir Tekinerdogan,et al.  Software Architecture Reliability Analysis Using Failure Scenarios , 2005, 5th Working IEEE/IFIP Conference on Software Architecture (WICSA'05).

[348]  Witold Pedrycz,et al.  Genetic granular classifiers in modeling software quality , 2005, J. Syst. Softw..

[349]  Les Hatton.  Repetitive failure, feedback and the lost art of diagnosis , 1999, J. Syst. Softw..

[350]  Maurizio Pighin,et al.  An empirical analysis of fault persistence through software releases , 2003, 2003 International Symposium on Empirical Software Engineering, 2003. ISESE 2003. Proceedings..

[351]  Sudheendra Hangal,et al.  Tracking down software bugs using automatic anomaly detection , 2002, ICSE '02.

[352]  Michel Wermelinger,et al.  Higher-order architectural connectors , 2003, TSEM.

[353]  Sandro Morasca,et al.  A proposal for using continuous attributes in classification trees , 2002, SEKE '02.

[354]  Orna Kupferman,et al.  Weak alternating automata are not that weak , 2001, TOCL.

[355]  Serge Demeyer,et al.  On The Detection of Test Smells: A Metrics-Based Approach for General Fixture and Eager Test , 2007, IEEE Trans. Software Eng..

[356]  Johnette Hassell,et al.  Designing a resourceful fault-tolerance system , 2002, J. Syst. Softw..

[357]  Jens Palsberg.  Equality-based flow analysis versus recursive types , 1998, TOPL.

[358]  Giuliana Franceschinis,et al.  Parametric Fault Tree for the Dependability Analysis of Redundant Systems and Its High-Level Petri Net Semantics , 2003, IEEE Trans. Software Eng..

[359]  Joseph Sifakis,et al.  Compiling Real-Time Specifications into Extended Automata , 1992, IEEE Trans. Software Eng..

[360]  Lorenzo Strigini,et al.  Fault Tolerance Against Design Faults , 2005 .

[361]  Yashwant K. Malaiya,et al.  On input profile selection for software testing , 1994, Proceedings of 1994 IEEE International Symposium on Software Reliability Engineering.

[362]  Geppino Pucci,et al.  A New Approach to the Modeling of Recovery Block Structures , 1992, IEEE Trans. Software Eng..

[363]  Branson W. Murrill.  An empirical, path-oriented approach to software analysis and testing , 2008, J. Syst. Softw..

[364]  Larry J Morell,et al.  A Theory of Fault-Based Testing , 1990, IEEE Trans. Software Eng..

[365]  Tom McCusker,et al.  TRW Inc. , 1993 .

[366]  William H. Sanders,et al.  Synergistic coordination between software and hardware fault tolerance techniques , 2001, 2001 International Conference on Dependable Systems and Networks.

[367]  Steven J. Vickers,et al.  Presheaves as Configured Specifications , 2001, Formal Aspects of Computing.

[368]  Ana R. Cavalli,et al.  Experimental evaluation of FSM-based testing methods , 2005, Third IEEE International Conference on Software Engineering and Formal Methods (SEFM'05).

[369]  Michael R. Lyu,et al.  An experimental evaluation on reliability features of N-version programming , 2005, 16th IEEE International Symposium on Software Reliability Engineering (ISSRE'05).

[370]  Victor F. Nicola,et al.  Modeling of Correlated Failures and Community Error Recovery in Multiversion Software , 1990, IEEE Trans. Software Eng..

[371]  Stefano Crespi-Reghizzi,et al.  A scalable formal method for design and automatic checking of user interfaces , 2001, Proceedings of the 23rd International Conference on Software Engineering. ICSE 2001.

[372]  Yves Le Traon,et al.  From diagnosis to diagnosability: axiomatization, measurement and application , 2003, J. Syst. Softw..

[373]  J. Voas,et al.  Software Testability: The New Verification , 1995, IEEE Softw..

[374]  S. C. De Sarkar,et al.  A Set of Inference Rules for Quantified Formula Handling and Array Handling in Verification of Programs Over Integers , 1989, IEEE Trans. Software Eng..

[375]  Carl E. Landwehr,et al.  Basic concepts and taxonomy of dependable and secure computing , 2004, IEEE Transactions on Dependable and Secure Computing.

[376]  Luis Olsina,et al.  Towards an ontology for software metrics and indicators as the foundation for a cataloging Web system , 2003, Proceedings of the IEEE/LEOS 3rd International Conference on Numerical Simulation of Semiconductor Optoelectronic Devices (IEEE Cat. No.03EX726).

[377]  Joseph R. Schoenfield.  Recursion theory , 1993 .

[378]  Anish Arora,et al.  Component Based Design of Multitolerant Systems , 1998, IEEE Trans. Software Eng..

[379]  Farokh B. Bastani,et al.  On the Uncertainty in the Correctness of Computer Programs , 1985, IEEE Transactions on Software Engineering.

[380]  Gursaran,et al.  An experimental evaluation of weak-branch criterion for class testing , 2004, J. Syst. Softw..

[381]  Avinash C. Kak,et al.  API-Based and Information-Theoretic Metrics for Measuring the Quality of Software Modularization , 2007 .

[382]  Kentaro Go,et al.  A Decomposition of a Formal Specification: An Improved Constraint Oriented Method , 1999, IEEE Trans. Software Eng..

[383]  Jorge Santos,et al.  A least upper bound on the fault tolerance of real-time systems , 2005, J. Syst. Softw..

[384]  Martin S. Feather.  Constructing Specifications by Combining Parallel Elaborations , 1989, IEEE Trans. Software Eng..

[385]  Claes Wohlin,et al.  Capture-recapture in software inspections after 10 years research--theory, evaluation and application , 2004, J. Syst. Softw..

[386]  Lee J. White,et al.  Detection of linear errors via domain testing , 1992, TSEM.

[387]  Rajeev Alur,et al.  Analysis of recursive state machines , 2001, TOPL.

[388]  William E. Howden,et al.  A functional approach to program testing and analysis , 1986, IEEE Transactions on Software Engineering.

[389]  Daniel M. Yellin,et al.  Extending Typestate Checking Using Conditional Liveness Analysis , 1993, IEEE Trans. Software Eng..

[390]  Johann Schumann,et al.  Automated Theorem Proving in High-Quality Software Design , 2013, Intellectics and Computational Logic.

[391]  David N. Card,et al.  Learning from Our Mistakes with Defect Causal Analysis , 1999, IEEE Softw..

[392]  Donald E. Neumann.  An Enhanced Neural Network Technique for Software Risk Analysis , 2002, IEEE Trans. Software Eng..

[393]  Barbara G. Ryder,et al.  A Critical Analysis of Incremental Iterative Data Flow Analysis Algorithms , 1990, IEEE Trans. Software Eng..

[394]  Wei-Tek Tsai,et al.  A framework for designing safe software systems , 1995, Proceedings Nineteenth Annual International Computer Software and Applications Conference (COMPSAC'95).

[395]  Keith L. Clark,et al.  Consequence Verification of Flowcharts , 1981, IEEE Transactions on Software Engineering.

[396]  Sarfraz Khurshid,et al.  TestEra: a novel framework for automated testing of Java programs , 2001, Proceedings 16th Annual International Conference on Automated Software Engineering (ASE 2001).

[397]  Victor R. Basili,et al.  Developing Interpretable Models with Optimized Set Reduction for Identifying High-Risk Software Components , 1993, IEEE Trans. Software Eng..

[398]  Derek Coleman,et al.  Formal Specification and Design Time Testing , 1990, IEEE Trans. Software Eng..

[399]  Rob J. Kusters,et al.  Exploring defect causes in products developed by virtual teams , 2005, Inf. Softw. Technol..

[400]  Peter Oehlert,et al.  Violating Assumptions with Fuzzing , 2005, IEEE Secur. Priv..

[401]  Taghi M. Khoshgoftaar,et al.  Resource-oriented software quality classification models , 2005, J. Syst. Softw..

[402]  Naohiro Ishii,et al.  Analysis of software bug causes and its prevention , 1999, Inf. Softw. Technol..

[403]  Xin Huang,et al.  Producing reliable software: an experiment , 2002, J. Syst. Softw..

[404]  Michael R. Lowry,et al.  Formal Analysis of a Space-Craft Controller Using SPIN , 2001, IEEE Trans. Software Eng..

[405]  Alessandro Orso,et al.  Classifying data dependences in the presence of pointers for program comprehension, testing, and debugging , 2004, TSEM.

[406]  Zakaria Bouziane,et al.  A primitive recursive algorithm for the general Petri net reachability problem , 1998, Proceedings 39th Annual Symposium on Foundations of Computer Science (Cat. No.98CB36280).

[407]  Colin Atkinson,et al.  An experimental comparison of reading techniques for defect detection in UML design documents , 2000, J. Syst. Softw..

[408]  Shing-Chi Cheung,et al.  Checking subsystem safety properties in compositional reachability analysis , 1996, Proceedings of IEEE 18th International Conference on Software Engineering.

[409]  Peter J. Denning,et al.  Fault Tolerant Operating Systems , 1976, CSUR.

[410]  Bingchiang Jeng.  Toward an integration of data flow and domain testing , 1999, J. Syst. Softw..

[411]  Imtiaz Ahmad,et al.  Recovery From Concurrent Failures in Communication Protocols , 1996, J. Syst. Softw..

[412]  Zachary F. Lansdowne,et al.  Reliability Estimation for a Software System with Sequential Independent Reviews , 2001, IEEE Trans. Software Eng..

[413]  Hongxia Jin,et al.  Approximate correctness-checking of computational results , 1999 .

[414]  Francesc D. Muñoz-Escoí,et al.  Recovery Protocols for Replicated Databases--A Survey , 2007, 21st International Conference on Advanced Information Networking and Applications Workshops (AINAW'07).

[415]  Norman E. Fenton,et al.  A Critique of Software Defect Prediction Models , 1999, IEEE Trans. Software Eng..

[416]  K. Suzanne Barber,et al.  Evaluating dynamic correctness properties of domain reference architectures , 2003, J. Syst. Softw..

[417]  Manuel Blum,et al.  Software reliability via run-time result-checking , 1997, JACM.

[418]  Andreas Blass,et al.  Inadequacy of computable loop invariants , 2001, TOCL.

[419]  Alberto Suárez,et al.  Globally Optimal Fuzzy Decision Trees for Classification and Regression , 1999, IEEE Trans. Pattern Anal. Mach. Intell..

[420]  Shari Lawrence Pfleeger.  Risky business: what we have yet to learn about risk management , 2000, J. Syst. Softw..

[421]  Keith E. Williamson,et al.  Industrial applications of software synthesis via category theory , 1999, 14th IEEE International Conference on Automated Software Engineering.

[422]  William E. Howden,et al.  Functional Program Testing , 1978, IEEE Transactions on Software Engineering.

[423]  Oleg Parshin,et al.  Towards an Integration of Low-Level Timing Analysis and Model-Based Code Generation , 2006, Second International Symposium on Leveraging Applications of Formal Methods, Verification and Validation (isola 2006).

[424]  Shing-Chi Cheung,et al.  An integrated method for effective behaviour analysis of distributed systems , 1994, Proceedings of 16th International Conference on Software Engineering.

[425]  Kai-Hsiung Chang,et al.  Testing object-oriented programs: from formal specification to test scenario generation , 1998, J. Syst. Softw..

[426]  Elaine J. Weyuker,et al.  A simplified domain-testing strategy , 1994, TSEM.

[427]  James Miller,et al.  Applying meta-analytical procedures to software engineering experiments , 2000, J. Syst. Softw..

[428]  Alan R. Hevner,et al.  Reviewing software diagrams: a cognitive study , 2004, IEEE Transactions on Software Engineering.

[429]  Bojan Cukic.  Combining testing and correctness verification in software reliability assessment , 1997, Proceedings 1997 High-Assurance Engineering Workshop.

[430]  Simeon C. Ntafos,et al.  A Comparison of Some Structural Testing Strategies , 1988, IEEE Trans. Software Eng..

[431]  Elaine J. Weyuker,et al.  Software performance testing based on workload characterization , 2002, WOSP '02.

[432]  Andrew W. Appel,et al.  Foundational proof-carrying code , 2001, Proceedings 16th Annual IEEE Symposium on Logic in Computer Science.

[433]  Elisabeth A. Strunk,et al.  A Survey of Tools for Model Checking and Model-Based Development , 2006 .

[434]  Michael E. Fagan.  Advances in software inspections , 1986, IEEE Transactions on Software Engineering.

[435]  Paul Ammann,et al.  Data Diversity: An Approach to Software Fault Tolerance , 1988, IEEE Trans. Computers.

[436]  Ravishankar K. Iyer,et al.  Faults, symptoms, and software fault tolerance in the Tandem GUARDIAN90 operating system , 1993, FTCS-23 The Twenty-Third International Symposium on Fault-Tolerant Computing.

[437]  Zha Ming,et al.  A formal software development approach based on COOZ and refinement calculus , 1999 .

[438]  Michael Jackson,et al.  Where Do Operations Come From: A Multiparadigm Specification Technique , 1996, IEEE Trans. Software Eng..

[439]  W. M. McKeeman,et al.  On preventing programming languages from interfering with programming , 1975, IEEE Transactions on Software Engineering.

[440]  Kang G. Shin,et al.  Measurement and Analysis of Workload Effects on Fault Latency in Real-Time Systems , 1990, IEEE Trans. Software Eng..

[441]  Roger B. Dannenberg,et al.  Formal Program Verification Using Symbolic Execution , 1982, IEEE Transactions on Software Engineering.

[442]  Elaine J. Weyuker,et al.  Theories of Program Testing and the Application of Revealing Subdomains , 1980, IEEE Transactions on Software Engineering.

[443]  Shmuel Katz,et al.  Architectural views of aspects , 2003, AOSD '03.

[444]  Éric Rutten,et al.  Modeling statecharts and activitycharts as signal equations , 2001, TSEM.

[445]  Jules Desharnais,et al.  Static Detection of Malicious Code in Executable Programs , 2000 .

[446]  Suku Nair,et al.  Statistical analysis of nonstationary software metrics , 1997, Inf. Softw. Technol..

[447]  Joanne M. Atlee,et al.  State-Based Model Checking of Event-Driven System Requirements , 1993, IEEE Trans. Software Eng..

[448]  Jingde Cheng,et al.  A Quantitative Analysis of Implicational Paradoxes in Classical Mathematical Logic , 2007, Electron. Notes Theor. Comput. Sci..

[449]  Lori A. Clarke,et al.  A Close Look at Domain Testing , 1982, IEEE Transactions on Software Engineering.

[450]  Kang G. Shin,et al.  Task construction for model-based design of embedded control software , 2006, IEEE Transactions on Software Engineering.

[451]  Beatrice Gralton,et al.  Washington DC - USA , 2008 .

[452]  Junfeng Yang,et al.  Using model checking to find serious file system errors , 2004, TOCS.

[453]  Lionel C. Briand,et al.  Assessing the Applicability of Fault-Proneness Models Across Object-Oriented Software Projects , 2002, IEEE Trans. Software Eng..

[454]  J. Collofello,et al.  An environment for training computer science students on software testing , 2005, Proceedings Frontiers in Education 35th Annual Conference.

[455]  Robyn R. Lutz,et al.  Empirical analysis of safety-critical anomalies during operations , 2004, IEEE Transactions on Software Engineering.

[456]  Dawson R. Engler,et al.  Using Redundancies to Find Errors , 2003, IEEE Trans. Software Eng..

[457]  David Wright,et al.  Some Conservative Stopping Rules for the Operational Testing of Safety-Critical Software , 1997, IEEE Trans. Software Eng..

[458]  P. Pop.  The generalized minimum spanning tree problem , 2000 .

[459]  Patrick Cousot,et al.  Systematic design of program analysis frameworks , 1979, POPL.

[460]  William D. Young.  Comparing Verification Systems: Interactive Consistency in ACL2 , 1997, IEEE Trans. Software Eng..

[461]  Shaoying Liu,et al.  The practice of formal methods in safety-critical systems , 1995, J. Syst. Softw..

[462]  Jonathan Jacky,et al.  Specifying a Safety-Critical Control System in Z , 1993, IEEE Trans. Software Eng..

[463]  Andrea Bondavalli,et al.  Temporal analysis of data flow control systems , 1998, Autom..

[464]  Doron A. Peled,et al.  Model checking, testing and verification working together , 2005, Formal Aspects of Computing.

[465]  Ravishankar K. Iyer,et al.  Characterization of linux kernel behavior under errors , 2003, 2003 International Conference on Dependable Systems and Networks, 2003. Proceedings..

[466]  Thomas G. Moher,et al.  PROVIDE: A Process Visualization and Debugging Environment , 1988, IEEE Trans. Software Eng..

[467]  Ståle Amland.  Risk-based testing: : Risk analysis fundamentals and metrics for software testing including a financial application case study , 2000, J. Syst. Softw..

[468]  Joel A. Tropp,et al.  ALGORITHMS FOR SIMULTANEOUS SPARSE APPROXIMATION , 2006 .

[469]  Galit Shmueli,et al.  Computing consecutive-type reliabilities nonrecursively , 2003, IEEE Trans. Reliab..

[470]  A. Pasquini,et al.  An input-domain based method to estimate software reliability , 1996, IEEE Trans. Reliab..

[471]  Jeffrey M. Voas,et al.  PIE: A Dynamic Failure-Based Technique , 1992, IEEE Trans. Software Eng..

[472]  Patrice Lacroix.  RTL-CHECK: A PRACTICAL STATIC ANALYSIS FRAMEWORK TO VERIFY MEMORY SAFETY AND MORE , 2006 .

[473]  Alan F. Babich.  Proving Total Correctness of Parallel Programs , 1979, IEEE Transactions on Software Engineering.

[474]  Bev Littlewood,et al.  Validation of ultrahigh dependability for software-based systems , 1993, CACM.

[475]  Erik Berglund.  Communicating bugs: global bug knowledge distribution , 2005, Inf. Softw. Technol..

[476]  David Rine.  Sharing objects as structural defects in object-oriented programming without safe typing , 1996, Inf. Softw. Technol..

[477]  Ann Q. Gates,et al.  FasTLInC: a constraint-based tracing approach , 2002, J. Syst. Softw..

[478]  Arie Shoshani,et al.  On the correctness of representing extended entity-relationship structures in the relational model , 1989, SIGMOD '89.

[479]  M. R. Woodward,et al.  From weak to strong, dead or alive? an analysis of some mutation testing issues , 1988, [1988] Proceedings. Second Workshop on Software Testing, Verification, and Analysis.

[480]  Kuo-Chung Tai.  Predicate-based test generation for computer programs , 1993, Proceedings of 1993 15th International Conference on Software Engineering.

[481]  James M. Rehg,et al.  Active learning for automatic classification of software behavior , 2004, ISSTA '04.

[482]  Dale Miller,et al.  A multiple-conclusion meta-logic , 1994, Proceedings Ninth Annual IEEE Symposium on Logic in Computer Science.

[483]  Brigitte Biebow,et al.  Exception Handling: Formal Specification and Systematic Program Construction , 1984, IEEE Transactions on Software Engineering.

[484]  Peter Fritzson,et al.  Usability criteria for automated debugging systems , 1995, J. Syst. Softw..

[485]  Yevgeniy Makarov.  Practical Program Extraction from Classical Proofs , 2005, MFPS.

[486]  Lionel C. Briand,et al.  A comprehensive and systematic methodology for client-server class integration testing , 2003, 14th International Symposium on Software Reliability Engineering, 2003. ISSRE 2003..

[487]  Bev Littlewood,et al.  Conceptual Modeling of Coincident Failures in Multiversion Software , 1989, IEEE Trans. Software Eng..

[488]  Anders P. Ravn,et al.  Specifying and Verifying Requirements of Real-Time Systems , 1993, IEEE Trans. Software Eng..

[489]  Mariagiovanna Sami,et al.  Some Properties Derived from Structural Analysis of Program Graph Models , 1983, IEEE Transactions on Software Engineering.

[490]  Dov Dori,et al.  The Model Multiplicity Problem: Experimenting with Real-Time Specification Methods , 2000, IEEE Trans. Software Eng..

[491]  Mark Harman,et al.  Conditioned slicing supports partition testing , 2002, Softw. Test. Verification Reliab..

[492]  David Notkin,et al.  Software Reflexion Models: Bridging the Gap between Design and Implementation , 2001, IEEE Trans. Software Eng..

[493]  B. Ramesh,et al.  Issues in the development of a requirements traceability model , 1993, [1993] Proceedings of the IEEE International Symposium on Requirements Engineering.

[494]  W. D. Itzfeldt.  Quality metrics for software management and engineering , 1990 .

[495]  David N. Card,et al.  Empirical Study of Software Design Practices , 2004 .

[496]  Russ Abbott,et al.  Resourceful systems for fault tolerance, reliability, and safety , 1990, CSUR.

[497]  N. Iwata,et al.  Porting classes and coding rules for C programs on CTRON , 1993, Proceedings the Tenth Project International Symposium, 1993.

[498]  Natarajan Shankar,et al.  Formal Verification for Fault-Tolerant Architectures: Prolegomena to the Design of PVS , 1995, IEEE Trans. Software Eng..

[499]  Tadao Murata,et al.  Petri nets: Properties, analysis and applications , 1989, Proc. IEEE.

[500]  Albert Endres.  An analysis of errors and their causes in system programs , 1975 .

[501]  Samuel T. Redwine.  An Engineering Approach to Software Test Data Design , 1983, IEEE Transactions on Software Engineering.

[502]  Vincenzo De Florio,et al.  A survey of linguistic structures for application-level fault tolerance , 2008, CSUR.

[503]  Ali Mili,et al.  Towards a Theory of Forward Error Recovery , 1985, IEEE Transactions on Software Engineering.

[504]  Ravishankar K. Iyer,et al.  Fault/failure analysis of the Tandem NonStop-UX operating system , 1996, 15th DASC. AIAA/IEEE Digital Avionics Systems Conference.

[505]  Ranga Vemuri,et al.  Finite state machine verification on MIMD machines , 1992, Proceedings EURO-DAC '92: European Design Automation Conference.

[506]  Alexandre Petrenko,et al.  Confirming configurations in EFSM testing , 2004, IEEE Transactions on Software Engineering.

[507]  Barbara G. Ryder,et al.  An incremental flow- and context-sensitive pointer aliasing analysis , 1999, Proceedings of the 1999 International Conference on Software Engineering (IEEE Cat. No.99CB37002).

[508]  Scott A. DeLoach,et al.  A Theory-Based Representation for Object-Oriented Domain Models , 2000, IEEE Trans. Software Eng..

[509]  Hui Liu,et al.  Covering code behavior on input validation in functional testing , 2009, Inf. Softw. Technol..

[510]  Dolores R. Wallace,et al.  Structured Testing: A Testing Methodology Using the Cyclomatic Complexity Metric , 1996 .

[511]  Barbara G. Ryder,et al.  Incremental Analysis of Side Effects for C Software Systems , 1997, Proceedings of the (19th) International Conference on Software Engineering.

[512]  Roy S. Freedman,et al.  Testability of Software Components , 1991, IEEE Trans. Software Eng..

[513]  Ian Sommerville,et al.  An empirical study of industrial requirements engineering process assessment and improvement , 2005, TSEM.

[514]  Farokh B. Bastani,et al.  Reliability of fully and partially replicated systems , 1992 .

[515]  E. K. Park,et al.  Algebraic software testing in vector spaces of functions , 1996, Proceedings of 20th International Computer Software and Applications Conference: COMPSAC '96.

[516]  Bertrand Meyer.  A Framework for Proving Contract-Equipped Classes , 2003, Abstract State Machines.

[517]  Cecília M. F. Rubira,et al.  A comparative study of exception handling mechanisms for building dependable object-oriented software , 2001, J. Syst. Softw..

[518]  James R. Lyle,et al.  A Two-Person Inspection Method to Improve Prog ramming Productivity , 1989, IEEE Transactions on Software Engineering.

[519]  Nancy G. Leveson,et al.  Safeware: System Safety and Computers , 1995 .

[520]  John Mylopoulos,et al.  RULE-BASED DETECTION OF INCONSISTENCY IN UML MODELS , 2002 .

[521]  Michael W. Godfrey,et al.  Using origin analysis to detect merging and splitting of source code entities , 2005, IEEE Transactions on Software Engineering.

[522]  Gilberto Filé,et al.  A unifying view of abstract domain design , 1996, CSUR.

[523]  Kuldeep Kumar,et al.  Informal and Formal Requirements Specification Languages: Bridging the Gap , 1991, IEEE Trans. Software Eng..

[524]  Raymond T. Boute,et al.  Supertotal Function Definition in Mathematics and Software Engineering , 2000, IEEE Trans. Software Eng..

[525]  Julie A. McCann,et al.  A survey of autonomic computing—degrees, models, and applications , 2008, CSUR.

[526]  Ravishankar K. Iyer,et al.  Diagnosing Rediscovered Software Problems Using Symptoms , 2000, IEEE Trans. Software Eng..

[527]  Chen Fu,et al.  Robustness testing of Java server applications , 2005, IEEE Transactions on Software Engineering.

[528]  Jan Willem Klop,et al.  Term Rewriting Systems: From Church-Rosser to Knuth-Bendix and Beyond , 1990, ICALP.

[529]  Gianna Reggio,et al.  Consistency Problems in UML-Based Software Development , 2004, UML Satellite Activities.

[530]  Kwangkeun Yi,et al.  An Abstract Interpretation for Estimating Uncaught Exceptions in Standard ML Programs , 1998, Sci. Comput. Program..

[531]  Todd M. Austin,et al.  Efficient detection of all pointer and array access errors , 1994, PLDI '94.

[532]  Enrico Vicario,et al.  Timed state space analysis of real-time preemptive systems , 2004, IEEE Transactions on Software Engineering.

[533]  Markus Stumptner,et al.  A Survey of Intelligent Debugging , 1998, AI Commun..

[534]  Ravishankar K. Iyer,et al.  Software Dependability in the Tandem GUARDIAN System , 1995, IEEE Trans. Software Eng..

[535]  Pierre N. Robillard,et al.  Engineering-based processes and agile methodologies for software development: a comparative case study , 2005, J. Syst. Softw..

[536]  James M. Bieman,et al.  Design patterns and change proneness: an examination of five evolving systems , 2003, Proceedings. 5th International Workshop on Enterprise Networking and Computing in Healthcare Industry (IEEE Cat. No.03EX717).

[537]  Albert Y. Zomaya,et al.  Dependable computing systems : paradigms, performance issues, and applications , 2005 .

[538]  Qian Feng,et al.  Bi-directional safety analysis of product lines , 2005, J. Syst. Softw..

[539]  Francesca Saglietti.  Software diversity metrics quantifying dissimilarity in the input partition , 1990, Softw. Eng. J..

[540]  Siddhartha R. Dalal,et al.  The Automatic Efficient Test Generator (AETG) system , 1994, Proceedings of 1994 IEEE International Symposium on Software Reliability Engineering.

[541]  Pau-Lo Hsu,et al.  General-structured unknown input observers , 1994, Proceedings of 1994 American Control Conference - ACC '94.

[542]  Robert L. Probert,et al.  Optimal Insertion of Software Probes in Well-Delimited Programs , 1982, IEEE Transactions on Software Engineering.

[543]  Michael Goldstein,et al.  Bayesian Graphical Models for Software Testing , 2002, IEEE Trans. Software Eng..

[544]  Mario Bravetti.  An Integrated Approach for the Specification and Analysis of Stochastic Real-Time Systems , 2002, PAPM-PROBMIV.

[545]  Victor R. Basili,et al.  An analysis of errors in a reuse-oriented development environment , 1995, J. Syst. Softw..

[546]  Martin P. Robillard,et al.  How effective developers investigate source code: an exploratory study , 2004, IEEE Transactions on Software Engineering.

[547]  Elaine J. Weyuker,et al.  Analyzing Partition Testing Strategies , 1991, IEEE Trans. Software Eng..

[548]  Oliver Laitenberger,et al.  An encompassing life cycle centric survey of software inspection , 2000, J. Syst. Softw..

[549]  Victor R. Basili,et al.  Analyzing Error-Prone System Structure , 1991, IEEE Trans. Software Eng..

[550]  Lawrence Yelowitz,et al.  Observations of Fallibility in Applications of Modern Programming Methodologies , 1976, IEEE Transactions on Software Engineering.

[551]  Tsong Yueh Chen,et al.  An Overview of Integration Testing Techniques for Object-Oriented Programs , 2002 .

[552]  Daniel A. Menascé,et al.  Assessing the robustness of self-managing computer systems under highly variable workloads , 2004 .

[553]  Kuo-Chung Tai,et al.  Theory of Fault-Based Predicate Testing for Computer Programs , 1996, IEEE Trans. Software Eng..

[554]  James D. Kiper.  Structural testing of rule-based expert systems , 1992, TSEM.

[555]  Hélène Waeselynck,et al.  STATEMATE applied to statistical software testing , 1993, ISSTA '93.

[556]  Jim Cunningham,et al.  Invariants for Specifications , 1979, ICSE.

[557]  Daniel Hoffman,et al.  Trace Specifications: Methodology and Models , 1988, IEEE Trans. Software Eng..

[558]  Pieter H. Hartel,et al.  Formalizing the safety of Java, the Java virtual machine, and Java card , 2001, CSUR.

[559]  Leon Moonen,et al.  A generic architecture for data flow analysis to support reverse engineering , 1997 .

[560]  Monica Nilsson,et al.  Software Engineering Research Laboratory , 2002 .

[561]  Wanchai Rivepiboon,et al.  Automated-generating test case using UML statechart diagrams , 2003 .

[562]  Borislav Nikolik.  Convergence debugging , 2005, AADEBUG'05.

[563]  Mark Harman,et al.  Amorphous program slicing , 1997, Proceedings Fifth International Workshop on Program Comprehension. IWPC'97.

[564]  Harlan D. Mills,et al.  Theory of Modules , 1987, IEEE Transactions on Software Engineering.

[565]  Mark Sullivan,et al.  A comparison of software defects in database management systems and operating systems , 1992, [1992] Digest of Papers. FTCS-22: The Twenty-Second International Symposium on Fault-Tolerant Computing.

[566]  A. Jefferson Offutt,et al.  Combination testing strategies: a survey , 2005, Softw. Test. Verification Reliab..

[567]  William G. Griswold,et al.  Dynamically discovering likely program invariants to support program evolution , 1999, Proceedings of the 1999 International Conference on Software Engineering (IEEE Cat. No.99CB37002).

[568]  Jules Desharnais,et al.  Describing data flow analysis techniques with Kleene algebra , 2007, Sci. Comput. Program..

[569]  John Cocke,et al.  A program data flow analysis procedure , 1976, CACM.

[570]  Charles Yang,et al.  Estimation of software reliability by stratified sampling , 1999, TSEM.

[571]  Hong Zhu.  A note on test oracles and semantics of algebraic specifications , 2003, Third International Conference on Quality Software, 2003. Proceedings..

[572]  Dewayne E. Perry,et al.  Classification and evaluation of defects in a project retrospective , 2002, J. Syst. Softw..

[573]  Simeon C. Ntafos,et al.  An Evaluation of Random Testing , 1984, IEEE Transactions on Software Engineering.

[574]  Michael Kifer,et al.  A logic for reasoning with inconsistency , 1992, Journal of Automated Reasoning.

[575]  Dinakar Dhurjati,et al.  Memory safety without garbage collection for embedded applications , 2005, TECS.

[576]  Christopher Landauer,et al.  Designing testable, heterogeneous software environments , 1995, J. Syst. Softw..

[577]  Toby Walsh,et al.  Handbook of Constraint Programming , 2006, Handbook of Constraint Programming.

[578]  Forouzan Golshani,et al.  Automatic program generation using sequent calculus , 1992, CSC '92.

[579]  Mark Weiser,et al.  Comparison of Structural Test Coverage Metrics , 1985, IEEE Software.

[580]  William Landi,et al.  Undecidability of static analysis , 1992, LOPL.

[581]  Mahadev Satyanarayanan,et al.  Disconnected Operation in the Coda File System , 1999, Mobidata.

[582]  J. C. Huang.  State Constraints and Pathwise Decomposition of Programs , 1990, IEEE Trans. Software Eng..

[583]  Richard Gerber,et al.  Model-checking concurrent systems with unbounded integer variables: symbolic representations, approximations, and experimental results , 1999, TOPL.

[584]  William M. Goble,et al.  Using Markov models for safety analysis of programmable electronic systems , 1995 .

[585]  Audris Mockus,et al.  Does Code Decay? Assessing the Evidence from Change Management Data , 2001, IEEE Trans. Software Eng..

[586]  John C. Grundy,et al.  Inconsistency Management for Multiple-View Software Development Environments , 1998, IEEE Trans. Software Eng..

[587]  Inderpal S. Bhandari,et al.  Orthogonal Defect Classification - A Concept for In-Process Measurements , 1992, IEEE Trans. Software Eng..

[588]  A. K. Halder.  Karnaugh map extended to six or more variables , 1982 .

[589]  Masao Mukaidono,et al.  A necessary and sufficient condition for Lukasiewicz logic functions , 1996, Proceedings of 26th IEEE International Symposium on Multiple-Valued Logic (ISMVL'96).

[590]  Bernhard Thalheim,et al.  Towards a theory of consistency enforcement , 1999, Acta Informatica.

[591]  Jonathan S. Ostroff,et al.  Formal methods for the specification and design of real-time safety critical systems , 1992, J. Syst. Softw..

[592]  E. P. Schan,et al.  Recommended C Style and Coding Standards , 1997 .

[593]  Kishor S. Trivedi,et al.  Modeling Correlation in Software Recovery Blocks , 1993, IEEE Trans. Software Eng..

[594]  Bruno Tuffin,et al.  Rare events, splitting, and quasi-Monte Carlo , 2007, TOMC.

[595]  Bob Fields,et al.  Comparing design options for allocating communication media in cooperative safety-critical contexts: a method and a case study , 1999, TCHI.

[596]  Richard H. Thayer,et al.  System and Software Requirements Engineering , 1994 .

[597]  S. Louis Hakimi,et al.  On Path Cover Problems in Digraphs and Applications to Program Testing , 1979, IEEE Transactions on Software Engineering.

[598]  Rob J. Kusters,et al.  Identification of factors that influence defect injection and detection in development of software intensive products , 2007, Inf. Softw. Technol..

[599]  Paul J. Kühn,et al.  The Feature and Service Interaction Problem in Telecommunications Systems. A Survey , 1998, IEEE Trans. Software Eng..

[600]  Axel van Lamsweerde,et al.  Elaborating security requirements by construction of intentional anti-models , 2004, Proceedings. 26th International Conference on Software Engineering.

[601]  James H. Morris,et al.  Subgoal induction , 1977, CACM.

[602]  Matthias Felleisen,et al.  Program verification through soft typing , 1996, CSUR.

[603]  Swapna S. Gokhale,et al.  Effect of repair policies on software reliability , 1997, Proceedings of COMPASS '97: 12th Annual Conference on Computer Assurance.

[604]  M. J. Reilly,et al.  An investigation of the applicability of design of experiments to software testing , 2002, 27th Annual NASA Goddard/IEEE Software Engineering Workshop, 2002. Proceedings..

[605]  Jiang Guo.  Software reuse through re-engineering the legacy systems , 2003, Inf. Softw. Technol..

[606]  Poong-Hyun Seong,et al.  Experimental analysis of specification language diversity impact on NPP software diversity , 2002, J. Syst. Softw..

[607]  Victor R. Basili,et al.  A Pattern Recognition Approach for Software Engineering Data Analysis , 1992, IEEE Trans. Software Eng..

[608]  Elaine J. Weyuker,et al.  Predicting the location and number of faults in large software systems , 2005, IEEE Transactions on Software Engineering.

[609]  Kishor S. Trivedi.  SREPT: a tool for Software Reliability Estimation and Prediction , 2002, Proceedings International Conference on Dependable Systems and Networks.

[610]  Mayuram S. Krishnan,et al.  Measuring Process Consistency: Implications for Reducing Software Defects , 1999, IEEE Trans. Software Eng..

[611]  David Gries,et al.  The Science of Programming , 1981, Text and Monographs in Computer Science.

[612]  Bev Littlewood,et al.  Modeling software design diversity: a review , 2001, CSUR.

[613]  Axel van Lamsweerde,et al.  Handling Obstacles in Goal-Oriented Requirements Engineering , 2000, IEEE Trans. Software Eng..

[614]  Chung-Horng Lung,et al.  Applications of clustering techniques to software partitioning, recovery and restructuring , 2004, J. Syst. Softw..

[615]  Martin P. Robillard,et al.  Representing concerns in source code , 2007, TSEM.

[616]  Jim Alves-Foss,et al.  Hidden Implementation Dependencies in High Assurance and Critical Computing Systems , 2006, IEEE Transactions on Software Engineering.

[617]  M. D. Hansen.  Survey of available software-safety analysis techniques , 1989, Proceedings., Annual Reliability and Maintainability Symposium.

[618]  Jules Desharnais,et al.  Kleene under a Demonic Star , 2000, AMAST.

[619]  Nancy G. Leveson,et al.  Integrated safety analysis of requirements specifications , 2008, Requirements Engineering.

[620]  Richard H. Carver,et al.  Testing abstract distributed programs and their implementations: A constraint-based approach , 1996, J. Syst. Softw..

[621]  Marcelo d'Amorim,et al.  Delta Execution for Efficient State-Space Exploration of Object-Oriented Programs , 2007, IEEE Transactions on Software Engineering.

[622]  Yi Deng,et al.  Formally analyzing software architectural specifications using SAM , 2004, J. Syst. Softw..

[623]  Alexander L. Wolf,et al.  Acm Sigsoft Software Engineering Notes Vol 17 No 4 Foundations for the Study of Software Architecture , 2022 .

[624]  Chao Liu,et al.  Test criteria for context-free grammars , 2004, Proceedings of the 28th Annual International Computer Software and Applications Conference, 2004. COMPSAC 2004..

[625]  W. Kent Fuchs,et al.  Progressive retry for software error recovery in distributed systems , 1993, FTCS-23 The Twenty-Third International Symposium on Fault-Tolerant Computing.

[626]  D. Prasad,et al.  Dependability evaluation using a multi-criteria decision analysis procedure , 1999, Dependable Computing for Critical Applications 7.

[627]  Sy-Yen Kuo,et al.  Applying various learning curves to hyper-geometric distribution software reliability growth model , 1994, Proceedings of 1994 IEEE International Symposium on Software Reliability Engineering.

[628]  John Parker,et al.  Formal specification languages , 1986 .

[629]  Z. Koono,et al.  Structural Way of Thinking as Applied to Quality Assurance Management , 1990, IEEE J. Sel. Areas Commun..

[630]  Jeffrey M. Voas,et al.  Investigating rare-event failure tolerance: reductions in future uncertainty , 1996, Proceedings. IEEE High-Assurance Systems Engineering Workshop (Cat. No.96TB100076).

[631]  Chyan-Goei Chung,et al.  An enhanced zero-one optimal path set selection method , 1997, J. Syst. Softw..

[632]  A. Jefferson Offutt,et al.  Experimental results from an automatic test case generator , 1993, TSEM.

[633]  Stephen Norman,et al.  Software Testing Tools , 1993 .

[634]  Paolo Tonella,et al.  Using a Concept Lattice of Decomposition Slices for Program Understanding and Impact Analysis , 2003, IEEE Trans. Software Eng..

[635]  Timothy Lindquist,et al.  Synthesizing and integrating legacy components as services using adapters , 2006 .

[636]  Gerald M. Weinberg,et al.  Reviews, Walkthroughs, and Inspections , 1984, IEEE Transactions on Software Engineering.

[637]  A. Finkelstein,et al.  A comedy of errors: the London Ambulance Service case study , 1996, Proceedings of the 8th International Workshop on Software Specification and Design.

[638]  Aditya P. Mathur,et al.  Foundations of Software Testing , 2007 .

[639]  Michael L. Fredman,et al.  The AETG System: An Approach to Testing Based on Combinatiorial Design , 1997, IEEE Trans. Software Eng..

[640]  Hong Zhu,et al.  Software requirements validation via task analysis , 2002, J. Syst. Softw..

[641]  William E. Howden,et al.  Weak Mutation Testing and Completeness of Test Sets , 1982, IEEE Transactions on Software Engineering.

[642]  Liba Svobodova.  Performance monitoring in computer systems: a structured approach , 1981, OPSR.

[643]  Robert M. Hierons.  Comparing test sets and criteria in the presence of test hypotheses and fault domains , 2002, TSEM.

[644]  Barry W. Boehm,et al.  Software Engineering Economics , 1993, IEEE Transactions on Software Engineering.

[645]  Oded Berman,et al.  Reliability analysis of communicating recovery blocks , 1998 .

[646]  Sunghun Kim,et al.  Memories of bug fixes , 2006, SIGSOFT '06/FSE-14.

[647]  G. B. Finelli,et al.  Real-time software failure characterization , 1990, Fifth Annual Conference on Computer Assurance, Systems Integrity, Software Safety and Process Security..

[648]  Ravishankar K. Iyer,et al.  Analysis of large system black-box test data , 1992, [1992] Proceedings Third International Symposium on Software Reliability Engineering.

[649]  Dirk Beyer,et al.  Efficient relational calculation for software analysis , 2005, IEEE Transactions on Software Engineering.

[650]  Peter Wegner,et al.  Computation beyond turing machines , 2003, CACM.

[651]  Thomas W. Reps,et al.  Undecidability of context-sensitive data-dependence analysis , 2000, TOPL.

[652]  Henry Muccini,et al.  Using software architecture for code testing , 2004, IEEE Transactions on Software Engineering.

[653]  David Powell.  Failure mode assumptions and assumption coverage , 1992 .

[654]  Gregg Rothermel,et al.  On test suite composition and cost-effective regression testing , 2004, TSEM.

[655]  Jim Alves-Foss,et al.  A multi-layered approach to security in high assurance systems , 2004, 37th Annual Hawaii International Conference on System Sciences, 2004. Proceedings of the.

[656]  Henny B. Sipma,et al.  Non-linear loop invariant generation using Gröbner bases , 2004, POPL.

[657]  James M. Purtilo,et al.  A pattern-based object-linking mechanism for component-based software development environments , 1996, J. Syst. Softw..

[658]  Michal Young,et al.  Towards scalable compositional analysis by refactoring design models , 2003, ESEC/FSE-11.

[659]  Narasimhaiah Gorla,et al.  Evaluation of process tools in systems analysis , 1995, Inf. Softw. Technol..

[660]  D. Richard Kuhn,et al.  Software fault interactions and implications for software testing , 2004, IEEE Transactions on Software Engineering.

[661]  Patrick Cousot,et al.  A static analyzer for large safety-critical software , 2003, PLDI.

[662]  David Lee,et al.  Principles and methods of testing finite state machines-a survey , 1996, Proc. IEEE.

[663]  Sorin Lerner,et al.  Automated soundness proofs for dataflow analyses and transformations via local rules , 2005, POPL '05.

[664]  Elaine J. Weyuker,et al.  Provable Improvements on Branch Testing , 1993, IEEE Trans. Software Eng..

[665]  Nancy G. Leveson,et al.  Safety Analysis Using Petri Nets , 1987, IEEE Transactions on Software Engineering.

[666]  Nicholas C. K. Phillips.  Safe Data Type Specifications , 1984, IEEE Transactions on Software Engineering.

[667]  Kwangkeun Yi,et al.  An uncaught exception analysis for Java , 2004, J. Syst. Softw..

[668]  Martin von Mohrenschildt.  Algebraic Composition of Function Tables , 2000, Formal Aspects of Computing.

[669]  Austen Rainer,et al.  A quantitative and qualitative analysis of factors affecting software processes , 2003, J. Syst. Softw..

[670]  Zhi-Hua Zhou,et al.  Using neural networks for fault diagnosis , 2000, Proceedings of the IEEE-INNS-ENNS International Joint Conference on Neural Networks. IJCNN 2000. Neural Computing: New Challenges and Perspectives for the New Millennium.

[671]  L. Camarinopoulos,et al.  Two formulas for computing the reliability of incomplete k-out-of-n:G systems , 1997 .

[672]  Egon Börger,et al.  Abstract State Machines , 2003 .

[673]  Yuanyuan Zhou,et al.  Rx: treating bugs as allergies---a safe method to survive software failures , 2005, SOSP '05.

[674]  Bharat K. Bhargava,et al.  Experimental evaluation of concurrent checkpointing and rollback-recovery algorithms , 1990, [1990] Proceedings. Sixth International Conference on Data Engineering.

[675]  Jeff Tian,et al.  Tool support for software measurement, analysis and improvement , 1997, J. Syst. Softw..

[676]  Alexander Birman,et al.  A Problem-Reduction Approach to Proving Simulation Between Programs , 1976, IEEE Transactions on Software Engineering.

[677]  J. C. Huang.  A New Verification Rule and Its Applications , 1980, IEEE Transactions on Software Engineering.

[678]  Joseph Kee-Yin Ng,et al.  Generating test cases from class vectors , 2003, J. Syst. Softw..

[679]  Jane Cleland-Huang,et al.  Goal-Centric Traceability: Using Virtual Plumblines to Maintain Critical Systemic Qualities , 2008, IEEE Transactions on Software Engineering.

[680]  Thomas E. Royce,et al.  A parallel algorithm for DNA alignment , 2003, CROS.

[681]  R. W. Selby,et al.  Empirically based analysis of failures in software systems , 1990 .

[682]  Ingunn Myrtveit,et al.  Reliability and validity in comparative studies of software prediction models , 2005, IEEE Transactions on Software Engineering.

[683]  Edward N. Bachelder,et al.  Describing and Probing Complex System Behavior: A Graphical Approach , 2001 .

[684]  Angelo Gargantini,et al.  Automated deductive requirements analysis of critical systems , 2001, TSEM.

[685]  Panayiotis E. Pintelas,et al.  Comparative study and categorization of high-level petri nets , 1998, J. Syst. Softw..

[686]  Junfeng Yang,et al.  An empirical study of operating systems errors , 2001, SOSP.

[687]  Danny De Schreye,et al.  Constraint-based termination analysis of logic programs , 1999, TOPL.

[688]  Saurabh Sinha,et al.  Analysis and Testing of Programs with Exception Handling Constructs , 2000, IEEE Trans. Software Eng..

[689]  Ron Patton,et al.  Software Testing , 2000 .

[690]  Marek Vokác.  Defect frequency and design patterns: an empirical study of industrial code , 2004, IEEE Transactions on Software Engineering.

[691]  Barbara A. Kitchenham,et al.  Critical review of quantitative assessment , 1994, Softw. Eng. J..

[692]  Brian Henderson-Sellers,et al.  A conceptual model of cognitive complexity of elements of the programming process , 1995, Inf. Softw. Technol..

[693]  Laurie A. Williams,et al.  On the value of static analysis for fault detection in software , 2006, IEEE Transactions on Software Engineering.

[694]  Robert Wahbe,et al.  Efficient software-based fault isolation , 1994, SOSP '93.

[695]  Patrice Godefroid,et al.  Dynamic partial-order reduction for model checking software , 2005, POPL '05.

[696]  S.P. Levitt.  C++: an evolving language , 2004, 2004 IEEE Africon. 7th Africon Conference in Africa (IEEE Cat. No.04CH37590).

[697]  Praerit Garg,et al.  Investigating coverage-reliability relationship and sensitivity of reliability to errors in the operational profile , 1994, Proceedings of 1994 1st International Conference on Software Testing, Reliability and Quality Assurance (STRQA'94).

[698]  Rajeev Alur,et al.  Deciding Global Partial-Order Properties , 1998, Formal Methods Syst. Des..

[699]  Alberto Pettorossi,et al.  A theory of totally correct logic program transformations , 2004, PEPM '04.

[700]  Kenneth A. Foster.  Error Sensitive Test Cases Analysis (ESTCA) , 1980, IEEE Transactions on Software Engineering.

[701]  Antonella Santone,et al.  Heuristic Search + Local Model Checking in Selective mu-Calculus , 2003, IEEE Trans. Software Eng..

[702]  Jiong Yang,et al.  Discovering Neglected Conditions in Software by Mining Dependence Graphs , 2008, IEEE Transactions on Software Engineering.

[703]  Alexander Egyed,et al.  A Scenario-Driven Approach to Trace Dependency Analysis , 2003, IEEE Trans. Software Eng..

[704]  A.M. Stavely.  Verifying Definite Iteration Over Data Structures , 1995, IEEE Trans. Software Eng..

[705]  Elaine J. Weyuker,et al.  An Applicable Family of Data Flow Testing Criteria , 1988, IEEE Trans. Software Eng..

[706]  Jeff Tian.  Measurement and continuous improvement of software reliability throughout software life-cycle , 1999, J. Syst. Softw..

[707]  Ajoy Kumar Datta,et al.  Self-Stabilizing Algorithms in DAG Structured Networks , 1999, Parallel Process. Lett..

[708]  Nancy G. Leveson,et al.  The Consistent Comparison Problem in N-Version Software , 1989, IEEE Trans. Software Eng..

[709]  Peter G. Neumann,et al.  On hierarchical design of computer systems for critical applications , 1986, IEEE Transactions on Software Engineering.

[710]  Kishor S. Trivedi,et al.  Non-Markovian Petri nets , 1995, SIGMETRICS '95/PERFORMANCE '95.

[711]  Salwa K. Abd-El-Hafiz,et al.  A method for documenting code components , 1996, J. Syst. Softw..

[712]  Nancy G. Leveson,et al.  An Empirical Comparison of Software Fault Tolerance and Fault Elimination , 1991, IEEE Trans. Software Eng..

[713]  Willard L. Miranker,et al.  Computer arithmetic in theory and practice , 1981, Computer science and applied mathematics.

[714]  Barton P. Miller,et al.  An empirical study of the reliability of UNIX utilities , 1990, Commun. ACM.

[715]  Yinong Chen.  Modelling software operational reliability via input domain-based reliability growth model , 1998, Digest of Papers. Twenty-Eighth Annual International Symposium on Fault-Tolerant Computing (Cat. No.98CB36224).

[716]  Michael R. Lyu,et al.  Applying reliability models more effectively (software) , 1992, IEEE Software.

[717]  Ivan A. Sag,et al.  Syntactic Theory: A Formal Introduction , 1999, Computational Linguistics.

[718]  Chao Liu,et al.  A Systematic Study of Failure Proximity , 2008, IEEE Transactions on Software Engineering.

[719]  Pavel Naumov,et al.  Logic of subtyping , 2006, Theor. Comput. Sci..

[720]  Danny De Schreye,et al.  Termination proofs for logic programs with tabling , 2001, TOCL.

[721]  Khaled El Emam,et al.  The repeatability of code defect classifications , 1998, Proceedings Ninth International Symposium on Software Reliability Engineering (Cat. No.98TB100257).

[722]  Rutger M. Dijkstra.  Computation calculus bridging a formalization gap , 2000, Sci. Comput. Program..

[723]  Art Lew.  On the emulation of flowcharts by decision tables , 1982, CACM.

[724]  Lanfranco Lopriore,et al.  Abstraction Mechanisms for Event Control in Program Debugging , 1989, IEEE Trans. Software Eng..

[725]  Richard G. Hamlet,et al.  Partition Testing Does Not Inspire Confidence , 1990, IEEE Trans. Software Eng..

[726]  Cormac Flanagan,et al.  Predicate abstraction for software verification , 2002, POPL '02.

[727]  Shanker Sanyal,et al.  Defect tracking and reliability modeling for a new product release , 1992, CASCON.

[728]  John C. Cherniavsky,et al.  Validation, Verification, and Testing of Computer Software , 1982, CSUR.

[729]  Elaine J. Weyuker,et al.  Testing software to detect and reduce risk , 2000, J. Syst. Softw..

[730]  Chadd C. Williams,et al.  Automatic mining of source code repositories to improve bug finding techniques , 2005, IEEE Transactions on Software Engineering.

[731]  Qinbao Song,et al.  Software defect association mining and defect correction effort prediction , 2006 .

[732]  Audris Mockus,et al.  Understanding the sources of variation in software inspections , 1998, TSEM.

[733]  Madeline Diep,et al.  Profiling deployed software: assessing strategies and testing opportunities , 2005, IEEE Transactions on Software Engineering.

[734]  Ming Zhao,et al.  A comparison between software design and code metrics for the prediction of software fault content , 1998, Inf. Softw. Technol..

[735]  F. A. van der Duyn Schouten,et al.  Modelling the influence of preventive maintenance on protection system reliability performance , 1998 .

[736]  Jeffrey D. Ullman,et al.  Analysis of a simple algorithm for global data flow problems , 1973, POPL.

[737]  Patrick Cousot,et al.  Types as abstract interpretations , 1997, POPL '97.

[738]  H. Lewis Chau,et al.  Algorithms for Constructing Minimal Deduction Graphs , 1989, IEEE Trans. Software Eng..

[739]  Nancy G. Leveson,et al.  Software Deviation Analysis , 1997, Proceedings of the (19th) International Conference on Software Engineering.

[740]  P. Boland,et al.  Component redundancy vs system redundancy in the hazard rate ordering , 1995 .

[741]  Lee J. White,et al.  Experiments determining best paths for testing computer program predicates , 1985, ICSE '85.

[742]  Yves Deville,et al.  Automatic test data generation for programs with integer and float variables , 2001, Proceedings 16th Annual International Conference on Automated Software Engineering (ASE 2001).

[743]  Rami G. Melhem,et al.  A Nonpreemptive Real-Time Scheduler with Recovery from Transient Faults and Its Implementation , 2003, IEEE Trans. Software Eng..

[744]  Yanping Chen,et al.  Effective test metrics for test strategy evolution , 2004, CASCON.

[745]  Peter G. Neumann.  Illustrative risks to the public in the use of computer systems and related technology , 1992, SOEN.

[746]  Robyn R. Lutz.  Targeting safety-related errors during software requirements analysis , 1993, SIGSOFT '93.

[747]  Shmuel Katz,et al.  A superimposition control construct for distributed systems , 1993, TOPL.

[748]  Mladen A. Vouk,et al.  Some issues in multi-phase software reliability modeling , 1993, CASCON.

[749]  Hareton K. N. Leung.  Selective regression testing - assumptions and fault detecting ability , 1995, Inf. Softw. Technol..

[750]  Norman F. Schneidewind,et al.  An Experiment in Software Error Data Collection and Analysis , 1979, IEEE Transactions on Software Engineering.

[751]  Yuanyuan Zhou,et al.  CP-Miner: finding copy-paste and related bugs in large-scale software code , 2006, IEEE Transactions on Software Engineering.

[752]  Marc Eisenstadt,et al.  My hairiest bug war stories , 1997, CACM.

[753]  Ian G. Harris,et al.  A domain coverage metric for the validation of behavioral VHDL descriptions , 2000, Proceedings International Test Conference 2000 (IEEE Cat. No.00CH37159).

[754]  Tsong Yueh Chen,et al.  Test case selection with and without replacement , 2000, Inf. Sci..

[755]  Neeraj Suri,et al.  PROPANE: an environment for examining the propagation of errors in software , 2002, ISSTA '02.

[756]  A. Jefferson Offutt,et al.  Investigations of the software testing coupling effect , 1992, TSEM.