Ontological Framework for Object-Oriented Analysis and Design

Regardless of the large number of Object-Oriented (OO) modeling languages currently being used in the Information Systems (IS) modeling process, unavailability of an OO modeling language that can be used in both the analysis and design phases disintegrates the two phases. The problem is, such disintegration can lead to a high level of missing information in the real world system from the analysis phase to the design phase. The approach of this study is to propose a framework to produce design phase models from analysis phase models using ontology based Unified Modeling Language (UML), thereby integrating the two phases. The results obtained from the porposed framework involve: A consructed language which can be used in generating the analysis phase scripts; and the development of script files based on the UML constructs at the analysis and design phases to automatically generate the UML scripts for those two phases. Since this study is a part of an ongoing research study, it can be concluded that, at the end of this study (1) both analysis and design phases would be able to integrate using a common OO modeling language (2) the manual work involved in the current analysis and design modeling would be reduced (3) the complexities and difficulties faced by the modelers (By modelers we mean the analysts and designers who are doing the analysis and design phase modeling) in using UML modeling tools would be reduced.


INTRODUCTION
According to Wand and Weber (1988), IS are not just representations of real world systems.They represent how the human beings perceive the real world systems.Human perceptions regarding the real world characteristics are identified, abstracted and modeled as conceptual and system models during the analysis and design phases.Primary objective of these two phases comprise making all the captured information readily available for the subsequent IS development activities with no missing information (Kim et al., 2008;Mishra and Lohani, 2007).Any transformation with missing information between either human perception of real world system and conceptual model, or conceptual model and system model will result an inaccurate final outcome.Hence, the final IS will not be an accurate representation of the real world system.Thus, faultless modeling plays a significant role in IS development.Nevertheless, IS projects do not use proper modeling during the analysis and design phases due to various reasons and most trivial of them are stated below: • No common OO modeling language exist for both analysis and design phases modeling (Evermann and Wand, 2009).To be used in both the phases in a disciplined way, an OO language should be able to model both real world characteristics (conceptual modeling) as well as the IS characteristics (system modeling) seamlessly.Many OO modeling languages do not have both these capabilities together.Thus,

Science Publications
AJEAS different modeling languages need to be used for each phase thereby disintegrating these phases • So far, considerable portion of analysis and design modeling processes are largely manual (Overmyer et al., 2001).Primary tools used for identification, abstraction and modeling the conceptual and system models are pencil and paper, with the results being transferred to a modeling tool after the modeling is largely completed • Various modeling tools are available to make the IS modeling process easier.But most of them are complex and less user friendly to be used.Moreover they do not provide adequate helping facilities for the modelers regarding the functionalities of those tools.Kuhrmann (2011) declares that complexity and less user friendliness associated with the modeling tools are major problems in conceptual and system modeling Availability of a proper framework or tool which mitigates the above problems may encourage the modelers to do their job well.Currently up to our knowledge, there is no such framework or tool available.Having observed the above problems, this study proposes an ontological framework as the solution, that uses UML as the OO modeling language.
The constructs (By constructs we mean concepts and core guidelines that are used to form a language or a domain) of the existing OO modelling languages primarily developed for system modeling and are not capable of modeling the characteristics of real world systems seamlessly (Evermann and Wand, 2005a).Since the analysis phase more concern on real world systems, Evermann and Wand (2005b) suggested adding the real world system characteristics for the constructs of generic UML using ontological approach.Consequently this will create a new version of UML with new ontological UML constructs, which can be used for conceptual modeling.Ultimately it will help the use of UML for both analysis and design phases in a disciplined way.
Use of a common OO modeling language (with two language versions) will preserve the real world characteristics during the transformation process from the human perception of real world system to conceptual model.Besides, a set of UML based transformation rules from-analysis-to-design can be defined when transferring the conceptual model to the system model.This research project expects to define such transformation rules to generate system models from the corresponding conceptual models with no human involvement thereby reducing the involved manual work.This is an ongoing research study.Thus, during this study the entire work to be covered by the research study will be presented in brief with necessary real life examples.Further experiments and empirical suited regarding this ongoing study will be covered in the future research activities.

