A Case Study Point of Sale (PowerPoint)

Document Sample
A Case Study Point of Sale (PowerPoint) Powered By Docstoc
					                                  Object-oriented Analysis and Design

        Applying UML and Patterns
                   An Introduction to
                 Object-oriented Analysis
                        and Design
                and Iterative Development

   Part V Elaboration Iteration 3 – Intermediate Topics

Software Engineering                                                    1
                                         Object-oriented Analysis and Design

  27.   Iteration 3 – intermediate topics
  28.   UML activity diagrams and modeling
  29.   UML state machine diagrams and modeling
  30.   Relating use cases
  31.   More SSDs and contracts
  32.   Domain model refinement
  33.   Architecture analysis
  34.   Logical architecture refinement
  35.   More object design with GoF patterns
  36.   Package design
  37.   UML deployment and component diagrams
  38.   Designing a persistence framework with patterns
  39.   Documenting architecture: UML & the N+1 view model

Software Engineering                                                           2
                          Object-oriented Analysis and Design

                   Chap 27
                  Iteration 3
             Intermediate Topics

Software Engineering                                            3
                                           Object-oriented Analysis and Design

                      NextGen POS
     Requirements in iteration-3 include
        Provide failover to local services when the remote services
         cannot be accessed.
            e.g., if the remote product database can't be accessed, use a
             local version with cached data.
        Provide support for POS device handling, such as the cash
         drawer and coin dispenser.
        Handle credit payment authorization.
        Support for persistent objects.

Software Engineering                                                             4
                       Object-oriented Analysis and Design

              Chap 28
UML Activity Diagrams and Modeling

Software Engineering                                         5
                                         Object-oriented Analysis and Design

                 Activity Diagram 1
   Once an action is finished, there is an automatic outgoing
   The diagram can show both control flow and data flow
        a sequence  of activities, including parallel activities.
        for visualizing business workflows and processes, and use
     Business Process Modeling
        The partitions are useful to see the multiple parties and
        parallel actions involved in the business process
     Data Flow Modeling
        the UML   data store node is applicable

Software Engineering                                                           6
                                                                            Object-oriented Analysis and Design

                             Activity Diagram 2
                                                                           Partitions . Show different
                                                                           parties involved in the process
                    Fulfillment                                Customer                               Finance

                                                                                      Action . It does something
                                                                                      There is an automatic
                                                                                      transition on its completion
                                                       Receive Video
     Object Node . An object                               Order                      A transition supports
     produced or used by actions                                                      modeling of control flow .
     This allows us to model data
     flows or object flows                                                                Fork . One incoming
                                                                                          transition , and multiple
                                                                                          outgoing parallel transitions
                                                                                          and/or object flows

                       Fill Order                                      Send Invoice


                         Deliver                                                                     Receive Payment

    Join . Multiple incoming transitions and /or
    object flows ; one outgoing transition
    The outgoing continuation does not happen           Close Order
    until all the inputs arrive from all flows.

                                  end of activity

Software Engineering                                                                                                      7
                                          Object-oriented Analysis and Design

                Activity Diagram 3
            Student             Registration


                        Check Course                 «datastore»
                         Availability                 Courses


          Accept/Deny   Check Applicant
             Reply       Qualification


Software Engineering                                                            8
                       Object-oriented Analysis and Design

Expanded activity to Another Diagram

Software Engineering                                         9
                        Object-oriented Analysis and Design

          Model Events as Action

Software Engineering                                          10
                                        Object-oriented Analysis and Design

   This technique proves most valuable for very complex
    processes, usually involving many parties.
   If modeling a business process, take advantage of the
    "rake" notation and sub-activity diagrams.
        "level 0" diagram keep all the actions at a very high level
         of abstraction. Expand the details in sub-diagrams at the
         level 1, and perhaps even more at the level 2.
     to make the level of abstraction of action nodes roughly
      equal within a diagram.
        bad  example: suppose in a "level 0" diagram there is an
         action node labeled "Deliver Order." And, a second action
         node "Calculate Tax." Those are very different levels of

Software Engineering                                                          11
                                                    Object-oriented Analysis and Design

      NextGen POS Activity Diagram
    Customer                      Cashier         NextGen POS

   Shop and Fill

                          Enter Cart Items

                                             Calculate Taxes
                                              and Discounts

                                             [ cash       [ else ]
                                             payment ]
                                                                 Submit            Authorize
                                                               Authorization       Payment

      Receipt                                 Create Receipt

                          Hand Over Items

Software Engineering                                                                           12
                                       Object-oriented Analysis and Design

         Activity Diagrams in the UP
     UP disciplines - Business Modeling
        itspurpose is to understand and communicate the structure
         and the dynamics of the organization in which a system is
         to be deployed.
        A key artifact of the Business Modeling discipline is the
         Business Object Model (a superset of the UP Domain
         Model), which essentially visualizes how a business
         works, using UML class, sequence, and activity diagrams.

Software Engineering                                                         13
                       Object-oriented Analysis and Design

                Chap 29
      UML State Machine Diagrams
            and Modeling

Software Engineering                                         14
                                          Object-oriented Analysis and Design

            State Machine Diagram 1
     State machine diagram
        shows    the lifecycle of an object: what events it
         experiences, its transitions, and the states it is in between
         these events.
        It need not illustrate every possible event.
        Transitions are shown as arrows, labeled with their event.
        States are shown in rounded rectangles.
        initial pseudo-state automatically transitions to another
         state when the instance is created.

