SE 2811 Weekly Outcomes (2019-20)

Week 1

  1. Define object-oriented.
  2. Define design pattern.
  3. State the motivation behind design patterns.
  4. Explain when it makes sense to provide some implementation in an abstract class, even though the class is not instantiable.
  5. Explain when use of an abstract class may be more favorable than use of a pure interface.
  6. Describe the Adapter Pattern and explain when it is useful.
  7. Describe the Null Object Pattern and explain when it is useful.
  8. Identify and make use of appropriate connectors in UML class diagrams that illustrate generalization (Java extends), realization (Java implements), composition, and usage, along with labeling connectors to indicate navigability (arrows), multiplicity (numbers), and end roles (attribute names)
  9. Differentiate problem space and solution space.
  10. Lab 1: UML notation review and review of implementing inheritance in Java

Week 2

  1. Explain how the Strategy Pattern delegates behaviors to separate classes.
  2. Explain the principle of Extend, don't Modify (also called the Open-Closed Principle).
  3. Explain why, in many contexts, composition is preferred to inheritance.
  4. Explain and apply the principles of domain-driven development.
  5. Explain the context, intent, and motivation of the (non-thread-safe) Singleton Pattern.
  6. Describe the specific consequences (advantages/disadvantages) of the Singleton Pattern
  7. List the principal methods of each main Singleton class
  8. Explain how a Singleton instance is created in the absence of a Singleton constructor
  9. State the three primary classifications of patterns, and explain them.
  10. Lab 2: applying the Strategy Pattern

Week 3

  1. Explain the Facade Pattern and how it differs from Adapter.
  2. Explain the context, intent, and motivation of the Decorator Pattern.
  3. List the principal attribute defined within the abstract class that defines an Abstract Decorator which concrete decorates extend
  4. Explain and apply the paradigm of the Favor Composition over Extend principle with respect to the Decorator Pattern.
  5. Describe how the Decorator Pattern is applied in the java.io package to various Java I/O classes, such as OutputStream, FileOutputStream, FilterOutputStream, along with the corresponding InputStream-related classes
  6. Apply the Decorator Pattern to implement a FilterOutputStream-based or FilterInputStreambased I/O concrete decorator class that manipulates the data within an output or input stream.
  7. Apply the Decorator Pattern to extend the behavior of graphical shapes.
  8. Explain the meaning of the term coupling; explain low (loose) coupling vs. high (tight) coupling.
  9. Explain the meaning of cohesion; explain low cohesion vs. high cohesion
  10. Explain why low coupling and high cohesion are characteristics of a good design.
  11. Critique the coupling and cohesion of existing code.
  12. Lab 3: applying the decorator Pattern to decode encrypted text

Holiday Break

Week 4

  1. [Review patterns covered, categories of patterns]
  2. [Review the principle of domain-driven development]
  3. Explain what a thread is and why they are useful.
  4. Explain what can happen when using the simple Singleton Pattern in a multi-threaded environment.
  5. Apply multithreading using the Java API to create and start multiple threads (both worker threads and Timer threads)
  6. Explain the purpose of the Runnable interface and its association with the Thread class
  7. Explain the purpose of thread synchronization.
  8. Create synchronized methods and synchronized blocks of code.
  9. Synchronize threads using notify() and wait() methods from the Java API.
  10. Explain the concept of thread-safety as to how it pertains to non-thread-safe classes such as those of the JCF.
  11. Explain why modifications or updates to a UI, once the UI is made visible, should only be done on the Event Dispatch thread.
  12. Explain the context, intent, and motivation of the Singleton Pattern
  13. Explain the concept of Eager vs. Lazy initialization of the Singleton's object
  14. Apply the Singleton Pattern to a specified application
  15. Lab 4: using Singleton with threads

Week 5

  1. Describe how the Composite Pattern is applied to create hierarchical structures composed of nodes known as Parts (or Leaf's) and Composites, which both implement the behavior defined by the abstract Component class.
  2. Explain how the Composite Pattern allows all objects (Parts and Composites) of a hierarchy to be treated uniformly, since they both implement Component behavior.
  3. Identify the principal behaviors defined by the Component abstraction.
  4. Illustrate the relationships between the primary classes of the Composite Pattern.
  5. Describe how to apply Model/View/Controller and discuss its advantages.
  6. Explain the context, intent, and motivation of the Observer Pattern
  7. State the two principal interfaces comprising the Observer Pattern
  8. List the principal methods defined by the Observer and Subject interfaces
  9. Implement the principal methods of the each interface in concrete classes
  10. Describe the specific consequences (advantages/disadvantages) of the Observer Pattern
  11. Identify candidate applications that could implement the Observer Pattern
  12. Apply the Observer Pattern to a specified application
  13. Labs 5 and 6, team based: applying the Observer Pattern to tracking bus

Week 6

  1. Describe how the Command Pattern represents a request to an object (that is, a command) as another type of object, which can be stored and passed around like any other object.
  2. Identify the primary classes of the Command Pattern: the Command interface, one or more concrete Commands which implement the interface, a command Invoker, and a contextspecific Receiver.
  3. Identify the principal behaviors defined by the Command interface and the Invoker abstraction.
  4. Illustrate the relationships between the primary elements of the Command Pattern in a UML class diagram.
  5. Stacking commands to implement undo.
  6. Describe how to use a stack with the Command Pattern to implement undo.
  7. Model/View/Controller with the Command Pattern.

Week 7

  1. Describe the principal behavior defined by the Factory Pattern as object creation.
  2. Describe how the Factory Pattern is used to define an interface for object creation in that is implemented in a Factory class - the interface consists of methods known as Factory Methods.
  3. Describe how the Abstract Factory Pattern method is used to create different types of concrete Factories, thus abstracting the process of creating the Factories.
  4. Describe how the Abstract Factory Pattern method is used to create different types of concrete Factories, thus abstracting the process of creating the Factories.
  5. Labs 7, 8, team based: model and implement an editor using MVC, Command Pattern, and at least one other pattern.

Week 8

  1. Explain the context, intent, and motivation of the Iterator Pattern
  2. Explain the context, intent, and motivation of the State Pattern
  3. Explain the context, intent, and motivation of the Momento Pattern
  4. Explain the context, intent, and motivation of the Visitor Pattern
  5. Explain the context, intent, and motivation of the Prototype Pattern
  6. Explain the context, intent, and motivation of the Flyweight Pattern
  7. Explain the context, intent, and motivation of the Proxy Pattern
  8. Illustrate the State, Momento, and Visitor Patterns in UML diagrams.
  9. Explain anti-patterns and describe at least one example of an anti-pattern

Week 9

  1. Explain why considering user goals is critical to designing effective interfaces.
  2. Explain how user levels influences user interfaces.
  3. Describe the different software postures and identify each in real applications.
  4. Describe "flow" in the context of user interfaces and describe a number of ways to improve flow.
  5. Describe several examples of excise in user interfaces.
  6. Describe how undo eliminates many forms of excise.
  7. Describe a number of navigation traps in user interfaces.
  8. Labs 9, 10, in groups: design and implement a system illustrating one of the patterns with clear separation between domain classes and solution-specific classes.

Week 10

  1. Presentations, concluding UI material, final exam prep.