Related Work
The accuracy of the final IS to be developed depends on how well it is modeled during the analysis and design phases.Erroneous transformation of information in either of the two phases will result an erroneous representation of the real world system at the implementation of the IS (Kim et al., 2008).Thus, the modeling plays a trivial role in IS development.
Nevertheless, the OO modeling process is largely manual and difficult.Normally modelers start modeling by identifying the characteristics of real world systems as perceived by human beings.Those characteristics will be transformed into conceptual models and, during this stage usually pencil and paper are used.Same manual procedure is being repeated at the design phase.Doing the modeling manually is not an easy task.The reason is that, OO modeling languages such as UML have grown quite large and currently covers about 250 modeling classes that are highly interrelated (Silingas and Butleris, 2009).Favre (2003) have evaluated UML using a quality framework and identified that UML is one of the most complex modeling approach.
Manual work and the complexity involve in current modeling practices are said to be reduced by modeling tools.But the user friendliness and documents support regarding the functionalities provided by many OO modeling tools are not adequate enough.Nguyen and Chun (2006) conducted a research study with six modeling tools and identified that those tools currently provide little assistance in managing the associations with the models and hence provide little support for modeling.
As aforementioned, although modelers tend to use OO modeling languages in both analysis and design phases, those languages are developed to be used only in system modeling.UML is one such standard OO modeling languages, which can be used in IS modeling (Koppe, 2010;Paige et al., 2003;Rumbaugh et al., 1999).Nevertheless, UML constructs are developed to describe and design the functionalities and characteristics of ISs.Thus, it provides less support in modeling the characteristics of real world systems and hence cannot be used effectively in conceptual modeling.
As a result of the above reasons, even if the OO modeling is important in IS development, it is not carried out in a proper and a disciplined way.Many IS development teams build OO models on whiteboards only during user group meetings to help communicate their understandings of the real world systems (Fowler, 2003).Hence it is important to find solutions to make the OO modeling in a more accurate and disciplined way.
Having observed the aforementioned requirements, Evermann and Wand (2005b) modified the UML to be used with conceptual modeling by defining new UML language constructs from Bunge's ontological concepts Science Publications AJEAS (Bunge, 1977;1979).A mapping is created between the ontology based real world characteristics and the UML constructs thereby making this new ontology based UML version to be used in conceptual modeling.Thus, UML can be used as a common OO modeling language in both analysis and design phases to integrate those two phases with no missing information.Core objective of the framework proposed in this study comprises defining proper UML based transformation rules to convert conceptual models into system models seamlessly.
Besides, the proposed framework converts the human perception of real world systems into language statements of a specific constructed language defined for this framework.Next, those constructed language statements will be transformed into conceptual models.Constructed language is a language that has been built by a person or a group of people, rather than naturally evolving over time (Gopsill, 1989;McGuigan and Foster, 2011).These languages are being built for various reasons; to ease human communication (e.g.Esperanto-an international auxiliary language), to develop computer programs (e.g., Python-a programming language), to do linguistic experiments.(Oostendorp, 2000).But up to our knowledge, currently no constructed language is built to satisfy the following three requirements together; (1) represents real world characteristics (2) uses normal English language words to represent them in constructed language statements (3) can be mapped with the constructs of UML.Hence the proper definition of a new constructed language for the framework rules will ultimately transforms the real world characteristics into conceptual models in a disciplined way, thereby integrating real world system, conceptual model and system model seamlessly.
The interface of the framework should be designed in a way to take inputs (real world system characteristics) in Natural Language (NL) format and produce constructed language statements.Since NL is easily used by anyone, many researchers try to develop NL based approaches for UML modeling.Tichy and Koerner (2010) use NL processing and semantic technologies to generate UML models from NL inputs.They directly convert the NL input documents into a constructed language which later will be transformed into UML models.Although the approach is similar to ours, the constructed language built by them has a graphical notation which cannot be incorporate with the UML constructs used in our framework.Deeptimahanti and Babar (2009) propose a domain independent UML tool which generates UML models from NL requirements using efficient Natural Language Processing (NLP) tools.They directly convert the NL inputs into XML Metadata Interchange (XMI) files of conceptual models using generic UML.Since the constructs of generic UML does not support conceptual modeling, this framework is also not suitable for our purpose.The interface proposed by Overmyer et al. (2001) in their software tool Linguistic Assistance for Domain Analysis (LIDA), is the most applicable interface to be incorporated with our framework.LIDA tool provides an interface for the analysts to feed NL documents, from which the UML models are being generated.Only the required NL words will be captured form the input documents in generating the diagrams.The basic structure of this interface needs to be modified to be suited with the requirements of our framework where it should; (1) allow the analysts to input real world characteristics except the concepts captured form the input document (2) convert all the captured NL words into constructed language statements using the rules specified for that language.With these modifications, LIDA tool interface can be used with our framework.
The study proceeds as follows.Materials and methods of the framework descibes next with the proposed modeling framework.Subsequently, the results obtained from the practical use of the proposed framework is explained.Since this is an ongoing research study, final part of the paper concludes the research study along with a discussion of the future research.