Software Engineering                                                            15
                                            Object-oriented Analysis and Design

                State Machine Diagram 2


                    initial state

                     off hook
       Idle                             Active                      state

                     on hook

   transition                       event

Software Engineering                                                              16
                                           Object-oriented Analysis and Design

       Events, States, and Transitions
     An event is a significant or noteworthy occurrence.
        A telephone   receiver is taken off the hook.
     A state is the condition of an object at a moment in time
      between events.
       A   telephone is in the state of being "idle" after the receiver
         is placed on the hook and until it is taken off the hook.
     A transition is a relationship between two states
        indicates that when an event occurs, the object moves
         from the prior state to the subsequent state.
        e.g. When the event "off hook" occurs, transition the
         telephone from the "idle" to "active" state.

Software Engineering                                                             17
                                                Object-oriented Analysis and Design

      Transition Actions and Guards
   A transition can cause an action to fire.
      this may be implemented as the invocation of a method of the
   A transition may also have a conditional guard or boolean test.
      The transition only occurs if the test passes.

                      transition action

                       off hook / play dial tone
                            [valid subscriber
        Idle                                                       Active

                                on hook
                                          guard condition

Software Engineering                                                                  18
                                            Object-oriented Analysis and Design

      Apply State Machine Diagrams 1
   State-Independent Objects (modeless)
      always responds the same way to an event.
   State-dependent objects
      react differently to events depending on their state or mode.
   Guideline
      state machines for state-dependent objects with complex behavior.
      The phone's reaction to pushing a particular button (generating an
        event) depends on the current mode of the phone off hook, engaged.
   Guideline
      business information systems have few complex state-dependent
        classes. It is seldom helpful to apply state machine modeling.
      process      control, device control, protocol handlers, and
        telecommunication domains have many state-dependent objects.

Software Engineering                                                              19
                                          Object-oriented Analysis and Design

      Apply State Machine Diagrams 2
    To model the behavior of a complex reactive object in
     response to events.
       Physical  Devices controlled by software: Phone, car,
        microwave oven. They have complex and rich reactions to
        events, and the reaction depends upon their current mode.
       Transactions and related Business Objects: a sale, order,
        payment. For example, what should happen to an Order if a
        cancel event occurs?
          understanding all the events and states that a Package can go
           through in the shipping business can help with design,
           validation, and process improvement.
       Role  Mutators (objects change their role): A Person
       changing roles from being a civilian to a veteran. Each role
       is represented by a state.
Software Engineering                                                            20
                                               Object-oriented Analysis and Design

      Apply State Machine Diagrams 3
    To model legal sequences of operations protocol or language
        Communication Protocols: TCP, and new protocols
           The diagram illustrates when operations are legal.
           a TCP "close" request should be ignored if the protocol handler is
            already in the "closed" state.
       UI Page/Window Flow or Navigation
           to understand the legal sequence between Web pages or windows;
            this is often complex.
       UI Flow Controllers or Sessions
           This is related to UI navigation modeling, but specifically focused
            on the server-side object that controls page flow.
           These are usually server-side objects representing an ongoing
            session or conversations with a client.
           e.g., a Web application that remembers the state of the session with
            a Web client and controls the transitions to new Web pages, or the
            modified display of the current Web page, based upon the state of
            the session and the next operation that is received.
Software Engineering                                                                 21
                                            Object-oriented Analysis and Design

     Apply State Machine Diagrams 3
   To model legal sequences of operations protocol or
    language specifications.
      Use   Case System Operations
         System operations for Process Sale: makeNewSale, enterItem,
          should arrive in a legal order;
         e.g., endSale should come after one or more enterItem
          operations. If the order is complex, a state machine can model
          this, treating the use case itself as an object.
      Individual UI   Window Event Handling
         Understanding the events and legal sequences for one window
          or form.
         e.g., the Edit-Paste action is only valid if there is something in
          the "clipboard" to paste.

