Learning Outcomes and Exam Study Guides

This course provides an introduction to software design principles, covers many of the "classic" design patterns from the "Gang of Four" textbook (Design Patterns: Elements of Reusable Object-Oriented Software, Gamma et. al.), and several other categories of patterns. There is also study guide information for the two classtime exams, and the final exam. The learning outcomes for the topics studied during the term are given below.

Course Introduction

The course introduction described the principles that you will strive to follow throughout your software design activities. Coupling, cohesion, encapsulation, interface over implementation, and composition over inheritance are a number of those principles. The learning outcomes are:

1. define the principles of coupling and cohesion
2. explain why coupling and cohesion are antagonistic principles
3. explain encapsulation and its relationship to behavior follows data
4. describe the benefits of interface (type) inheritance over implementation (class) inheritance and when you might choose class inheritance
5. describe the benefits of composition over inheritance and when you might choose inheritance

Domain Models

Domain modeling is a modeling concept introduced at the beginning of this course. It is used early in the development process to create a common understanding between the customer and the developers of the scope and major entities that exist in the system. The learning outcomes are:

1. define the main benefits of developing a domain model
2. describe the process for creating a domain model
3. explain the notations used to diagram a domain model
4. explain the limitations on the terminology that is used in a domain model
5. describe the connections and differences between a domain model and an implementation class structure model

Model-View-Control Architecture

The model-view-control architecture is a primary architecture used for building interactive software systems. The learning outcomes are:

1. identify the responsibilities of the model, view, and control subsystems
2. describe the interactions that occur between the model, view, and control, subsystems
3. apply appropriate design patterns in the design of a model-view-control system

"Classic" Design Patterns

For each pattern studied, you should be able to:

1. state the intent
2. draw the structure of the pattern
3. identify the participants
4. describe the responsibilities for each of the participants
5. describe how the participants collaborate to achieve the intent of the pattern
6. specify the applicability of the pattern
7. suggest sample application areas including at least one application not discussed in the Gang of Four (GoF) textbook

On the two exams, you will have a design pattern cheat sheet that gives you the first three items for each pattern studied. There will not be questions directed at this level of memorization. The exam questions will be at a higher level of understanding of the design patterns. You should still know this information for each pattern, however, so that you can have meaningful discussions while working on your software design without having to constantly refer to reference material.

In addition, there are pattern-specific learning outcomes that you are responsible for:

• Abstract Factory
• Adapter
• Command
• Composite
• Decorator
• Mediator
• Memento
• Observer
• Proxy
• Singleton
• State
• Strategy
• Visitor

Bonus Design Patterns

The following patterns will not be presented in class. You should study these patterns on your own. One or more of these patterns will most likely be appropriate to use in your project work in the course. In addition, there may be questions on these patterns on the exams that you can answer for bonus points. To get bonus points, you should be able to answer questions on items 1 through 7 above, and the pattern-specific learning outcomes linked below.

• Builder
• Facade
• Factory Method
• Iterator
• Template Method

Refactoring

The learning outcomes for our discussion of refactoring are:

• Discuss the reasons that cause refactoring to be needed and the steps involved in doing a refactoring operation
• Describe the refactoring that your project team did in the case-study project
• Discuss what the cyclomatic complexity metric measures and how you can reduce it in your program flow

Anti-Patterns

In class, we discussed the following anti-patterns: The Blob, Copy-and-Paste Programming, Lava Flow, Poltergeists, Golden Hammer, and Functional Decomposition. The learning outcomes for anti-patterns are:

• Define an anti-pattern
• For each of the anti-patterns discussed:
  • Describe the symptoms that often exist in a software system that are indicators of the anti-pattern
  • Describe the forces that cause the anti-pattern to form in the first place
  • Describe the steps that should be followed to eliminate an anti-pattern from your software system

Design Problem

The design problem will be similar to the design exercise done at the very start of the course, and the one that was done as part of the Final Exam review. The requirements for a small software system will be provided to you. You will be required to:

1. Decompose the system into object classes and document the decomposition using UML class diagrams
2. Describe the responsiblities and collaborations for each class with a CRC card
3. Apply appropriate design patterns and describe the use of the pattern in the context of the specific software system being designed
4. Show the dynamic operation of system features using UML sequence diagrams

Exam Study Guides

There are three exams during the course. Each exam will cover the Classic Design Patterns listed above for that exam. These were the patterns discussed in class and you should have been doing additional studying of them outside of the class discussion. Each exam may also have questions on one or more of the bonus patterns. You can answer questions on these patterns for bonus points on the exam.

Exam 1 will cover any design patterns that were introduced in class prior to the exam (possibly including the bonus patterns). It also will cover the introduction to software design material discussed at the beginning of the course, the model-view-control architecture, and domain modeling concepts.

Exam 2 will cover any patterns that were introduced in class after the first midterm and the bonus patterns.

The Final Exam will present you with two design problems and ask you to produce a "mini-design" for each that includes a Noun/Verb analysis, a UML class diagram, a GoF pattern card, and a sequence diagram. You will also need to write a design rationale explaining your choice of design patterns and the impact on the design of the system using design language.

For patterns covered by the exams, you will be expected to demonstrate the common learning outcomes applicable to every pattern, as well as the pattern-specific learning outcomes. You may also refer to this list of potential exam questions. Questions may also be taken from the weekly discussion topics in myCourses.

You may bring to each exam one 8.5" x 11" sheet of paper with notes on the front and back. This must be handwritten. At Exam 1, you will be given a design pattern information packet that has the intent and structure for each classic pattern and bonus pattern listed above. Save this design pattern information packet and remember to bring it to Exam 2 and the Final Exam. If you lose your copy, you will have to print another copy on your own.