MATERIALS AND METHODS OF THE FRAMEWORK
Current modeling process in IS development is depicted in Fig. 1.It distinctly shows that both analysis and design phases build models using two different modeling languages.Besides, large portion of analysis and design phases modeling is manual.The UML based ontological framework proposed in this study mitigates above problems thereby enhancing the current IS modeling process.Primary objective of this proposed framework involve integrating both analysis and design phases using a common OO modeling language, UML.Thus, UML must be capable to be used in both analysis and design phases in a disciplined way.The ontology based framework that comprises a new UML version for the analysis phase proposed by Evermann and Wand (2005b) is used in our framework for the creation of conceptual models.Evermann and Wand's framework is specifically chosen because: • They have selected UML as the OO modeling language for their framework, which is the same used in our framework • The concept behind their framework well suits in solving the problem of using the OO modeling languages in conceptual modeling in a disciplined way Science Publications AJEAS Fig. 1.Existing modeling process in the current practice.(Before introducing the framework) • They have initiated incorporating the real world characteristics to UML, which can be used as the starting point of our framework Having a common OO modeling language for both conceptual and system modeling only, will not precisely integrate analysis and design phases.Along with a common modeling language, the availability of proper transformation rules to transform the conceptual models into system models with no missing information will ensure a proper and accurate integration between analysis and design phases.A precise comparison between the UML constructs defined for each phase will help to build new transformation rules.Nevertheless, analysis phase UML constructs are defined based on Bunge's ontology (Evermann and Wand, 2005b).Thus prior to the comparison, design phase UML constructs also need to be defined using the same ontology.
Currently up to our knowledge, no research study has been carried out to define ontology based UML constructs for the design phase.To define ontology based UML constructs, IS characteristics need to be applied for UML using ontology.Once the UML constructs of both analysis and design phases are defined using Bunge's ontology, definition of the transformation rules can be initiated.Next, those rules need to be mapped to the UML version used in system modeling (i.e., generic UML).Subsequently, if the transformation rules are defined seamlessly, two important conclusions can be made out of that: • A model created using analysis phase UML version can precisely be transformed into a model of the design phase UML version seamlessly.Which means conceptual models can be transformed into system models without losing any information captured from the real world system • A precise integration can be created between analysis and design phases using UML.The first conclussion is used as the basis of the proposed framework.
Besides, the framework is further enhanced as depicted in Fig. 2. Enhanced framework is capable of taking the human perception regarding real world systems into the statements of a constructed language (a language specifically built for this framework) at the analysis phase and to output the conceptual models from them The framework interface is developed according to the interface of the LIDA tool (Overmyer et al., 2001), as specified in the Related work section.The LIDA interface will be modified based on the language rules of a constructed language, thereby converting all the inputs fed to the interface into constructed language statements.Interface development will be done during the implementation of the software solution of the framework, which is out of the scope of this research study.Even though NL is more convenient for the modelers, a constructed language is devised to be used inside the framework except NL.Because, NL words and sentences are too complicated to be mapped with UML constructs.The constructed language is also similar to NL but more specific and abstract than that and easy to be mapped with UML constructs.Further details about this constructed language are given under the Framework in practice section with real world examples.

. Proposed ontological framework
Once the constructed language statements are provided by the interface, those will be converted into ontological UML constructs of conceptual model, using an ontological approach.The ontological UML constructs generated for the conceptual model are used as the input at the design phase, thereby transforming them into ontological UML constructs of system model.
Next, the created ontological UML constructs for both analysis and design phases will be converted into the language statements of another language, Extensible Markup Language (XML).The ontological UML constructs will not directly be converted into UML models.Because, our purpose is to make the final conceptual and system model to be accessed using most of the currently available UML modeling tools.In order to do so, the information of the two models (the UML constructs) needs to be saved using a file format which is compatible with most of the standard UML modeling tools in the current practice.Hence, XMI is selected as the file format which is compatible with most of the standard UML modeling tools.XML is the programming language which is used to create XMI files.Thus, the ontological UML constructs of both analysis and design phases need to be transformed into XML language statements.Later, those XMI statements will create the XMI script files for both constructs sets.
This XMI script files contains transformation information about how to convert the UML language constructs into UML symbols.Since XMI format is compatible with most UML modeling tools, once a script file is imported to a UML tool, it has the ability to transform the symbols into the corresponding UML diagram as specified in the script file.Ultimately conceptual model for the analysis phase and system model for the design phase can be generated with the help of these XMI script files.