Software Engineering                                                              22
                                                 Object-oriented Analysis and Design

                        Nested States
   A state allows nesting to contain substates; a substate
    inherits the transitions of its superstate
      itleads to succinct state machine diagrams.
      e.g., when a transition to the Active state occurs, creation and
       transition into the PlayingDialTone substate occurs. No
       matter what substate the object is in, if the on hook event
       related to the Active superstate occurs, a transition to the Idle
       state occurs.
               Off hook/play dial tone                         Active
                  [valid subscriber                                         Talking
     Idle                                    PlayingDialTone

                                         digit       digit        connected
                     On hook                     Dialing       complete

Software Engineering                                                                   23
                                          Object-oriented Analysis and Design

UI Navigation Modeling with State Machines
   Some (Web) UI applications have complex page flows.
      State machines are a great way to to model page flows, during
       creative design.
      The states represent the pages and the events represent the
       events that cause transfer from one page to another, such as a
       button click.

Software Engineering                                                            24
                       Object-oriented Analysis and Design

NextGen POS State Machine Diagram

Software Engineering                                         25
                                        Object-oriented Analysis and Design

  State Machine Diagrams in the UP
     There is not one model in the UP called the "state
        Any    element in any model (Design Model, Domain
         Model, Business Object Model) may have a state machine
         to better understand or communicate its dynamic behavior
        e.g., a state machine associated with the Sale design class
         of the Design Model is itself part of the Design Model

Software Engineering                                                          26
                          Object-oriented Analysis and Design

                   Chap 30
              Relating Use Cases

Software Engineering                                            27
                                            Object-oriented Analysis and Design

            The include Relationship                           1

    Some partial behavior across several use cases.
       paying by credit occurs in several use cases, including Process
        Sale, Process Rental, Contribute to Lay-away Plan.
       to separate it into its own subfunction use case, and indicate its
       This is simply refactoring and linking text to avoid duplication
    UC1: Process Sale
       Main Success Scenario:
           1.Customer arrives at a POS checkout with goods and/or
            services to purchase
           .…
           7.Customer pays and System handles payment.…
       Extensions:
           7b. Paying by credit: Include Handle Credit Payment.
           7c. Paying by check: Include Handle Check Payment.…
    UC7: Process Rental
       Extensions:
           6b. Paying by credit: Include Handle Credit Payment.
Software Engineering                                                              28
                                         Object-oriented Analysis and Design

           The include Relationship                         2

     UC12: Handle Credit Payment
        Level: Subfunction
        Main Success   Scenario:
           1.Customer enters their credit account information.
           2.System sends payment authorization request to an external
            Payment Authorization Service System, and requests
            payment approval.
           3.System receives payment approval and signals approval to
        Extensions:
           2a.  System detects failure to collaborate with external
               System signals error to Cashier.
               Cashier asks Customer for alternate payment.

Software Engineering                                                           29
                                                Object-oriented Analysis and Design

            The include Relationship                               3

    Using include with Asynchronous Event Handling
       when a user is able to, at any time, select or branch to a particular
         window, function, or Web page, or within a range of steps.
    a*, b*, ... style labels in the Extensions section.
    UC1: Process FooBars
       Main Success Scenario:
       Extensions:
            a*. At any time, Customer selects to edit personal information: Edit
             Personal Information.
            b*. At any time, Customer selects printing help: Present Printing Help.
            2-11. Customer cancels: Cancel Transaction Confirmation
    Subfunction use cases and use the include relationship when:
       They are duplicated in other use cases.
       A use case is very complex and long, and separating it into subunits
         aids comprehension.
    As a first rule, always use the include relationship between use cases.
Software Engineering                                                                   30
                                                            Object-oriented Analysis and Design

                   The include Relationship                                     4

                                          NextGen POS

                                          Process Sale

                              «include»                  «include»                     «actor»
                                                «include»                              System
                     Handle Check         Handle Cash           Handle Credit
                       Payment             Payment               Payment
      Customer                                                                          «actor»
                                                «include»                                Credit
                            «include»                       «include»                 Authorization
UML notation:
the base use
                                          Process Rental
case points to
the included use
                       Handle Returns

                                           Manage Users


Software Engineering                                                                                  31
                                         Object-oriented Analysis and Design

            Concrete/Abstract Use Cases
   Concrete use case
      Be  initiated by an actor and performs the entire behavior
       desired by the actor.
      Process Sale is a concrete use case.
   Abstract use case
      Be  never instantiated by itself; it is a subfunction use case
       that is part of another use case.
      Handle Credit Payment is abstract; it doesn't stand on its
       own, but is always part of another story, such as Process

Software Engineering                                                           32
                                         Object-oriented Analysis and Design

               Base/Addition Use Cases
   Base use case
      includes  another use case, or is extended or specialized by
       another use case. Process Sale is a base use case with respect
       to the included Handle Credit Payment.
   Addition use case
      be  an inclusion, extension, or specialization. Handle Credit
       Payment is the addition use case in the include relationship
       to Process
   Sale. Addition use cases are usually abstract. Base use
    cases are usually concrete.

Software Engineering                                                           33
                                                     Object-oriented Analysis and Design

             The extend Relationship                                   1

     The extend relationship
        Suppose a use case's text should not be modified or has been baselined
          as a stable artifact, and can't be touched.
        to create an extending or addition use case, and within it, describe
          where and under what condition it extends the behavior of some base
          use case.
     UC1: Process Sale (the base use case)
        Extension Points: VIP Customer, step 1. Payment, step 7.
        Main Success Scenario:
             1.Customer arrives at a POS checkout with goods         and/or services to
             .…
             7.Customer pays and System handles payment.…
     UC15: Handle Gift Certificate Payment (the extending use case)
        Trigger: Customer wants to pay with gift certificate.
        Extension Points: Payment in Process Sale.
        Level: Subfunction
        Main Success Scenario:
             1.Customer gives gift certificate to Cashier.
             2.Cashier enters gift certificate ID.
Software Engineering                                                                       34
                                        Object-oriented Analysis and Design

           The extend Relationship                        2

     The use of an extension point, and that the extending use
      case is triggered by some condition.
        Extension  points are labels in the base use case which the
         extending use case references as the point of extension.
        the extension point may simply "At any point in use case
         X." with many asynchronous events, such as a word
         processor ("do a spell check now," "do a thesaurus lookup
         now"), or reactive control systems.
   updating the Extensions section is usually the preferred
    solution, rather than creating complex use case
   Practically motivates using the extend technique
   when it is undesirable for some reason to modify the
    base use case.
Software Engineering                                                          35
                                                Object-oriented Analysis and Design

           The extend Relationship                                3

        Process Sale

     Extension Points :
         Payment                                  UML notation  :
       VIP Customer                               1. The extending use case
                                                  points to the base use case .
                   Payment, if Customer           2. The condition and
                  presents a gift certificate     extension point can be
                                                  shown on the line .
    Handle Gift Certificate

Software Engineering                                                                  36
                                           Object-oriented Analysis and Design

         The generalize Relationship
     Can do use case work without this optional relationship
        adds another level   of complexity to use cases.

Software Engineering                                                             37
                       Object-oriented Analysis and Design

                Chap 31
         More SSDs and Contracts

Software Engineering                                         38
                                             Object-oriented Analysis and Design

                       NextGen POS 1
    New System Sequence Diagrams
       In the current iteration, the new payment handling requirements
         involve new collaborations with external systems.
       To review, SSDs use sequence diagram to illustrate inter-system
         collaborations, treating each system as a blackbox.
    To illustrate the new system events in SSDs in order to clarify:
       new system operations that the NextGen POS system will need to
       calls to other systems, and the responses to expect from these calls
    Common Beginning of Process Sale Scenario
       The SSD for the beginning portion of a basic scenario includes
         makeNewSale, enterItem, and endSale system events; it is common
         regardless of the payment method

Software Engineering                                                               39
                                                    Object-oriented Analysis and Design

                          NextGen POS 2

                     Process Sale Scenario                                    «actor»
                                                  System                   TaxCalculator
     : Cashier            makeNewSale

loop [more items ]
                      enterItem(itemID, quantity)


                             endSale                           taxLineItems=
                          total with taxes

 Software Engineering                                                                      40
                                                        Object-oriented Analysis and Design

                               NextGen POS 3
                                Credit payment SSD

                         :NextGenPOS                                                  «actor»
                            System                            :CreditAuthorization
                                                                    Service          :Accounts

       (credNum, expiryDate)

                                  reply = requestApproval( request )

                                                postReceivable( receivable )

                                                       postSale( sale )

Software Engineering                                                                             41
                                             Object-oriented Analysis and Design

                       NextGen POS 4
    In both cases of credit and check payments, a assumption (for this
     iteration) - the payment is exactly equal to the sale total, and a
     different amount does not have be an input parameter.
    the call to the external CreditAuthorization Service is modeled as a
     regular synchronous message with a return value.
        This is an abstraction that could be implemented with a SOAP
          request over secure HTTPS, or any remote communication
    The makeCreditPayment system operation and the use case assume
        the credit information (credit account number and expiry date) of
          the customer is coming from a credit card (reader).
    when a credit authorization service approves a credit payment, it owes
     the store for the payment; thus, a receivables entry needs to be added
     to the accounts receivable system.

Software Engineering                                                               42
                                                Object-oriented Analysis and Design

                        NextGen POS 5
     Check payment SSD.

   :Cashier                                                           Service

          (driversLicenseNumber )

                                      reply = requestApproval(request)

Software Engineering                                                                   43
                                             Object-oriented Analysis and Design

                       NextGen POS 6
   In this iteration, the new system operations must handle are:
       makeCreditPayment
       makeCheckPayment
   In the first iteration, the system operation for the cash payment was
    simply makePayment.
       Now that the payments are of different types, it is renamed to
   To review, system operation contracts are an optional requirements
    artifact (part of the Use-Case Model)
       Usually, the use case text is itself sufficient, and these contracts
         aren't useful.
       But on occasion they bring value by their precise and detailed
         approach to identifying what happens when a complex operation
         is invoked on the system, in terms of state changes to objects
         defined in the Domain Model.
Software Engineering                                                               44
                                            Object-oriented Analysis and Design

                       NextGen POS 7
    Contract CO5: makeCreditPayment
       Operation:makeCreditPayment(             creditAccountNumber,
        expiryDate )
       Cross References:Use Cases: Process Sale
       Preconditions: An underway sale exists and all items have been
       Postconditions:
            a CreditPayment pmt was created
            pmt was associated with the current Sale sale
            a CreditCard cc was created; cc.number = creditAccountNumber,
             cc.expiryDate = expiryDate
            cc was associated with pmt
            a CreditPaymentRequest cpr was created
            pmt was associated with cpr
            a ReceivableEntry re was created
            re was associated with the external AccountsReceivable
            sale was associated with the Store as a completed sale
    postcondition indicating the association of a new receivable entry in
     accounts receivable.
Software Engineering                                                              45
                                                 Object-oriented Analysis and Design

                        NextGen POS 8
    During testing, it is clear from this post-condition that the accounts
     receivable system should be tested for the presence of a new
     receivable entry.
    Contract CO6: makeCheckPayment
        Operation:makeCheckPayment( driversLicenceNumber )
        Cross References:Use Cases: Process SalePreconditions:An
         underway sale exists and all items have been entered.
        Postconditions:
            a CheckPayment pmt was created
            pmt was associated with the current Sale sale
            a DriversLicense dl was created;                      dl.number       =
            dl was associated with pmt
            a CheckPaymentRequest cpr was created.
            pmt was associated with cpr
            sale was associated with the Store as a completed sale

Software Engineering                                                                   46
                          Object-oriented Analysis and Design

                 Chapter 33
            Architectural Analysis

Software Engineering                                            47
                                      Object-oriented Analysis and Design

   Introduction
   When to do “architectural analysis”
   Definition: variation and evolution point
   Architectural analysis
   Identification and analysis of architectural factors
   Resolution of architectural factors

Software Engineering                                                        48
                                  Object-oriented Analysis and Design

   The essence   of architectural analysis is
     to   identify factors that should influence the
       architecture, understand their variability and
       priority, and resolve them.

Software Engineering                                                    49
                               Object-oriented Analysis and Design

When Do We Start Architectural Analysis?

   Should   start even before the first development
    iteration, as architectural issues need to be
    identified and resolved in early development
   Architecturally-significant factor
     "must  be internationalized to support English,
      Chinese, and Hindi"
     "must handle 500 concurrent transactions with
      on-average one-second response time"

Software Engineering                                                 50
                                 Object-oriented Analysis and Design

Definition: Variation and Evolution Points

   Variation   point
     Variations     in the existing current system or
       requirements, such as the multiple tax calculator
       interfaces that must be supported.
   Evolution   point
     Speculative   points of variation that may arise in
       the future, but which are not present in the
       existing requirements
   Variation and evolution points are recurring key
    elements in architectural analysis

Software Engineering                                                   51
                                   Object-oriented Analysis and Design

            Architectural analysis
   Architectural      analysis is concerned with
     The  identification and resolution of the system's
      non-functional requirements (for example,
      security), in the context of the functional
      requirements (for example, processing sales).
     The identification of variation points and the
      most probable evolution points.

Software Engineering                                                     52
                                          Object-oriented Analysis and Design

     Examples of the many issues to be identified and
      resolved at an architectural level:
        How  do reliability and fault-tolerance requirements affect
        the design
           in the NextGen POS, for what remote services (e.g., tax
            calculator) will fail-over to local services be allowed
        How  do the adaptability and configurability requirements
        affect the design
           most   retailers have variations in business rules they want
            represented in their POS applications. What are the
            variations? What is the "best" way to design for them? What
            is the criteria for best?

Software Engineering                                                            53
                                  Object-oriented Analysis and Design

   Common     Steps in Architectural Analysis
     Identify    and analyze the non-functional
      requirements that have an impact on the
     Analyze alternatives and create solutions that
      resolve the impact. These are architectural
         "remove the requirement,"
         "stop the project,”
         "hire an expert.”
Software Engineering                                                    54
                               Object-oriented Analysis and Design

         Identification and Analysis of
            Architectural Factors
   When    defining quality requirements during
    architectural factor analysis, quality scenarios
    are recommended.
   Quality scenarios
     Define   measurable (or at least observable)
      responses, and thus can be verified.
     It is not much use to vaguely state "the system
      will be easy to modify" without some measure of
      what that means

Software Engineering                                                 55
                                 Object-oriented Analysis and Design

                Quality Scenario
   Quality  scenarios are short statements of the
    form <stimulus> <measurable response>; for
     When   the completed sale is sent to the remote tax
      calculator to add the taxes, the result is returned
      within 2 seconds "most" of the time, measured
      in a production environment under "average"
      load conditions.
     When a bug report arrives from a NextGen beta
      test volunteer, reply with a phone call within 1
      working day
Software Engineering                                                   56
                                      Object-oriented Analysis and Design

                   Pick Your Battles
   A caution: Writing these quality scenarios can be a
    mirage of usefulness.
   It's easy to write these detailed specifications, but not to
    realize them.
            anyone ever really test them?
        Will
        How and by whom?
     A strong dose of realism is required when writing these;

Software Engineering                                                        57
                                          Object-oriented Analysis and Design

                     Factor Table

          One important goal of architectural analysis is to understand the
          influence of the factors, their priorities, and their variability
Software Engineering                                                            58
                         Object-oriented Analysis and Design

         Factors and UP Artifacts

Software Engineering                                           59
                                               Object-oriented Analysis and Design

  Resolution of Architectural Factors
     Technical Memo:                        Solution
     Issue:                                   …
         ReliabilityRecovery from           Motivation
          Remote Service Failure                …
     Solution Summary:                      Unresolved Issues
         …                                    …
     Factors                                Alternatives Considered
         Robust     recovery from             …
          remote service failure (e.g.,
          tax calculator, inventory)
         Robust     recovery from
          remote     product     (e.g.,
          descriptions and prices)                    Technical Memo
          database failure

Software Engineering                                                                 60
                                  Object-oriented Analysis and Design

 Basic Architectural Design Principles
   low coupling
   high cohesion
   protected variation
   Separation of Concerns and Localization of
     Modularize       the   concern    into      a      separate
     Use decorators.
     Use     post-compilers      and         aspect-oriented

Software Engineering                                                    61
                       Object-oriented Analysis and Design

               Chapter 3
    Logical Architecture Refinement

Software Engineering                                         62
                                Object-oriented Analysis and Design

   Explore   more issues in logical architecture and
    the Layers pattern, including inter-layer
   Present the logical architecture for this iteration
    of the case studies.
   Apply the Facade, Observer, and Controller
    patterns in the context of architectural layers

Software Engineering                                                  63
                                       Object-oriented Analysis and Design

                       Example: NextGen Logical Architecture

                          Dependency lines can be used to communicate
                          coupling between packages or types in packages

Software Engineering                                                         64
                       Object-oriented Analysis and Design

                           Hide the specific types, and
                           focus on illustrating the
                           package-package coupling

Software Engineering                                         65
                         Object-oriented Analysis and Design

                       Architecturally significant scenarios

Software Engineering                                           66
                                Object-oriented Analysis and Design

Collaborations with the Layers Pattern
   Facade
     For packages that represent subsystems, the most
      common pattern of access is Façade
     A public facade object defines the services for
      the subsystem, and clients collaborate with the
      facade, not internal subsystem components.

Software Engineering                                                  67
                             Object-oriented Analysis and Design

  Number of interfaces exposed to upper layers

Software Engineering                                               68
                             Object-oriented Analysis and Design

Session Facades and the Application Layer

   When    an application has many system
    operations and supports many use cases, it is
    common to have more than one object mediating
    between the UI and Domain layers

Software Engineering                                               69
                                Object-oriented Analysis and Design


Software Engineering                                                  70
                                       Object-oriented Analysis and Design

               “Controller” Pattern
     The GRASP Controller pattern describes common
      choices in client-side handlers (or controllers, as they've
      been called) for system operation requests emitting from
      the UI layer

Software Engineering                                                         71
                                Object-oriented Analysis and Design


Software Engineering                                                  72
                       Object-oriented Analysis and Design

Upward Collaboration with Observer

Software Engineering                                         73
                       Object-oriented Analysis and Design

 The Classic Three-Tier Architecture

Software Engineering                                         74
                                             Object-oriented Analysis and Design

     A three-tier logical division deployed in two physical architectures

Software Engineering                                                               75
                                         Object-oriented Analysis and Design

           Model-View Separation and
           "Upward" Communication
     How can windows obtain information to display?
        Pull-from-above:
           send messages to domain objects, querying for information
            which they then display in widget
        Push-from-below
           changing domain objects to communicate with windows to
            cause a display update as the state of domain objects
           Observer pattern: making the GUI object simply appear as
            an object that implements an interface such as
           A UI facade object

Software Engineering                                                           76
                               Object-oriented Analysis and Design

                       UI facade

Software Engineering                                                 77
                           Object-oriented Analysis and Design

                   Chapter 36
                 Package Design

Software Engineering                                             78
                                   Object-oriented Analysis and Design

   Organize packages to reduce the impact of changes.
   Know alternative UML package structure notation.

Software Engineering                                                     79
                                        Object-oriented Analysis and Design

      Package Organization Guidelines
     Guideline: Package Functionally Cohesive Vertical
      and Horizontal Slices
        Modularization  based on functional cohesion - types
         (classes and interfaces) are grouped together that are
         strongly related in terms of their participation in a
         common purpose, service, collaborations, policy, and
     Guideline: Package a Family of Interfaces
        Place  a family of functionally related interfaces in a
         separate package - separate from implementation classes.
        EJB package javax.ejb is an example: It is a package of at
         least twelve interfaces; implementations are in separate

Software Engineering                                                          80
                                            Object-oriented Analysis and Design

     Guideline: Package by Work and by Clusters of Unstable
        Suppose
           1) there is an existing large package P1 with thirty classes,
           2) there is a work trend that a particular subset of ten classes
            (C1 through C10) is regularly modified and re-released.
        In this case, refactor P1 into P1-a and P1-b, where P1-b
         contains the ten frequently worked on classes.

