oder
Loggen Sie sich ein, um 1-Click® einzuschalten.
oder
Mit kostenloser Probeteilnahme bei Amazon Prime. Melden Sie sich während des Bestellvorgangs an. Erfahren Sie mehr
Alle Angebote
Möchten Sie verkaufen? Hier verkaufen
Design by Contract by Example
 
Größeres Bild
 
Den Verlag informieren!
Ich möchte dieses Buch auf dem Kindle lesen.

Sie haben keinen Kindle? Hier kaufen oder eine gratis Kindle Lese-App herunterladen.

Design by Contract by Example [Englisch] [Taschenbuch]

Richard Mitchell , Jim McKim , Bertrand Meyer

Preis: EUR 44,99 kostenlose Lieferung. Siehe Details.
  Alle Preisangaben inkl. MwSt.
o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o
Auf Lager.
Verkauf und Versand durch Amazon.de. Geschenkverpackung verfügbar.
Nur noch 1 Stück auf Lager - jetzt bestellen.
Lieferung bis Mittwoch, 6. Juni: Wählen Sie an der Kasse Morning-Express. Siehe Details.

Produktinformation


Mehr über die Autoren

Entdecken Sie Bücher, lesen Sie über Autoren und mehr

Produktbeschreibungen

Kurzbeschreibung

Design by Contract is a systematic approach to specifying and implementing object-oriented software elements based on precisely defined obligations between them. This is the first practical, example-centered guide to using Design by Contract. The authors introduce powerful design principles for writing good contracts and supporting guidelines -- and demonstrate those principles with real-world Java and Eiffel code examples. They review the fundamentals of Design by Contract -- preconditions, postconditions and invariants -- and presenting a real-world example. Next, drawing on their unparalleled experience with Design by Contract, they present six powerful design principles -- each with a clear statement of goals, rationale, examples in both Java and Eiffel, and supporting notes. Developers will learn how to strengthen their components' internal support for contracts; how to use contracts to specify subclasses whose objects can safely be substituted for superclass objects; how to extend contract to specify and check properties that remain unchanged; and how to use contracts in analysis-level models. The book concludes by summarizing key principles and presenting a realistic cost/benefit analysis of their use.

Synopsis

Design by Contract is a systematic approach to specifying and implementing object-oriented software elements based on precisely defined obligations between them. This is the first practical, example-centered guide to using Design by Contract. The authors introduce powerful design principles for writing good contracts and supporting guidelines -- and demonstrate those principles with real-world Java and Eiffel code examples. They review the fundamentals of Design by Contract -- preconditions, postconditions and invariants -- and presenting a real-world example. Next, drawing on their unparalleled experience with Design by Contract, they present six powerful design principles -- each with a clear statement of goals, rationale, examples in both Java and Eiffel, and supporting notes. Developers will learn how to strengthen their components' internal support for contracts; how to use contracts to specify subclasses whose objects can safely be substituted for superclass objects; how to extend contract to specify and check properties that remain unchanged; and how to use contracts in analysis-level models.

The book concludes by summarizing key principles and presenting a realistic cost/benefit analysis of their use.


Tags

 (Was ist das?)
Bei einem Tag handelt es sich um ein Schlagwort, das zum Produkt passt.
Tags erleichtern allen Kunden die Suche und die Sortierung ihrer Lieblingsprodukte.
 

Eine digitale Version dieses Buchs im Kindle-Shop verkaufen

Wenn Sie ein Verleger oder Autor sind und die digitalen Rechte an einem Buch haben, können Sie die digitale Version des Buchs in unserem Kindle-Shop verkaufen. Weitere Informationen

Kundenrezensionen

