Teaching OO

Nevertheless, despite the mastery of elementary OO techniques (such as the definition of classes and their interfaces, and the use of inheritance as a mechanism for incremental programming and code sharing) additional teaching of OO concepts is still required to provide the students with the practical and theoretical knowledge needed for OO software development.

The course Object-Oriented Software Development, for CS3 and CS4, at the Vrije Universiteit is meant to satisfy this need. The course deals with software engineering issues, issues of programming language design (including concurrency and distribution), theoretical aspects (concerning abstract data types, polymorphism and correctness) and a number of miscellaneous issues (such as the development and use of object-oriented libraries and frameworks).

The course starts with a discussion of the ways an object-oriented approach may affect the software (project) life cycle, in particular the claims with respect to smoothening the transition between the various phases (analysis, design and implementation), and the potential benefits of software reuse and software maintainability. Also the opportunities for prototyping, bottom-up class library development, and its ultimate consequence -- overturning the traditional waterfall model -- are discussed. Naturally, these claims must be looked at with some caution, since the potential gains of adopting an object-oriented approach will only be realized when the endeavor results in sufficiently stable abstractions!

The remainder of the software engineering track of the course deals with language mechanisms supporting object-oriented programming, guidelines for design and techniques for validating design and implementation.

On a language level we look at support for data abstraction, that is (basically) class-based encapsulation and features allowing for polymorphism, notably templates and inheritance.

Discussing design, we look at the method of CRC cards  [CRC], heuristics for selecting candidate classes  [Booch], responsability-driven design  [Wirfs] and its formalization in terms of contracts. Also, attention is paid to high level abstractions, or patterns  [GOF], capturing the interaction between collections of objects, as well as the use of events to objectify particular interaction protocols.

Although the use of formal methods is only hinted at, the notion of contracts plays a central role in the course. Contracts not only provide a high level characterization of the functionality of an object type, but allow in addition for the validation of a system's run-time consistency, simply by enabling the testing of method pre- and post-conditions and object invariants. Moreover, contracts provide the foundation upon which to base a precise definition of behavioral refinement and a manageable notion of correctness for object oriented systems.

Employing patterns, on the other hand, is motivated from more pragmatic considerations. As explained in  [GOF], patterns may be regarded as the cristallization of practical design experience. As may be observed in the growing body of literature on patterns, e.g.  [PLOP], there is a wide range between what we may regard as idiomatic solutions to programming problems and high-level (domain-specific) design guidelines. In our course at the Vrije Universiteit, we focus on the lower end of the spectrum, concentrating on patterns that allow for an idiomatic solution employing basic object-oriented programming constructs.

The use of events as a means to hide complex interactions between objects may be regarded as an example of such a pattern, employing what we may call the objectify idiom  [PLOP].