Design by Contract from Bertrand Meyer
Duration
8
hours
Location
Online
Language
English
Code
PTRN-022
Training for 7-8 or more people?
Customize trainings
for your specific needs
Description
Design by Contract covers a set of techniques to produce self-documenting, self-testing software with a much higher degree of reliability than is currently the norm. Drawing their roots from the theory of axiomatic semantics and made popular by the Eiffel language, they have found applications in many different programming languages, from Java with the Java Modeling Language (JML) extension, to UML with the OCL formalism and C# with the Spec# research extension. More recently, Microsoft’s "Code Contracts", a contract-based reengineering of the .NET base libraries based on mechanisms also available to user programs, has made the use of Design by Contract techniques accessible to an even broader range of developments.Applications of Design by Contract extend throughout the software lifecycle, from analysis and design to testing, documentation, inheritance and exception handling but also to project management and software maintenance.
The basic idea is to extend software systems with elements of specification describing the precise goal of each component. Such "contracts" include in particular preconditions, postconditions and invariants.
The course presents the fundamental concepts and how they can improve both the quality and productivity of software development. It describes how to use Design by Contract principles in a number of languages and environments, including Eiffel and extensions of Java, C#, UML and other languages. Microsoft’s Code Contracts.
After completing the course, a certificate
is issued on the Luxoft Training form
is issued on the Luxoft Training form
Target Audience
CIOs; software project leaders; software developers; software testers and QA engineers.
Roadmap
- Equipping software with contracts; kinds of contract element.
- Applications to program construction, documentation, testing.
- Explaining inheritance through contracts.
- Handling abnormal cases. Management applications.
- Design by Contract in various languages and environments.
- How to apply the principles with a language that does not directly provide Design by Contract mechanisms.
Program
9:00–10:30 Basic ideas. Historical origin (axiomatic semantics). Varieties of contract mechanisms, examples. Applications to software documentation.
11:00–12:30 Contracts and inheritance. Contracts for testing and debugging. A contract-based testing environment.
14:00–15:30 Handling abnormal cases: contracts and exception handling. Contracts and object-oriented analysis. Contracts for Java: the Java Modeling Language (JML).
15:45–17:00 Contracts for .NET: Spec#, Code Contracts. Contracts for UML: The Object Constraint Language. Applying contracts in a non-contract- supporting environment. Assessment and conclusion.
Trainer – Bertrand Meyer.
Dr. Bertrand Meyer is Professor of Software Engineering at ETH Zurich. As Chief Architect of Eiffel Software, he has made major contributions to modern software engineering, in particular through pioneering work on object technology and his development of the ideas of Design by Contract™, recognized by several top international awards (ACM Software System Award, IEEE Harlan Mills Award and others). He has published numerous articles and 11 books on software engineering topics.
This training will be held in Russian.
We can organize the same training in English on request.
"TYPE"html";}