Docstoc

Dvd Case Template - PowerPoint

Document Sample
Dvd Case Template - PowerPoint Powered By Docstoc
					     Matching Effectiveness and
       OTS Model Richness


   Weimin Ma          Kendra Cooper          Lawrence Chung
weiminma@utdallas.edu kcooper@utdallas.edu   chung@utdallas.edu

               Department of Computer Science
               The University of Texas at Dallas
Outline

  The CAT
  Similarity metric calculation for keyword matching
  •   Keyword matching without structure
  •   Keyword matching with structure
  Similarity metric calculation for case-based matching
  •   Case-based matching without structure
  •   Case-based matching with structure
  Conclusions
         The CAT

The proposal of CAT (Component Aware Techniques) is effectively using components
that meet the stakeholders’ needs for a component based application
Matching Off-The-Shelf (OTS) components, using a representation of OTS components
as an aggregate of their functional and non-functional requirements and architecture, is
an important activity


           OTS Component Repository                                                        SUD Product Model Repository
      Java Authentication and                                    …    Secure     Good Performance     Easy to Use Interface   …
       Authorization Service        C                                                                                                    Search theCatalog

                                                                                 -                                                                   …
                               R            A                                                     Configurable
                                                                                                  Interface
                                                              +                                                          Variety of
                                                                                                                          Interface
       Tivoli     C                                           + Encryption                  PC platform                    Options
                                                C    PDA      + Role Based
            R                                       Protect                                                                           Touch Screen
                        A                                     + Access Control                 Novice                                 Interface
                                        R     A               +                             Configuration          GUI
                        Security, communication,                        Authentication
                      … multimedia, compression, etc.                                                         Expert              Audio/Video
                                                              +                                               Configuration       User Interface
                                                              + --
                        components
      Legend
                Softgoal (non-functional)                 NFR Contribution               OTS Component                 Hardgoal (functional)
                Claim                                     Or Decomposition               And Decomposition

      Figure 1. Results of Matching, Ranking, and Selecting OTS components




                            But, how do we do the matching effectively?
                     Keyword Matching without Structure
                                         Table 1: Keyword matching format and its text
                                         match value and depth information
                                                                                           Depth of
                                         Priority      Query Value     Text_match         traversing       Default value for
                                                                                           structure
                                                                                                           matching without
                                                                             0                 0
                                            1        Security                                              structure is 1.
                                            1        Confidentiality         0                0
                                            1        Logon                   1                1
                                            1        Deactivate fire
Given the request, “Logon and with                                           0                0
                                                     alarm
the capability to operate AC                1        AC Controller           0                0

Controller and DVD Controller and           1        DVD Controller          0                0

deactivate fire alarm with security
and confidentiality”.                 Use Case           Logon
                                      Description        Logon                                           The query will be
                                      Actors             User
                                      Main Flow          User logons with valid username and             matched against each
                                                         password, the system displays main menu.        use case description,
                                      Special            None                                            and the best result
                                      Requirement                                                        will be used for
                                      Included Use
                                      Cases
                                                         None
                                                                                                         similarity metric
                                      Extended Use       None                                            calculation next step.
                                      Cases

                                                          (a) A “Logon” use case

                                      Use Case           Logon With Timeout
                                      Description        Logon, automatic logout, idle for more than 1
                                                         min.
                                      Actors             User
                                      Main Flow          After logon, if idle more than 1 min, system
                                                         automatically logouts.
                                      Special            None
                                      Requirement
                                      Included Use       None
                                      Cases
                                      Extended Use       Logon
                                      Cases

                                                    (b) A “Logon with timeout” use case

                                      Figure 2: Examples of simple use case descriptions
Similarity Metric for keyword Matching without Structure

                                                        
                   Similarity _ Metric : STRINGS  KB  R

                   Similarity _ Metric({query}, SimpleUseCase)

                                                         text _ match(i, S _ SRS)
                                 
                            i{i{query}}
                                            [ priorityi
                                                           depth(i, S _ SRS)  1
                                                                                  ]
                     1
                                                         priorityi
                                                   i{i{query}}

 Table 2: Calculation of similarity metric for keyword matching without structure
 walkthrough
                                                      Depth of                               Priority *
    Priority         Query Value      Text_match     traversing     depth + 1 Text_match text_match /
                                                      structure               / (depth + 1) (depth + 1)
                                                       (depth)
       1            Security              0               0              1              0       0
       1            Confidentiality       0               0              1              0       0
       1            Logon                 1               1              2             0.5     0.5
       1            Deactivate fire       0               0              1              0       0
                    alarm
       1            AC Controller         0               0              1             0.0     0.0
       1            DVD Controller        0               0              1             0.0     0.0
    1 = 6                                                                                    2= 0.5
                              Similarity_Metric = 1 - 1 /  2 = 1 - 0.5 / 6 = 0.917
               .
                Keyword Matching with Structure
                             Table 3: Keyword matching format and its text
                             match value and depth information
                                                                         Depth of
                              Priority    Query Value      Text_match    Spanning
                                                                         Structure
                                 1       Security                 0          0
                                 1       Confidentiality          0         0
                                 1       Logon                    1         0
                                 1       Deactivate fire                    0
                                                                  0
                                         alarm
                                 1       AC Control               1         3
                                 1       DVD Controller                     3
                                                                  1