Software Engineering                                                              81
                                       Object-oriented Analysis and Design

     Guideline: Most Responsible Are Most Stable
        If the most responsible (depended-on) packages are
         unstable, there is a greater chance of widespread change
         dependency impact

Software Engineering                                                         82
                                     Object-oriented Analysis and Design

     Guideline: Factor out Independent Types

Software Engineering                                                       83
                                        Object-oriented Analysis and Design

     Guideline: No Cycles in Packages
        If a group of packages have cyclic dependency, then they
         may need to be treated as one larger package in terms of a
         release unit.
        This is undesirable because releasing larger packages (or
         package aggregates) increases the likelihood of affecting

Software Engineering                                                          84
                        Object-oriented Analysis and Design

               Chapter 37.
            UML Deployment and
            Component Diagrams

Software Engineering                                          85
                                Object-oriented Analysis and Design

     Summarize UML deployment and component diagram

Software Engineering                                                  86
                                    Object-oriented Analysis and Design

            Deployment Diagrams
   A deployment diagram shows the assignment of
    concrete software artifacts (such as executable files) to
    computational nodes (something with processing
   It shows the deployment of software elements to the
    physical architecture and the communication (usually
    on a network) between physical elements.

Software Engineering                                                      87
                       Object-oriented Analysis and Design

Software Engineering                                         88
                                          Object-oriented Analysis and Design

     The basic element of a deployment diagram is a node, of
      two types:
        device node (or device)
        execution environment node (EEN) a software computing
         resource that runs within an outer node (such as a
         computer) and which itself provides a service to host and
         execute other executable software elements. For example:
           an operating system (OS)
           a virtual machine
           a database engine (such as PostgreSQL)
           a Web browser hosts and executes JavaScript, Java applets,
            Flash, and other executable technologies
           a workflow engine
           a servlet container or EJB container

Software Engineering                                                            89
                                        Object-oriented Analysis and Design

               Component Diagrams
     Components are a slightly fuzzy concept in the UML
        The   distinction between a structured class and a
         component is somewhat vague and more a matter of intent
         than firm semantics. [RJB04]
        A component represents a modular part of a system that
         encapsulates its contents and whose manifestation is
         replaceable within its environment. A component defines
         its behavior in terms of provided and required interfaces.
         As such, a component serves as a type, whose
         conformance is defined by these provided and required
         interfaces. [OMG03b]

Software Engineering                                                          90
                                        Object-oriented Analysis and Design

     When one uses a UML component, the modeling and
      design intent is to emphasize
        1) thatthe interfaces are important, and
        2) it is modular, self-contained and replaceable. The
         second point implies that a component tends to have little
         or no dependency on other external elements (except
         perhaps standard core libraries); it is a relatively stand-
         alone module.
     Home entertainment system;
        we expect to be able to easily replace the DVD player or
         speakers. They are modular, self-contained, replaceable,
         and work via standard interfaces.

