Abstract:
A method for analyzing a target system that includes generating a characteristics model using a schema defining a domain, obtaining a plurality of characteristics from the target system using a characteristics extractor, wherein the plurality of characteristics is associated with the characteristics model storing each of the plurality of characteristics in a characteristics store, and analyzing the target system by issuing at least one query to the characteristics store to obtain an analysis result.

Description:
CROSS-REFERENCE TO RELATED APPLICATIONS 
   The present application contains subject matter that may be related to the subject matter in the following U.S. applications filed on May 20, 2005, and assigned to the assignee of the present application: “Method and Apparatus for Tracking Changes in a System” (Ser. No. 11/133,831); “Method and Apparatus for Transparent Invocation of a Characteristics Extractor for Pattern-Based System Design Analysis” (Ser. No. 11/134,154); “Method and Apparatus for Generating Components for Pattern-Based System Design Analysis Using a Characteristics Model” Ser. No. 11/133,717; “Method and Apparatus for Pattern-Based System Design Analysis” Ser. No. 11/134,062; “Method and Apparatus for Cross-Domain Querying in Pattern-Based System Design Analysis” Ser. No. 11/133,507; “Method and Apparatus for Pattern-Based System Design Analysis Using a Meta Model” Ser. No. 11/134,021 and “Pattern Query Language” Ser. No. 11/133,660. 
   BACKGROUND 
   As software technology has evolved, new programming languages and increased programming language functionality has been provided. The resulting software developed using this evolving software technology has become more complex. The ability to manage the quality of software applications (including design quality and architecture quality) is becoming increasingly more difficult as a direct result of the increasingly complex software. In an effort to manage the quality of software applications, several software development tools and approaches are now available to aid software developers in managing software application quality. The following is a summary of some of the types of quality management tools currently available. 
   One common type of quality management tool is used to analyze the source code of the software application to identify errors (or potential errors) in the source code. This type of quality management tool typically includes functionality to parse the source code written in a specific programming language (e.g., Java™, C++, etc.) to determine whether the source code satisfies one or more coding rules (i.e., rules that define how source code in the particular language should be written). Some quality management tools of the aforementioned type have been augmented to also identify various coding constructs that may result in security or reliability issues. While the aforementioned type of quality management tools corrects coding errors, it does not provide the software developer with any functionality to verify the quality of the architecture of software application. 
   Other quality management tools of the aforementioned type have been augmented to verify that software patterns have been properly implemented. Specifically, some quality management tools of the aforementioned type have been augmented to allow the software developer to indicate, in the source code, the type of software pattern the developer is using. Then the quality management tool verifies, during compile time, that the software pattern was used/implemented correctly. 
   In another implementation of the aforementioned type of quality management tools, the source code of the software is parsed and the components (e.g., classes, interfaces, etc.) extracted from the parsing are subsequently combined in a relational graph (i.e., a graph linking all (or sub-sets) of the components). In a subsequent step, the software developer generates an architectural design, and then compares the architectural design to the relational graph to determine whether the software application conforms to the architectural pattern. While the aforementioned type of quality management tool enables the software developer to view the relationships present in the software application, it does not provide the software developer with any functionality to conduct independent analysis on the extracted components. 
   Another common type of quality management tool includes functionality to extract facts (i.e., relationships between components (classes, interfaces, etc.) in the software) and subsequently displays the extracted facts to the software developer. While the aforementioned type of quality management tool enables the software developer to view the relationships present in the software application, it does not provide the developer with any functionality to independently query the facts or any functionality to extract information other than facts from the software application. 
   Another common type of quality management tool includes functionality to extract and display various statistics (e.g., number of lines of code, new artifacts added, software packages present, etc.) of the software application to the software developer. While the aforementioned type of quality management tool enables the software developer to view the current state of the software application, it does not provide the developer with any functionality to verify the quality of the architecture of the software application. 
   SUMMARY 
   In general, in one aspect, the invention relates to a method for analyzing a target system, comprising generating a characteristics model using a schema defining a domain, obtaining a plurality of characteristics from the target system using a characteristics extractor, wherein the plurality of characteristics is associated with the characteristics model, storing each of the plurality of characteristics in a characteristics store, and analyzing the target system by issuing at least one query to the characteristics store to obtain an analysis result. 
   In general, in one aspect, the invention relates to a system, comprising a characteristics model defining at least one artifact and a plurality of characteristics associated with the at least one artifact, wherein the characteristics model is generated using a schema defining a domain, a target system comprising at least one of the plurality of characteristics defined in the characteristics model, at least one characteristics extractor configured to obtain at least one of the plurality of characteristics from the target system, a characteristics store configured to store the at least one of the plurality of characteristics obtained from the target system, and a query engine configured to analyze the target system by issuing at least one query to the characteristics store and configured to obtain an analysis result in response to the at least one query. 
   In general, in one aspect, the invention relates to a computer readable medium comprising software instructions for analyzing a target system, comprising software instructions to generate a characteristics model using a schema defining a domain, obtain a plurality of characteristics from the target system using a characteristics extractor, wherein the plurality of characteristics is associated with the characteristics model, store each of the plurality of characteristics in a characteristics store, and analyze the target system by issuing at least one query to the characteristics store to obtain an analysis result. 
   Other aspects of the invention will be apparent from the following description and the appended claims. 

   
     BRIEF DESCRIPTION OF DRAWINGS 
       FIG. 1  shows a system in accordance with one embodiment of the invention. 
       FIG. 2  shows a characteristics model in accordance one embodiment of the invention. 
       FIGS. 3 through 6  show flowcharts in accordance with one embodiment of the invention. 
       FIG. 7  shows a computer system in accordance with one embodiment of the invention. 
   

   DETAILED DESCRIPTION 
   Exemplary embodiments of the invention will be described with reference to the accompanying drawings. Like items in the drawings are shown with the same reference numbers. 
   In the exemplary embodiment of the invention, numerous specific details are set forth in order to provide a more thorough understanding of the invention. However, it will be apparent to one of ordinary skill in the art that the invention may be practiced without these specific details. In other instances, well-known features have not been described in detail to avoid obscuring the invention. 
   In general, embodiments of the invention relate to a method and apparatus for pattern-based system design analysis. More specifically, embodiments of the invention provide a method and apparatus for using one or more characteristics models, one or more characteristics extractors, and a query engine configured to query the characteristics of a target system to analyze the system design. Embodiments of the invention provide the software developer with a fully configurable architectural quality management tool that enables the software developer to extract information about the characteristics of the various artifacts in the target system, and then issue queries to determine specific details about the various artifacts including, but not limited to, information such as: number of artifacts of the specific type present in the target system, relationships between the various artifacts in the target system, the interaction of the various artifacts within the target system, the patterns that are used within the target system, etc. Further, one or more embodiments of the invention provide a method and apparatus for automatically generating the characteristics model from a schema (e.g., an XML schema) defining a domain (discussed below). 
     FIG. 1  shows a system in accordance with one embodiment of the invention. The system includes a target system ( 100 ) (i.e., the system that is to be analyzed) and a number of components used in the analysis of the target system. In one embodiment of the invention, the target system ( 100 ) may correspond to a system that includes software, hardware, or a combination of software and hardware. More specifically, embodiments of the invention enable a user to analyze specific portions of a system or the entire system. Further, embodiments of the invention enable a user to analyze the target system with respect to a specific domain (discussed below). Accordingly, the target system ( 100 ) may correspond to any system under analysis, where the system may correspond to the entire system including software and hardware, or only a portion of the system (e.g., only the hardware portion, only the software portion, a sub-set of the hardware or software portion, or any combination thereof). As shown in  FIG. 1 , the system includes the following components to aid in the analysis of the target system: one or more characteristics extractors (e.g., characteristics extractor A ( 102 A), characteristics extractor N ( 102 N)), a characteristics store application programming interface (API) ( 104 ), a characteristics store ( 106 ), a characteristics model ( 108 ), a query engine ( 110 ), and visualization engine ( 112 ). Each of these components is described below. 
   In one embodiment of the system, the characteristics model ( 108 ) describes artifacts (i.e., discrete components) in a particular domain. In one embodiment of the invention, the domain corresponds to any grouping of “related artifacts” (i.e., there is a relationship between the artifacts). Examples of domains include, but are not limited to, a Java™ 2 Enterprise Edition (J2EE) domain (which includes artifacts such as servlets, filters, welcome file, error page, etc.), a networking domain (which includes artifacts such as web server, domain name server, network interface cards, etc), and a DTrace domain (described below). In one embodiment of the invention, each characteristics model includes one or more artifacts, one or more relationships describing the interaction between the various artifacts, and one or more characteristics that describe various features of the artifact. An example of a characteristics model ( 108 ) is shown in  FIG. 2 . Those skilled in the art will appreciate that the system may include more than one characteristics model ( 108 ). 
   In one embodiment of the invention, the use of a characteristics model ( 108 ) enables a user to analyze the target system ( 100 ) with respect to a specific domain. Further, the use of multiple characteristics models allows the user to analyze the target system ( 100 ) across multiple domains. In addition, the use of multiple characteristics models allows the user to analyze the interaction between various domains on the target system ( 100 ). 
   In one embodiment of the invention, the characteristics model ( 108 ) is generated from a schema defining the domain. Embodiments detailing the generation of the characteristics model ( 108 ) from a schema defining the domain are described in  FIGS. 4 and 5  below. 
   In one embodiment of the invention, the characteristics extractors (e.g., characteristics extractor A ( 102 A), characteristics extractor N ( 102 N)) are used to obtain information about various artifacts (i.e., characteristics) defined in the characteristics model ( 108 ). In one embodiment of the invention, the characteristics extractors (characteristics extractor A ( 102 A), characteristics extractor B ( 102 N)) are generated manually using the characteristics model ( 108 ). 
   In one embodiment of the invention, the characteristics extractor (e.g., characteristics extractor A ( 102 A), characteristics extractor B ( 102 N)) corresponds to an agent loaded on the target system ( 100 ) that is configured to monitor and obtain information about the artifacts in the target system ( 100 ). Alternatively, the characteristics extractor (e.g., characteristics extractor A ( 102 A), characteristics extractor B ( 102 N)) may correspond to an interface that allows a user to manually input information about one or more artifacts in the target system ( 100 ). In another embodiment of the invention, the characteristics extractor (e.g., characteristics extractor A ( 102 A), characteristics extractor B ( 102 N)) may correspond to a process (or system) configured to obtain information about one or more artifacts in the target system ( 100 ) by monitoring network traffic received by and sent from the target system ( 100 ). In another embodiment of the invention, the characteristics extractor (e.g., characteristics extractor A ( 102 A), characteristics extractor B ( 102 N)) may correspond to a process (or system) configured to obtain information about one or more artifacts in the target system ( 100 ) by sending requests (e.g., pinging, etc.) for specific pieces of information about artifacts in the target system ( 100 ) to the target system ( 100 ), or alternatively, sending requests to the target system and then extracting information about the artifacts from the responses received from target system ( 100 ). Those skilled in the art will appreciate that different types of characteristics extractors may be used to obtain information about artifacts in the target system ( 100 ). 
   Those skilled in the art will appreciate that each characteristics extractor (or set of characteristics extractors) is associated with a particular characteristics model ( 108 ). Thus, each characteristics extractor typically only retrieves information about artifacts described in the characteristics model with which the characteristics extractor is associated. Furthermore, if there are multiple characteristics models in the system, then each characteristics model may be associated with one or more characteristics extractors. 
   The information about the various artifacts in the target system ( 100 ) obtained by the aforementioned characteristics extractors (e.g., characteristics extractor A ( 102 A), characteristics extractor N ( 102 N)) is stored in the characteristics store ( 106 ) via the characteristic store API ( 104 ). In one embodiment of the invention, characteristics store API ( 104 ) provides an interface between the various characteristics extractors (characteristics extractor A ( 102 A), characteristics extractor N ( 102 N)) and the characteristics store ( 106 ). Further, the characteristics store API ( 104 ) includes information about where in the characteristics store ( 106 ) each characteristic obtained from the target system ( 100 ) should be stored. 
   In one embodiment of the invention, the characteristics store ( 106 ) corresponds to any storage that includes functionality to store characteristics in a manner that allows the characteristics to be queried. In one embodiment of the invention, the characteristics store ( 106 ) may correspond to a persistent storage device (e.g., hard disk, etc). In one embodiment of the invention, the characteristics store ( 106 ) corresponds to a relational database that may be queried using a query language such as Structure Query Language (SQL). Those skilled in the art will appreciate that any query language may be used. In one embodiment of the invention, if the characteristics store ( 106 ) is a relational database, then the characteristics store ( 106 ) includes a schema associated with the characteristics model ( 108 ) that is used to store the characteristics associated with the particular characteristics model ( 108 ). Those skilled in the art will appreciate that, if there are multiple characteristics models, then each characteristics model ( 108 ) may be associated with a separate schema. 
   In one embodiment of the invention, if the characteristics store ( 106 ) is a relational database that includes a schema associated with the characteristics model ( 108 ), then the characteristics store API ( 104 ) includes the necessary information to place characteristics obtained from target system ( 100 ) in the appropriate location in the characteristics store ( 106 ) using the schema. 
   In one embodiment of the invention, the query engine ( 110 ) is configured to issue queries to the characteristics store ( 106 ). In one embodiment of the invention, the queries issued by the query engine ( 110 ) enable a user (e.g., a system developer, etc.) to analyze the target system ( 100 ). In particular, in one embodiment of the invention, the query engine ( 110 ) is configured to enable the user to analyze the presence of specific patterns in the target system as well as the interaction between various patterns in the target system. 
   In one embodiment of the invention, a pattern corresponds to a framework that defines how specific components in the target system ( 100 ) should be configured (e.g., what types of information each component should manage, what interfaces should each component expose), and how the specific components should communicate with each other (e.g., what data should be communicated to other components, etc.). Patterns are typically used to address a specific problem in a specific context (i.e., the software/system environment in which the problem arises). Said another way, patterns may correspond to a software architectural solution that incorporates best practices to solve a specific problem in a specific context. 
   Continuing with the discussion of  FIG. 1 , the query engine ( 110 ) may also be configured to issue queries about interaction of specific patterns with components that do not belong to a specific pattern. Further, the query engine ( 110 ) may be configured to issue queries about the interaction of components that do not belong to any patterns. 
   In one embodiment of the invention, the query engine ( 110 ) may include pre-specified queries and/or enable to the user to specify custom queries. In one embodiment of the invention, both the pre-specified queries and the custom queries are used to identify the presence of one or more patterns and/or the presence of components that do not belong to a pattern in the target system ( 100 ). 
   In one embodiment of the invention, the pre-specified queries and the custom queries are specified using a Pattern Query Language (PQL). In one embodiment of the invention, PQL enables the user to query the artifacts and characteristics of the artifacts stored in the characteristics store ( 106 ) to determine the presence of a specific pattern, specific components of a specific pattern, and/or other components that are not part of a pattern, within the target system ( 100 ). 
   In one embodiment of the invention, the query engine ( 110 ) may include information (or have access to information) about the characteristics model ( 108 ) that includes the artifact and/or characteristics being queried. Said another way, if the query engine ( 110 ) is issuing a query about a specific artifact, then the query engine ( 110 ) includes information (or has access to information) about the characteristics model to which the artifact belongs. Those skilled in the art will appreciate that the query engine ( 110 ) only requires information about the particular characteristics model ( 108 ) to the extent the information is required to issue the query to the characteristics store ( 106 ). 
   Those skilled in the art will appreciate that the query engine ( 110 ) may include functionality to translate PQL queries (i.e., queries written in PQL) into queries written in a query language understood by the characteristics store ( 106 ) (e.g., SQL). Thus, a query written in PQL may be translated into an SQL query prior to being issued to the characteristics store ( 106 ). In this manner, the user only needs to understand the artifacts and/or characteristics that the user wishes to search for and how to express the particular search using PQL. The user does not need to be concerned with how the PQL query is handled by the characteristics store ( 106 ). 
   Further, in one or more embodiments of the invention, PQL queries may be embedded in a programming language such as Java™, Groovy, or any other programming language capable of embedding PQL queries. Thus, a user may embed one or more PQL queries into a program written in one of the aforementioned programming languages. Upon execution, the program issues one or more PQL queries embedded within the program and subsequently receives and processes the results prior to displaying them to the user. Those skilled in the art will appreciate that the processing of the results is performed using functionality of the programming language in which the PQL queries are embedded. 
   In one embodiment of the invention, the results of the individual PQL queries may be displayed using the visualization engine ( 112 ). In one embodiment of the invention, the visualization engine ( 112 ) is configured to output the results of the queries on a display device (i.e., monitor, printer, projector, etc.). 
   As discussed above, each characteristics model defines one or more artifacts, one or more relationships between the artifacts, and one or more characteristics for each artifact. The following is an example of a Web Service Definition Language (WSDL) characteristics model. In the example, the WSDL characteristics model includes the following attributes: Definition, ExternalImport, Type, Message, Part, Binding, Operation, PortType, Fault, Parameter, Body, and Service. 
   The following is a WSDL characteristics model in accordance with one embodiment of the invention. 
   
     
       
             
           
             
             
           
         
             
                 
             
             
               WSDL Characteristics Model 
             
             
                 
             
           
           
             
                 
             
           
        
         
             
               1 
               persistent class Definition { 
             
             
               2 
                 string name; 
             
             
               3 
                 string targetNamespace; 
             
             
               4 
                 references ExternalImport imports (0,n) inverse definition (1,1); 
             
             
               5 
                 references Type types (0,n) inverse definition (1,1); 
             
             
               6 
                 references Message messages (0,n) inverse definition (1,1); 
             
             
               7 
                 references Binding bindings (0,n) inverse definition (1,1); 
             
             
               8 
                 references PortType portTypes (0,n) inverse definition (1,1); 
             
             
               9 
                 references Service services (0,n) inverse definition (1,1); 
             
             
               10 
                 PRIMARY KEY (name); 
             
             
               11 
               } 
             
             
               12 
             
             
               13 
               persistent class ExternalImport{ 
             
             
               14 
                 string namespace; 
             
             
               15 
                 string location; 
             
             
               16 
               } 
             
             
               17 
             
             
               18 
               persistent class Type { } 
             
             
               19 
             
             
               20 
               persistent Message { 
             
             
               21 
                 string name; 
             
             
               22 
                 references Part parts (0,n) inverse message (1,1); 
             
             
               23 
                 PRIMARY KEY (name); 
             
             
               24 
               } 
             
             
               25 
             
             
               26 
               persistent class Binding { 
             
             
               27 
                 string name; 
             
             
               28 
                 string type; 
             
             
               29 
                 string transport; 
             
             
               30 
                 string style; 
             
             
               31 
                 references Operation operations (0,n) inverse binding (1,1); 
             
             
               32 
                 PRIMARY KEY (name); 
             
             
               33 
               } 
             
             
               34 
             
             
               35 
               persistent class Operation { 
             
             
               36 
                 string name; 
             
             
               37 
                 string parameterOrder; 
             
             
               38 
                 string type; 
             
             
               39 
                 string soapAction; 
             
             
               40 
                 string style; 
             
             
               41 
                 references Fault faults (0,n) inverse operation (1,1); 
             
             
               42 
                 references Parameter inputParams (0,n) inverse inOperation 
             
             
                 
                 (1,1); 
             
             
               43 
                 references Parameter outputParams (0,n) inverse outOperation 
             
             
                 
                 (1,1); 
             
             
               44 
                 PRIMARY KEY (name); 
             
             
               45 
               } 
             
             
               46 
             
             
               47 
               persistent class Fault { 
             
             
               48 
                 string name; 
             
             
               49 
                 string message; 
             
             
               50 
                 PRIMARY KEY (name); 
             
             
               51 
               } 
             
             
               52 
             
             
               53 
               persistent class Parameter { 
             
             
               54 
                 string name; 
             
             
               55 
                 string message; 
             
             
               56 
                 references Body bodys (0,n) inverse parameter (1,1); 
             
             
               57 
                 PRIMARY KEY (name); 
             
             
               58 
               } 
             
             
               59 
             
             
               60 
               persistent class Body { 
             
             
               61 
                 string namespace; 
             
             
               62 
                 string use; 
             
             
               63 
                 string encodingStyles; 
             
             
               64 
                 string parts; 
             
             
               65 
                 PRIMARY KEY (namespace); 
             
             
               66 
               } 
             
             
               67 
             
             
               68 
               persistent class PortType { 
             
             
               69 
                 string name; 
             
             
               70 
                 string location; 
             
             
               71 
                 references Operation operations (0,n) inverse portType (1,1); 
             
             
               72 
                 PRIMARY KEY (name); 
             
             
               73 
               } 
             
             
               74 
             
             
               75 
               persistent class Service { 
             
             
               76 
                 string name; 
             
             
               77 
                 references portTypes (0,n) inverse service (1,1); 
             
             
               78 
                 PRIMARY KEY (name); 
             
             
               79 
               } 
             
             
               80 
             
             
               81 
             
             
               82 
               persistent class Part { 
             
             
               83 
                 string name; 
             
             
               84 
                 string element; 
             
             
               85 
                 string type&#39; 
             
             
               86 
                 PRIMARY KEY (name); 
             
             
               87 
               } 
             
             
                 
             
           
        
       
     
   
   In the above WSDL Characteristics Model, the Definition artifact is defined in lines 1-11, the ExternalImport artifact defined in lines 13-16, the Type artifact is defined in line 18, the Message artifact is defined in lines 20-24, the Binding artifact is defined in lines 26-33, the Operation artifact is defined in lines 35-45, the Fault artifact is defined in 47-51, the Parameter artifact is defined in lines 53-58, the Body artifact is defined in lines 60-66, the PortType artifact is defined in lines 68-72, the Service artifact is defined in lines 75-79, and the Part artifact is defined in lines 82-87. 
   A graphical representation of the aforementioned WSDL Characteristics Model is shown in  FIG. 2 . Specifically, the graphical representation of the WSDL characteristics model shows each of the aforementioned artifacts, characteristics associated with each of the aforementioned artifacts, and the relationships (including cardinality) among the artifacts. In particular, box ( 120 ) corresponds to the Definition artifact, box ( 122 ) corresponds to the ExternalImport artifact, box ( 124 ) corresponds to the Type artifact, box ( 126 ) corresponds to the Message artifact, box ( 128 ) corresponds to the Part artifact, box ( 130 ) corresponds to the Binding artifact, box ( 132 ) corresponds to the Operation artifact, box ( 134 ) corresponds to the Fault artifact, box ( 136 ) corresponds to the Parameter artifact, box ( 138 ) corresponds to the Body artifact, box ( 140 ) corresponds to the PortType artifact, and box ( 142 ) corresponds to the Service artifact. 
     FIG. 3  shows a flowchart in accordance with one embodiment of the invention. Initially, a characteristics model is generated from a schema (ST 100 ). The process of generating the characteristics model is discussed in  FIGS. 4 and 5 . Continuing with the discussion of  FIG. 3 , a schema for the characteristics store is subsequently created and associated with characteristics model (ST 102 ). One or more characteristics extractors associated with characteristics model are subsequently created (ST 104 ). Finally, a characteristics store API is created (ST 106 ). In one embodiment of the invention, creating the characteristics store API includes creating a mapping between characteristics obtained by the characteristics extractors and tables defined by the schema configured to store the characteristics in the characteristics store. 
   Those skilled in the art will appreciate that ST 100 -ST 106  may be repeated for each characteristics model. In addition, those skilled in the art will appreciate that once a characteristics store API is created, the characteristics store API may only need to be modified to support additional schemas in the characteristics data store and additional characteristics extractors. Alternatively, each characteristics model may be associated with a different characteristics store API. 
   As discussed above, embodiments of the invention provide a method and apparatus for generating a characteristics model from a schema defining a domain.  FIG. 4  shows a flowchart describing a method for generating a characteristics model using a schema defining a domain in accordance with one embodiment of the invention. Initially, the schema defining the domain is obtain (ST 110 ). In one embodiment of the invention, the schema is defined using a schema standard such as eXtensible Mark-Language Schema Definition (XSD). 
   SD is a standard created by the World Wide Web Consortium (W3C) that specifies how to formally describe the elements in an XML document. Thus, one could define a domain, such as a WSDL domain in an XML document, using XSD. The following is an example of an XML document defining the WSDL domain using XSD. 
   
     
       
             
           
             
             
           
         
             
                 
             
             
               Schema for WSDL described using XSD 
             
             
                 
             
           
           
             
                 
             
           
        
         
             
               1 
                &lt;xs:schema xmlns:xs=“http://www.w3.org/2001/XMLSchema” 
             
             
               2 
                     xmlns:wsdl=“http://schemas.xmlsoap.org/wsdl/” 
             
             
               3 
                     targetNamespace=“http://schemas.xmlsoap.org/wsdl/” 
             
             
               4 
                     elementFormDefault=“qualified” &gt; 
             
             
               5 
             
             
               6 
                &lt;xs:complexType mixed=“true” name=“tDocumentation” &gt; 
             
             
               7 
                 &lt;xs:sequence&gt; 
             
             
               8 
                  &lt;xs:any minOccurs=“0” maxOccurs=“unbounded” processContents=“lax” /&gt; 
             
             
               9 
                 &lt;/xs:sequence&gt; 
             
             
               10 
                &lt;/xs:complexType&gt; 
             
             
               11 
             
             
               12 
                &lt;xs:complexType name=“tDocumented” &gt; 
             
             
               13 
                 &lt;xs:annotation&gt; 
             
             
               14 
                  &lt;xs:documentation&gt; 
             
             
               15 
                  This type is extended by component types to allow them to be 
             
             
               16 
               documented 
             
             
               17 
                  &lt;/xs:documentation&gt; 
             
             
               18 
                 &lt;/xs:annotation&gt; 
             
             
               19 
                 &lt;xs:sequence&gt; 
             
             
               20 
                  &lt;xs:element name=“documentation” type=“wsdl:tDocumentation” 
             
             
               21 
               minOccurs=“0” /&gt; 
             
             
               22 
                 &lt;/xs:sequence&gt; 
             
             
               23 
                &lt;/xs:complexType&gt; 
             
             
               24 
             
             
               25 
                &lt;xs:complexType name=“tExtensibleAttributesDocumented” abstract=“true” &gt; 
             
             
               26 
                 &lt;xs:complexContent&gt; 
             
             
               27 
                  &lt;xs:extension base=“wsdl:tDocumented” &gt; 
             
             
               28 
                   &lt;xs:annotation&gt; 
             
             
               29 
                    &lt;xs:documentation&gt; 
             
             
               30 
                    This type is extended by component types to allow attributes from 
             
             
               31 
               other namespaces to be added. 
             
             
               32 
                    &lt;/xs:documentation&gt; 
             
             
               33 
                   &lt;/xs:annotation&gt; 
             
             
               34 
                   &lt;xs:anyAttribute namespace=“##other” processContents=“lax” /&gt; 
             
             
               35 
                  &lt;/xs:extension&gt; 
             
             
               36 
                 &lt;/xs:complexContent&gt; 
             
             
               37 
                &lt;/xs:complexType&gt; 
             
             
               38 
             
             
               39 
                &lt;xs:complexType name=“tExtensibleDocumented” abstract=“true” &gt; 
             
             
               40 
                 &lt;xs:complexContent&gt; 
             
             
               41 
                  &lt;xs:extension base=“wsdl:tDocumented” &gt; 
             
             
               42 
                   &lt;xs:annotation&gt; 
             
             
               43 
                    &lt;xs:documentation&gt; 
             
             
               44 
                    This type is extended by component types to allow elements from 
             
             
               45 
               other namespaces to be added. 
             
             
               46 
                    &lt;/xs:documentation&gt; 
             
             
               47 
                   &lt;/xs:annotation&gt; 
             
             
               48 
                   &lt;xs:sequence&gt; 
             
             
               49 
                    &lt;xs:any namespace=“##other” minOccurs=“0” maxOccurs=“unbounded” 
             
             
               50 
               processContents=“lax” /&gt; 
             
             
               51 
                   &lt;/xs:sequence&gt; 
             
             
               52 
                  &lt;/xs:extension&gt; 
             
             
               53 
                 &lt;/xs:complexContent&gt; 
             
             
               54 
                &lt;/xs:complexType&gt; 
             
             
               55 
             
             
               56 
                &lt;xs:element name=“definitions” type=“wsdl:tDefinitions” &gt; 
             
             
               57 
                 &lt;xs:key name=“message” &gt; 
             
             
               58 
                  &lt;xs:selector xpath=“wsdl:message” /&gt; 
             
             
               59 
                  &lt;xs:field xpath=“@name” /&gt; 
             
             
               60 
                 &lt;/xs:key&gt; 
             
             
               61 
                 &lt;xs:key name=“portType” &gt; 
             
             
               62 
                  &lt;xs:selector xpath=“wsdl:portType” /&gt; 
             
             
               63 
                  &lt;xs:field xpath=“@name” /&gt; 
             
             
               64 
                 &lt;/xs:key&gt; 
             
             
               65 
                 &lt;xs:key name=“binding” &gt; 
             
             
               66 
                  &lt;xs:selector xpath=“wsdl:binding” /&gt; 
             
             
               67 
                  &lt;xs:field xpath=“@name” /&gt; 
             
             
               68 
                 &lt;/xs:key&gt; 
             
             
               69 
                 &lt;xs:key name=“service” &gt; 
             
             
               70 
                  &lt;xs:selector xpath=“wsdl:service” /&gt; 
             
             
               71 
                  &lt;xs:field xpath=“@name” /&gt; 
             
             
               72 
                 &lt;/xs:key&gt; 
             
             
               73 
                 &lt;xs:key name=“import” &gt; 
             
             
               74 
                  &lt;xs:selector xpath=“wsdl:import” /&gt; 
             
             
               75 
                  &lt;xs:field xpath=“@namespace” /&gt; 
             
             
               76 
                 &lt;/xs:key&gt; 
             
             
               77 
                &lt;/xs:element&gt; 
             
             
               78 
             
             
               79 
                &lt;xs:group name=“anyTopLevelOptionalElement” &gt; 
             
             
               80 
                 &lt;xs:annotation&gt; 
             
             
               81 
                  &lt;xs:documentation&gt; 
             
             
               82 
                  Any top level optional element allowed to appear more then once - any 
             
             
               83 
               child of definitions element except wsdl:types. Any extensibility element is 
             
             
               84 
               allowed in any place. 
             
             
               85 
                  &lt;/xs:documentation&gt; 
             
             
               86 
                 &lt;/xs:annotation&gt; 
             
             
               87 
                 &lt;xs:choice&gt; 
             
             
               88 
                  &lt;xs:element name=“import” type=“wsdl:tImport” /&gt; 
             
             
               89 
                  &lt;xs:element name=“types” type=“wsdl:tTypes” /&gt; 
             
             
               90 
                  &lt;xs:element name=“message” type=“wsdl:tMessage” &gt; 
             
             
               91 
                   &lt;xs:unique name=“part” &gt; 
             
             
               92 
                    &lt;xs:selector xpath=“wsdl:part” /&gt; 
             
             
               93 
                    &lt;xs:field xpath=“@name” /&gt; 
             
             
               94 
                   &lt;/xs:unique&gt; 
             
             
               95 
                  &lt;/xs:element&gt; 
             
             
               96 
                  &lt;xs:element name=“portType” type=“wsdl:tPortType” /&gt; 
             
             
               97 
                  &lt;xs:element name=“binding” type=“wsdl:tBinding” /&gt; 
             
             
               98 
                  &lt;xs:element name=“service” type=“wsdl:tService” &gt; 
             
             
               99 
                   &lt;xs:unique name=“port” &gt; 
             
             
               100 
                    &lt;xs:selector xpath=“wsdl:port” /&gt; 
             
             
               101 
                    &lt;xs:field xpath=“@name” /&gt; 
             
             
               102 
                   &lt;/xs:unique&gt; 
             
             
               103 
                   &lt;/xs:element&gt; 
             
             
               104 
                 &lt;/xs:choice&gt; 
             
             
               105 
                &lt;/xs:group&gt; 
             
             
               106 
             
             
               107 
                &lt;xs:complexType name=“tDefinitions” &gt; 
             
             
               108 
                 &lt;xs:complexContent&gt; 
             
             
               109 
                  &lt;xs:extension base=“wsdl:tExtensibleDocumented” &gt; 
             
             
               110 
                   &lt;xs:sequence&gt; 
             
             
               111 
                    &lt;xs:group ref=“wsdl:anyTopLevelOptionalElement” minOccurs=“0” 
             
             
               112 
               maxOccurs=“unbounded” /&gt; 
             
             
               113 
                   &lt;/xs:sequence&gt; 
             
             
               114 
                   &lt;xs:attribute name=“targetNamespace” type=“xs:anyURI” use=“optional” /&gt; 
             
             
               115 
             
             
               116 
                   &lt;xs:attribute name=“name” type=“xs:NCName” use=“optional” /&gt; 
             
             
               117 
                  &lt;/xs:extension&gt; 
             
             
               118 
                 &lt;/xs:complexContent&gt; 
             
             
               119 
                &lt;/xs:complexType&gt; 
             
             
               120 
             
             
               121 
                &lt;xs:complexType name=“tImport” &gt; 
             
             
               122 
                 &lt;xs:complexContent&gt; 
             
             
               123 
                  &lt;xs:extension base=“wsdl:tExtensibleAttributesDocumented” &gt; 
             
             
               124 
                   &lt;xs:attribute name=“namespace” type=“xs:anyURI” use=“required” /&gt; 
             
             
               125 
                   &lt;xs:attribute name=“location” type=“xs:anyURI” use=“required” /&gt; 
             
             
               126 
                  &lt;/xs:extension&gt; 
             
             
               127 
                 &lt;/xs:complexContent&gt; 
             
             
               128 
                &lt;/xs:complexType&gt; 
             
             
               129 
             
             
               130 
                &lt;xs:complexType name=“tTypes” &gt; 
             
             
               131 
                 &lt;xs:complexContent&gt; 
             
             
               132 
                  &lt;xs:extension base=“wsdl:tExtensibleDocumented” /&gt; 
             
             
               133 
                 &lt;/xs:complexContent&gt; 
             
             
               134 
                &lt;/xs:complexType&gt; 
             
             
               135 
             
             
               136 
                &lt;xs:complexType name=“tMessage” &gt; 
             
             
               137 
                 &lt;xs:complexContent&gt; 
             
             
               138 
                  &lt;xs:extension base=“wsdl:tExtensibleDocumented” &gt; 
             
             
               139 
                   &lt;xs:sequence&gt; 
             
             
               140 
                    &lt;xs:element name=“part” type=“wsdl:tPart” minOccurs=“0” 
             
             
               141 
               maxOccurs=“unbounded” /&gt; 
             
             
               142 
                   &lt;/xs:sequence&gt; 
             
             
               143 
                   &lt;xs:attribute name=“name” type=“xs:NCName” use=“required” /&gt; 
             
             
               144 
                  &lt;/xs:extension&gt; 
             
             
               145 
                 &lt;/xs:complexContent&gt; 
             
             
               146 
                &lt;/xs:complexType&gt; 
             
             
               147 
             
             
               148 
                &lt;xs:complexType name=“tPart” &gt; 
             
             
               149 
                 &lt;xs:complexContent&gt; 
             
             
               150 
                  &lt;xs:extension base=“wsdl:tExtensibleAttributesDocumented” &gt; 
             
             
               151 
                   &lt;xs:attribute name=“name” type=“xs:NCName” use=“required” /&gt; 
             
             
               152 
                   &lt;xs:attribute name=“element” type=“xs:QName” use=“optional” /&gt; 
             
             
               153 
                   &lt;xs:attribute name=“type” type=“xs:QName” use=“optional” /&gt; 
             
             
               154 
                  &lt;/xs:extension&gt; 
             
             
               155 
                 &lt;/xs:complexContent&gt; 
             
             
               156 
                &lt;/xs:complexType&gt; 
             
             
               157 
             
             
               158 
                &lt;xs:complexType name=“tPortType” &gt; 
             
             
               159 
                 &lt;xs:complexContent&gt; 
             
             
               160 
                  &lt;xs:extension base=“wsdl:tExtensibleAttributesDocumented” &gt; 
             
             
               161 
                   &lt;xs:sequence&gt; 
             
             
               162 
                    &lt;xs:element name=“operation” type=“wsdl:tOperation” minOccurs=“0” 
             
             
               163 
               maxOccurs=“unbounded” /&gt; 
             
             
               164 
                   &lt;/xs:sequence&gt; 
             
             
               165 
                   &lt;xs:attribute name=“name” type=“xs:NCName” use=“required” /&gt; 
             
             
               166 
                  &lt;/xs:extension&gt; 
             
             
               167 
                 &lt;/xs:complexContent&gt; 
             
             
               168 
                &lt;/xs:complexType&gt; 
             
             
               169 
             
             
               170 
                &lt;xs:complexType name=“tOperation” &gt; 
             
             
               171 
                 &lt;xs:complexContent&gt; 
             
             
               172 
                  &lt;xs:extension base=“wsdl:tExtensibleDocumented” &gt; 
             
             
               173 
                    &lt;xs:sequence&gt; 
             
             
               174 
                    &lt;xs:choice&gt; 
             
             
               175 
                     &lt;xs:group ref=“wsdl:request-response-or-one-way-operation” /&gt; 
             
             
               176 
                     &lt;xs:group ref=“wsdl:solicit-response-or-notification-operation” /&gt; 
             
             
               177 
             
             
               178 
                    &lt;/xs:choice&gt; 
             
             
               179 
                   &lt;/xs:sequence&gt; 
             
             
               180 
                   &lt;xs:attribute name=“name” type=“xs:NCName” use=“required” /&gt; 
             
             
               181 
                   &lt;xs:attribute name=“parameterOrder” type=“xs:NMTOKENS” use=“optional” /&gt; 
             
             
               182 
             
             
               183 
                  &lt;/xs:extension&gt; 
             
             
               184 
                 &lt;/xs:complexContent&gt; 
             
             
               185 
                &lt;/xs:complexType&gt; 
             
             
               186 
             
             
               187 
                &lt;xs:group name=“request-response-or-one-way-operation” &gt; 
             
             
               188 
                 &lt;xs:sequence&gt; 
             
             
               189 
                  &lt;xs:element name=“input” type=“wsdl:tParam” /&gt; 
             
             
               190 
                   &lt;xs:sequence minOccurs=‘0’ &gt; 
             
             
               191 
                    &lt;xs:element name=“output” type=“wsdl:tParam” /&gt; 
             
             
               192 
                     &lt;xs:element name=“fault” type=“wsdl:tFault” minOccurs=“0” 
             
             
               193 
               maxOccurs=“unbounded” /&gt; 
             
             
               194 
                  &lt;/xs:sequence&gt; 
             
             
               195 
                 &lt;/xs:sequence&gt; 
             
             
               196 
                &lt;/xs:group&gt; 
             
             
               197 
             
             
               198 
                &lt;xs:group name=“solicit-response-or-notification-operation” &gt; 
             
             
               199 
                 &lt;xs:sequence&gt; 
             
             
               200 
                  &lt;xs:element name=“output” type=“wsdl:tParam” /&gt; 
             
             
               201 
                   &lt;xs:sequence minOccurs=‘0’ &gt; 
             
             
               202 
                    &lt;xs:element name=“input” type=“wsdl:tParam” /&gt; 
             
             
               203 
                     &lt;xs:element name=“fault” type=“wsdl:tFault” minOccurs=“0” 
             
             
               204 
               maxOccurs=“unbounded” /&gt; 
             
             
               205 
                   &lt;/xs:sequence&gt; 
             
             
               206 
                 &lt;/xs:sequence&gt; 
             
             
               207 
                &lt;/xs:group&gt; 
             
             
               208 
             
             
               209 
                &lt;xs:complexType name=“tParam” &gt; 
             
             
               210 
                 &lt;xs:complexContent&gt; 
             
             
               211 
                  &lt;xs:extension base=“wsdl:tExtensibleAttributesDocumented” &gt; 
             
             
               212 
                   &lt;xs:attribute name=“name” type=“xs:NCName” use=“optional” /&gt; 
             
             
               213 
                   &lt;xs:attribute name=“message” type=“xs:QName” use=“required” /&gt; 
             
             
               214 
                 &lt;/xs:extension&gt; 
             
             
               215 
                 &lt;/xs:complexContent&gt; 
             
             
               216 
                &lt;/xs:complexType&gt; 
             
             
               217 
             
             
               218 
                &lt;xs:complexType name=“tFault” &gt; 
             
             
               219 
                 &lt;xs:complexContent&gt; 
             
             
               220 
                  &lt;xs:extension base=“wsdl:tExtensibleAttributesDocumented” &gt; 
             
             
               221 
                   &lt;xs:attribute name=“name” type=“xs:NCName” use=“required” /&gt; 
             
             
               222 
                   &lt;xs:attribute name=“message” type=“xs:QName” use=“required” /&gt; 
             
             
               223 
                  &lt;/xs:extension&gt; 
             
             
               224 
                 &lt;/xs:complexContent&gt; 
             
             
               225 
                &lt;/xs:complexType&gt; 
             
             
               226 
             
             
               227 
                &lt;xs:complexType name=“tBinding” &gt; 
             
             
               228 
                 &lt;xs:complexContent&gt; 
             
             
               229 
                  &lt;xs:extension base=“wsdl:tExtensibleDocumented” &gt; 
             
             
               230 
                   &lt;xs:sequence&gt; 
             
             
               231 
                    &lt;xs:element name=“operation” type=“wsdl:tBindingOperation” 
             
             
               232 
               minOccurs=“0” maxOccurs=“unbounded” /&gt; 
             
             
               233 
                   &lt;/xs:sequence&gt; 
             
             
               234 
                   &lt;xs:attribute name=“name” type=“xs:NCName” use=“required” /&gt; 
             
             
               235 
                   &lt;xs:attribute name=“type” type=“xs:QName” use=“required” /&gt; 
             
             
               236 
                  &lt;/xs:extension&gt; 
             
             
               237 
                 &lt;/xs:complexContent&gt; 
             
             
               238 
                &lt;/xs:complexType&gt; 
             
             
               239 
             
             
               240 
                &lt;xs:complexType name=“tBindingOperationMessage” &gt; 
             
             
               241 
                 &lt;xs:complexContent&gt; 
             
             
               242 
                  &lt;xs:extension base=“wsdl:tExtensibleDocumented” &gt; 
             
             
               243 
                   &lt;xs:attribute name=“name” type=“xs:NCName” use=“optional” /&gt; 
             
             
               244 
                  &lt;/xs:extension&gt; 
             
             
               245 
                 &lt;/xs:complexContent&gt; 
             
             
               246 
                &lt;/xs:complexType&gt; 
             
             
               247 
             
             
               248 
                &lt;xs:complexType name=“tBindingOperationFault” &gt; 
             
             
               249 
                 &lt;xs:complexContent&gt; 
             
             
               250 
                  &lt;xs:extension base=“wsdl:tExtensibleDocumented” &gt; 
             
             
               251 
                   &lt;xs:attribute name=“name” type=“xs:NCName” use=“required” /&gt; 
             
             
               252 
                  &lt;/xs:extension&gt; 
             
             
               253 
                 &lt;/xs:complexContent&gt; 
             
             
               254 
                &lt;/xs:complexType&gt; 
             
             
               255 
             
             
               256 
                &lt;xs:complexType name=“tBindingOperation” &gt; 
             
             
               257 
                 &lt;xs:complexContent&gt; 
             
             
               258 
                  &lt;xs:extension base=“wsdl:tExtensibleDocumented” &gt; 
             
             
               259 
                   &lt;xs:sequence&gt; 
             
             
               260 
                    &lt;xs:element name=“input” type=“wsdl:tBindingOperationMessage” 
             
             
               261 
               minOccurs=“0” /&gt; 
             
             
               262 
                    &lt;xs:element name=“output” type=“wsdl:tBindingOperationMessage” 
             
             
               263 
               minOccurs=“0” /&gt; 
             
             
               264 
                    &lt;xs:element name=“fault” type=“wsdl:tBindingOperationFault” 
             
             
               265 
               minOccurs=“0” maxOccurs=“unbounded” /&gt; 
             
             
               266 
                   &lt;/xs:sequence&gt; 
             
             
               267 
                   &lt;xs:attribute name=“name” type=“xs:NCName” use=“required” /&gt; 
             
             
               268 
                  &lt;/xs:extension&gt; 
             
             
               269 
                 &lt;/xs:complexContent&gt; 
             
             
               270 
                &lt;/xs:complexType&gt; 
             
             
               271 
             
             
               272 
                &lt;xs:complexType name=“tService” &gt; 
             
             
               273 
                 &lt;xs:complexContent&gt; 
             
             
               274 
                  &lt;xs:extension base=“wsdl:tExtensibleDocumented” &gt; 
             
             
               275 
                   &lt;xs:sequence&gt; 
             
             
               276 
                    &lt;xs:element name=“port” type=“wsdl:tPort” minOccurs=“0” 
             
             
               277 
               maxOccurs=“unbounded” /&gt; 
             
             
               278 
                   &lt;/xs:sequence&gt; 
             
             
               279 
                   &lt;xs:attribute name=“name” type=“xs:NCName” use=“required” /&gt; 
             
             
               280 
                  &lt;/xs:extension&gt; 
             
             
               281 
                 &lt;/xs:complexContent&gt; 
             
             
               282 
                &lt;/xs:complexType&gt; 
             
             
               283 
             
             
               284 
                &lt;xs:complexType name=“tPort” &gt; 
             
             
               285 
                 &lt;xs:complexContent&gt; 
             
             
               286 
                  &lt;xs:extension base=“wsdl:tExtensibleDocumented” &gt; 
             
             
               287 
                   &lt;xs:attribute name=“name” type=“xs:NCName” use=“required” /&gt; 
             
             
               288 
                   &lt;xs:attribute name=“binding” type=“xs:QName” use=“required” /&gt; 
             
             
               289 
                  &lt;/xs:extension&gt; 
             
             
               290 
                 &lt;/xs:complexContent&gt; 
             
             
               291 
                &lt;/xs:complexType&gt; 
             
             
               292 
             
             
               293 
                &lt;xs:attribute name=“arrayType” type=“xs:string” /&gt; 
             
             
               294 
                &lt;xs:attribute name=“required” type=“xs:boolean” /&gt; 
             
             
               295 
                &lt;xs:complexType name=“tExtensibilityElement” abstract=“true” &gt; 
             
             
               296 
                 &lt;xs:attribute ref=“wsdl:required” use=“optional” /&gt; 
             
             
               297 
                &lt;/xs:complexType&gt; 
             
             
               298 
             
             
               299 
               &lt;/xs:schema&gt; 
             
             
                 
             
           
        
       
     
   
   In the above WSDL Schema, the Definition artifact is defined in lines 107-128, the ExternalImport artifact defined in lines 121-128, the Type artifact is defined in lines 130-134, the Message artifact is defined in lines 136-146, the Binding artifact is defined in lines 227-238, the Operation artifact is defined in lines 170-207, the Parameter artifact is defined in lines 209-216, the Fault artifact is defined in lines 218-225, the PortType artifact is defined in lines 158-168, and the Service artifact is defined in lines 272-282. 
   Continuing with the discussion of  FIG. 4 , the schema defining the domain may be parsed to obtain parsed information (ST 112 ). In one embodiment of the invention, the parsed information corresponds to complexTypes, complexType attributes, and nest complexTypes if the schema is an XML document written in accordance with XSD. Those skilled in the art will appreciate that other heuristics may be used to map the parsed information to artifacts and characteristics within the characteristics model. Continuing with the discussion of  FIG. 4 , the parsed information is subsequently mapped to either an artifact or a characteristics (ST 114 ). In this manner, the characteristics model is generated. In some cases the parsed information may include sufficient information to define relationships between the various artifacts as well as the cardinality of the relationships. Those skilled in the art will appreciate that the characteristics model generated using the method described in  FIG. 4 , may not be a complete characteristics model. For example, the characteristics model generated using the method described in  FIG. 4  may not define all the relationships between the artifacts and the cardinality of each of the relationships. In such cases, the relationships and cardinality of each of the relationships may be input manually by the user. 
     FIG. 5  shows a flowchart in accordance with one embodiment of the invention. More specifically,  FIG. 5  describes a method for generating a characteristics model when the schema is an XML document. Initially, the schema defining the domain is obtained (ST 120 ). The schema is subsequently processed by a Java™ Architecture for XML Binding (JAXB) tool to obtain Java™ objects (ST 122 ). In one embodiment of the invention, the each of the Java™ objects corresponds to an artifact in the domain. Further, each of the Java™ objects includes one or more variables, where each of the variables corresponds to characteristics within the domain. 
   Continuing with the discussion of  FIG. 5 , the Java™ Reflection API is subsequently used to introspect the Java™ to obtain information about the artifacts and characteristics within the domain (ST 124 ). More specifically, the Java™ Reflection API includes functionality to obtain information about: the class of each object, variables and constants used in the object, etc. In some cases, the Java™ Reflection API may also be used to obtain information about the relationships and cardinality of the relationships between the various artifacts. The ability the obtain information about the relationships and the cardinality of the relationships is typically dependent on the detail of the schema that defines the domain. 
   The information obtained from introspecting the Java™ objects created in ST 122  is subsequently used to create the characteristics model corresponds to the domain defined by the schema (ST 126 ). Those skilled in the art will appreciate that the information obtained from introspecting the Java™ object is equivalent to the information obtained from parsing the schema (defined above in  FIG. 4 ). 
   Those skilled in the art will appreciate that the characteristics model generated using the methods described in  FIGS. 4 and 5  may be modified to include additional artifacts and characteristics prior to using the characteristics models to analyze the target system. 
   At this stage, the system is ready to analyze a target system.  FIG. 6  shows a flowchart in accordance with one embodiment of the invention. Initially, characteristics are obtained from the target system using one or more characteristics extractors (ST 130 ). In one embodiment of the invention, the characteristics extractors associated with a given characteristics model only obtain information about characteristics associated with the artifacts defined in the characteristics model. 
   Continuing with the discussion of  FIG. 6 , the characteristics obtained from the target system using the characteristics extractors are stored in the characteristics store using the characteristics store API (ST 132 ). Once the characteristics are stored in the characteristics store, the target system may be analyzed using the characteristics model (or models), a query engine, and the characteristics stored in the characteristics store (ST 134 ). In one embodiment of the invention, the user uses the query engine to issue queries to characteristics store. As discussed above, the query engine may include information (or have access to information) about the characteristics models currently being used to analyze the target system. The results of the analysis are subsequently displayed using a visualization engine (ST 136 ). 
   Those skilled in the art will appreciate that ST 130 -ST 132  may be performed concurrently with ST 124 -ST 136 . In addition, steps in  FIG. 3 , may be performed concurrently with the steps in  FIG. 6 . 
   An embodiment of the invention may be implemented on virtually any type of computer regardless of the platform being used. For example, as shown in  FIG. 7 , a networked computer system ( 200 ) includes a processor ( 202 ), associated memory ( 204 ), a storage device ( 206 ), and numerous other elements and functionalities typical of today&#39;s computers (not shown). The networked computer ( 200 ) may also include input means, such as a keyboard ( 208 ) and a mouse ( 210 ), and output means, such as a monitor ( 212 ). The networked computer system ( 200 ) is connected to a local area network (LAN) or a wide area network via a network interface connection (not shown). Those skilled in the art will appreciate that these input and output means may take other forms. Further, those skilled in the art will appreciate that one or more elements of the aforementioned computer ( 200 ) may be located at a remote location and connected to the other elements over a network. Further, software instructions to perform embodiments of the invention may be stored on a computer readable medium such as a compact disc (CD), a diskette, a tape, a file, or any other computer readable storage device. 
   While the invention has been described with respect to a limited number of embodiments, those skilled in the art, having benefit of this disclosure, will appreciate that other embodiments can be devised which do not depart from the scope of the invention as disclosed herein. Accordingly, the scope of the invention should be limited only by the attached claims.