CS U370 Object-Oriented Design

 

 
The course presents the theory and practice of object-oriented programming.  
The course enhances students understanding of the concepts of object, class, 
message, method, inheritance, and genericity.  The course covers a basic 
model for objects; the principles of types and polymorphism in object-oriented 
programming languages; different forms of abstraction; and theory and practice 
of reuse. The course also introduces students to some object-oriented design 
patterns that practitioners have found useful.

 

 
CS U213.

 

 
The choice of textbook is left to the individual instructor.

4.1 Possible primary textbooks

4.1.1 Bertrand Meyer, Object-Oriented Software Construction,
2nd edition, Prentice Hall PTR, 2000, ISBN 0-13-629155-4.

4.1.2 Timothy A. Budd, An Introduction to Object-Oriented
Programming, 3rd edition, Addison-Wesley, ISBN 0-201-76031-2.

4.1.3 Cay Horstmann, Object-Oriented Design & Patterns,
Wiley, 2004, ISBN 0-471-31966X.

4.2 Possible references for faculty

4.2.1 Erich Gamma, Richard Helm, Ralph Johnson, & John
Vlissides, Design Patterns: Elements of Reusable Object-Oriented
Software, Addison-Wesley, 1995, ISBN 0-201-63361-2.

4.2.2 Martin Fowler, Refactoring: Improving the Design of
Existing Code, Addison-Wesley, 1999, ISBN 0-201-48567-2.

4.2.3 Martin Fowler, UML Distilled, 3rd Edition,
Addison-Wesley, 2004, ISBN 0-321-19368-7.

4.2.4 Kent Beck, eXtreme Programming eXplained: Embrace Change,
Addison-Wesley, 2000, ISBN 0-201-61641-6.

4.2.5 Kent Beck, Test-Driven Development by Example,
Addison-Wesley, 2003, 0-321-14653-0.

4.2.6 Gene Korienek, Tom Wrensch, and Doug Dechow, SQUEAK
 A Quick Trip to ObjectLand, Addison-Wesley, 2002, ISBN
0-201-73114-2.



 

 
This outline is topical, not chronological.

5.1 The Basics of Objects and OOP

5.2 Object-Oriented Programming
    5.2.1 Ad hoc polymorphism
    5.2.2 Inclusion polymorphism (subtype polymorphism)
    5.2.3 Parametric polymorphism
    5.2.4 Dynamic dispatch (single-, double-, and multi-dispatch)

5.3 Object-Oriented Design
    5.3.1 What are the objects?
    5.3.2 How do objects behave?
    5.3.3 How do objects interact?
    5.3.4 Organized approaches to designing objects and classes    
    5.3.5 Immutable versus mutable
    5.3.6 Overloading versus overriding
    5.3.7 Refactoring
    5.3.8 Class diagrams (UML) for inheritance and composition

5.4 Abstraction
    5.4.1 The abstraction barrier
    5.4.2 The client perspective versus the implementor perspective
    5.4.3 Specifications as contracts
    5.4.4 Interfaces 
    5.4.5 Interchangeability/substitutability of implementations
    5.4.6 Representation independence
    5.4.7 Information hiding
    5.4.8 Minimizing information exposure
    5.4.9 Encapsulation
    5.4.10 Tradeoffs between information hiding, encapsulation, and reuse
    5.4.11 Abstract classes

5.5 Reuse
    5.5.1 Inheritance 
    5.5.2 Composition 
    5.5.3 Standard data types
    5.5.4 Standard data structures
    5.5.5 Standard components
    5.5.6 Designing software for reuse
    
5.6 Common Design Patterns
    5.6.1 Factory
    5.6.2 Visitor    
    5.6.3 Iterator
    5.6.4 Wrapper/Adaptor
    5.6.5 Composite

5.7 Testing
    5.7.1 Black-box testing
    5.7.2 Glass-box testing
    5.7.3 Unit testing
    5.7.4 Integration testing


 

 
Upon completion of this course, a student should

6.1 Understand the fundamental concepts of object-oriented
programming

    6.1.1 The concept of "object", "class", "message", "method",
    "inheritance"

    6.1.2 The use of the idiom of dynamic dispatch as supported
    by at least one object-oriented language in contrast to the
    use of explicit control structures.

6.2 Be able to design an object-oriented system through
programming in at least one OO language

    6.2.1 Be aware of whether the student is a client or the
    implementor of each abstraction the student uses

    6.2.2 Understand how the abstraction barrier facilitates
    program transformations such as refactoring that can
    transform a prototype into a better program

    6.2.3 Recognize simple examples of subtyping in an OO
    language.

    6.2.4 Be able to reuse software through inheritance,
    composition, inclusion polymorphism, parametric polymorphism,
    and libraries of standard data structures and components

    6.2.5 Be able to use several of the most common design
    patterns, including at least the factory, visitor, and
    iterator patterns

    6.2.6 Know at least one organized approach to the design
    of objects and classes in an OO program

    6.2.7 Be able to build basic test suites

6.3 Be equipped with a foundation for learning other OO
languages and other programming paradigms

 

 
The course outcomes will be measured and verified by:

7.1 Programming homeworks (five to ten recommended)

It is recommended that several of the assignments be graded by
executing the code, not just by reading it; and that several
of the assignments be graded by reading the code, not just
by executing it.  It is recommended that several of the
assignments involve black-box testing of code written by other
students in the class. It is recommended that the practical
parts of the course include teaching students how to build
and to manage automated tests.

7.2 Written homeworks (optional at the discretion of instructor)

It is recommended that inline documentation be always required
as part of the coding standards. It is recommended that several
of the assignments require external documentation as well as
inline documentation.

7.3 Other optional means at the discretion of instructor:
    - Quizzes
    - Major exams during the term
    - Final exam
    - Electronic portfolio


 

 
CS U370 presents the fundamental design principles and
thought processes of the object-oriented programming paradigm.
These concepts are reinforced through practical programming
exercises.  Since the object-oriented methodology is widely
used in industry, this course is a central course for preparing
students for their first coop assignment.


 

 
Omitted.