DOCSLIB.ORG

Assertion and Exception Techniques Can Aid in Class Correctness

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Assertion and Exception Techniques Can Aid in Class Correctness Writing Correct Software Assertion and exception techniques can aid in class correctness Bertrand Meyer y aim in designing Eiffel was barring the occurrence of a major ca­ to produce a major program­ tastrophe resulting from faulty software, ming language for the 1990s, sooner or later someone will call the catering to the needs of those software engineers' bluff and ask them . software engineers willing to exactly why they think their systems Mdo what it takes to produce high-qual­ will perform as announced. It is diffi­ ity software. A key aspect of Eiffel, cult to answer that question convinc­ which makes it original in the world ingly given the current state of the art. of object-oriented languages, and in Eiffel won't provide the magical key the world of programming languages to the kingdom of software reliability. at large, is its strong emphasis on tech­ No existing method or tools wilL I do niques that help produce highly reli­ believe, however, that the EiffeI tech­ able software. niques are an impOItant step in the Although, there are many more as­ right direction. pects to Eiffel (including those described If you are expecting a sermon wliing in my book Object-Oriented Software you to improve your software's reli­ Construction, Prentice-Hall, 1988) the ability by adding a lot of consistency reliability features deserve a presenta­ checks, you are in for a few surprises. tion of their own. That is the focus of I suggest that one should llstl:.tlly check this article. I will show how it is possi­ less. According to conventional soft­ ble to write software that programmers ware engineering wisdom, "dett.>I1sive . (and users) can place a much higher programming" is considered to be a degree of confidence in than that writ­ programmer's best shot at reliability. I ten with traditional techniques. In par­ flexible software that is easy to build believe that defensive programming is ticular, I will discuss the all important and easy to maintain, but we also need a dangerow; practice that defeats the notion of assertion - the specification to be concerned that the software does velY purpose it tries to achieve. To element included within the software what it is supposed to do. program defen!'iively i!'i one of the worst itself. This will lead to a systematic From reading most of the object­ pieces of advice thm can be given to a view of exception handling, and a look oriented literature, one would think this programmer. at techniques (such as those offered is not a problem. Correctness concerns That more checking l'ttr1 make soft­ by Ada) that I find somewhat unsafe. are hardly ever mentioned. Actually, it ware less reliable may seem foolish. is unfair just to pick on object-oriented Remember, though, that in science cmu­ Why All the Fuss? programming. Take any standard text­ mon sense is not al\vays the best gUide. The issue is simple. It is great to have books you have on programming, al­ If YOli have ever hit a \\'(}otk~n table gorithms, data structures, and similar with your fist, you probably found it Bertrand is the preSident ofInteractive topics. See how many of them list "cor­ hard to believe rhe physics protf.:ssur Software Engineering and is the main rectness," "reliability," "invariant," or who told you rhar mattl'r is a !'et Df tiny designer ofthe Eiffellanguage. His book, "assertion" in their indexes. I have quite atoms with mostly nothing in-IX'twt,'(.~n. Object-Oriented Software Construction, a few textbooks on my shelves, but waspublished by Prentice Hall in 1988. could not find many that passed this Expressing the Specification He can be reached at 805-685-1006, simple test. 111e ideas that hdp achieve corr(.·t'ml';~s.s or through e-mail as Bertrand at This apparent disregard for correct­ in EitTd are mtK~h ()kk~r than EithA it,· Eiffel.com. ness issues cannot last forever. Even (continued Wl!UIJ{{' 52} 48 < EIFFEL (continued from page 48) ware element is correct or incorrect per may still publish the manuscript, but self. They come from work on program se; it is correct or incorrect only con­ does not have to. The situation is out­ proving and fonnal specification. Oddly cerning a particular specification, or side of the contract's bounds. enough, research on these topics has statement of its purpose. Correct ele­ remained estranged from most "real­ ments cannot be written unless the time Routine as Contract world" software development. Part of is taken to express all or part of this Specifying a routine is based on the the reason, at least in the United States, specification. transposition of these observations to is the widespread view that fonnal speci­ Writing the specification will not guar­ software. First, we need the equivalent fication and verification are specialized antee that it is met. But the presence of the contract document. It bewilders research topics whose application is of a specification, even one that is only me that no such concept exists in stan­ mostly relevant to "mission-critical" soft­ partially spelled out, goes a surpris­ dard approaches to software construc­ ware. Correctness, however, should be ingly long way toward helping pro­ tion. a universal concern. Eiffellooked at speci­ duce elements that satisfy their correct­ The specification consists of two fication and verification work to see ness requirements. parts: how much of it could be made part of This idea was captured by the title a standard programming methodology. of an article by Harlan Mills, then of • The precondition of a routine states Eiffel is a production language and IBM, published in 1975: "How to Write the obligations of clients, which are environment. It is not a research vehi­ Correct Programs and Know Why." If also the benefits for the routine itself. cle. Eiffel relies on the technology of you are a serious software engineer, • The postcondition states the obliga­ the last part of the twentieth century. you don't just want to hope that your tions of the routine, which are also It has to work now. This means that no programs are correct because you have the benefits for the clients. miracles can be expected. In fact, the been careful, and done a lot of testing, techniques are modest and almost naive. and so on. You need precise argu­ The precondition is a set of initial con­ They are the result of an engineering ments that document the correctness ditions under which the routine oper­ trade-off between what is desirable in of your software. ates. Ensuring the precondition at the an ideal world and what can realisti­ In Eiffel, such arguments are ex­ time of any call to the routine is the cally be implemented today. But they pressed as assertions -:- elements of for­ clients' responsibility. make a big difference and I can't un­ mal specification that can be attached The postcondition is a set of final derstand why no widespread language, to software components, classes and conditions the routine is expected to other than Eiffel, has made any signifi­ their routines. ensure. Ensuring the postcondition at. cant attempt in a similar direction. return time (if the precondition was The basic idea is rather trivial. Cor­ The Contract met on entry) is the routine's responsi­ rectness is a relative notion. No soft- Let's look at routines first. A routine is bility. the description of some computation The concept of a contract is one of the on the instances of a class, made avail­ most useful aids to understanding Eif­ able by that class to its clients (to other fel programming. The role of contracts Bring in manuscript Get published telC! classes relying on its services). How in Eiffel can be compared to what mes­ before March 1st before May 1st do we specify the purpose of a routine? sage passing represents in Smalltalk. The view I find most helpful is that Publish before No need to do Figure 3 illustrates this idea. The func­ May 1st anything if no a routine provides clients with a way tion intersect1 in a class CIRCIE (as­ manuscript is received before to contract out for a certain task that sumed to be part of some graphic pack­ March 1st the client's designer finds advantageous age) returns one of the two intersecting not to implement within the text of the points of two circles (see Figure 2). client. This is the same way that we We will look at how to associate the Figure 1: Contract between a humans at times contract out for part precondition and the postcondition to publisher and an author or all of a task that we need to perfonn. the text of the function in the actual Human contracts have two impor­ Eiffel class. In this example: tant properties: • The precondition is that the two rec­ • Each party expects some benefits and tangles should intersect. is prepared to incur some obligations • The postcondition is that the function in return. What is an obligation for result is a point that is on both circles. one party is a benefit for the other. • The obligations and benefits are Contract Variants spelled out in a contract document. This is not the only possible specifica­ Figure 2: Circle intersection tion. Programmers may feel uneasy Figure 1 illustrates an example of a about the just mentioned "demanding" contract between a publisher and an fonn of the routine, which only works Obligations Benefits author. The author's obligation is to in some cases. Instead, a tolerant ver­ Client Call the routine on ObtaIn as result of bring in a manuscript before March 1st.
Load more

Recommended publications
  • Génération Automatique De Tests Unitaires Avec Praspel, Un Langage De Spécification Pour PHP the Art of Contract-Based Testing in PHP with Praspel
    CORE Metadata, citation and similar papers at core.ac.uk Provided by HAL - Université de Franche-Comté G´en´erationautomatique de tests unitaires avec Praspel, un langage de sp´ecificationpour PHP Ivan Enderlin To cite this version: Ivan Enderlin. G´en´eration automatique de tests unitaires avec Praspel, un langage de sp´ecificationpour PHP. Informatique et langage [cs.CL]. Universit´ede Franche-Comt´e,2014. Fran¸cais. <NNT : 2014BESA2067>. <tel-01093355v2> HAL Id: tel-01093355 https://hal.inria.fr/tel-01093355v2 Submitted on 19 Oct 2016 HAL is a multi-disciplinary open access L'archive ouverte pluridisciplinaire HAL, est archive for the deposit and dissemination of sci- destin´eeau d´ep^otet `ala diffusion de documents entific research documents, whether they are pub- scientifiques de niveau recherche, publi´esou non, lished or not. The documents may come from ´emanant des ´etablissements d'enseignement et de teaching and research institutions in France or recherche fran¸caisou ´etrangers,des laboratoires abroad, or from public or private research centers. publics ou priv´es. Thèse de Doctorat école doctorale sciences pour l’ingénieur et microtechniques UNIVERSITÉ DE FRANCHE-COMTÉ No X X X THÈSE présentée par Ivan Enderlin pour obtenir le Grade de Docteur de l’Université de Franche-Comté K 8 k Génération automatique de tests unitaires avec Praspel, un langage de spécification pour PHP The Art of Contract-based Testing in PHP with Praspel Spécialité Informatique Instituts Femto-ST (département DISC) et INRIA (laboratoire LORIA) Soutenue publiquement
    [Show full text]
  • Assertions, Pre/Post- Conditions and Invariants
    9/14/12 Assertions, pre/post- conditions and invariants Section 2.1 in Walls and Mirrors Section 4.5 Rosen Programming as a contract n Specifying what each method does q Specify it in a comment before method's header n Precondition q What is assumed to be true before the method is executed q Caller obligation n Postcondition q Specifies what will happen if the preconditions are met q Method obligation 1 9/14/12 Class Invariants n A class invariant is a condition that all objects of that class must satisfy while it can be observed by clients n What about Points in Cloud? q boundaries? q center? What is an assertion? n An assertion is a statement that says something about the state of your program n Should be true if there are no mistakes in the program //n == 1 while (n < limit) { n = 2 * n; } // what could you state here? 2 9/14/12 What is an assertion? n An assertion is a statement that says something about the state of your program n Should be true if there are no mistakes in the program //n == 1 while (n < limit) { n = 2 * n; } //n >= limit //more? What is an assertion? n An assertion is a statement that says something about the state of your program n Should be true if there are no mistakes in the program //n == 1 while (n < limit) { n = 2 * n; } //n >= limit //n is the smallest power of 2 >= limit 3 9/14/12 assert Using assert: assert n == 1; while (n < limit) { n = 2 * n; } assert n >= limit; When to use Assertions n We can use assertions to guarantee the behavior.
    [Show full text]
  • Chapter 23 Three Design Principles
    23 Three Design Principles Chapter 23 ContaxT / Kodax Tri-X Nunnery — Chichen Itza, Mexico Three Design Principles Learning Objectives • List the preferred characteristics of an object-oriented application architecture • State the definition of the Liskov Substitution Principle (LSP) • State the definition of Bertrand Meyer's Design by Contract (DbC) programming • Describe the close relationship between the Liskov Substitution Principle and Design by Contract • State the purpose of class invariants • State the purpose of method preconditions and postconditions • Describe the effects weakening and strengthening preconditions have on subclass behavior • Describe the effects weakening and strengthening postconditions have on subclass behavior • State the purpose and use of the Open-Closed Principle (OCP) • State the purpose and use of the Dependency Inversion Principle (DIP) • State the purpose of Code Contracts and how they are used to enforce preconditions, postconditions, and class invariants C# For Artists © 2015 Rick Miller and Pulp Free Press — All Rights Reserved 757 Introduction Chapter 23: Three Design Principles Introduction Building complex, well-behaved, object-oriented software is a difficult task for several reasons. First, simply programming in C# does not automatically make your application object-oriented. Second, the pro- cess by which you become proficient at object-oriented design and programming is characterized by expe- rience. It takes a lot of time to learn the lessons of bad software architecture design and apply those lessons learned to create good object-oriented architectures. The objective of this chapter is to help you jump-start your object-oriented architectural design efforts. I begin with a discussion of the preferred characteristics of a well-designed object-oriented architecture.
    [Show full text]
  • Grammar-Based Testing Using Realistic Domains in PHP Ivan Enderlin, Frédéric Dadeau, Alain Giorgetti, Fabrice Bouquet
    Grammar-Based Testing using Realistic Domains in PHP Ivan Enderlin, Frédéric Dadeau, Alain Giorgetti, Fabrice Bouquet To cite this version: Ivan Enderlin, Frédéric Dadeau, Alain Giorgetti, Fabrice Bouquet. Grammar-Based Testing using Realistic Domains in PHP. A-MOST 2012, 8th Workshop on Advances in Model Based Testing, joint to the ICST’12 IEEE Int. Conf. on Software Testing, Verification and Validation, Jan 2012, Canada. pp.509–518. hal-00931662 HAL Id: hal-00931662 https://hal.archives-ouvertes.fr/hal-00931662 Submitted on 16 Jan 2014 HAL is a multi-disciplinary open access L’archive ouverte pluridisciplinaire HAL, est archive for the deposit and dissemination of sci- destinée au dépôt et à la diffusion de documents entific research documents, whether they are pub- scientifiques de niveau recherche, publiés ou non, lished or not. The documents may come from émanant des établissements d’enseignement et de teaching and research institutions in France or recherche français ou étrangers, des laboratoires abroad, or from public or private research centers. publics ou privés. Grammar-Based Testing using Realistic Domains in PHP Ivan Enderlin, Fred´ eric´ Dadeau, Alain Giorgetti and Fabrice Bouquet Institut FEMTO-ST UMR CNRS 6174 - University of Franche-Comte´ - INRIA CASSIS Project 16 route de Gray - 25030 Besanc¸on cedex, France Email: fivan.enderlin,frederic.dadeau,alain.giorgetti,[email protected] Abstract—This paper presents an integration of grammar- Contract-based testing [5] has been introduced in part to based testing in a framework for contract-based testing in PHP. address these limitations. It is based on the notion of Design It relies on the notion of realistic domains, that make it possible by Contract (DbC) [6] introduced by Meyer with Eiffel [7].
    [Show full text]
  • Design by Contract: the Lessons of Ariane
    . Editor: Bertrand Meyer, EiffelSoft, 270 Storke Rd., Ste. 7, Goleta, CA 93117; voice (805) 685-6869; [email protected] several hours (at least in earlier versions of Ariane), it was better to let the computa- tion proceed than to stop it and then have Design by to restart it if liftoff was delayed. So the SRI computation continues for 50 seconds after the start of flight mode—well into the flight period. After takeoff, of course, this com- Contract: putation is useless. In the Ariane 5 flight, Object Technology however, it caused an exception, which was not caught and—boom. The exception was due to a floating- point error during a conversion from a 64- The Lessons bit floating-point value, representing the flight’s “horizontal bias,” to a 16-bit signed integer: In other words, the value that was converted was greater than what of Ariane can be represented as a 16-bit signed inte- ger. There was no explicit exception han- dler to catch the exception, so it followed the usual fate of uncaught exceptions and crashed the entire software, hence the onboard computers, hence the mission. This is the kind of trivial error that we Jean-Marc Jézéquel, IRISA/CNRS are all familiar with (raise your hand if you Bertrand Meyer, EiffelSoft have never done anything of this sort), although fortunately the consequences are usually less expensive. How in the world everal contributions to this made up of respected experts from major department have emphasized the European countries, which produced a How in the world could importance of design by contract report in hardly more than a month.
    [Show full text]
  • Contracts for Concurrency Piotr Nienaltowski, Bertrand Meyer, Jonathan S
    Contracts for concurrency Piotr Nienaltowski, Bertrand Meyer, Jonathan S. Ostroff To cite this version: Piotr Nienaltowski, Bertrand Meyer, Jonathan S. Ostroff. Contracts for concurrency. Formal Aspects of Computing, Springer Verlag, 2008, 21 (4), pp.305-318. 10.1007/s00165-007-0063-2. hal-00477897 HAL Id: hal-00477897 https://hal.archives-ouvertes.fr/hal-00477897 Submitted on 30 Apr 2010 HAL is a multi-disciplinary open access L’archive ouverte pluridisciplinaire HAL, est archive for the deposit and dissemination of sci- destinée au dépôt et à la diffusion de documents entific research documents, whether they are pub- scientifiques de niveau recherche, publiés ou non, lished or not. The documents may come from émanant des établissements d’enseignement et de teaching and research institutions in France or recherche français ou étrangers, des laboratoires abroad, or from public or private research centers. publics ou privés. DOI 10.1007/s00165-007-0063-2 BCS © 2007 Formal Aspects Formal Aspects of Computing (2009) 21: 305–318 of Computing Contracts for concurrency Piotr Nienaltowski1, Bertrand Meyer2 and Jonathan S. Ostroff3 1 Praxis High Integrity Systems Limited, 20 Manvers Street, Bath BA1 1PX, UK E-mail: [email protected] 2 ETH Zurich, Zurich, Switzerland 3 York University, Toronto, Canada Abstract. The SCOOP model extends the Eiffel programming language to provide support for concurrent programming. The model is based on the principles of Design by Contract. The semantics of contracts used in the original proposal (SCOOP 97) is not suitable for concurrent programming because it restricts parallelism and complicates reasoning about program correctness. This article outlines a new contract semantics which applies equally well in concurrent and sequential contexts and permits a flexible use of contracts for specifying the mutual rights and obligations of clients and suppliers while preserving the potential for parallelism.
    [Show full text]
  • Implementing Closures in Dafny Research Project Report
    Implementing Closures in Dafny Research Project Report • Author: Alexandru Dima 1 • Total number of pages: 22 • Date: Tuesday 28th September, 2010 • Location: Z¨urich, Switzerland 1E-mail: [email protected] Contents 1 Introduction 1 2 Background 1 2.1 Closures . .1 2.2 Dafny . .2 3 General approach 3 4 Procedural Closures 5 4.1 Procedural Closure Type . .5 4.2 Procedural Closure Specifications . .6 4.3 A basic procedural closure example . .6 4.3.1 Discussion . .6 4.3.2 Boogie output . .8 4.4 A counter factory example . 13 4.5 Delegation example . 17 5 Pure Closures 18 5.1 Pure Closure Type . 18 5.2 A recursive while . 19 6 Conclusions 21 6.1 Limitations . 21 6.2 Possible extensions . 21 6.3 Acknowledgments . 21 2 BACKGROUND 1 Introduction Closures represent a particularly useful language feature. They provide a means to keep the functionality linked together with state, providing a source of ex- pressiveness, conciseness and, when used correctly, give programmers a sense of freedom that few other language features do. Smalltalk's standard control structures, including branches (if/then/else) and loops (while and for) are very good examples of using closures, as closures de- lay evaluation; the state they capture may be used as a private communication channel between multiple closures closed over the same environment; closures may be used for handling User Interface events; the possibilities are endless. Although they have been used for decades, static verification has not yet tack- led the problems which appear when trying to reason modularly about closures.
    [Show full text]
  • Study on Eiffel
    Study on Eiffel Jie Yao Anurag Katiyar May 11, 2008 Abstract This report gives an introduction to Eiffel, an object oriented language. The objective of the report is to draw the attention of the reader to the salient features of Eiffel. The report explains some of these features in brief along with language syntax. The report includes some code snippets that were written in the process of learning Eiffel. Some of the more detailed tutorials, books and papers on Eiffel can be found at www.eiffel.com 1 Contents 1 Introduction 3 2 Eiffel Constructs and Grammar 3 2.1 ”Hello World” . 3 2.2 Data Types . 3 2.3 Classes . 3 2.4 Libraries . 4 2.5 Features . 4 2.6 Class relations and hierarchy . 4 2.7 Inheritance . 4 2.8 Genericity . 5 2.9 Object Creation . 5 2.10 Exceptions . 6 2.11 Agents and Iteration . 6 2.12 Tuples . 6 2.13 Typing . 6 2.14 Scope . 7 2.15 Memory Management . 7 2.16 External software . 7 3 Fundamental Properties 7 3.1 ”Has” Properties . 8 3.2 ”Has no” Properties . 9 4 Design principles in Eiffel 10 4.1 Design by Contract . 10 4.2 Command Query Separation . 11 4.3 Uniform Access Principle . 11 4.4 Single Choice Principle . 11 5 Compilation Process in Eiffel 11 6 Exception Handling in the compiler 12 7 Garbage Collection for Eiffel 12 7.1 Garbage Collector Structure . 12 7.2 Garbage Collector in Action . 13 8 Eiffel’s approach to typing 13 8.1 Multiple inheritance .
    [Show full text]
  • 3. Design by Contract
    3. Design by Contract Oscar Nierstrasz Design by Contract Bertrand Meyer, Touch of Class — Learning to Program Well with Objects and Contracts, Springer, 2009. 2 Bertrand Meyer is a French computer scientist who was a Professor at ETH Zürich (successor of Niklaus Wirth) from 2001-2015. He is best known as the inventor of “Design by Contract”, and as the designer of the Eiffel programming language, which provides built-in for DbC. DbC was first described in a technical report by Meyer in 1986: https://en.wikipedia.org/wiki/Design_by_contract Who’s to blame? The components fit but the system does not work. Who’s to blame? The component developer or the system integrator? 3 DbC makes clear the “contract” between a supplier (an object or “component”) and its client. When something goes wrong, the contract states whose fault it is. This simplifies both design and debugging. Why DbC? > Design by Contract —documents assumptions (what do objects expect?) —simplifies code (no special actions for failure) —aids debugging (identifies who’s to blame) 4 As we shall see, DbC improves your OO design in several ways. First, contracts make explicit the assumptions under which an object (supplier) will work correctly. Second, they simplify your code, since no special action is required when things go wrong — the exception handling framework provides the necessary tools. Third, contracts help in debugging since errors are caught earlier, when contracts are violated, not when your program crashes because of an invalid state, and it is clear where to lay the blame for the violation (i.e., in the object or its client).
    [Show full text]
  • Verification of Object Oriented Programs Using Class Invariants
    Verification of Object Oriented Programs Using Class Invariants Kees Huizing and Ruurd Kuiper and SOOP?? Eindhoven University of Technology, PO Box 513, 5600 MB Eindhoven, The Netherlands, [email protected], [email protected] Abstract A proof system is presented for the verification and derivation of object oriented pro- grams with as main features strong typing, dynamic binding, and inheritance. The proof system is inspired on Meyer’s system of class invariants [12] and remedies its unsound- ness, which is already recognized by Meyer. Dynamic binding is treated in a flexible way: when throughout the class hierarchy overriding methods respect the pre- and post- conditions of the overridden methods, very simple proof rules for method calls suffice; more powerful proof rules are supplied for cases where one cannot or does not want to follow this restriction. The proof system is complete relative to proofs for properties of pointers and the data domain. 1 Introduction Although formal verification is not very common in the discipline of object oriented programming, the importance of formal specification is generally ac- knowledged ([12]). With the increased interest in component based develop- ment, it becomes even more important that components are specified in an un- ambiguous manner, since users or buyers of components often have no other knowledge about a component than its specification and at the same time rely heavily on its correct functioning in their framework. The specification of a class, sometimes called contract, usually contains at least pre- and postcondi- tions for the public mehtods and a class invariant. A class invariant expresses which states of the objects of the class are consis- tent, or “legal”.
    [Show full text]
  • You Say 'JML' ? Wikipedia (En)
    You say 'JML' ? Wikipedia (en) PDF generated using the open source mwlib toolkit. See http://code.pediapress.com/ for more information. PDF generated at: Mon, 06 Jan 2014 09:58:42 UTC Contents Articles Java Modeling Language 1 Design by contract 5 Formal methods 10 References Article Sources and Contributors 15 Image Sources, Licenses and Contributors 16 Article Licenses License 17 Java Modeling Language 1 Java Modeling Language The Java Modeling Language (JML) is a specification language for Java programs, using Hoare style pre- and postconditions and invariants, that follows the design by contract paradigm. Specifications are written as Java annotation comments to the source files, which hence can be compiled with any Java compiler. Various verification tools, such as a runtime assertion checker and the Extended Static Checker (ESC/Java) aid development. Overview JML is a behavioural interface specification language for Java modules. JML provides semantics to formally describe the behavior of a Java module, preventing ambiguity with regard to the module designers' intentions. JML inherits ideas from Eiffel, Larch and the Refinement Calculus, with the goal of providing rigorous formal semantics while still being accessible to any Java programmer. Various tools are available that make use of JML's behavioral specifications. Because specifications can be written as annotations in Java program files, or stored in separate specification files, Java modules with JML specifications can be compiled unchanged with any Java compiler. Syntax JML specifications are added to Java code in the form of annotations in comments. Java comments are interpreted as JML annotations when they begin with an @ sign.
    [Show full text]
  • Precondition Enforcement Analysis for Quality Assurance
    Precondition Enforcement Analysis for Quality Assurance Nadja Beeli Submitted to the degree of Master of Science ETH in Computer Science Supervised by Prof. Dr. Bertrand Meyer and Dr. Karine Arnout April - October 2004 Abstract The crash of Ariane 5 dramatically showed the importance of correctness in software and that the goal to produce reliable software has not yet been achieved. Therefore, this master thesis targets the development of a static analysis, which ensures preconditions and thus enhances a sound reuse of software. As a result, we could determine many preconditions to be fulfilled, especially preconditions of a certain class, which are used most often. This confirms that static analysis is justified in a development process of quality software. Acknowledgements I would like to deeply thank Dr. Karine Arnout for her support and explanations on the subject of the thesis, and her prompt answers. Furthermore I thank Prof. Dr. Bertrand Meyer, who gave me the opportunity to accomplish my master thesis in the field of Design by Contract, and for his introduction on the static analysis of preconditions. A special thank goes to Éric Bezault, who introduced me to GOBO Eiffel, and swiftly answered my questions. 2 Table of Contents Chapter 1 - Concept of Contracts ........................................................................................6 1.1. The Crash of Ariane 5.............................................................................................6 1.2. Design by Contract in Context of Ariane 5..............................................................6
    [Show full text]