See more Design by contract articles on AOD.

Powered by
TTSReader
Share this page on
Article provided by Wikipedia


( => ( => ( => Design by contract [pageid] => 39289 ) =>
""
""
A design by contract scheme

Design by contract (DbC), also known as contract programming, programming by contract and design-by-contract programming, is an approach for designing "software. It prescribes that software designers should define "formal, precise and verifiable interface specifications for "software components, which extend the ordinary definition of "abstract data types with "preconditions, "postconditions and "invariants. These specifications are referred to as "contracts", in accordance with a "conceptual metaphor with the conditions and obligations of business contracts.

The DbC approach assumes all client components that invoke an operation on a server component will meet the preconditions specified as required for that operation. Where this assumption is considered too risky (as in multi-channel client-server or distributed computing) the opposite ""defensive design" approach is taken, meaning that a server component tests (before or while processing a client's request) that all relevant preconditions hold true, and replies with a suitable error message if not.

Contents

History[edit]

The term was coined by "Bertrand Meyer in connection with his design of the "Eiffel programming language and first described in various articles starting in 1986[1][2][3] and the two successive editions (1988, 1997) of his book "Object-Oriented Software Construction. Eiffel Software applied for trademark registration for Design by Contract in December 2003, and it was granted in December 2004.[4][5] The current owner of this trademark is Eiffel Software.[6][7]

Design by contract has its roots in work on "formal verification, "formal specification and "Hoare logic. The original contributions include:

Description[edit]

The central idea of DbC is a metaphor on how elements of a software system collaborate with each other on the basis of mutual obligations and benefits. The metaphor comes from business life, where a "client" and a "supplier" agree on a "contract" that defines, for example, that:

Similarly, if a routine from a "class in "object-oriented programming provides a certain functionality, it may:

The contract is semantically equivalent to a "Hoare triple which formalises the obligations. This can be summarised by the "three questions" that the designer must repeatedly answer in the contract:

Many "programming languages have facilities to make "assertions like these. However, DbC considers these contracts to be so crucial to "software correctness that they should be part of the design process. In effect, DbC advocates writing the assertions first. Contracts can be written by "code comments, enforced by a "test suite, or both, even if there is no special language support for contracts.

The notion of a contract extends down to the method/procedure level; the contract for each method will normally contain the following pieces of information:["citation needed]

Subclasses in an "inheritance hierarchy are allowed to weaken preconditions (but not strengthen them) and strengthen postconditions and invariants (but not weaken them). These rules approximate "behavioural subtyping.

All class relationships are between client classes and supplier classes. A client class is obliged to make calls to supplier features where the resulting state of the supplier is not violated by the client call. Subsequently, the supplier is obliged to provide a return state and data that does not violate the state requirements of the client. For instance, a supplier data buffer may require that data is present in the buffer when a delete feature is called. Subsequently, the supplier guarantees to the client that when a delete feature finishes its work, the data item will, indeed, be deleted from the buffer. Other design contracts are concepts of "class invariant". The class invariant guarantees (for the local class) that the state of the class will be maintained within specified tolerances at the end of each feature execution.

When using contracts, a supplier should not try to verify that the contract conditions are satisfied; the general idea is that code should "fail hard", with contract verification being the safety net. DbC's "fail hard" property simplifies the debugging of contract behavior, as the intended behaviour of each routine is clearly specified. This distinguishes it markedly from a related practice known as "defensive programming, where the supplier is responsible for figuring out what to do when a precondition is broken. More often than not, the supplier throws an exception to inform the client that the precondition has been broken, and in both cases—DbC and defensive programming—the client must figure out how to respond to that. DbC makes the supplier's job easier.

Design by contract also defines criteria for correctness for a software module:

Design by contract can also facilitate code reuse, since the contract for each piece of code is fully documented. The contracts for a module can be regarded as a form of "software documentation for the behavior of that module.

Performance implications[edit]

Contract conditions should never be violated during execution of a bug-free program. Contracts are therefore typically only checked in debug mode during software development. Later at release, the contract checks are disabled to maximize performance.

In many programming languages, contracts are implemented with "assert. Asserts are by default compiled away in release mode in C/C++, and similarly deactivated in C#[8] and Java. This effectively eliminates the run-time costs of contracts in release.

Relationship to software testing[edit]

Design by contract does not replace regular testing strategies, such as "unit testing, "integration testing and "system testing. Rather, it complements external testing with internal self-tests that can be activated both for isolated tests and in production code during a test-phase. The advantage of internal self-tests is that they can detect errors before they manifest themselves as invalid results observed by the client. This leads to earlier and more specific error detection.

Language support[edit]

Languages with native support[edit]

Languages that implement most DbC features natively include:

Languages with third-party support[edit]

Various libraries, preprocessors and other tools have been developed for existing programming languages without native Design by Contract support:

See also[edit]

Notes[edit]

  1. ^ Meyer, Bertrand: Design by Contract, Technical Report TR-EI-12/CO, Interactive Software Engineering Inc., 1986
  2. ^ Meyer, Bertrand: Design by Contract, in Advances in Object-Oriented Software Engineering, eds. D. Mandrioli and B. Meyer, Prentice Hall, 1991, pp. 1–50
  3. ^ Meyer, Bertrand: Applying "Design by Contract", in Computer (IEEE), 25, 10, October 1992, pp. 40–51, also available online
  4. ^ United States Patent and Trademark Office registration for "DESIGN BY CONTRACT"
  5. ^ United States Patent and Trademark Office registration for the graphic design with words "Design by Contract"
  6. ^ Current status of United States Patent and Trademark Office registration for "DESIGN BY CONTRACT"
  7. ^ Current status of United States Patent and Trademark Office registration for the graphic design with words "Design by Contract"
  8. ^ https://msdn.microsoft.com/en-us/library/ttcc4x86.aspx
  9. ^ Bright, Walter (2014-11-01). "D Programming Language, Contract Programming". Digital Mars. Retrieved 2014-11-10. 
  10. ^ Findler, Felleisen Contracts for Higher-Order Functions
  11. ^ Hodges, Nick. "Write Cleaner, Higher Quality Code with Class Contracts in Delphi Prism". Embarcadero Technologies. Retrieved 20 January 2016. 
  12. ^ http://beanvalidation.org/1.1/spec/
  13. ^ https://www.parasoft.com/wp-content/uploads/pdf/JtestDataSheet.pdf
  14. ^ https://cofoja.googlecode.com/files/cofoja-20110112.pdf p. 2
  15. ^ https://github.com/nhatminhle/cofoja/issues/5

Bibliography[edit]

External links[edit]

) )