RESULTS FROM THE PRACTICAL USE OF THE FRAMEWORK
UML possesses fourteen different types of diagrams which can be used in OO modeling.Out of them, only class diagram is considered to be used with the proposed framework.Class diagram is the main diagram type in UML which represent the main objects and their interactions of an IS to be developed.Its purpose is to graphically depict the relationships holding among objects manipulated by a system (Evans, 1998).Specifically this diagram type is used because, UML class diagrams are already enhanced to be used in both conceptual and system modeling.
Using UML class diagrams, some parts of the framework are being investigated.Those parts are described below with a real world scenario.An IT institute wants to develop a system to assign their students to lecturers, based on the subjects they have selected.Properties of a student include student ID, name and address and for a lecturer those are lecturer ID, name and subjects they are teaching.Registration of the student and lecturer records needs to be performed.Furthermore modification and deletion of student records and subject assignment for the lecturers need be done via the system.Each student should be assigned to one lecturer and each lecture can have zero to many students.This scenario is used in the following two sub sections to describe the activities of the framework.

Building the Constructed Language
This sub section presents information about the use of constructed language for the proposed framework.The modified LIDA interface (Overmyer et al., 2001) will be capable of converting the inputs fed into to the interface constructed language statements.Although modelers can feed inputs to the LIDA interface in NL, a specific constructed language is used within the Science Publications AJEAS framework except NL, because of the complexity in using NL.NL inputs can contain thousands of words and different complex sentences, which may be difficult to map with the ontological UML constructs (analysis phase).Hence, a specific constructed language will be built for our framework.
As depicted in Fig. 2, constructed language statements generated from the modified LIDA interface are converted into the ontological UML constructs of analysis phase.This means, the scope of the constructed language comprises representing the UML constructs defined for the analysis phase with no missing information.Hence, this language uses the UML constructs defined for the analysis phase as the basis in building the language.Thus, the constructed language uses normal English words and sentences but builds in a way to represent the large English vocabulary with a limited but sufficient number of words.Once the constructed language is built to represent all the UML constructs defined for the analysis phase precisely, it can be claimed that the limit of the constructed language is reached up to the required level.Besides, this constructed language organizes the long and complex English sentences in a clearer manner with simple statements.Thus, all the aforementioned factors ultimately help to make the constructed language statements more precise and clearer than the NL inputs (McGuigan and Foster, 2011).Some important constructed language rules are specified below.Fundamental ontological UML constructs defined for the analysis phase are considered in building those rules.

Rule 1
A UML class must be declared with a single word and within square brackets.
Evermann and Wand (2005b) defined UML rules for the analysis phase using Bunge (1977;1979) ontology.According to their definition and according to Bunge's ontology, only physical things in the world are modeled as objects (Evermann and Wand, 2005b).They have found alternative constructs in UML for conceptual items such as 'lecture', 'order' and described those in their research paper in detail.Having observed Evermann and Wand's UML rules for the analysis phase, we have made some amendments to the aforementioned rule as corollary one.

Corollary 1
In OO conceptual modeling, every class name specified inside a square bracket must represent a physical thing in the real world.
UML classes and attributes need to be defined in constructed language statements as follows.

Definition 1
Once a class is identified, that can be declared as; class: [class name].Initially 'class' key word should be declared along with the class name, which is separated by a colon.

Definition 2
Once an attribute is identified, that can be declared as; attribute: Attribute name [respective class name].Initially 'attribute' key word should be declared along with the attribute name which is separated by a colon.Attribute name should follow the respective class name.
The above language rules defined for the constructed language can be illustrated using the real world scenario as follows.Two main classes are identified from the scenario, student and lecturer: According to the analysis phase UML rules, UML attributes are divided into two parts as attributes of ordinary classes and of association classes.Attributes of an ordinary classes means the attributes possess by the class itself (e.g., colour).Attributes of association classes means the attributes that exist between two or more classes (e.g.employed by) (Evermann and Wand, 2005b).According to this UML rule, following constructed language rules can be defined.