Use Case           Logon
Description        Logon
Actors             User
Main Flow          User logons with valid username and
                   password, the system displays main menu.

Special            None
Requirement
Included Use       None                                                              (a) A simple use case diagram
Cases
Extended Use       None
Cases
                                                                                           1
                    (a) A “Logon” use case

Use Case           Logon With Timeout
Description        Logon, automatic logout, idle for more than 1                                2
                   min.
Actors             User                                                                3
                                                                                           3
Main Flow          After logon, if idle more than 1 min, system
                   automatically logouts.
Special            None
Requirement
Included Use       None
Cases
Extended Use       Logon                                                               (b) A richer class diagram
Cases                                                                   Figure 3: Various diagrams supporting {simple use
                                                                        case, richer class diagram, simple NFR} structure
              (b) A “Logon with timeout” use case

   Figure 2: Examples of use case descriptions
     Similarity Metric for keyword Matching with Structure
                                     
Similarity _ Metric : STRINGS  KB  R

Similarity _ Metric({query},{SimpleUseCase, RicherClassDiagram, SimpleNFR} _ Structure)

                                         text _ match(i, S _ SRS)
                  
       i{i{query}}
                         [ priorityi
                                           depth(i, S _ SRS)  1
                                                                  ]
 1
                                         priorityi
                                    i{i{query}}



Table 4: Calculation of similarity metric for keyword matching with structure
walkthrough
                                                     Depth of                              Priority *
   Priority        Query Value       Text_match     traversing    depth + 1 Text_match text_match /
                                                     structure              / (depth + 1) (depth + 1)
                                                      (depth)
      1           Security                0              0            1               0       0
      1           Confidentiality         0              0            1               0       0
      1           Logon                   1              1            2              0.5     0.5
      1           Deactivate fire         0              0            1               0       0
                  alarm
      1           AC Controller           1             3             4          0.25        0.25
      1           DVD Controller          1             3             4          0.25        0.25
   1 = 6                                                                                   2= 1.0
                           Similarity_Metric = 1 - 1 /  2 = 1 – 1.0 / 6 = 0.833.
              .
      Criteria for OTS Component Selection


Interested criteria of this
          study




                 Figure 4: Hierarchical structure of criteria for an OTS component
                             Case-based Matching without Structure
Table 5: Case-based matching format and its text match value and depth
information for each feature corresponding to user’s query
          Feature                                                       Depth of Spanning
 Priority Name            Search Value                  Text match          Structure

   1     Use Case         Logon                         (1) / 1 = 1.0
                                                                             (depth)
                                                                                1
                                                                                            A tentative acquiring of query in case-
   1     Description      Logon                         (1) / 1 = 1.0          1            based format
   1     Main Flow        Logon                         (1) / 1 = 1.0          1
   1     Unmatched        Security, Confidentiality,         0                 0               Table 1: Text match value and depth information
         Items            Deactivate Fire Alarm, AC                                            for each keyword
                          Controller, DVD Controller
                                                                                                               Priority      Query Value
                                                                                                                  1       Security
                                                                                                                  1       Confidentiality
          Use Case           Logon                                                                                1       Logon
          Description        Logon                                                                                1       Deactivate fire alarm
          Actors             User                                                                                 1       AC Controller
          Main Flow          User logons with valid username and
                                                                                                                  1       DVD Controller
                             password, the system displays main menu.
          Special            None
          Requirement
          Included Use       None
          Cases                                                                                  Query Conversion by keyword searching
          Extended Use       None                                                                the use case description. Only matched
          Cases                                                                                  entries of use case template are shown.
                             (a) A “Logon” use case

          Use Case           Logon With Timeout
          Description        Logon, automatic logout, idle for more
                             than 1 min.                                                       Table 5: A user’s equivalent query in case-based format
          Actors             User
          Main Flow          After logon, if idle more than 1 min,                             Priority        Feature Name                   Search Value
                             system automatically logouts.
                                                                                                  1       Use Case                    Logon
          Special            None
          Requirement                                                                             1       Description                 Logon
          Included Use       None                                                                 1       Main Flow                   Logon
          Cases                                                                                   1       Unmatched Items             Security, Confidentiality,
          Extended Use       Logon                                                                                                    Deactivate Fire Alarm, AC
          Cases                                                                                                                       Controller, DVD Controller
                       (b) A “Logon with timeout” use case

              Figure 2: Examples of use case descriptions
Similarity Metric for Case-based Matching without Structure
                                                 
            Similarity _ Metric : STRINGS  KB  R

            Similarity _ Metric({query},{SimpleUseCase} _ Structure)

                                                    text _ match(i, S _ SRS)
                          
                     i{i{ feature}}
                                        [ priorityi
                                                      depth(i, S _ SRS)  1
                                                                             ]
             1
                                                    priorityi
                                              i{i{ feature}}



