Ontology Support for Abstraction Layer Modularization

Document Sample
Ontology Support for Abstraction Layer Modularization Powered By Docstoc
					1




         Ontology Support for
    Abstraction Layer Modularization

         Hyun Cho, Jeff Gray                        Jules White
    Department of Computer Science         Bradley Dept. of Electrical and
        University of Alabama                  Computer Engineering
        hcho7@crimson.ua.edu                        Virginia Tech
           gray@cs.ua.edu


                           Support by NSF CAREER.
    Overview of Presentation
2


       Overview of Abstraction Layer
       Overview of Ontology
       Issues in Abstraction Layer Modularization
       Research Approach
       Conclusion
    Examples of the Abstraction Layer
3


       Java Virtual Machine
                                     Applets and Applications
         Java            Java Base API              Java Standard Extension API
                      Java Base Classes         Java Standard Extension Classes
         Base
                                         Java Virtual Machine
        Platform
                                           Porting Interface
                    Adapter          Adapter            Adapter
                    Browser                                              JavaOS
                                         OS
                       OS                                 OS
                   Hardware         Hardware           Hardware         Hardware
         Network
                    Java on          Java on             Java on          Java on
                   a Browser      a Desktop OS        a Smaller OS       a JavaOS
    Examples of the Abstraction Layer (cont.)
4


       GIGA Platform
           Mobile platform developed by SK Telecome in South Korea
    Benefits and issues of abstraction layers
5


       Removes dependencies from underlying resources
       Promote portability and reusability
       Require much effort and time to build an abstraction layer
           Same amount of efforts and time may be required if a new underlying
            resource is introduced or the supported resources are evolved
       Focus on portability, reusability and reducing overhead
           Little attention to the modularity of the abstraction layer


                Construct the abstraction layer using ontology
    Ontologies
6


       An ontology is an explicit description of a domain
           concepts
           properties and attributes of concepts
           constraints on properties and attributes




    Ontology allows people to share common understanding
    of the structure of information and enable reuse of domain
    knowledge.
    Criteria for Introducing Ontologies
7


       Large amounts of data
       Complex data structures
           Inheritance, containment and many relationships
       Diverse sources
           Many legacy systems
           Sources using different formats
       Requirement for formal proofs
           Contracts and policy enforcement
    Characteristics of APIs
8


       APIs can be decomposed into multiple semantic units
           Ex.) OS APIs: Thread Management, Memory Management, I/O
            Management
       APIs are structured with a hierarchy and can be represented
        as a Tree
           Java APIs, Microsoft Foundation Class
       APIs follow a naming convention
           Noun only: Normally constructor/destructor
               Socket(), Array()
           Verb followed by noun
               createProcess(), deleteProcess()
           Verb only
               add(), append()
    Process of Ontology Support
                     for Abstraction Layer Modularization
9


                         Domain Feature
                            Model



    Natural Language       Ontology
       Processing          Processing        Feature
                           Classify the     Model for       API
     Tokenizer APIs
                              tokens        Abstraction   Generator
      Annotate the         Identify API       Layer
         tokens            relationship


        APIs of             Accesses                       APIs for
       Underlying       Abstraction Layer                 Abstraction
       Resources          Modularity                        Layer

                       Traceability Link
     Feature Model of Abstraction Layer
10


                                                                          OS




                     Process                                Synchronization                                File
                                                    ...                                ...



                                                                                             Conditional
     Thread              Task                             Mutex            Semaphore
                                     Process                        ...                       Variable




                                                                   Mutex
              Cyg_mutex_t *mutex::eCos:cyg_mutex_init     /* mutex to initialize */
              SEM_ID semId::VxWorks:semMGiveForce        /* semaphore ID to give */
              LPSECURITY_ATTRIBUTES lpMutextAttributes::WinCE:CreateMutex
              ...                                        datatype VariableName::PackageName:APIName
              void cyg_mutex_init ( cyg_mutex_t )::eCos
              void cyg_mutex_destroy ( cyg_mutex_t *mutex )::eCos
              SEM_ID semMCreate ( int options )::VxWorks
              STATUS semMGiveForce( SEM_ID semId )::VxWorks
              HANLDE CreateMutex( LPSECURITY_ATTRIBUTES lpMutextAttributes, BOOL bInitialOwner, LPCTSRT lpName)::WinCE
              ...                                            ReturnType APIName:: PackageName
Measurement of Abstraction Layer Modularity

   Object-Oriented Metrics
       Weighted methods per class (MWC)
           Measure class complexity by summing the complexity of each method
       Depth of inheritance tree (DIT)
           Measure the length o the maximum path from the node to the root of the tree
           Derive the modularity by measuring affected classes from a change
       Number of children (NOC)
           Measure the number of direct subclasses
       Coupling between object classes (CBO)
       Response for class (RFC)
                                                              Chidamber, S.R.,Kemerer, C.F., "A
       Lack of cohesion metric (LCOM)                        metrics suite for object oriented
                                                              design," Software Engineering, IEEE
                                                              Transactions on , vol.20, no.6, pp.476-
                                                              493, Jun 1994



                                                                                  11
     Coupling between object classes (CBO)
12


        Measure the number of other classes to which the class is
         coupled
        Excessive coupling indicates weakness of class encapsulation,
         or modularity
     Response for class (RFC)
13


        a set of methods that can potentially be executed in response
         to a message received by an object of that class.
        Useful to check testability
        Smaller numbers are better
            Larger numbers indicate increased complexity and debugging
             difficulties
     Lack of cohesion metric (LCOM)
14


        A measure of the “tightness” of the code
            Consider a class C with three methods M1,M2 and M3.
            Let {I1} = { a , b . c , d , e }, {I2} = {a , b , e}, and {I3} = {x,y,z}.
             {I1}∏{I2} is nonempty,
             {I1} ∏{I3} and {I2} ∏{I3} are null sets
            LCOM = 2 – 1 =1


        The larger the number of LCOM, the more cohesive the class
     Conclusions
15


        The approach helps maintain the abstraction layer consistently
        A feature model can provide insight the modularity and
         functionality of the underlying resources
        The approach is transparent to the implementation technology
         of underlying resources
        Need to find the appropriate measurement to predict the
         modularity in model level
        Generative programming has the potential to automate the
         creation of APIs for the abstraction layer.
16




     Support by NSF CAREER.

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:6
posted:8/25/2012
language:English
pages:16