Rule 2
Attributes of ordinary classes should be declared with 'attributeA' key word and attributes of association classes should be declared with 'arrtibuteO' keyword.

Corollary 2
Attributes of ordinary classes can only have one corresponding class and attributes of association classes must have more than one class.
The given examples for the two attribute types; colour and employed by, are not given in the real world scenario.But we can add them to the student and lecturer classes as the below given way: During the design phase of OO modeling, methods that each class is responsible of are modeled.Nevertheless, at the analysis phase not the methods but the messages sent and received by each class are modeled.For the ease of transforming the conceptual model into system model, the word method will be used as the constructed language symbol.

Definition 3
Once a method (message to or from) of a particular class is identified, that can be declared as; method: Science Publications AJEAS method name [respective class name].Initially 'method' key word should be declared along with method name which is separated by a colon.Method name should follow the respective class name.For example, method (message to or from) can be added to the above defined classes as follows: method: getRegistered(), makeModify() [Student]; addCourse() [Lecturer] UML class diagrams possess three different relationship types; association, whole/part relationships and generalization/specialization.Out of those three relationship types, an association relationship can be represented in constructed language as follows.Tour

Definition 4
Association relationship-Two class names should be written as declared earlier and should be written in between the 'association' key word.
Multiplicity also can be declared with the association relationship declaration.Multiplicity means the term used to describe constraints on the number of participating classes (Bennett et al., 2001).

3
Multiplicity of a class should be defined just after the name of that class and it should be declared within brackets.
The two classes identified from the scenario can be related with each other through association relationship.This association relationship can be represented using constructed language statements along with their multiplicity, as follows: Above constructed language rules are defined for classes, attributes, operations and association relationships.Those rules are defined in a way to map the constructed language statements with the analysis phase UML constructs.But the analysis phase ontology based UML contains hundreds of different constructs and more complex UML rules also remain.Hence the constructed language needs to be built in a way to be correctly mapped with as much as currently available analysis phase ontological UML constructs and UML rules.

XMI Script Files
The proposed ontological framework does not directly convert the ontological UML constructs generated for conceptual and system models into UML diagrams.But it converts these ontological UML constructs into a file which stores information about the UML diagram to be generated.The reason behind this is; if the UML constructs directly convert into conceptual and system models, a new file format (e.g., *.doc is the file format for MS Word 2003) which is specific to this framework needs to be defined to save the outputs.Then the output results can only be modified using this framework.Nevertheless, the aim is to develop the framework in a way, where the conceptual and system models output by the framework can be modified using almost all UML modeling tools.Thus, the modelers can either use this framework or their preferred modeling tool to modify the models output from our framework.
In order to achieve this, ontological UML constructs need to be converted into a file format which is compatible with most of the standard UML modeling tools.This compatibility requirement triggered the use of XMI in our framework.XMI is a file format which mostly used to interchange the data between different UML modeling tools.Most of the standard UML modeling tools can import XMI files as well as export the UML diagrams developed using those tools as XMI files.What XMI files do is, they store the details of UML diagrams given by the ontological UML constructs using XML language.XML is the markup language which is used to script XMI files.For example, student class can be taken from the aforementioned real world scenario with student-ID attribute and register operation.As depicted in Fig. 3, details of class student are stored in a XMI script file using XML language statements.
As illustrated, XMI file only contains some XML tags (XML statements written within < > are known as XML tags) and XMI file is only a text document.Hence XMI script file itself does not show the conceptual or system model directly; instead that file needs to be open with an XMI compatible UML modeling tool thereby the tool converts the XML tags specified in the XMI script file into corresponding UML symbols.
Definition or modifications of the existing UML constructs will not be performed during this research study.Instead, mapping ontological concepts to the existing UML constructs and transformation rules definition for the design phase will be performed.Hence, defining new XML tags for the existing UML constructs is not required.Because that, if an existing UML construct or a set of constructs is drawn using a XMI compatible modeling tool, that tool is capable of exporting the corresponding UML diagram as an XMI file.This means for each existing UML construct, predefined XML tags are available in each UML modeling tool.
Thus, we only have to ensure that the ontological UML constructs generated by the framework for each conceptual and system model, are transformed into XML tags with no missing information.In order to do this, necessary XML tag(s) need to be assigned for each ontological construct for both UML versions.So mapping the XML tags for the ontological UML constructs can be achieved as depicted in Table 1.The first two columns of the table are taken from Evermann and Wand (2005b) research study and in the third column necessary XML tags are mentioned.The table only illustrates the primary XML tag which includes the UML construct name.Except this tag, some more XML tags are required to describe a UML construct precisely.For example, the XML tags set depicted in Fig. 4, are required to describe an UML object correctly.
The XML language used in Fig. 4 is known as XML Processing Description Language (XPDL), hence all the XML tags start from that word.Each object represented in this language an arbitrary mixture of ATTR (attribute) and OBJ (sub-object) elements and using them all the objects will be described in the XMI script file.Correspondingly, the above depicted set of XML tags includes all the details of the UML object; Student.
Thus, all the XML tags used for each ontological UML construct need to be identified clearly, to have a perfect transformation.Sometimes, merging the XML tags of two different UML constructs may need to be done in order to map the XML tags seamlessly with the ontological UML constructs and their corresponding ontological concepts.Correspondingly this process need to be continued for the ontological UML constructs of both analysis and design phases.Accurate XML tag assignment ensures a faultless transformation form conceptual and system models to XMI script files thereby representing the real world system accurately in both analysis and design phases.