Software Engineering                                                          91
                                     Object-oriented Analysis and Design

     For example, at a large-grained level, a SQL database
      engine can be modeled as a component;
        any database that understands the same version of SQL
         and supports the same transaction semantics can be

Software Engineering                                                       92
                        Object-oriented Analysis and Design

      Ch 38: Designing a Persistence
        Framework with Patterns

Software Engineering                                          93
                                            Object-oriented Analysis and Design

                     Persistence object
     In the NextGen application, ProductDescription data
      resides in a relational database.
        Itmust be brought into local memory during application
        Persistent objects are those that require persistent storage,
         such as ProductDescription instances.
     Storage mechanism
        Object database
        Relational    database: a special OR mapping service is
        Other
               Flat files, XML, Palm OS PDB files, …

Software Engineering                                                              94
                                       Object-oriented Analysis and Design

            Persistence Framework
   A persistence framework is a general-purpose,
    reusable, and extendable set of types that provides
    functionality to support persistent objects.
   A persistence service (or subsystem) in the persistence
    framework actually provides the service, and will be
    created with a persistence framework.
   A persistence service is usually written to work with
    RDBs, in which case it is also called an O-R mapping
      A   persistence service must translate objects into records
        and save them in a database, and
       translate records into objects when retrieving from a

Software Engineering                                                         95
                                   Object-oriented Analysis and Design

   A framework is an extendable set of objects for related
    functions. The quintessential example is a GUI
    framework, such as Java's Swing framework
   It provides an implementation for the core and
    unvarying functions, and includes a mechanism to allow
    a developer to plug in the varying functions, or to
    extend the functions.
   Has abstract classes that may contain both abstract and
    concrete methods
   Relies on the Hollywood Principle
       "Don't  call us, we'll call you.“
       user-defined classes will receive messages from the
        predefined framework classes. These are handled by
        implementing superclass abstract methods

