Engr 691-12: Special Topics in Engineering Science
Software Architecture
Fall Semester 2000

Exam #1 Study Guide
3 November 2000 Version

You may prepare a single, 8.5 by 11 inch page that you can use in taking the exam Wednesday, 8 November.

This is a study guide I am providing to assist you in your study for the exam. However, I reserve the right to ask questions on any material that we have covered this semester -- unless I say explicitly that it will not be on the exam.

1. Lecture Notes on Data Abstraction

   Introductory concepts:

   procedural and data abstraction, concrete data structures, abstract data structures, abstract data types, information hiding, encapsulation

   Definition of ADTs:

   name, sets, signatures, semantics

   axiomatic versus constructive approaches

   preconditions, postconditions, invariants (interface and implementation)

   constructors, mutators, accessors, destructors

   Defining ADTs as Java classes:

   instance and class methods, instance and class variables

   private versus public accessibility

   reference versus value (copy) semantics

   How can ADTs be implemented as Java classes? as Java interfaces?

   client-supplier relationship

   criteria for good class interfaces

2. ADT Case Study: Ranked Sequence

   The key point of including this case study is to give a more sophisticated example of an ADT design/implementation using Java. The case study uses: Java interfaces to separate specification from implementation, Java exceptions, Javadoc annotations, iterators, an assertion checking mechanism, Java packages

   Improvement notes: use Java Iterator instead of Enumeration, use inner classes to implement iterator

3. Cunningham and Wang. Building a Layered Table Framework for the Table Abstraction

   What I wanted to illustrate when we talked about this paper was the use of design contracts (pre- and postconditions, invariants) as a means for being careful in the design. (The paper online has been corrected since I gave you a paper copy.) I also wanted to show an approach to building a data/file structure that separated concerns such as the access mechanisms from the storage mechanisms.

   Since we have now studied patterns, you will notice that this paper uses the Layered Architecture, Bridge, Proxy, and Iterator patterns.

   This paper also introduces the concept of framework.

4. Understanding Inheritance

   abstract concepts of data types and inheritance (subtypes) -- substitutability

   programming language constructs of classes and subclasses

   What is the relationship between class/subclass and type/subtype concepts?

   forms of inheritance -- which preserve substitutability?

   how are preconditions, postconditions, and invariants affected by inheritance?

   tree-structured versus forest-structured class hierarchies

   advantages/disadvantages of each

   Java inheritance and class hierarchy features?

5. Mechanisms for Software Reuse

   The purpose of this handout is to discuss the differences between inheritance and composition (or aggregation) as reuse mechanisms. How do you do each of these in Java? advantages and disadvantages of each?

6. Implications of Inheritance

   The purpose of this handout is to discuss other programming language issues that are affected by the choice to include inheritance: polymorphic variables, storage allocation/deallocation issues, copy versus reference semantics, copy creation, equality testing

7. Polymorphism

   The purpose of this handout is to discuss the polymorphism and its various forms in programming languages: polymorphic variables, overloading, overriding, deferred methods, pure polymorphism, and generics. What does Java have and not have?

8. Second Look at Classes

   The purpose of this handout is to discuss the meta-class structure of Java. That is the class Class and the association of its instances with classes in Java. What facilities are provided by Class?

9. Overview of UML from Grand textbook chapter 2

   The purpose of this discussion is for you to be able to understand the UML class diagrams. You should be able to draw simple class diagrams giving inheritance, aggregation, and association relationships among classes. You should know the three main parts of the class diagram, but do not have to worry about the details of accessibility markers and such.

10. Introduction to Patterns

    What is a pattern? What are the three main components of a pattern description? What are the three main kinds of patterns? What are some examples of each (not just the ones listed in this handout)? How do you go about using patterns in design? (The latter point ties this handout to the Designing Patterns handout).

11. Pipes and Filters Architectural Pattern

    What is this pattern all about? When is this pattern applicable and when not? What are the various kinds of components? What is meant by active and passive filters? How do you go about implementing the pipes and filters pattern?

12. Mary Shaw. "Some Patterns for Software Architecture".

    What is the basic idea of each of the architectural patterns -- including the process control patterns? When is each applicable and when not?

13. Patterns discussions from Grand textbook:

    You should know the basic purpose of each pattern we talked about.

    Cunningham:

    Factory Method, Strategy, Template Method

    Student groups:

    Decorator, Composite, Iterator, Builder, Proxy, Adapter, Bridge, Mediator, Observer, Visitor, Flyweight

14. Vazhkudai and Cunningham. A Reusable Software Framework for Distributed Decision-Making Protocols

    The purpose of discussion of this paper was to show a framework design under development. It sketches how patterns can be used in the design -- such as layered architecture, template method, and strategy.

15. John Vlissides. "Designing with Patterns", In Pattern Hatching: Design Patterns Applied, Addison-Wesley, 1998.

    The purpose of discussion of this paper was to fit together a several of the patterns and illustrate how you might go about designing real systems with them. It should also provide some further explanation of some of the patterns.

16. Java programming

    You should understand well how to build abstract data types in Java as you did on the bingo program.

    You should also understand how to build simple frameworks using template method and strategy patterns as we did on the second homework.

    You should understand how inheritance and polymorphism work in Java. I am likely to give you a set of classes using inheritance and overriding and ask you to answer questions about them. In particular, I might ask you to show the output of a program that uses inheritance and polymorphism. Give the class diagrams. Show which mutators are accessors, mutators, etc. Maybe I will ask you to add a new class that does something useful (: or maybe does something useless :).

UP to ENGR 691 root document?