CONCLUSION
This study proposes an ontology based UML framework for OO conceptual and system modeling.It is a part of an ongoing research project and certain parts of the framework are illustrated using real world examples.The future work will cover the following aspects of the framework: • As explained in the Constructed language sub section; to represent the characteristics of real world systems precisely at the analysis phase, constructed language rules need to be developed to map the ontological UML constructs defined for the analysis phase with no missing information • As mentioned in this study, a faultless model transformation can be achieved by defining proper transformation rules between analysis and design phases by matching the two sets of ontological language constructs defined for each phase.Since ontological UML constructs are already defined for analysis phase, we hope to work in defining Once the system domain characteristics are assigned with necessary ontological concepts, those need to be mapped with generic UML to define UML constructs for the design phase.According to Bunge's ontology, thing is the fundamental concept and all the other ontological concepts built under this thing.The world consist of things and only of things and moreover those substantial things physically exist in the world.Only the constructs of UML class diagram are considered for the mapping with ontological concepts because, in this study we only use UML class diagrams to explain the framework.Since all the concepts of Bunge's ontology are built under thing, logically it should be mapped with the fundamental UML construct, object.But, OO system modeling defines a UML object as; Something that is or is capable of being seen, touched or otherwise sensed and about which users store data and associated behavior (Whitten and Bentley, 2005).Hence objects can or cannot be physical (substantial) in OO system modeling thereby mapping Bunge thing to UML object is infeasible.Since Bunge's fundamental ontological concept (thing) is difficult to map with a design phase UML construct, mapping the other ontological concepts with relevant UML constructs may not be an easy task.Because, until a suitable UML construct will be found for Bunge-thing, it will not be possible to proceed with the remaining ontological concepts.Hence, this part of the framework is supposed to be carried out as a future research work: • Subsequently, the framework will convert the two sets ontological UML constructs defined for analysis and design phases into XML language statements.Using these statements, XMI scrip files will be generated.As in the Framework in practice section, no new XML tag or set of tags need to be defined to be suited with ontological UML constructs.What need to be done is, ensuring that all the ontological UML constructs used in conceptual and system modleing can be precisely mapped using the predefined XML tags with no missing information.At this level this activity is continuing and to be completed as a future work.
• Once the activities comprises in the proposed framework are being completed precisely, an empirical study will be carried out to evaluate the validity and the usefullness of the framework in the practical scenario • Finally we hope to do an investigation to find the UML tools in current practice, which can be made compatible with our framework.Because, XMI cannot be used with every UML tool.Even if XMI is used, different tools may have different unique ways in representing the XMI script file.After a thorough analysis of these conflicts and gaps, we expect to find a standard format for the XMI script file, which may capable to be used with all the UML tools that uses XMI.This is the final future activity we expect to carry out with our research study With all the above mentioned activities, our final goal is to create an UML based ontological framework that can be used to (1) integrate both analysis and design phases using a common OO modeling language (2) reduce the manual work involved in the current OOAD process (3) minimize the complexities and difficulties faced by the modelers in using UML modeling tools.

ACKNOWLEDGEMENT
We are indebted to Prof. Ron Weber (Faculty of Information Technology-Monash University, Australia) and Mr. Kapila Dias (University of Colombo School of Computing, Sri Lanka) for the helpful comments and reference suggestions given on this study.