Software Engineering                                                     96
                                   Object-oriented Analysis and Design

 Requirements for Persistence Service
   PFW (Persistence FrameWork in this book) is a
    simplified framework – a full-blown, industrial-strength
    persistence framework is outside the scope of this
   The framework should provide functions such as:
       store and retrieve objects in a persistent storage
       commit and rollback transactions

Software Engineering                                                     97
                                         Object-oriented Analysis and Design

                          Key Idea
     Mapping
        There   must be some mapping between a class and its
         persistent store (for example, a table in a database), and
         between object attributes and the fields (columns) in a
     Object identity
        To easily relate records to objects, and to ensure there are
         no inappropriate duplicates, records and objects have a
         unique object identifier.
     Database mapper
       A  Pure Fabrication database mapper is responsible for
         materialization and dematerialization

Software Engineering                                                           98
                                              Object-oriented Analysis and Design

                      Key Idea (conti.)
     Materialization and dematerialization
        Materialization
            the act of transforming a non-object representation of data
               (for example, records) from a persistent store into objects.
        Dematerialization
            the opposite activity (also known as passivation).
     Lazy materialization
        Not  all objects are materialized at once; a particular
         instance is only materialized on-demand, when needed.

Software Engineering                                                                99
                                     Object-oriented Analysis and Design

