DOCSLIB.ORG

Reactive Variability Realization with Test-Driven Development and Refactoring

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Reactive Variability Realization with Test-Driven Development and Refactoring Reactive Variability Realization with Test-Driven Development and Refactoring Glauco Silva Neves Patrícia Vilain Informatics and Statistics Department - INE Informatics and Statistics Department - INE Federal University of Santa Catarina - UFSC Federal University of Santa Catarina - UFSC Florianópolis, Brazil Florianópolis, Brazil [email protected] [email protected] Abstract— Software product line is a practice that has proven its Despite its advantages, a SPL requires a high upfront and advantages since it can offer to a company the reduction of time long-term investment to design and to develop the core assets to market, the decrease of development costs, the increase of repository, hindering the SPL use in dynamic markets due to productivity and the improvement of the final product quality. the risk of unforeseen changes and the cost of developing However, this practice requires a high initial investment and artifacts that may no longer be reused. To overcome this offers long-term risks to dynamic markets where changes are difficulty, there is a proposal of combining agile software difficult to predict. One of these markets is the mobile application development practices with SPL, resulting in the Agile Product development, which presents a growing demand, with Line Engineering (APLE) [2]. smartphone and tablets having already surpassed sales of PCs and notebooks. Currently, proposals bring the advantages of One example of a dynamic market that has grown rapidly is software product line for dynamic markets through the use of the one of applications for mobile devices. Smartphones and agile software development practices, which is called Agile tablets have surpassed PC and laptop sales [3]. New and Product Line Engineering (APLE). This paper investigates the different devices are constantly released with different use of test-driven development (TDD) and refactoring techniques connection capacities, pixels densities, resolutions, screen for performing reactive variability in APLE. The variability sizes, sensors (accelerometer, barometer, gyroscope), GPS and mechanism chosen is the configuration file that allows achieving storage [4] besides using different operating systems such as more than one platform, an important problem in mobile iOS, Android, Windows Phone, and others. application development. In that manner, new products can be built as needed, without the high upfront investment, but with a Considering this scenario where changes are constant, code easier to maintain. APLE is an interesting proposal for mobile application companies that want to make use of SPL but do not want to Keywords- Software product line, test-driven development, suffer the disadvantages the traditional SPL development. refactoring, variability realization This article uses the APLE approach to define a process for developing reactive SPLs using agile practices. The SPL I. INTRODUCTION variability is carried out on demand using Test-Driven A Software Product Line (SPL) is a set of applications that Development (TDD) and refactoring practices. The variability share common artifacts addressing the need of a particular mechanism used is the configuration file. market segment. This practice has already proven the advantages of reducing the time to market, decreasing This paper is organized as follows. Section 2 describes SPL development costs, increasing productivity and improving the combined with agile software development. In section 3 the quality of applications [1]. There are two essential activities in proposed process is explained. Section 4 shows an example of the SPL development: domain engineering and application a mobile application that was developed by applying the engineering [1]. proposed process. Related work is discussed in section 5. Finally, section 6 presents some conclusions. In domain engineering an initial planning to identify the commonalities and variability points of the applications is done II. AGILE PRODUCT LINE ENGINEERING and the system architecture is defined. Moreover, the resources that will be reused in applications are produced and become There are several reasons for combining SPL practices with part of the core assets repository. Application engineering, in agile software development practices [2]. This combination can its turn, focuses on understanding the needs of each specific be applied when: application and then reusing the resources (e.g. architecture, 1. There is not much knowledge about the domain to perform code, tests) in the core assets repository through the activation domain engineering; of variability points and selection of components necessary to satisfy the requirements. 2. It is not possible to predict changes in product requirements; 100 3. There is a need to decrease the risk of developing artifacts When new requirements are variations of features that may not be reused, due to market modifications. previously added to the SPL, unit tests and code changes are applied to allow activating this new variability. Testing helps According to Silva [5], Scrum and Extreme Programming with making sure that the first application continues to behave (XP) are the most used agile methods in SPL development. properly. The new unit tests will drive the changes in the Some studies combine Scrum and XP due to the fact that the source code for the integration of variability points, which are nature of these methods has different focus. While Scrum then configured in the second application. focuses on project management, XP focuses on development practices. One of the most famous practices of XP is the Test- The main mechanism to activate the variability is the Driven Development (TDD). configuration file. In addition to centralize the settings for building applications, the configuration file also documents the TDD is a way of programming where the coding tasks are variations of each application. The file format chosen was the performed in small cycles according to the mantra JavaScript Object Notation (JSON) [7], because it is a Red/Green/Refactor [6]. In the red phase, a failed unit test is lightweight file format, easy to read and is commonly used to written, which may not even compile. In the green phase, code data-interchange. is modified in the simplest way just to pass the test. And in the last phase, refactor, the code is modified in order to improve The configuration file is created when features are added as and maintain the behavior. It is in the refactor phase that design variabilities to the features that already exist in the core assets decisions are made, one at a time. repository. This file has a key and a value to configure each feature. Along with this file a test class is created for testing the TDD also assists in preventing bugs and may serve as possible combinations of keys and values. It is also necessary documentation of the system. According to Beck [6], TDD can to create a class in the code to read the configuration file and to also aid the framework development because it focuses on what instantiate a configurator object, which will be used to inform is needed instead of attempting to accommodate different the application of what variability will be activated. The features at once. As new features arise, the code is tested and configuration file is modified as more variabilities are added to refactored, eliminating duplicated code. The common code is the SPL. Each application has its own configuration file, placed in separate from the specific code, facilitating the reuse activating and configuring variabilities as needed. of common code later. The proposed process can be described as follows: There are two main strategies for building a SPL: proactive and reactive [1]. The more traditional approach is proactive, 1. The first application is developed using TDD as if it were where scope, architecture, components, and other resources, are the only one, without attempting to predict future features defined in early stages, anticipating commonalities and and variations. specificities. In the reactive approach one or more applications 2. Tests related to the first application become part of the are developed at first, then the core assets are extracted from them. It is also possible an incremental approach, combining core asset artifacts. the ideas of both strategies at different times. 3. The features of the second application are gathered and In this work, we choose the reactive approach to be used in described by user stories, which is a usual technique to define requirements in agile methods. conjunction with agile practices because among its advantages is the lower cost for development, since the core assets 4. The features of the second application that are not related repository is not constructed upfront [1]. In this way, the risk of to existing features are developed with TDD. developing useless components is lower since there is no need to provide the variations of products in advance and the 5. The features of the second application that are variations knowledge about the domain can grow as applications are of existing features follow a slightly different path: developed. 5.1. Identify where the existing feature is tested. 5.2. Add new(s) test(s) to include the new expected III. A PROCESS FOR REACTIVE SPL DEVELOPMENT behavior and refactor the existing code to pass these The goal of this work is to define a process for developing a tests. reactive SPL. Such process applies TDD and refactoring agile practices to product conception and variability realization. 5.3. Refactor the existing code to use the configurator object that is modified. During this process, the first application is developed focusing only on satisfying its existing requirements. This 5.4. Add new tests to verify the behavior of the new development is test-driven and its results include the entries in the configurator object. application and a unit test suite that ensures its behavior. IV. EXAMPLE During the development of the second application, its requirements are either mapped to new features or the existing To illustrate the use of our proposed process, the features can be modified.
Load more