Table 6: Calculation of similarity metric for case-based matching
without structure walkthrough
          Feature                                                              Depth of            Text_match Priority *
 Priority Name            Search Value                           Text_match   traversing   depth+1 / (depth+1) text_match /
                                                                               structure                         (depth+1)
                                                                                (depth)
   1      Use Case        Logon                                     1.0            1              2    0.5          0.5
   1      Description     Logon                                     1.0            1              2    0.5          0.5
   1      Main Flow       Logon                                     1.0            1              2    0.5          0.5
   1      Unmatched       Security, Confidentiality,                 0             0              1     0           0
          Items           Deactivate Fire Alarm, AC
                          Controller, DVD Controller
 1 = 4                                                                                                          2 = 1.50
                                        Similarity_Metric = 1 - 1 /  2 = 1 - 1.5 / 4 = 0.625.
                                   Case-based Matching with Structure
Table 7: Case-based matching format and its text match value and
depth information for each feature for user’s query
 Priority Feature      Search Value                   Text_match      Depth of
          Name                                                       traversing
                                                                      structure
                                                                       (depth)
   1     Use Case      Logon                              1.0             0                   Average of the depth
   1     Description   Logon                              1.0             1
                                                                                              information of “AC Controller”
   1     Main Flow     Logon                              1.0             1
                                                                                              and “DVD Controller”, i.e.,
   1     Unmatched     Security, Confidentiality,     (0 + 0 + 0 +        3
         Items         Deactivate Fire Alarm, AC
                       Controller, DVD Controller
                                                      1 + 1) / 5 =
                                                                                              3 + 3 /2 = 3.
                                                           0.4



                                      Use Case           Logon
                                      Description        Logon
                                      Actors             User
                                      Main Flow          User logons with valid username and
                                                         password, the system displays main menu.

                                      Special            None
                                      Requirement
                                      Included Use       None                                                           (a) A simple use case diagram
                                      Cases
                                      Extended Use       None
                                      Cases
                                                                                                                               1
                                                          (a) A “Logon” use case

                                      Use Case            Logon With Timeout
                                      Description         Logon, automatic logout, idle for more than 1                            2
                                                          min.
                                      Actors              User                                                             3
                                                                                                                               3
                                      Main Flow           After logon, if idle more than 1 min, system
                                                          automatically logouts.
                                      Special             None
                                      Requirement
                                      Included Use        None
                                      Cases
                                      Extended Use        Logon                                                            (b) A richer class diagram
                                      Cases                                                                   Figure 3: Various diagrams supporting {simple use
                                                                                                              case, richer class diagram, simple NFR} structure
                                                    (b) A “Logon with timeout” use case

                                          Figure 2: Examples of use case descriptions
 Similarity Metric for Case-based Matching with Structure
                                                 
            Similarity _ Metric : STRINGS  KB  R
                                                                                                                                    text _ match(i, S _ SRS)
                                                                                                                        [ priorityi
                                                                                                                                      depth(i, S _ SRS)  1
                                                                                                                                                             ]
            Similarity _ Metric({query},{SimpleUseCase} _ Structure)                            1
                                                                                                      i{i{ feature}}

                                                                                                                                    priorityi
                                                                                                                              i{i{ feature}}

Table 8: Calculation of similarity metric for case-based matching
without structure walkthrough
          Feature                                                       Depth of            Text_match Priority *
 Priority Name          Search Value                    Text_match     traversing   depth+1 / (depth+1) text_match /
                                                                        structure                         (depth+1)
                                                                         (depth)
   1      Use Case      Logon                               1.0             1              2      0.5                        0.5
   1      Description   Logon                               1.0             1              2      0.5                        0.5
   1      Main Flow     Logon                               1.0             1              2      0.5                        0.5
   1      Unmatched     Security, Confidentiality,      (0 + 0 + 0 +        3              4      0.1                        0.1
          Items         Deactivate Fire Alarm, AC       1 + 1) / 5 =
                        Controller, DVD Controller          0.4
 1 = 4                                                                                                               2 = 1.60
                                 Similarity_Metric = 1 - 1 /  2 = 1 - 1.60 / 4 = 0.60.
                                                              Conclusions
  The richer the representation in terms of structure of metamodel can improve
  the ability to retrieve use case components more accurately against user’s query;

Keyword Without Structure << Keyword with Structure
                                                                      Case-based without Structure << Case-based with Structure



                                              Correlation between Matching Effectiveness and OTS Richness
                                                                  for keyword matching


                                                                                                     Log. (Keyword
                                              S_SSS S_SSR S_SRS S_SRR S_RSS S_RSR S_RRS S_RRR
                                                                                                     without Structure)
                                        0.5
              Matching Effectiveness




                                       0.55                                                          Log. (Keyword with
                                        0.6                                                          Structure)
                                       0.65
                                        0.7
                                       0.75
                                                                                                     Log. (Case-based
                                        0.8                                                          without Structure)
                                       0.85
                                        0.9                                                          Log. (Case-based
                                       0.95                                                          with Structure)
                                          1
                                                             OTS Model Richness

				
DOCUMENT INFO
Shared By:
Categories:
Stats:
views:72
posted:11/14/2010
language:English
pages:13
Description: Dvd Case Template document sample