Pattern: Representing Objects as Tables
     Defining a table in an RDB for each persistent object
      class. Object attributes containing primitive data types
      (number, string, boolean, and so on) map to columns

Software Engineering                                                       100
                                           Object-oriented Analysis and Design

         UML Data Modeling Profile
     UML has become a popular notation for data models
     These stereotypes are not part of the core UML- they are an
     To generalize, the UML has the concept of a UML profile: a
      coherent set of UML stereotypes, tagged values, and constraints for
      a particular purpose.

Software Engineering                                                             101
                                     Object-oriented Analysis and Design

         Pattern: Object Identifier
   The Object Identifier pattern proposes assigning an
    object identifier (OID) to each record and object (or
    proxy of an object).
   Every table will have an OID as primary key, and each
    object will (directly or indirectly) also have an OID.
   If every object is associated with an OID, and every table
    has an OID primary key, every object can be uniquely
    mapped to some row in some table

Software Engineering                                                       102
                                Object-oriented Analysis and Design


Software Engineering                                                  103
                                  Object-oriented Analysis and Design

      Accessing a Persistence Service
              with a Facade
   Define a facade for the persistence services
   An operation is needed to retrieve an object given an
   The subsystem needs to know what type of object to

Software Engineering                                                    104
                                         Object-oriented Analysis and Design

 Mapping Objects: Database Mapper
   PersistenceFacade - as true of all facades - does not do
    the work itself, but delegates requests to subsystem
   Who should be responsible for materialization and
    dematerialization of objects (for example, a
    ProductDescription) from a persistent store ?
   If a persistent object class defines the code to save itself
    in a database, it is called a direct mapping design
       Strong  coupling of the persistent object class to persistent
        storage knowledge - violation of Low Coupling.
       Complex responsibilities in a new and unrelated area to
        what the object was previously responsible for - violation
        of High Cohesion

