International Journal of Research and Reviews in Software Engineering Vol. 1, No. 1, March 2011 Copyright © Science Academy Publisher, United Kingdom www.sciacademypublisher.com Science Academy Publisher
Study of Ontology in Software Modelling Process and Life Cycle A. Anandaraj1, G. Dheepak2 and K. Raja1 1
CSE Department, Narasu’s Sarathy Institute of Technology,Salem, India ECE Department, Rajalakshmi Institute of Technology, Chennai, India
2
Correspondence should be addressed to
[email protected],
[email protected] and
[email protected]
Abstract – Semantic web technology is the emerging field that provides new incentive for software engineering research. As the root of semantic engineering is knowledge engineering, it is sometimes impossible for software engineers to overlook the ontology enabled approaches. This paper presents few examples of ontological applications throughout the software engineering life cycle. It also discusses about the advantages and provides a frame work for the usage of ontology’s in software engineering. Keywords – Software Engineering, Ontology, Semantic Web.
1.
Introduction
The Semantic web is the second generation of the web to share and reuse data across application, enterprise and community boundaries. The communities of software engineering and knowledge engineering work in the basis of sharing their knowledge with each other. Software engineering researchers are striving hard towards a higher degree of abstraction and emphasizing software modeling. As because of this, knowledge engineering community promotes several modeling approaches in order to realize the vision of semantic web[1]. Although the field is growing steadily, the discussions between both the communities are relatively small. However both the communities mostly live in their own world. The discussions tend to be academic, focusing on aspects like meta-modeling. Some important aspects like applicability are thereby neglected. Both are creating central concepts up to their own way of understanding, this creates difficulty for the members of each community to grasp the concepts of the other one. To bridge these gap ontologies can be applied in software engineering throughout its several stages of the development lifecycle. This paper is of threefold. A concise description of various ontology based approaches in software engineering is provided first, secondly a framework has been proposed to classify the different approaches, and finally we derive few generic advantages of ontologies in the context of software engineering. 1.1. Software Engineering Software engineering is the “application of a systematic, disciplined, quantifiable approach to the development, operation, and maintenance of software”[2]. The discipline has undergone many fundamental changes during the last three
decades. This assertion is for both emergence of new technology and sophistication of methodology. The level of abstraction has been raised through modeling in order to cope up with the complexity of the software. For example, the paradigm of model driven development proposes that the modeling artifacts are “executable” [3]. Many problems like composition, validation, information, application integration, testing and quality have only been solved partially. This affects every single aspect in software engineering. 1.2. Knowledge Engineering The engineering of knowledge based systems is a discipline that is related to software engineering. The term knowledge engineering is associated with the expert systems development. It includes methodologies as well as knowledge representation techniques. In the field of computer science, the area ontology is interpreted in many different ways and dimensions. Different kinds of ontologies can be classified according to purpose, specificity and expressiveness. This classification is according to Oberle [4]. Purpose dimension is primarily used to reduce terminological ambiguity among members of the community. In the specificity dimension generic, core and domain ontologies are distinguished. According to expressiveness, one can further distinguish lightweight and heavyweight ontologies. Ontologies have been attracted more in recent days, this is due to the emergence of semantic web. New technologies have been developed for ontology representation, this makes their adoption in real world applications much easier. While ontologies are applied in software engineering there increases terminological confusion. This paper tries to alleviate some of the confusions by proposing a framework to categorize
International Journal of Research and Reviews in Software Engineering potential uses of ontologies in software engineering.
2.
Applications of Ontologies in Software Engineering
A concrete approaches for using ontologies are to be presented over here. The presentation will be in the order of appearance in software engineering life cycle. Each approach will be described concerning the general problem it tries to solve. 2.1. Analysis and Design In this phase two main areas should be concentrated more. One is requirements engineering in terms of knowledge representation and the other is component reuse as a potential application. In design, ontologies are mainly used as domain knowledge to check the initial phases of software system design with the aim of detecting conceptual errors within the domain knowledge. The reliability in software systems with respect to consistency checking is tested in different domains such as business process modeling or system dynamics.
14
search for reusable components takes place. Since most reuse repositories are limited to a plain syntactical keyword based search, they are suffering from low precision and low recall. Depiction of Approach: Functionalities of components can be described with the help of ontologies using a knowledge representation formalism that allows more convenient and powerful querying. Semantic descriptions of components in a knowledge base can be implemented, stored and run semantic queries using the approach called KOntoR system [6]. Advantages of Ontologies: Ontologies provide two advantages for this scenario compared to traditional approaches. One is, help provided to join information which is isolated in several separate component descriptions and the other is it provides background knowledge that allows non experts to query from their point of view. query from their point of view. ONTOLOGY DESCRIBES
CONCEPTUALIZATION
2.2. Requirement Engineering Problem Analysis: This phase deals with gathering the desired system functionality from the customers. The problem of the domain has to be learnt thoroughly, as software engineers are not often domain experts. This should be done to avoid ambiguity, incomplete specification and major rework after implementation. Changing of customer’s objectives leads to change of requirements, hence it should be bothered. Depiction of Approach: Description and representation of requirement specification can use ontology. In most cases, requirements are described using the natural languages, for e.g. in the form of use cases. However it can be represented using formal specification languages which are generally more precise. As degree of expressiveness can be adapted to the actual needs, ontologies can cover semi-formal and structured as well as formal representation [5].A domain which is under consideration can be understood using the domain model representation. However the formalization can be done using the modeling languages such as the UML. The problem domain can be described using an ontology language with varying degrees of formalization and expressiveness. Advantages of Ontologies: For the specification of requirements and domain knowledge [5], ontologies seem to be well suited for the evolutionary approach. Automated validation and consistency checking are considered as a potential benefit compared to semi-formal or informal approaches providing no logical formalism or model theory. To realize model driven approaches in the design and implementation phase formal specification is chosen as the best. 2.3. Component Reuse: Problem Analysis: Modern software engineering practices encourages to look for a component that exists already. Reuse can avoid rework, save money and system quality can be improved. After completing the analysis phase and when the functional requirements are settled then the
Informal or conceptual model
semiformal
Iterative refinement Provides ontological commitments for
Verify Formal Specification KNOWLEDGE BASE
Implementation Implemented KBS
Represents
DOMAIN
Figure 1. Verification of Knowledge Based Systems by deploying Core Ontologies
Implementation: Moving from analysis and design to implementation is a critical step in the development process. The way in which the problem domain is mapped to code has always been playing a pivotal role. Two areas of interest are the overlaps of software modeling with ontology languages for bridging the gap between design and implementation. 2.4. Amalgamation with Software Modeling Languages: Problem Analysis: For creating, defining transformations and managing the metadata between models Model Driven Architecture (MDA) based infrastructure is used. Description languages for the semantics of the domain are limited compared to knowledge representation languages. MDA based languages do not have a knowledge based foundation to enable reasoning. Depiction of approach: MDA-based information
International Journal of Research and Reviews in Software Engineering representation languages and ontology languages which are exemplified in can be alternated by several ways [7]. UML can be regarded as ontology representation language by defining direct mappings even though it is employed as modeling syntax for ontology development. The Ontology Definition Metamodel (ODM) [8] is an effort to standardize the mappings between knowledge representation and conceptual modeling languages. Advantages of Ontologies: Software modeling languages and methodologies can benefit from the integration with ontology languages such as RDF and OWL in various ways, e.g. by reducing language ambiguity, enabling validation and automated consistency checking [9]. Ontology languages provide better support for logical inference, integration and interoperability than MOF-based languages. Domain vocabularies and ontologies creation has been supported by UML-based tools. Since ontologies promote the notion of identity, ODM and related approaches simplify the sharing and mediation of domain models. 2.5. Deployment and Run-time Semantic Middleware Problem Analysis: Sophisticated middleware infrastructure like application servers shield a lot of complexity from the application developer, but create challenging tasks for the administrator. Management of middleware system becomes a cumbersome task because of interdependencies between modules or legal constraints. Depiction of Approach: Oberle developed a number of ontologies for the formal description of concepts from component-based and service-oriented development. His goal is to support system administrators in managing server applications. The conceptualization of ontologies has two objectives, one is to provide a precise, formal definition of some ambiguous terms from software engineering and other is to provide structured support to the formalization of the middleware languages. Advantages of Ontologies: Ontologies provide a mechanism to capture knowledge about the problem domain. So in this approach semantic tools create an information space where knowledge can be stored. Reasoning can then be applied to reuse this knowledge for various purposes. 2.6. Maintenance Software maintenance is a knowledge intensive process where knowledge of activities, legacy software, system architecture, problem requirements coming from different sources is handled to maintain the software. Therefore, ontology provides a solid basis to conceptualize such knowledge. 2.7. Project Support Problem Analysis: In software maintenance workflows, several kinds of related information exist without an explicit connection. Since a unified view could avoid redundant work and speed up problem solving, this is problematic. A bug resolution process is depicted. Since it is difficult to manage larger amount of bugs without all existing context information, the lack of tool support may lead to delays in fixing of bugs. Depiction of Approach: In web communities problem
15
solving processes can be supported by Dhruv [10,11] which is a semantic web enabled prototype. The application scenario is based on hoe the open source communities deal with bugs in their software under development. Ontologies help to connect the electronic communication of the developers with bug reports and the affected areas in the source code. The knowledge is codified with three kinds of ontologies: First, describe the structure of artifacts. Second, ontology of interactions describes the communication flow among the developers. Third, community ontology defines several roles that are involved in the problem solving process. Components of the software maintenance projects ontology Maintenance ontology
Products sub ontology
Activities sub ontology
Process sub ontology
Agent sub ontology
Workflow ontology
Measure ontology
Figure 1. Structure of the software maintenance projects ontology Advantages of Ontologies: In the Dhruv system, ontologies primarily provide a layer to integrate data from different source into a unified semantic model. The combined data can then be used to derive additional information that was not stated explicitly. 2.8. Testing: Problem analysis: Software tests are an important part of quality assurance [2]. However, the writing of test cases is an expensive Endeavour that does no directly yield business value. It is also not a trivial task, since the derivation of suitable test cases demands a certain amount of domain knowledge. Depiction of Approach: Ontologies could help to generate basic test cases since they encode domain knowledge in a machine process able format. A simple example for this would be regarding cardinality constraints. Since those constraints define restrictions on the association of certain classes, they can be used to derive equivalency classes for testing. Advantages of Ontologies: Ontologies may not be the first candidate for such a scenario, since there are formalisms like OCL that are specialized for such tasks. However, once domain knowledge is available in an ontology format anyway (e.g. due to one of the various other scenarios described in this paper), it might be feasible to reuse that knowledge.
3.
Categorizing Ontologies in Software Engineering
We have seen number of different approaches for using ontologies in the context of software engineering in the preceding section. In this, we propose a simple classification scheme for the better differentiation among the various ideas. Common categorizations of ontologies rank them by their level of abstraction and their expressivity. The Ontology Driven Architecture served as a starting point to elaborate a systematic categorization of the
International Journal of Research and Reviews in Software Engineering approaches and to derive more clearly defined acronyms. First, we distinguish the role of ontologies in the context of software engineering between usage at run time and development time. Second, we have seen the kind of knowledge what the ontology actually comprise of. Here, we distinguish the problem domain that the software needs to tackle itself and infrastructure aspects to make the software or its development more convenient. Four basic areas are: Ontology-driven development (ODD): It tells the usage of ontologies at development time that describe the problem domain itself. Examples are the approaches in the context of MDD. Ontology-enabled development (OED): It also uses ontologies at development time for supporting developers with their tasks. For example, component search or problem solving support. Ontology-based architecture (OBA): It uses ontology as a primary artifact at the run time. The Ontology makes up central part of the application logic. Ontology-Enabled Architectures (OEA): Leverage ontologies to provide support at the run time of a software system. Examples are semantic web services where ontologies add a semantic layer on top of the existing web service descriptions, adding functionality for the automatic discovery, matching and composition of service-based workflows.
4.
Ontology based Software Engineering
It is important to demonstrate the advantages one can gain by applying ontologies in software engineering. The fact is that most of the formal foundations of ontologies have been in place for a long time, without enjoying a wide-spread adoption by software engineers. In a certain sense, the importance of standardization can be compared to the situation of visual modeling in software engineering before UML. Another important factor is flexibility of ontologies. Ontologies are well-suited to combine information from various sources and infer new facts based on this. Also, the flexibility allows the system to foster reuse of existing work. This is further promoted by the web-focus of current ontology approaches. Due to the fact that software systems also get increasingly web-enabled and must thus cope with data from heterogeneous sources that may not be known at development time. Thus, experts in the field like Grady Booch are expecting semantic web technology to be one of the next big things in the architecture of web-based applications[12]. Also, the web makes easier to share knowledge. Having URIs as globally unique identifiers, it is easy to relate one’s ontology to someone else’s conceptualization. This in turn encourages interoperability and reuse. Regarding more software engineering specific advantages, ontologies make domain models first order citizens. While domain models are clearly driving the core of every software system, their importance in current software engineering processes decreases after the analysis phase. The
16
core purpose of ontologies is by definition the formal descriptions of a domain and thus encourages a broader usage throughout the whole software engineering lifecycle.
5.
Ontologies for Software Engineering Process: Ontologies as Software Artifacts
Development process Domain Oriented Software Development Environment (DOSDE), the aim was to develop an environment to help software developers in domains which are not familiar to them. Two different kinds of knowledge were considered: related to application domain and related to tasks. The first kind of knowledge was implemented as domain ontology, divided into sub-ontologies to model the main concepts of the domain. The second kind as a task ontology combined with a problem solving method (PSM) into a single model that considered three different levels to describe both the tasks and the way to carry them out. Run time Ontology Driven Architecture (ODA) The W3C’s software engineering task force has proposed the Ontology Driven Architecture(ODA), where ontology describes the properties, relationships and behaviors of the components required in a software development process. The Ontology is used as a conceptual model both for the development and run-time software components. The ontology is divided into generic modules, to model both semantic and syntactic metadata.
6.
Ontology-based Infrastructure for Intelligent systems
Ontologies are used for data integration from several sources and for intelligent systems operations. The usage of ontology is tested as part of a help system for online learning. Ontologies are used as domain models to develop web information system. Domain ontology and behavior ontology are considered. First model describes static entities such as system structures and stored data. Second model describes dynamic processes such as system activities and interactions.
7.
Conclusion
Software development processes are becoming increasingly complex, with shorter development times at lower cost. Therefore it has been considered ontologies as a core element for software engineering. Ontologies provide a backbone for software projects as conceptualization of fundamental concepts and their relationships for a sub domain. There is some discussion about how ontologies and software engineering fit together, and how both communities can learn from each other. As a contribution to this process, we presented a couple of approaches that use ontologies in a software engineering context in this paper. Therefore examples have been selected from the entire software engineering lifecycle. Without a proper framework for analysis, it is hard to grasp the real benefits as well as the purpose of ontologies. Thus we came up with an initial proposal for a better categorization, refining the notion of “Ontology Driven Architecture (ODA)” into four categories, which describe the usage of ontologies in different contexts. However, we think
International Journal of Research and Reviews in Software Engineering that this is just a preliminary step towards a better understanding of possible benefits of ontologies in software engineering. Those benefits are a core part of a better understanding of ontologies in software engineering as oberle pointed out, ontologies demand additional modeling effort, which must pay off by saving at other places. Thus, we think that one key to promote the advantages of ontologies is in a higher reuse of ontological knowledge across the software engineering lifecycle. While this may be partially conflicting with the present approaches in detail, it would be interesting to perform a case study to what extent single domain ontology can be leveraged across some of the presented works. Despite the obvious benefits on the usage of ontologies, some issues still remain. Methodologies and tools originally for ontology engineering, but not developed to fulfill software engineering requirements. Possibly, to reach a consensus among ontology developers within the software engineering community is too time and effort consuming.
References [1]
Berners-Lee, T., Hendler J. and Lassila, O.: The Semantic Web. Scientific American 284(5)(2001) [2] Abran, A., and Moore, J.W. (Exec. Eds.), Bourque, P. and Dupuis, R. (Eds.) Guide to the Software Engineering Body of Knowledge (2004) [3] MG:MDAGuide.http://www.omg.org/docs/omg/03-06-01.pdf (2003) [4] Oberle, D.: Semantic Management of Middleware, Volume I of The Semantic Web and Beyond Springer, New York (2006) [5] Wouters, B., Deridder, D., Van Paesschen, E: The Use of Ontologies as a Backbone for Use Case Management. In: “European Conference on Object-Oriented Programming (ECOOP 2000), Workshop: objects and Classifications, a natural convergence”(2000) [6] Happel, H.j., Korthaus, A., Seedorf, S., Tomczyk.: KOntor: An ontology-enabled Approach to software Reuse In: Proc. Of the 18th Int. Conf. on Software Engineering. W3C, Semantic Web best Practices and Development Working Group, Draft (2006). [7] Kiko, k and Atkinsion, C.: Integrating Enterprise Information Representation Languages. In: Proc , of Int. Workshop on Vocubularies , Ontologies and Rules for the Enterprise (VORTE 2005), Enschede, The Netherlands(2005). [8] MG: Ontology Definition Metamodel RFP, http://www.omg.org/dontology/, 6th Revised Submission(2006). [9] Tetlow, p., Pan, J., Oberle, D., Wallace E., Uschold, M., Kendall, E.: Ontology Driven Architectures and Potential Uses of the Semantic Web in Software Engineering , W3C, Semantic Web Practices and Deployment Working Group, Draft (2006). [10] Ankollekar, A.:Towards a semantic Web of Community, Content and Interactions, Ph.D. Thesis September, CMU- HCII-05-103(2005).
17