Recommended publications
  • Change and Version Management in Variability Models for Modular Ontologies
    Change and Version Management in Variability Models for Modular Ontologies Melanie Langermeier1, Thomas Driessen1, Heiner Oberkampf1;2, Peter Rosina1 and Bernhard Bauer1 1Software Methodologies for Distributed Systems, University of Augsburg, Augsburg, Germany 2Siemens AG, Corporate Technology, Munich, Germany Keywords: Variability Model, Modular Ontologies, Version Management, Change Management, Enterprise Architecture Management. Abstract: Modular ontology management tries to overcome the disadvantages of large ontologies regarding reuse and performance. A possibility for the formalization of the various combinations are variability models, which originate from the software product line domain. Similar to that domain, knowledge models can then be individualized for a specific application through selection and exclusion of modules. However, the ontology repository as well as the requirements of the domain are not stable over time. A process is needed, that enables knowledge engineers and domain experts to adapt the principles of version and change management to the domain of modular ontology management. In this paper, we define the existing change scenarios and provide support for keeping the repository, the variability model and also the configurations consistent using Semantic Web technologies. The approach is presented with a use case from the enterprise architecture domain as running example. 1 INTRODUCTION quirements, for instance, that the domain Ontology A and Ontology B should not be used together. For the Knowledge management is an important aspect in or- creation of a configuration, this variability knowledge ganizations. Typically, different models are used to can be automatically processed, and therewith sup- capture all relevant aspects of the organization. These ports the domain expert in creating a consistent con- models can extend each other, but can also overlay figuration.
    [Show full text]
  • Innovations in Model-Based Software and Systems Engineering
    Journal of Object Technology Published by AITO — Association Internationale pour les Technologies Objets http://www.jot.fm/ Innovations in Model-based Software And Systems Engineering Katrin Hölldoblera Judith Michaela Jan Oliver Ringertb Bernhard Rumpea Andreas Wortmanna a. Software Engineering, RWTH Aachen University, Germany b. Department of Informatics, University of Leicester, UK Abstract Engineering software and software intensive systems has become in- creasingly complex over the last decades. In the ongoing digitalization of all aspects of our lives in almost every domain, including, e.g., mechanical engineering, electrical engineering, medicine, entertainment, or jurisdiction, software is not only used to enable low-level controls of machines, but also to understand system conditions and optimizations potentials. To remain in control of all these heterogeneous systems of systems, a precise, but abstract understanding of these systems is necessary. To this end, models in their various forms are an important prerequisite to gain this understanding. In this article, we summarize research activities focusing on the de- velopment and use of models in software and systems engineering. This research has been carried out by the working group of Bernhard Rumpe, which started 25 years ago in Munich, continued in Braunschweig, and since 10 years carries on at RWTH Aachen University. Keywords Model, Modeling, Software Engineering, Language Workbench 1 Introduction Development of a system consists of understanding what the system should do, decom- posing the problem into smaller problems until they can be solved individually and composed into an overall solution. An important part of this process is decomposition, which leads to an architecture for the individual components.
    [Show full text]
  • Feature-Based Composition of Software Architectures Carlos Parra, Anthony Cleve, Xavier Blanc, Laurence Duchien
    Feature-based Composition of Software Architectures Carlos Parra, Anthony Cleve, Xavier Blanc, Laurence Duchien To cite this version: Carlos Parra, Anthony Cleve, Xavier Blanc, Laurence Duchien. Feature-based Composition of Soft- ware Architectures. 4th European Conference on Software Architecture, Aug 2010, Copenhagen, Denmark. pp.230-245, 10.1007/978-3-642-15114-9_18. inria-00512716 HAL Id: inria-00512716 https://hal.inria.fr/inria-00512716 Submitted on 31 Aug 2010 HAL is a multi-disciplinary open access L’archive ouverte pluridisciplinaire HAL, est archive for the deposit and dissemination of sci- destinée au dépôt et à la diffusion de documents entific research documents, whether they are pub- scientifiques de niveau recherche, publiés ou non, lished or not. The documents may come from émanant des établissements d’enseignement et de teaching and research institutions in France or recherche français ou étrangers, des laboratoires abroad, or from public or private research centers. publics ou privés. Feature-based Composition of Software Architectures Carlos Parra, Anthony Cleve, Xavier Blanc, and Laurence Duchien INRIA Lille-Nord Europe, LIFL CNRS UMR 8022, Universit´edes Sciences et Technologies de Lille, France {carlos.parra, anthony.cleve, xavier.blanc, laurence.duchien}@inria.fr Abstract. In Software Product Lines variability refers to the definition and utilization of differences between several products. Feature Diagrams (FD) are a well-known approach to express variability, and can be used to automate the derivation process. Nevertheless, this may be highly complex due to possible interactions between selected features and the artifacts realizing them. Deriving concrete products typically involves the composition of such inter-dependent software artifacts.
    [Show full text]
  • A Model-Based Approach to Managing Feature Binding Time in Software Product Line Engineering
    A Model-Based Approach to Managing Feature Binding Time in Software Product Line Engineering Armaya’u Zango Umar Jaejoon Lee Lancaster University Lancaster University Lancaster, United Kingdom Lancaster, United Kingdom [email protected] [email protected] ABSTRACT EduPL Software Product Line Engineering (SPLE) is a software reuse par- Course Registration adigm for developing software products, from managed reusable Result Computation................. Account Creation Payment ...... ..... assets, based on analysis of commonality and variability (C & V) .......... ......... Application of a product line. Many approaches of SPLE use a feature as a Messaging Service Sub-degree key abstraction to capture the C&V. Recently, there have been in- Contact Validation Email Graduate creasing demands for the provision of flexibility about not only Text Message Under Graduate the variability of features but also the variability of when features Composition Rule Legend should be selected (i.e., variability on feature binding times). Cur- Contact Validation Requires Messaging Service Optional Alternative Group rent approaches to support variations of feature binding time mostly GraduateRequires Payment OR group Composed-of relationship focused on ad hoc implementation mechanisms. In this paper, we first identify the challenges of feature binding time management and then propose an approach to analyze the variation of feature Figure 1: Partial feature model of EduPl binding times and use the results to specify model-based architec- tural components for the product line. Based on the specification, components implementing variable features are parameterized with be tailored to produce a potentially unique architecture for each of the binding times and the source codes for the components and the the products of a product line.
    [Show full text]
  • Feature and Class Models in Clafer: Mixed, Specialized, and Coupled
    Feature and Class Models in Clafer: Mixed, Specialized, and Coupled University of Waterloo Technical Report CS-2010-10 Kacper Bąk1, Krzysztof Czarnecki1, and Andrzej Wąsowski2 1 Generative Software Development Lab, University of Waterloo, Canada, {kbak,kczarnec}@gsd.uwaterloo.ca 2 IT University of Copenhagen, Denmark, [email protected] Abstract. We present Clafer, a class modeling language with first-class support for feature modeling. We designed Clafer as a concise notation for class models, feature models, mixtures of class and feature models (such as components with options), and models that couple feature models and class models via constraints (such as mapping feature configurations to component configurations). Clafer also allows arranging models into mul- tiple specialization and extension layers via constraints and inheritance. We identified four key mechanisms allowing a class modeling language to express feature models concisely and show that Clafer meets its design objectives using a sample product line. 1 Introduction Both feature and class modeling have been used in software product line en- gineering to model variability. Feature models are tree-like menus of mostly Boolean—but sometimes also integer and string—configuration options, aug- mented with cross-tree constraints [15]. These models are typically used to show the variation of user-relevant characteristics of products within a product line. In contrast, class models, as supported by the Unified Modeling Language (UML), have been used to represent the components and connectors of product line ar- chitectures and the valid ways to connect them. Thus, the nature of variability expressed by each type of models is different: feature models capture simple se- lections from predefined (mostly Boolean) choices within a fixed (tree) structure; and class models support making new structures by creating multiple instances of classes and connecting them via object references.
    [Show full text]
  • Mapping SPL Feature Models to a Relational Database
    Mapping SPL Feature Models to a Relational Database Hazim Shatnawi∗ H. Conrad Cunningham University of Mississippi University of Mississippi Department of Computer and Information Science Department of Computer and Information Science University, Mississippi 38677 University, Mississippi 38677 [email protected] [email protected] ABSTRACT may vary in how those features are realized. To identify these com- Building a software product line (SPL) is a systematic strategy for monalities and variabilities, developers must analyze the domain reusing software within a family of related systems from some ap- to identify the organization’s business goals, the SPL’s scope, the plication domain. To dene an SPL, domain analysts must identify types of products to be developed, and the features of those prod- the common and variable aspects of systems in the family and cap- ucts. They often document the details of the feature analysis as a ture this information so that it can be used eectively to construct tree-structured feature model. A parent node represents a decision specic products. Often analysts record this information using a fea- in the design of a product. The children of that node represent more ture model expressed visually as a feature diagram. The overall goal detailed decisions for realizing the parent decision. The constraints of this project is to enable wider use of SPLs by identifying relevant among the nodes determine how valid products can be congured concepts, dening systematic methods, and developing practical in the SPL. tools that leverage familiar web programming technologies. This Feature models are represented in various ways in the litera- paper presents a novel approach to specication of feature models: ture.
    [Show full text]
  • Using Feature Modeling for Program Comprehension and Software
    Using Feature Modeling for Program Comprehension and Software Architecture Recovery Ilian Pashov, Matthias Riebisch Technical University Ilmenau, Max-Planck-Ring 14, P.O. Box 100565 98684 Ilmenau, Germany {idpashov|matthias.riebisch}@tu-ilmenau.de Abstract: The available evidence in a legacy software their life cycle. Evolving often means refactoring or system, which can help in its understanding and recovery migrating to a new approach, for example component based systems or product lines. However, to succeed in of its architecture are not always sufficient. Very often the system’s documentation is poor and outdated. One such a step, a full understanding of the software system may argue that the most reliable resource of information is required leading to the need for its architecture and design decisions to be recovered. is the system’s source code. Nevertheless a significant knowledge about the problem domain is required in Due to the long life cycle of these systems, in most of order to facilitate the extraction of the system’s useful the cases it is impossible to keep the same development architectural information. team. A lot of knowledge about the system is lost along In this approach feature modeling is introduced as an with the developers. Often the system’s documentation is additional step in a system’s architectural recovery out of date and insufficient. This means that additional process. Feature modeling structures the system’s help is required for the architectural recovery of the system from the reverse engineers and the reverse functionality and supports reverse engineering by detecting the relations between source code elements and engineering methods.
    [Show full text]
  • An Overview of Feature-Oriented Software Development
    Vol. 8, No. 4, July{August 2009 An Overview of Feature-Oriented Software Development Sven Apel, Department of Informatics and Mathematics, University of Passau, Germany Christian K¨astner, School of Computer Science, University of Magdeburg, Germany Feature-oriented software development (FOSD) is a paradigm for the construction, customization, and synthesis of large-scale software systems. In this survey, we give an overview and a personal perspective on the roots of FOSD, connections to other software development paradigms, and recent developments in this field. Our aim is to point to connections between different lines of research and to identify open issues. 1 INTRODUCTION Feature-oriented software development (FOSD) is a paradigm for the construction, customization, and synthesis of large-scale software systems. The concept of a fea- ture is at the heart of FOSD. A feature is a unit of functionality of a software system that satisfies a requirement, represents a design decision, and provides a potential configuration option. The basic idea of FOSD is to decompose a software system in terms of the features it provides. The goal of the decomposition is to construct well-structured software that can be tailored to the needs of the user and the appli- cation scenario. Typically, from a set of features, many different software systems can be generated that share common features and differ in other features. The set of software systems generated from a set of features is also called a software product line [45,101]. FOSD aims essentially at three properties: structure, reuse, and variation. De- velopers use the concept of a feature to structure design and code of a software system, features are the primary units of reuse in FOSD, and the variants of a software system vary in the features they provide.
    [Show full text]
  • Quality Attributes Modeling in Feature Models and Feature Model
    A thesis submitted in fulfillment of requirement for the degree of Doctor of Philosophy GUOHENG ZHANG School of Electrical Engineering and Computer Science The University of Newcastle, Callaghan, NSW, 2308, Australia March 2013 Statement of Originality The thesis contains no material which has been accepted for the award of any other degree or diploma in any university or other tertiary institution and, to the best of my knowledge and belief, contains no material previously published or written by another person, except where due reference has been made in the text. I give consent to the final version of my thesis being made available worldwide when deposited in the University’s Digital Repository. Guoheng Zhang Acknowledgement I would like to acknowledge the support and encouragement of several people, without whom, this thesis would not be possible. Firstly, I am grateful for my two supervisors, Associate Prof. Huilin Ye and Dr. Yuqing Lin. I have learnt almost everything about research from them. In the last four years, they have given me guidance and encouragement, support and generosity in sharing their time, knowledge, and expertise during the preparation of my Ph.D thesis and throughout my research work. My research has been funded by Australian Research Council under Discovery Project DP0772799. I would like to thank the Council for this great opportunity. I wish to thank my wife for her love, encouragement and continuous support. I am grateful to my parents for their support and education. During several conferences, I had the pleasure to meet many passionate people from the software product line community.
    [Show full text]
  • Agile Product Line Engineering: the Agifpl Method
    Agile Product Line Engineering: The AgiFPL Method Hassan Haidar1, Manuel Kolp1 and Yves Wautelet2 1LouRIM-CEMIS, Université Catholique de Louvain, Belgium 2KULeuven, Faculty of Economics and Business, Belgium Keywords: Software Product Line Engineering, Agile Software Development, Agile Product Line Engineering, AgiFPL, Scrum, Scrumban, Features. Abstract: Integrating Agile Software Development (ASD) with Software Product Line Engineering (PLE) has resulted in proposing Agile Product Line Engineering (APLE). The goal of combining both approaches is to overcome the weaknesses of each other while maximizing their benefits. However, combining them represents a big challenge in software engineering. Several methods have been proposed to provide a practical process for applying APLE in organizations, but none covers all the required APLE features. This paper proposes an APLE methodology called AgiFPL: Agile Framework for managing evolving PL with the intention to address the deficiencies identified in current methods, while making use of their advantages. 1 INTRODUCTION as presenting strengths and weaknesses. Furthermore, the study of the existing APLE methods has revealed Over the past years, the software industry has been that no single method covers all the needed APLE searching for methods, processes and techniques to features. increase the delivery of high quality software while In this context, this paper proposes an APLE reducing development costs. Several paradigms have methodology called AgiFPL (Agile Framework for been proposed in order to fulfil this target. “Agile managing evolving SPL). The intention behind the Software Development” (ASD) and “Product Line definition of this APLE method is to address the Engineering” (PLE) are well-known approaches deficiencies identified in current methods, while proposed by researchers and practitioners for dealing making use of their advantages.
    [Show full text]
  • Applying Feature-Oriented Software Development in Saas Systems: Real Experience, Measurements, and Findings
    Applying Feature-Oriented Software Development in SaaS Systems: Real Experience, Measurements, and Findings Oscar Pedreira1, Fernando Silva-Coira1, Angeles´ Saavedra Places1, Miguel R. Luaces1 and Leticia Gonzalez´ Folgueira2 1Universidade da Coruña, Centro de Investigación CITIC, Facultade de Informática, A Coruña, Spain 2Enxenio S.L., A Coruña, Spain E-mail: [email protected]; [email protected]; [email protected]; [email protected]; [email protected] Received 14 January 2019; Accepted 06 June 2019 Abstract Distributing software as a service (SaaS) has become a major trend for web-based systems. However, this software distribution model poses many challenges. One of them is feature variability, that is, some features of the system may be required by some users, but not by all of them. In addition, variability is more complex than just including or excluding a feature, since different types of relationships may exist between features. The implementation of this variability, and the parametrization and configuration of the system can be complex in this context, so the development process of a SaaS system must adequately address variability management. In this paper we present an Journal of Web Engineering, Vol. 18 4-6, 447–476. doi: 10.13052/jwe1540-9589.18467 c 2019 River Publishers 448 O. Pedreira et al. experience applying feature oriented software development (FOSD) in the context of SaaS web-based systems development. We present a real experience in the development of a web-based system for managing home care services for dependent people. The article describes the problem of variability management in this domain, and the feature model of the system.
    [Show full text]
  • Ontology-Based Context Event Representation, Reasoning, and Enhancing in Academic Environments
    future internet Article Ontology-Based Context Event Representation, Reasoning, and Enhancing in Academic Environments Josué Padilla-Cuevas , José A. Reyes-Ortiz * and Maricela Bravo Departamento de Sistemas, Universidad Autónoma Metropolitana, Azcapotzalco 02200, Mexico; [email protected] (J.P.-C.); [email protected] (M.B.) * Correspondence: [email protected] Abstract: An Ambient Intelligence responds to user requests based on several contexts. A relevant context is related to what has happened in the ambient; therefore, it focuses a primordial interest on events. These involve information about time, space, or people, which is significant for modeling the context. In this paper, we propose an event-driven approach for context representation based on an ontological model. This approach is extendable and adaptable for academic domains. Moreover, the ontological model to be proposed is used in reasoning and enrichment processes with the context event information. Our event-driven approach considers five contexts as a modular perspective in the model: Person, temporal (time), physical space (location), network (resources to acquire data from the ambient), and academic events. We carried out an evaluation process for the approach based on an ontological model focused on (a) the extensibility and adaptability of use case scenarios for events in an academic environment, (b) the level of reasoning by using competence questions related to events, (c) and the consistency and coherence in the proposed model. The evaluation Citation: Padilla-Cuevas, J.; process shows promising results for our event-driven approach for context representation based on Reyes-Ortiz, J.A.; Bravo, M. the ontological model. Ontology-Based Context Event Representation, Reasoning, and Keywords: knowledge engineering; event-driven representation; ontology model; context reasoning; Enhancing in Academic event enhancing Environments.
    [Show full text]