Es gibt noch keine Kundenrezensionen auf Amazon.de
5 Sterne
4 Sterne
3 Sterne
2 Sterne
1 Sterne
Die hilfreichsten Kundenrezensionen auf Amazon.com (beta)
Amazon.com:  9 Rezensionen
13 von 13 Kunden fanden die folgende Rezension hilfreich
The best tutorial on design by contract 11. Mai 2002
Von Charles Ashbacher - Veröffentlicht auf Amazon.com
Format:Taschenbuch
Despite its' power, design by contract is an underutilized software development technique. That is most likely explained by the speed of software development and the time that would be required to learn it well enough to use it. Most developers either do not, or feel that they do not have the time to stop and learn how to use design by contract effectively. Well, the former group simply cannot be helped, as not even design by contract will extend the time in a day. However, for the latter group, this book is for you.
Design by contract is not difficult to learn, as is demonstrated in this book. The examples are very easy to understand and are chosen for their combination of ease of use as well as having applicability to the kinds of programs that developers create. While Eiffel and Java are used to create the examples, it is not critical that you know them to understand the code. The only requirement is that you understand the basic principles of object-oriented programming. While some background in logic would be helpful, all that is needed is what is required for writing correct Boolean expressions in programs.
I am a big proponent of the design by contract model of software development. The writing of the contract principles forces a level of intellectual rigor that can dramatically improve the quality of your software. In this book, you can not only learn how to do it, but you will also learn how to do it well and the ways in which you can do it wrong. I have placed it in my list of the top ten books of the year.
12 von 13 Kunden fanden die folgende Rezension hilfreich
Not enough material 9. März 2006
Von a reader - Veröffentlicht auf Amazon.com
Format:Taschenbuch
The aim of the book is to teach readers about contracts and how to write good ones. The main points are summarized at the start of the book in a series of six guidelines (as described in the review above):

- Separate queries from commands

- Separate basic queries from derived queries

- Write a postcondition for each derived query that specifies what result can be returned

- Write a postcondition for each command that specifies the value of every basic query

- Decide on a suitable precondition for every query and command

- Write invariants to define unchanging properties of objects

This part is well written and provides good advice for people new to writing contracts. The presentation is however very academic with examples based on stacks and dictionaries.

The authors then try to present more realistic examples. Unfortunately that's where they fail badly.

The first example shows how to use contracts to write an observer pattern. The only thing that the authors show is that you can write a contract that makes sure that the observers are properly added to the list of observers. Since most modern languages implement the observer pattern in the language itself (via events), this is a contract that no-one needs to write. The problem that usually happens in real programming is that the events are wired up too early or too late. Contracts provide little help for this. The authors should have chosen an example that better demonstrates the power of contracts.

The second example is an over-extended explanation about how you can write code so that you never call a method when its precondition is false. The explanation is convoluted and offers no real insight into programming by contracts.

The final chapter discusses applying contracts to languages that do not support them natively (basically all languages other than Eiffel). I had high hopes for this chapter. Unfortunately, the authors recommend using a pre-processor (e.g., iContracts) or only implementing preconditions with assertions. Most programmers with a little experience will already be using assertions and will not learn much from the chapter.

The book is a compilation of various papers that the authors published in conferences (mainly TOOLS). The problem is that the material is suited to a 20 page paper not a 200+ page book. Even with repetitions and ample space the lack of useful information is apparent. The second half of the book is a waste of paper.

Contracts are a very useful tool when properly applied. The guidelines presented at the start of the book are very good. Unfortunately the book is marred by a lack of real world examples.
7 von 7 Kunden fanden die folgende Rezension hilfreich
Clear and to the Point 8. März 2002
Von John Childs - Veröffentlicht auf Amazon.com
Format:Taschenbuch
This is surely the definitive work on contracts and assertions. The title says it all, as the book makes effective use of examples to illustrate this important topic. Before I read "Design by Contract by Example" I had not a clue as to how to write assertions. Mitchell and McKim's Six Principles simplified this subject such that I was able to write a fairly reasonable contract for a small system on my first try. This work demystifies the subject.

Kunden diskutieren

Das Forum zu diesem Produkt
Diskussion Antworten Jüngster Beitrag
Noch keine Diskussionen

Fragen stellen, Meinungen austauschen, Einblicke gewinnen
Neue Diskussion starten
Thema:
Erster Beitrag:
Eingabe des Log-ins
 


Aktive Diskussionen in ähnlichen Foren
Kundendiskussionen durchsuchen
Alle Amazon-Diskussionen durchsuchen
   
Ähnliche Foren


Lieblingslisten


Ähnliche Artikel finden


Anhand des Sachgebietes nach ähnlichen Produkten suchen:


Ihr Kommentar


Datenschutzerklärung von Amazon.de Versandbedingungen von Amazon.de Umtausch- & Rücknahme bei Amazon.de