Showing papers on "Database-centric architecture published in 2006"
TL;DR: In the MADAM (mobility- and adaptation-enabling middleware) project, this work follows an architecture-centric approach where it represents architecture models at runtime to allow generic middleware components to reason about and control adaptation.
Abstract: Every software system has architecture. The architecture strongly influences the software system's properties, including maintainability and runtime properties such as performance and reliability. By describing the architecture in models, we can make the architecture explicit. Developers typically use software architecture models at design time to capture the significant decisions about a software system's organization and to describe and establish a common understanding about the system's abstract properties. In the MADAM (mobility- and adaptation-enabling middleware) project, we aim to facilitate adaptive application development for mobile computing. We follow an architecture-centric approach where we represent architecture models at runtime to allow generic middleware components to reason about and control adaptation.
347 citations
TL;DR: Software architecture has emerged as the principled understanding of the large-scale structures of software systems as discussed by the authors and has made the transition from basic research to an essential element of software system design and construction.
Abstract: Since the late 1980s, software architecture has emerged as the principled understanding of the large-scale structures of software systems. From its roots in qualitative descriptions of empirically observed useful system organizations, software architecture has matured to encompass a broad set of notations, tools, and analysis techniques. Whereas initially the research area interpreted software practice, it now offers concrete guidance for complex software design and development. It has made the transition from basic research to an essential element of software system design and construction. This retrospective examines software architecture's growth in the context of a technology maturation model, matching its significant accomplishments to the model's stages to gain perspective on where the field stands today. This trajectory has taken architecture to its golden age.
234 citations
01 Feb 2006
TL;DR: This document covers the logical and process architectures of provenance systems: the logical architecture identifies key roles and their interactions, whereas the process architecture discusses distribution and security.
Abstract: This document covers the logical and process architectures of provenance systems. The logical architecture identifies key roles and their interactions, whereas the process architecture discusses distribution and security. A fundamental aspect of our presentation is its technology-independent nature, which makes it reusable: the principles that are exposed in this document may be applied to different technologies.
142 citations
01 Apr 2006
TL;DR: A novel approach to recovering software architecture from component based systems at runtime and changing the runtime systems via manipulating the recovered software architecture, described formally with the extension of traditional architecture description language.
Abstract: Recently, more attention is paid to the researches and practices on how to use software architecture in software maintenance and evolution to reduce their complexity and cost. The key in such architecture-based maintenance and evolution is to recover software architecture from existing systems. Almost all studies on architecture recovery focus on analyzing the source code and other documents. Such recovered software architecture can hardly capture runtime states and behaviors of the system. At the same time, current work pays little attention on how to change the system directly via manipulating the recovered software architecture. This paper presents a novel approach to recovering software architecture from component based systems at runtime and changing the runtime systems via manipulating the recovered software architecture. Containing much more details than the designed software architecture, the recovered software architecture can accurately and thoroughly describe the actual states and behaviors of the runtime system. It can be described formally with the extension of traditional architecture description language, which enables the recovered software architecture to absorb the semantics embedded in the designed software architecture. The recovered software architecture can be represented as multiple views so as to help different users to control the complexity from different concerns. Based on the reflective ability of the component framework, the recovered software architecture is up-to-date at any time and changes made on it will immediately lead to the corresponding changes in the runtime system. The approach presented in this paper is demonstrated on PKUAS, a reflective J2EE (Java 2 Platform Enterprise Edition) application server, and the performance is also evaluated.
100 citations
22 Mar 2006
TL;DR: Ten distinct purposes and needs for static architecture evaluations are identified and illustrated using a set of industrial and academic case studies and it is shown how subsequent steps in architecture development are influenced by the results from architecture evaluations.
Abstract: The software architecture is one of the most crucial artifacts within the lifecycle of a software system. Decisions made at the architectural level directly enable, facilitate, hamper, or interfere with the achievement of business goals, functional and quality requirements. Architecture evaluations play an important role in the development and evolution of software systems since they determine how adequate the architecture is for its intended usage. This paper summarizes our practical experience with using architecture evaluations and gives an overview on when and how static architecture evaluations contribute to architecture development. We identify ten distinct purposes and needs for static architecture evaluations and illustrate them using a set of industrial and academic case studies. In particular, we show how subsequent steps in architecture development are influenced by the results from architecture evaluations.
96 citations
TL;DR: In this article, the authors address the modeling of SOA architectures by refining business-oriented architectures, which abstract from technology aspects, into service-oriented ones, focusing on the ability of dynamic reconfiguration (binding to new services at run-time) typical for SOA.
Abstract: Service-oriented architectures (SOA) provide a flexible and dynamic platform for implementing business solutions In this paper, we address the modeling of such architectures by refining business-oriented architectures, which abstract from technology aspects, into service-oriented ones, focusing on the ability of dynamic reconfiguration (binding to new services at run-time) typical for SOA The refinement is based on conceptual models of the platforms involved as architectural styles, formalized by graph transformation systems Based on a refinement relation between abstract and platform-specific styles we investigate how to realize business-specific scenarios on the SOA platform by automatically deriving refined, SOA-specific reconfiguration scenarios
94 citations
01 Apr 2006
TL;DR: This paper proposes a light-weight approach to architectural recovery, called Focus, which has three unique facets: first, it uses a system's evolution requirements to isolate and incrementally recover only the fragment of the system's architecture affected by the evolution, and secondly, in addition to software components, it recovers the key architectural notions of software connector and architectural style.
Abstract: Ideally, a software project commences with requirements gathering and specification, reaches its major milestone with system implementation and delivery, and then continues, possibly indefinitely, into an operation and maintenance phase. The software system's architecture is in many ways the linchpin of this process: it is supposed to be an effective reification of the system's technical requirements and to be faithfully reflected in the system's implementation. Furthermore, the architecture is meant to guide system evolution, while also being updated in the process. However, in reality developers frequently deviate from the architecture, causing architectural erosion, a phenomenon in which the initial, "as documented'' architecture of an application is (arbitrarily) modified to the point where its key properties no longer hold. Architectural recovery is a process frequently used to cope with architectural erosion whereby the current, "as implemented" architecture of a software system is extracted from the system's implementation. In this paper we propose a light-weight approach to architectural recovery, called Focus, which has three unique facets. First, Focus uses a system's evolution requirements to isolate and incrementally recover only the fragment of the system's architecture affected by the evolution. In this manner, Focus allows engineers to direct their primary attention to the part of the system that is immediately impacted by the desired change; subsequent changes will incrementally uncover additional parts of the system's architecture. Secondly, in addition to software components, which are the usual target of existing recovery approaches, Focus also recovers the key architectural notions of software connector and architectural style. Finally, Focus does not only recover a system's architecture, but may in fact rearchitect the system. We have applied and evaluated Focus in the context of several off-the-shelf applications and architectural styles to date. We discuss its key strengths and point out several open issues that will frame our future work.
73 citations
TL;DR: This paper describes a new architecture improvement method called APTIA (Analytic Principles and Tools for the Improvement of Architectures), which almost entirely reuses pre-existing techniques but in a new combination, with new goals and results.
63 citations
TL;DR: This work introduces a survey of technology-independent patterns that are relevant for SOAs, and is working towards a formalised pattern-based reference architecture model to describe SOA concepts.
Abstract: Service-Oriented Architectures (SOA) are a promising means to integrate heterogeneous systems, but virtually no technology-neutral approach to holistically understand SOAs exists. We tackle this problem by introducing a survey of technology-independent patterns that are relevant for SOAs, and are working towards a formalised pattern-based reference architecture model to describe SOA concepts.
62 citations
TL;DR: A deeper understanding of the function of a framework is found, and nine fundamental dimensions that seem to underlie architectural thinking are discovered that can be used to clarify the meaning of individual architecture documents independent of the framework they originate from.
Abstract: In recent years architecture has acquired recognition as playing a pivotal role in change processes. Despite this recognition, describing architecture has proven to be difficult. Architecture frameworks have been defined to address this problem. However, there are many of them, and together they leave us with seemingly contradicting terminology. What are the underlying forces that caused people to create so many different frameworks? What do these frameworks teach us about the essence of architecting? Where do I start to select or create a framework for my current project? With these questions in mind we set out to perform a comparison of existing architecture frameworks. We ended up with a deeper understanding of the function of a framework, and "discovered" nine fundamental dimensions that seem to underlie architectural thinking. These "base dimensions" can be used to clarify the meaning of individual architecture documents independent of the framework they originate from, and they can be helpful in defining new architecture frameworks or situational architecture descriptions. In this paper we also relate our findings to IEEE 1471, which is another important generalisation of existing frameworks.
61 citations
24 Apr 2006
TL;DR: Using this architecture classification scheme, several well-known SOA-based applications are reviewed including the architectures proposed and adopted by major computer companies and standard organizations.
Abstract: The architecture of SOA-based applications is different from traditional software architecture where the architecture is mainly static. The architecture of an SOA-based application is dynamic, i.e., the application may be composed at runtime using existing services. Thus SOA has provided a new direction for software architecture study, where the architecture is determined at runtime and architecture can be dynamically changed at runtime to meet the new software requirements. This paper proposes an architecture classification scheme for SOA-based applications. Using this classification, several well-known SOA-based applications are reviewed including the architectures proposed and adopted by major computer companies and standard organizations. The architecture classification provides a unified way to evaluate a variety of architectures for SOA-based applications.
29 Jun 2006
TL;DR: In this paper, the authors present an Aspect-Oriented Architecture Description Language (AOADL) to specify software architectures of complex, dynamic and distributed software systems, and demonstrate how PRISMA AOADL improves the management, maintainability and reusability of software architectures introducing the notion of aspect in its ADL.
Abstract: A great deal of languages have emerged and have demonstrated the advantages that Aspect-Oriented Programming offers. For this reason, the aspect-oriented approach is being introduced into the early phases (analysis and design) of the software life cycle. In this work, we present an Aspect-Oriented Architecture Description Language (AOADL) to specify software architectures of complex, dynamic and distributed software systems. This AOADL follows the PRISMA approach, which integrates the advantages of Component-Based Software Development (CBSD) and Aspect-Oriented Software Development (AOSD). The PRISMA AOADL combines components and aspects in an elegant and novel way achieving a better management of crosscutting-concerns. In addition, it is independent of the technology, and it has great expressive power in order to facilitate the automatic code generation from its specifications. In this work, we demonstrate how PRISMA AOADL improves the management, maintainability and reusability of software architectures introducing the notion of aspect in its ADL.
01 Sep 2006
TL;DR: Promising results from (1) computation of bibliographic couplings, (2) graph searches for sub-circuit motifs within integrated circuit netlists, and (3) a new approach to word sense disambiguation in natural language processing, all suggest that the computational science community might be able to make good use of these new database machines.
Abstract: While relational databases have become critically important in business applications and web services, they have played a relatively minor role in scientific computing, which has generally been concerned with modeling and simulation activities. However, massively parallel database architectures are beginning to offer the ability to quickly search through terabytes of data with hundred-fold or even thousand-fold speedup over server-based architectures. These new machines may enable an entirely new class of algorithms for scientific applications, especially when the fundamental computation involves searching through abstract graphs. Three examples are examined and results are reported for implementations on a novel, massively parallel database computer, which enabled very high performance. Promising results from (1) computation of bibliographic couplings, (2) graph searches for sub-circuit motifs within integrated circuit netlists, and (3) a new approach to word sense disambiguation in natural language processing, all suggest that the computational science community might be able to make good use of these new database machines.
TL;DR: The US Department of Defense began developing the high level architecture (HLA) for distributed computer simulation systems, which separates the data model from the architecture's functions for exchanging information.
Abstract: Over the past years a series of architectures have addressed the need to link multiple simulations. These efforts have been driven primarily by the desire to reuse existing "best of breed" simulations in new combinations to avoid developing any single, monolithic architecture with the impossible goal of meeting all simulation needs. The US Department of Defense began developing the high level architecture (HLA) for distributed computer simulation systems. The high level architecture addresses the need to link multiple computer simulation systems. HLA separates the data model from the architecture's functions for exchanging information.
23 Apr 2006
TL;DR: A new UML2.0 profile is proposed to describe the change of software architectures by introducing a set of stereotypes for modeling the structural and the dynamic aspect as well as architectural constraints.
Abstract: In this paper, we propose a new UML2.0 profile to describe the change of software architectures. The profile introduces a set of stereotypes for modeling the structural and the dynamic aspect as well as architectural constraints. We adapt the component diagrams metamodel on specific purposes by extending existing metaclasses. The adaptations are defined using stereotypes which are grouped in a profile. The profile offers to the architects an intuitive and complete way to specify the software architecture based on visual notations.
TL;DR: This article develops, and illustrates with an industrial study-case, an approach to IS preliminary architecture design that combines dialectic analysis as put forward in the OTSM-TRIZ theory, and proposes to exploit this framework and lead to a target architecture.
TL;DR: A reverse engineering method to derive a change architecture from Revision Control System (RCS) change history is described and this method is compared to other reverse engineering methods used to derive software architectures using other types of data.
Abstract: Problems related to interactions between components is a sign of problems with the software architecture of the system and are often costly to fix. Thus it is very desirable to identify potential architectural problems and track them across releases to see whether some relationships between components are repeatedly change-prone. This paper shows a study of combining two technologies for software architecture: architecture recovery and change dependency analysis based on version control information. More specifically, it describes a reverse engineering method to derive a change architecture from Revision Control System (RCS) change history. It compares this method to other reverse engineering methods used to derive software architectures using other types of data. These techniques are illustrated in a case study on a large commercial system consisting of over 800 KLOC of C, C++, and microcode. The results show identifiable problems with a subset of the components and relationships between them, indicating systemic problems with the underlying architecture.
TL;DR: The objective of this research was to conduct a Features Analysis for three Architectural Evaluation Methods applied to a single case, which resulted in two significant contributions; the aspects which must be present in an architectural evaluation method which is translated in a set of 49 metrics, grouped into features and sub-features to enable the evaluation of a particular method.
27 Mar 2006
TL;DR: This paper introduces a language for specifying patterns and verifications that ensure that the concern represented by a pattern can be safely integrated into an existing architecture.
Abstract: Software architectures must frequently evolve to cope with changing requirements, and this evolution often implies integrating new concerns. Unfortunately, existing architecture description languages provide little or no support for this kind of evolution. The software architect must modify the architecture manually, which risks introducing inconsistencies. In previous work, we have proposed the TranSATframework, which provides a pattern construct for describing new concerns and their integration into an existing architecture. As the interaction between the new concern and the existing architecture may be complex, it is essential that the framework ensure the coherence of the resulting architecture. In this paper, we introduce a language for specifying patterns and verifications that ensure that the concern represented by a pattern can be safely integrated into an existing architecture. The verifications comprise static verifications that check coherence properties before the architecture is modified and dynamic verifications that focus on the parts of the architecture that are affected by the pattern. As a result of these verifications, patterns can be provided as a commodity, such that a software architect can confidently apply a pattern obtained from a third-party developer.
TL;DR: π-AAL is a formal, well-founded theoretically language based on the modal μ-calculus designed to enable the specification of structural and behavioural properties and their verification using an analytical toolset based on theorem proving and model checking techniques.
Abstract: A key aspect of the design of any software system is its architecture. An architecture description, from a runtime perspective, provides a formal representation of the architecture in terms of its components and connectors, their ports and behaviours, and how they are composed together. In the past decade, several Architecture Description Languages (ADLs) have been defined for representing the structure and behaviour of software architectures. However, describing the structure and behaviour of an architecture in terms of a configuration of components and connectors is needed, but it is not enough. Indeed, in addition to representing software architectures, we need to rigorously specify their required and desired architectural properties, in particular related to completeness, consistency and correctness. This article presents π-AAL, a novel Architecture Analysis Language (AAL) that has been designed in the ArchWare European Project to address formal analysis of software architectures. It is a formal, well-founded theoretically language based on the modal μ-calculus designed to enable the specification of structural and behavioural properties and their verification using an analytical toolset based on theorem proving and model checking techniques.
11 Apr 2006
TL;DR: This paper presents a novel scheme for data-centric multipath routing in wireless sensor networks utilizing a fuzzy logic controller architecture at each node in the network to determine its capability to transfer named data packets based on its own battery power levels and the type of data being forwarded.
Abstract: This paper presents a novel scheme for data-centric multipath routing in wireless sensor networks utilizing a fuzzy logic controller architecture at each node in the network to determine its capability to transfer named data packets based on its own battery power levels and the type of data being forwarded. These are important criteria as not all nodes may have equal power levels which may preclude certain low-power nodes from transferring larger data. During route discovery, a decision is made whether to return or forward the data packets based on the output of the fuzzy logic controller. Multipaths are established to enable an energy-efficient recovery from failure of the primary or shortest path for a source-sink combine.
12 Jun 2006
TL;DR: This paper proposes a metamodeling concept that enables a common under-standing of architecture variability and describes a domain architecture in which commonality and variability are explicitly considered.
Abstract: Architecture describes the organizational structure of a system including components, interactions, and constraints. Reusable components, units of software systems, have been considered to support a considerable improvement in reducing development costs and time to market because their interfaces and functionality are explicitly defined. Instead of reusing an individual component, however, it is much more advantageous to reuse a whole design or architecture. A domain architecture, sharing a common software architecture across a product line, includes common components shared by all products and optional components exploited by a subset of the products. Variability, one of the key concepts in the development of domain architectures indicates the ability to derive various products from the product line. Clearly, we need to support variability during domain architecture development. In this paper, we suggest a metamodeling concept that enables a common under-standing of architecture variability. The domain architecture metamodel reflects the Object Management Group's (OMGTM) Reusable Asset Specification (RAS) which addresses the engineering elements of reuse. We describe a domain architecture in which commonality and variability are explicitly considered.
Journal Article•
TL;DR: A metamodel for architecture evaluation is presented as a basis for the precise description of the quality attribute structure and the evaluation methodology and the relationships between architectural elements and quality attributes and interdependencies between quality attributes can be represented and investigated.
Abstract: Short innovation cycles in software and hardware make architecture design a key issue in future development processes for embedded systems. The basis for architectural design decisions is a transparent architecture evaluation. Our model-based approach supports a uniform representation of hierarchies of quality attributes and an integration of different architecture evaluation techniques and methods. We present a metamodel for architecture evaluation as a basis for the precise description of the quality attribute structure and the evaluation methodology. By modelling architecture evaluation, the relationships between architectural elements and quality attributes and interdependencies between quality attributes can be represented and investigated. Thereby, the architecture exploration process with its evaluations, decisions, and optimizations is made explicit, traceable, and analyzable.
01 Jan 2006
TL;DR: In this article, the authors investigated Persian precedents architecture, principles and characteristics in order to extract some lost values, found in this heritage, and pointed out how these values might be used in establishing a scope in sustainable architecture through eco-concepts in eco-building design approach.
Abstract: Architecture as a process of change, converts a set of in-puts into out-puts. This process creates building through dealing with four aspects of social, economical, environmental and design related issues. In this process technology and conceptual framework are two pivotal factors balancing the aspects needed for the design context equilibrium. Application of technology and specific strategies in design concept as well as prudent selection of materials and energy resources can decrease the rate of environmental impacts. Hence, the process management in general and the out-put management in particular are addressed in design stage. There are many lessons, thoughts and philosophies in precedent works in architecture long term education, which could be engaged in current projects experience. Here, Persian precedents architecture, principles and characteristics are investigated in order to extract some lost values, found in this heritage. Then the paper points out how these values might be used in establishing a scope in sustainable architecture through eco-concepts in eco-building design approach. Quality concept originated in Iranian past architecture codes indicates that their architecture not only includes eco-concepts but also has a great respect for the environment. This paper is addressing some of the lost values in order to be revitalised.
TL;DR: This paper proposes a Process-Embedded Service-Oriented Infrastructure to build SOA-based applications, which embeds the entire software lifecycle management and service-oriented system engineering into the application developed on this infrastructure.
Abstract: Service-Oriented Architecture (SOA) has drawn significant attention recently, and numerous architecture approaches have been proposed to represent SOA-based applications. The architecture of SOA-based applications is different from traditional software architecture, which is mainly static. The architecture of an SOA-based application is dynamic, i.e., the application can be composed at runtime using existing services, and thus the architecture is really determined at runtime, instead of design time. SOA applications have provided a new direction for software architecture study, where the architecture can be dynamically changed at runtime to meet the new application requirements. This paper proposes a Process-Embedded Service-Oriented Infrastructure to build SOA-based applications. This infrastructure embeds the entire software lifecycle management and service-oriented system engineering into the application developed on this infrastructure. Thus, the users can easily re-develop the applications during operation to meet the changing environments and requirements, through the supports provided
25 Jun 2006
TL;DR: A new hybrid architecture is introduced in this article, which is based on the subsumption architecture and integrates the behaviour based planning, and the results show this architecture is simple and effective.
Abstract: Control architecture is an important investigative content in mobile robot. After studying the subsumption architecture, a kind of new hybrid architecture is introduced in this article, which is based on the subsumption architecture and integrates the Behaviour Based planning. The process of Behaviour Based planning use the concept of attention to coordinate the behaviours, it can hold the intention of sub-behaviors perfectly. The simulation uses 6 layers control architecture including wander, avoiding obstacle, behaviour planning and so on. The results show this architecture is simple and effective.
29 Aug 2006
TL;DR: An interactive tool is presented that efficiently and effectively combines visual presentation of component-based architectures with that of areas of interest and helps users investigate how various system properties correlate with each other and correspond to the actual architecture, while preserving the visual architecture layout familiar to designers.
Abstract: Understanding complex component-based systems often requires getting insight in how certain system properties, such as performance, trust, reliability, or structural attributes, correspond to the actual system architecture. Such properties can be seen as defining several ?areas of interest? over the system architecture. We present an interactive tool that efficiently and effectively combines visual presentation of component-based architectures with that of areas of interest. Our tool helps users investigate how various system properties correlate with each other and correspond to the actual architecture, while preserving the visual architecture layout familiar to designers. We validate our tool and the proposed techniques on a component framework used in the industry.
Proceedings Article•
01 May 2006
TL;DR: The goal of this paper is to extract from literature and best-practices such a list of criteria for design and evaluation of layered architectures, notably the ISO/OSI network model and the Semantic Web language architecture.
Abstract: The architecture of a system is an indispensable mechanism required to map business processes to information systems. The terms architecture, layered architecture and system architecture are often used by researchers, as well as system architects and business process analysts inconsistently. Furthermore, the concept architecture is commonplace in discussions of software engineering topics such as business process management and system engineering, but agreedupon design and evaluation criteria are lacking in literature. Such criteria are on the one hand valuable for the determination of system architectures during the design phase, and on the other hand, provides a valuable tool for the evaluation of already existing architectures. The goal of this paper is thus to extract from literature and best-practices such a list of criteria. We applied these findings to two prominent examples of layered architectures, notably the ISO/OSI network model and the Semantic Web language architecture.
24 Apr 2006
TL;DR: This work presents a new type architecture, an abstract model analogous to the von Neumann machine for sequential computers, that can serve as common ground for algorithm designers, language designers, and hardware architects and shows that many parallel architectures, including platform FPGAs, are implementations of this type architecture.
Abstract: Recently, platform FPGAs that integrate sequential processors with a spatial fabric have become prevalent. While these hybrid architectures ease the burden of integrating sequential and spatial code in a single application, programming them, and particularly their spatial fabrics remains challenging. The difficulty arises in part from the lack of an agreed upon computational model and family of programming languages. In addition, moving algorithms into hardware is an arcane art far removed from the experience of most programmers. To address this challenge, we present a new type architecture, an abstract model analogous to the von Neumann machine for sequential computers, that can serve as common ground for algorithm designers, language designers, and hardware architects. We show that many parallel architectures, including platform FPGAs, are implementations of this type architecture. Using examples from a variety of application domains, we show how algorithms can be analyzed to estimate their performance on implementations of this type architecture. This analysis is done without having to delve into the details of any architecture in particular. Finally, we describe some of the common features of languages designed for expressing micro-parallelism, highlighting connections with the type architecture.
TL;DR: This paper identifies the foundations for an architectural description language (ADL) to specify multi-agent system architectures based on the BDI (belief-desire-intention) agent model and existing classical ADLs and conceptualizes it with the Z specification language to capture a "core" model of structural and behavioural elements fundamental to an architecture description for BDI-MAS.
Abstract: Multi-Agent Systems (MAS) constitute a highly promising software architectural approach for modern application domains such as peer-to-peer and ubiquitous computing, information retrieval, semantic web services or e-business. Unfortunately, despite considerable work in software architecture during the last decade, few research efforts have aimed at truly defining languages for designing such architectures. This paper identifies the foundations for an architectural description language (ADL) to specify multi-agent system architectures. We propose a set of system design concepts based on the BDI (belief-desire-intention) agent model and existing classical ADLs. We conceptualize it with the Z specification language to capture a "core" model of structural and behavioural elements fundamental to an architecture description for BDI-MAS. We partially apply it on a data integration system example to illustrate our proposal.