1. Unified Process
    • Generic framework for iterative and incremental software development.
    • 1) Inception
    • 2) Elaboration
    • 3) Construction
    • 4) Transition
  2. GRASP
    General Responsibility Assignment Software Patterns
  3. What are these characters? << >>
  4. Coupling
    • Degree to which each object relies on other objects
    • Low Coupling is good
  5. Cohesion
    • Focus of objects responsibilities
    • High Cohesion is good
  6. Operation Contract
    • Detailed analysis of individual operations of System Sequence Diagram.
    • -
    • Operation: Name of operation and parameters
    • Cross References: Use cases this operation can occur with
    • Preconditions: What has happened before execution of the operation
    • Postconditions: What happens after the execution of the operation
  7. UP Elaboration
    • Build core architecture
    • Resolve high risk elements
    • Define requirements
    • Estimate Schedule
  8. FURPS+
    • Functional, Usability, Reliability, Performance, and Supportability
    • Implementation, Interface, Operations, Packaging, and Legal
  9. Design
    • Blueprint of software components to guide implementation.
    • The How
    • Do the "Thing Right"
  10. Analysis
    • Conceptual description of software requirements
    • The what
    • Do the "Right Thing"
    • Conceptual solution
  11. Design Model
    A blueprint of software components that guide implementation.
  12. Domain Model
    Conceptual description of a software system
  13. CRC
    Class Responsibility Collaboration
  14. UP
    Unified Process
  15. UML
    Unified Modeling Language
  16. Creator
    • GRASP Pattern
    • Who creates object X?
    • A doing Responsibility.
    • General Rule: Containers create contained things (or compositely aggregated things)
  17. Information Expert
    • GRASP Pattern
    • Who should be responsible for knowing a X, given a Key?
    • A knowing responsibility.
    • General Rule: The object that knows how to fulfill the need is the one responsible for knowing X given a key.
  18. Low Coupling
    • GRASP Pattern
    • How strongly is one object connected to (or dependent on) other objects. How can we reduce change impact?
    • General Rule: Keep coupling low
  19. High Cohesion
    • GRASP Pattern
    • The methods of an object should group into a related set
    • This set should be small and lightweight, delegating to other objects when helpful
  20. Controller
    • GRASP Pattern
    • Keep model separate from view
    • What model should first get a UI message
    • Controllers facilitate reuse, UI framework change, UI replacement with commands, and maintenance.
  21. Command Method
    Performs an action which changes the state of an object
  22. Query
    Returns data to the caller. Doesn't change the state of objects.
  23. Visibility
    Ability of one object to see another object.
  24. What are the four types of visibility?
    • 1) Attribute: B is an attribute of A
    • 2) Parameter: B is a parameter of a method of A
    • 3) Local: B is a local object in a method
    • 4) Global: B is globally visible
  25. What is "Test Driven Development and Refactering"?
    Write a single test case for a method, get it working, and repeat for next method.
  26. Refactoring
    A structured diciplined method to rewrite or restructure code without changing behavior.
  27. What is "Smelly Code"?
    • 1) Duplicated code
    • 2) Big Methods
    • 3) Too many instance vars in a class
    • 4) Too much code in a class.
    • 5) Similar subclasses
    • 6) Too little use of interfaces
    • 7) High coupling
  28. Polymorphism
    Giving the same method name to different objects that share a superclass.
  29. Why choose interfaces over abstract classes?
    Don't commit the subclass to a specific hierarchy.
  30. Indirection
    Ability to reference something using a name, reference or container instead of the value itself.
  31. Protected Variation
    Information hiding.
  32. Open-Closed Principle
    Modules should be both open (for extension:adaptable) and closed (closed to modification).
  33. UML Activity Diagram
    Used for sequential and parallel activities. Based on Petri Net.
  34. Generalization
    Consists of Superclass and Subclass.
  35. Rules for Generalization
    • 1) 100% rule. Superclass's defenition should be applicable to subclass. Subclass must confirm to 100% of superclass's attributes and associations
    • 2) Members of subclass set must be members of superclass set.
  36. 100% rule
    A rule of generalization. Superclass's definition should be applicable to subclass. Subclass must conform to 100% of superclass's attributes and associations.
  37. Association Class
    • Considered when:
    • 1) Many to many relationship between two classes
    • 2) Attribute best placed in relationship between two classes
    • 3) Related class must exist (doesn't make sense if it doesn't)Image Upload 1
  38. Composition
    • In UML, the black diamond. If in doubt, leave it out. An exclusive lifeline dependance between a whole and it's parts.
    • Image Upload 2
  39. Inheritance
    An OO mechanism that allows subclass to inherit methods and attributes from its superclass.
  40. True of False: Favor composition over inheritance.
  41. True of False: Favor inheritance over composition
  42. Benefits of composition
    • 1) Front end wrapper can expose back end clas methods
    • 2) Front end class can match method names or make them different
    • 3) Anything can be done with inheritance as with composition
    • 4) Composition allows back end class to be changed dynamically
  43. Architectural Analysis
    Use to 1) Reduce Risk 2) Position for future 3) Align with future goals.
  44. Decorator Solution
    • 1) Attach responsibilities to an object dynamically.
    • 2) Decorators provide a flexable alt. to subclassing for extending functionality
  45. Transient Objects
    In object persistence, the object disappears when "power" goes out
  46. Persistent
    In object persistence, the object state preserved across "power outages"
  47. Serialization
    In object persistence, flattening object into stream and save them to disk.
  48. Storing an object state
    1) Serialize, pickle, dematerialize, passivate
  49. Retrieving an object state
    Deserialize, unpickle, materialize, activate
  50. Schema Mapping
    In object persistence, changing object state format to match the format required for target repository.
  51. Object Identifier
    In object persistence, a unique primary key for each object.
  52. Deployment Diagrams
    Communicate physical architecture.
  53. Program to ________________, not ________________.
    Program to interfaces, not implementations.
  54. Imperative paradigm
    Programs that specify a series of steps.
  55. Functional Programming advantages
    1) Extreme Modularity, 2) No side effects 3) heavy use of recursion and composition 4) less bugs
Card Set
Final Test,,