Software Engineering                                                           105
                                       Object-oriented Analysis and Design

     We will explore a classic indirect mapping approach,
      that uses other objects to do the mapping for persistent
       A   different mapper class is defined for each persistent
         object class

Software Engineering                                                         106
                                Object-oriented Analysis and Design


Software Engineering                                                  107
                       Object-oriented Analysis and Design

Software Engineering                                         108
                                       Object-oriented Analysis and Design

         Pattern: Template Method
   The heart of framework design
   The idea
       to define a method (the Template Method) in a superclass
        that defines the skeleton of an algorithm, with its varying
        and unvarying parts.
       The Template Method invokes other methods, some of
        which are methods that may be overridden in a subclass.
        Thus, subclasses can override the varying methods in
        order to add their own unique behavior at points of

Software Engineering                                                         109
                               Object-oriented Analysis and Design


Software Engineering                                                 110
                                                Object-oriented Analysis and Design

     The basic repeating algorithm structure for materializing
      an object is:
           if (object in cache)
               return it
              create the object from its representation in storage
              save object in cache
              return it

Software Engineering                                                                  111
                       Object-oriented Analysis and Design

Materialization and Template Method

Software Engineering                                         112
                       Object-oriented Analysis and Design

  Template method and hook method

Software Engineering                                         113
                       Object-oriented Analysis and Design

Software Engineering                                         114
                       Object-oriented Analysis and Design

Software Engineering                                         115
                                        Object-oriented Analysis and Design

Transactional States and State Pattern
     Transactional support
        Persistent objects can be inserted, deleted, or modified.
        Operating on a persistent object (for example, modifying
         it) does not cause an immediate database update; rather, an
         explicit commit operation must be performed

Software Engineering                                                          116
                       Object-oriented Analysis and Design

Software Engineering                                         117
                       Object-oriented Analysis and Design

Software Engineering                                         118
                                       Object-oriented Analysis and Design

      Designing a Transaction with
           Command Pattern
   Informally, a transaction is a unit of work- a set of tasks
    whose tasks must all complete successfully, or none
    must be completed. That is, its completion is atomic.
   The tasks of a transaction include inserting, updating,
    and deleting objects.
       One  transaction could contain two inserts, one update, and
        three deletes, for example.
       To represent this, a Transaction class is added
       the order of database tasks within a transaction can
        influence its success (and performance)

Software Engineering                                                         119
                         Object-oriented Analysis and Design

              Pattern: Command

Software Engineering                                           120
                       Object-oriented Analysis and Design

Software Engineering                                         121
                                      Object-oriented Analysis and Design

        Lazy Materialization with a
              Virtual Proxy
   It is sometimes desirable to defer the materialization of
    an object until it is absolutely required, usually for
    performance reasons
   For example, suppose that ProductDescription objects
    reference a Manufacturer object, but only very rarely
    does it need to be materialized from the database
   A Virtual Proxy is a proxy for another object (the real
    subject) that materializes the real subject when it is first
    referenced; therefore, it implements lazy materialization.
    It is a lightweight object that stands for a "real" object
    that may or may not be materialized.

Software Engineering                                                        122
                       Object-oriented Analysis and Design

Software Engineering                                         123
                                            Object-oriented Analysis and Design

How to Represent Relationships in Tables
      The answer is given in the Representing Object Relationships as
       Tables pattern, which proposes the following:
      one-to-one associations
         Place an OID foreign key in one or both tables representing the
          objects in relationship.
         Or, create an associative table that records the OIDs of each
          object in relationship.
      one-to-many associations, such as a collection
         Create an associative table that records the OIDs of each object
          in relationship.
      many-to-many associations
         Create an associative table that records the OIDs of each object
          in relationship.

 Software Engineering                                                             124
                                        Object-oriented Analysis and Design

      PersistentObject Superclass and
          Separation of Concerns
     A common partial design solution to providing
      persistence for objects is
        to  create an abstract technical services superclass
         PersistentObject that all persistence objects inherit from
     Such a class usually defines attributes for persistence,
      such as a unique OID, and methods for saving to a

Software Engineering                                                          125
                       Object-oriented Analysis and Design

Chapter 39: UML and N+1 View Model

Software Engineering                                         126
                           Object-oriented Analysis and Design

             Logic view of Struts

Software Engineering                                             127
                       Object-oriented Analysis and Design

Software Engineering                                         128
                       Object-oriented Analysis and Design

Software Engineering                                         129