By Topic

Enterprise Distributed Object Computing Conference, 2004. EDOC 2004. Proceedings. Eighth IEEE International

Date 20-24 Sept. 2004

Filter Results

Displaying Results 1 - 25 of 35
  • Mapping EDOC to Web services using YATL

    Page(s): 286 - 297
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (420 KB) |  | HTML iconHTML  

    Modeling is a technique used extensively in industry to define software systems, the UML being the most prominent example. With the increased use of modeling techniques has come the desire to use model transformations. The current paper presents the mapping from EDOC profiles to Web services using a transformation language called YATL (yet another transformation language). This transformation language has been defined to perform transformations within the OMG's model driven architecture (MDA) framework. After having presented YATL, we present an experiment to show how YATL can be used to map from EDOC to Web services. YATL is still evolving since it is supposed to match the forthcoming OMG's query/views/transformations (QVT) standard. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Strong and flexible domain typing for dynamic e-business

    Page(s): 98 - 107
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (335 KB) |  | HTML iconHTML  

    This work introduces the concept of the typed domain, as an aid to the establishment and enactment of successful service consumer-provider relationships. The typed domain consists of the relationship life cycle, projections and their documents, and domain building blocks of different granularity from which the relationship can be described, established and built. It is based on the idea of a relationship type, containing the necessary information from which the relationship life cycle can be supported and from which negotiation, configuration, enactment and termination directives can be generated. We show how the information from the business projections can help determine the type of relationship that is desired. The typed domain can also serve as the framework and context in which an agreement reached in one projection can be translated into agreements in other projections - where necessary, involving further negotiation cycles and input from the two related parties. The paper provides two examples of how relationship types can be used: selection from exhaustive monolithic types versus dynamic assembly from finer granularity type building-blocks. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • QoS aggregation for Web service composition using workflow patterns

    Page(s): 149 - 159
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (955 KB) |  | HTML iconHTML  

    Contributions in the field of Web services have identified that (a) finding matches between semantic descriptions of advertised and requested services and (b) nonfunctional characteristics - the quality of service (QoS) - are the most crucial criteria for composition of Web services. A mechanism is introduced that determines the QoS of a Web service composition by aggregating the QoS dimensions of the individual services. This allows to verify whether a set of services selected for composition satisfies the QoS requirements for the whole composition. The aggregation performed builds upon abstract composition patterns, which represent basic structural elements of a composition, like sequence, loop, or parallel execution. This work focusses on workflow management environments. We define composition patterns that are derived from Van der Aalst's et al. comprehensive collection of workflow patterns. The resulting aggregation schema supports the same structural elements as found in workflows. Furthermore, the aggregation of several QoS dimensions is discussed. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • A logical viewpoint on architectures

    Page(s): 73 - 83
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (338 KB) |  | HTML iconHTML  

    We introduce a logical viewpoint on architectures. The logical viewpoint is based on the distinction between symbolic and semantic models of architectures. The core of a symbolic model consists of its signature that specifies symbolically its structural elements and their relationships. A semantic model is defined as a formal interpretation of the symbolic model. This leads to more precise characterization of the concepts introduced in IEEE standard 1471-2000, and provides a formal approach to the design of enterprise of architectural description languages and a general mathematical foundation for the use of formal methods in enterprise architectures. Additionally, we show how this logical viewpoint allows for the definition of a simple general XML language for the description of both static and dynamic aspects of an architecture. For the meta-analysis of both these aspects we introduce a new XML tool for general XML transformations based on a rule markup language. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Write once, deploy N: a performance oriented MDA case study

    Page(s): 123 - 134
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (302 KB) |  | HTML iconHTML  

    Optimizing the performance of distributed database applications is difficult to combine with middleware vendor independence since cache, transaction and cluster configuration is database and application server specific. The most promising approach is to use a flexible code generator. The model driven architecture can become a successful standard for model based code generation by offering a set of high quality code generation languages. To focus the comparison of such languages on criteria that matter in practical development, there is an urgent need for more, and more realistic, case studies. Therefore, we present a complex middleware performance pattern that should be generated for at least two application servers. The code generator should have maximal reuse, separation of concerns and evolution support. From this case study, we derive the requirements for model refinement and code generation languages. We illustrate how existing UML standards can be integrated to satisfy these requirements and conclude with an overview of the language features that were needed to provide an elegant solution to the case study. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Automated glue/wrapper code generation in integration of distributed and heterogeneous software components

    Page(s): 275 - 285
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (334 KB) |  | HTML iconHTML  

    UniFrame is a framework to help organizations to build interoperable distributed computing systems. Using UniFrame, a new system is built by assembling predeveloped heterogeneous and distributed software components. UniFrame solves the heterogeneity problem by explicitly modeling the domain knowledge of various technology domains (component model domains, programming language domains, operating system platform domains, etc.), from which the interoperation generative domain model (IGDM) straddling the technology domains can be constructed. The glue/wrapper code that realizes the interoperation among the distributed and heterogeneous software components can be generated from the IGDM. An informal implementation in Java of glue/wrapper code generator is given, followed by a discussion on a formalization of IGDM. The formalism comes from the fact that if the family of glue/wrapper code can be modeled formally, an instance glue/wrapper code can be generated automatically. In this formalization, the IGDM is formally modeled as a language definition using a grammar; the code that realizes the interoperation is a valid sentence derivable from the grammar, and will be generated automatically from the IGDM during the assembly time. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Notations for the specification and verification of composite Web services

    Page(s): 35 - 46
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (343 KB) |  | HTML iconHTML  

    Availability of a wide variety of Web services over the Internet offers opportunities of providing new value added services built by composing them out of existing ones. Service composition poses a number of challenges. A composite service can be very complex in structure, containing many temporal and data-flow dependencies between their constituent services. Furthermore, each individual service is likely to have its own sequencing constraints over its operations. It is highly desirable therefore to be able to validate that a given composite service is well formed: proving that it will not deadlock or livelock and that it respects the sequencing constraints of the constituent services. With this aim in mind, the paper proposes simple extensions to Web service definition language (WSDL) enabling the order in which the exposed operations should be invoked to be specified. In addition, the paper proposes a composition language for defining the structure of a composite service. Both languages have an XML notation and a formal basis in the π-calculus (a calculus for concurrent systems). The paper presents the main features of these languages, and shows how it is possible to validate a composite service by applying the π-calculus reaction rules. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Supporting viewpoint-oriented enterprise architecture

    Page(s): 201 - 211
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (305 KB) |  | HTML iconHTML  

    Increasingly, organisations establish what is called an enterprise architecture. The enterprise architecture combines and relates all architectures describing some aspect of the organization, such as the business process architecture, the information architecture, and the application architecture. It is a blueprint of the organisation, which serves as a starting point for analysis, design and decision making. Viewpoints define abstractions on the set of models representing the enterprise architecture, each aimed at a particular type of stakeholder and addressing a particular set of concerns. The use of viewpoints is widely advocated for managing the inherent complexity in enterprise architecture. Viewpoints can both be used to view certain aspects in isolation, and for relating two or more aspects. However, in order to make such a viewpoint-oriented approach practically feasible, architects require a tool environment, which supports the definition, generation, editing and management of architectural views. Moreover, such an environment should work in concert with existing domain-specific modelling tools. We present the design of such a tool environment for viewpoint-oriented enterprise architecture. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • A framework for integrating business processes and business requirements

    Page(s): 9 - 20
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (352 KB) |  | HTML iconHTML  

    Service-oriented architectures and Web service infrastructure provide the ideal framework for interconnecting organizations and for defining distributed business applications. The possibility to exploit business process definition and execution languages is particularly relevant for capturing the process-oriented nature of these applications. However, business processes by themselves are not enough to manage the changes and to allow an organization to continuously adapt its business model to the typical needs of distributed applications. To achieve this flexibility, it is of uttermost importance to link the business processes to the organizational strategy and to the business goals that motivate the need of these processes. We propose a framework for representing strategies and goals of an organization in terms of business requirements. The framework allows to describe how an organizational strategy is operationalized into activities and implemented by business processes. It also allows to represent the assumptions on the interactions between the different business applications. Finally, this framework allows for the usage of formal analysis techniques, in particular model checking, to pinpoint problems and to identify possible solutions in this domain. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Using subject-oriented modeling to develop Jini applications

    Page(s): 111 - 122
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (339 KB) |  | HTML iconHTML  

    A major contributing factor to the complexity of creating and evolving distributed systems is the tangling of middleware-specific functionality with core business functionality in system designs. Changing middleware functionality that is entangled with business functionality can lead to costly and risky rearchitecting of the system or extensive redesign of parts of the system. The subject-oriented software development approach addresses this problem by separating the design of crosscutting features into design subjects. We describe an approach for separating Jini middleware features as design subjects which can be composed with primary design subjects that realize the core functionality of the application. In this context, we identify limitations in the existing specification notation and propose extensions. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Security patterns: a method for constructing secure and efficient inter-company coordination systems

    Page(s): 84 - 97
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (338 KB) |  | HTML iconHTML  

    As the Internet, intranets and other wide-area open networks grow, novel techniques for building distributed systems, notably mobile agents, are attracting increasing attention. This is particularly the case for inter-company system coordination applications. A key difficulty in constructing such systems is to meet the security requirements while at the same time respecting the requirements for efficient implementation. We propose a method that addresses this problem and show an application of the method to a real implemented system, the environmentally conscious product (ECP) design support system. Our approach enables developers to specify several candidate system behaviors that satisfy the security requirements. We use patterns for this purpose. Patterns are abstract templates of system behavior fragments. The patterns include agent migrations, communications between applications and security procedures. We model the performance data associated with each pattern. Developers can then select an efficient implementation using this model to compare the performance data of the candidates. We evaluate our approach with a significant real-world example, the ECP design support system that essentially requires inter-company system coordination. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Applying MDA approach for Web service platform

    Page(s): 58 - 70
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (730 KB) |  | HTML iconHTML  

    We present the development of an illustrative example of e-business based on two different applications of a Model-Driven Architecture (MDA) approach. In the first application, the platform-independent model (PIM) is created using the Unified Modeling Language (UML). This PIM is transformed using Atlas Transformation Language (ATL) to generate the platform-specific model (PSM) based on three target platforms: Java, Web service and Java Web service developer pack (JWSDP). In the second application, the PIM is created using enterprise distributed object computing (EDOC) and transformed into another PSM based on the same target platforms. For this purpose we use the illustrative example of a travel agency to depict some issues of the approach. Then, we discuss mappings between meta-models. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • On the notion of abstract platform in MDA development

    Page(s): 253 - 263
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (339 KB) |  | HTML iconHTML  

    Although platform-independence is a central property in MDA models, the study of platform-independence has been largely overlooked in MDA. As a consequence, there is a lack of guidelines to select abstraction criteria and modelling concepts for platform-independent design. In addition, there is little methodological support to distinguish between platform-independent and platform-specific concerns, which could be detrimental to the beneficial exploitation of the PIM-PSM separation-of-concerns adopted by MDA. This work is an attempt towards clarifying the notion of platform-independent modelling in MDA development. We argue that each level of platform-independence must be accompanied by the identification of an abstract platform. An abstract platform is determined by the platform characteristics that are relevant for applications at a certain level of platform-independence, and must be established by balancing various design goals. We present some methodological principles for abstract platform design, which forms a basis for defining requirements for design languages intended to support platform-independent design. Since our methodological framework is based on the notion of abstract platform, we pay particular attention to the definition of abstract platforms and the language requirements to specify abstract platforms. We discuss how the concept of abstract platform relates to UML. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Formalizing ODP computational viewpoint specifications in Maude

    Page(s): 212 - 223
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (475 KB) |  | HTML iconHTML  

    The ODP computational viewpoint describes the functionality of a system and its environment, in terms of a configuration of objects which interact at interfaces. Computational objects provide a functional decomposition of the system, independently of its distribution. Although several notations have been proposed to model this ODP viewpoint, either they are not expressive enough to faithfully represent all its concepts, or they tend to suffer from a lack of formal support. We explore the use of Maude as a formal notation for writing ODP computational viewpoint specifications. Maude is an executable rewriting logic language specially well suited for the specification of object-oriented open and distributed systems. We show how Maude offers a simple, natural, and accurate way of modelling the ODP computational viewpoint concepts, allows the execution of the specifications produced, and offers good tool support for reasoning about them. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Web service composition in UML

    Page(s): 47 - 57
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (346 KB) |  | HTML iconHTML  

    As the number of available Web services is steadily increasing, there is a growing interest for reusing basic Web services in new, composite Web services. Several organizations have proposed composition languages (BPML, BPMN, BPEL4WS, BPSS, WSCI), but no winner has been declared so far. This work proposes a method that uses UML Activity models to design Web service compositions, and OMG's Model Driven Architecture (MDA) to generate executable specifications in different composition languages. The method utilizes standard UML constructs with a minimal set of extensions for Web services. An important step in the method is the transformation of WSDL descriptions into UML This information is used to complete the composition models. Another key aspect of the method is its independence of the Web service composition language. The user can thus select his preferred composition language - and execution engine - for realizing the composite Web service. Currently, the method has been implemented to support two executable composition languages BPEL4WS and WorkSCo, with corresponding execution engines. WorkSco is a Web service enabled workflow composition language. The method is illustrated with an example from a crisis management scenario. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Towards executable models: transforming EDOC behavior models to CORBA and BPEL

    Page(s): 267 - 274
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (517 KB) |  | HTML iconHTML  

    At the last EDOC conference we presented our open modelling infrastructure "medini" which is based on MOF compliant meta-tools. Based on medini, we have developed a modelling suite for telecom services which consists of EDOC as a platform independent modelling technique and CORBA/Corba component model (CCM) as a platform specific modelling technique. Since that time, this modelling suite has been significantly enhanced: Support for Web services has been added as an alternative target platform and we have extended the model transformers to consider EDOC behavior models (namely choreographies). The behavior descriptions can now be transformed to Web service behavior expressed using BPEL (business process execution language) and to behavior descriptions for our CORBA/CCM based platform facilitating UML 2 state-machines and the creation of Java code. We explain our behavior transformations and report on the experiences we have made by simultaneously addressing two different target platforms with different kinds of behavior descriptions. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Elemental and Pegamento: the final cut applying the MDA pattern

    Page(s): 240 - 252
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (649 KB) |  | HTML iconHTML  

    We provide an investigation of the applicability of the model driven architecture ™ to the development of a technical architecture in a specific domain, viz: contract monitoring. We define MDA in terms of a single basic pattern, which is then composed in several ways to represent the behaviour of a large range of MDA tools. The paper introduces both the work of the Elemental project to provide the domain example, and the Pegamento project to explain the metamodels and tools in the MDA framework which might be applied to the domain. Elemental has developed an architecture and a language for supporting enterprise contract management (ECM) as part of an extended enterprise model. Pegamento has specified and built MDA prototype tools using several modelling languages, meta-languages and platforms. As the work of both these projects reaches maturity, "the Final Cut" is our proposed application of this toolset to facilitate building a model-based implementation of the relevant parts of Elemental's ECM system. We discover several generic MDA pattern matches in this case study, and several specific to the ECM. We also identify and discuss pattern mismatches. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Quality of service in middleware and applications: a model-driven approach

    Page(s): 160 - 171
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (366 KB) |  | HTML iconHTML  

    Quality of service (QoS) management has become an important requirement for middleware platforms and distributed applications. Early QoS engineering attempts focused on single-category extensions to standard middleware. In recent years generic middleware frameworks have been proposed in order to facilitate multicategory QoS management. Our experience with such a framework has revealed that QoS management cannot be shielded from the applications. Applications need to be designed in a QoS-aware manner and application QoS requirements need to be translated into appropriate middleware extensions. Therefore we propose a comprehensive, model-driven development process for QoS-enabled distributed applications on top of QoS-enhanced middleware platforms. Our approach builds on OMG's Model-Driven Architecture (MDA). We demonstrate the mapping from the platform-independent to the platform-specific model, and we show how the design approach is applied targeting a .NET-based QoS-enabled middleware. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Towards an MDA-oriented UML profile for distribution

    Page(s): 227 - 239
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (369 KB) |  | HTML iconHTML  

    The era of distributed systems is upon us. Middleware-specific concerns, and especially the distribution concern, which is the core of any middleware-mediated application, are addressed every day in all sorts of enterprise systems. However, object-oriented UML designs offer a very limited perspective on what exactly is distributed, how exactly the distribution is achieved, and where exactly distributed services are located. In order to answer these questions, the MDA-compliant enterprise Fondue method proposes a hierarchy of UML profiles as a means for addressing the distribution concern at three different MDA-levels of abstraction. Model transformations are provided to incrementally refine existing design models according to the proposed profiles. For the last phase of the enterprise Fondue process, code generation for specific middleware infrastructures is supported through the Parallax framework. The CORBA technology is used for illustrating the entire approach on a concrete example. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Data consistency in a heterogeneous IT landscape: a service oriented architecture approach

    Page(s): 3 - 8
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (349 KB) |  | HTML iconHTML  

    Consistent data across applications is the centerpiece for a successful integration of IT systems. Heterogeneous IT environments, as found in most mature industries, pose a challenge not only in integrating applications, but also in ensuring a consistent set of data being used. Based on an industry example we describe how data consistency is realized through data modeling concepts and a service-oriented architecture. A directory service and adapters handle the information transfer between applications using a global information model derived from an industry standard. Two use cases show how a synchronization service reacts and resolves data inconsistencies. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Evaluating the performance of middleware load balancing strategies

    Page(s): 135 - 146
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (441 KB) |  | HTML iconHTML  

    This work presents three contributions to research on middleware load balancing. First, it describes the design of Cygnus, which is an extensible open-source middleware framework developed to support adaptive and nonadaptive load balancing strategies. Key features of Cygnus are its ability to make load balancing decisions based on application-defined load metrics, dynamically (re)configure load balancing strategies at run-time, and transparently add load balancing support to client and server applications. Second, it describes the design of LBPerf, an open-source middleware load balancing benchmarking toolkit developed to evaluate load balancing strategies at the middleware level. Third, it presents the results of experiments that systematically evaluate the performance of adaptive load balancing strategies implemented using the Cygnus middleware framework using workloads generated by LBPerf. The workloads used in our experiments are based on models of CPU-bound requests that are representative of a broad range of distributed applications. Our experiments with LBPerf illustrate the need for evaluating different adaptive and nonadaptive load balancing strategies under different workload conditions. In addition to assisting in choosing a suitable load balancing strategy for a particular class of distributed applications, our empirical results help configure run-time parameters properly and analyze their behavior in the presence of different workloads. Our results also indicate that integrating Cygnus into distributed applications can improve their scalability, while incurring minimal run-time overhead. As a result, developers can concentrate on their core application behavior, rather than wrestling with complex middleware mechanisms needed to enhance the scalability of their distributed applications. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Integrated quality of service (QoS) management in service-oriented enterprise architectures

    Page(s): 21 - 32
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (361 KB) |  | HTML iconHTML  

    One of the significant challenges for making service-oriented architectures (SOA) effective for enterprise systems is quality of service (QoS) management because of the dynamic, flexible, and compositional nature of SOA. QoS management must be integrated into service-oriented enterprise architectures. It must support a set of common QoS characteristics and provide comprehensive QoS services end to end, from application, to middleware, and to network and from source hosts to destination hosts across a network. We describe such an integrated QoS management architecture and its services. We classify QoS characteristics into four categories and each of which is decomposed into a set of measurable attributes. We integrate these characteristics into an XML-based language for applications and QoS providers to express QoS requirements and contracts. We model an integrated QoS management architecture based on standard specifications from organizations like ISO and OMG. We implement a comprehensive set of QoS management services with innovation resource management techniques and adaptation mechanisms. We provide test data to validate our architecture and solution first in a publish/subscribe style of enterprise SOA. In comparison with other work in QoS management, our architecture and solution provide innovative techniques, extensions, and generalizations beyond traditional task-oriented QoS management in object-oriented middleware and domain specific applications. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • A rigorous approach to relate enterprise and computational viewpoints

    Page(s): 187 - 200
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (386 KB) |  | HTML iconHTML  

    Multiviewpoint approaches allow stakeholders to design a system from stakeholder-specific viewpoints. By this, a separation of concerns is achieved, which makes designs more manageable. However, to construct a consistent multiviewpoint design, the relations between viewpoints must be defined precisely, so that the consistency of designs from these viewpoints can be verified. The goal of this paper is to make the consistency rules between (a slightly adapted version of) the RM-ODP enterprise and computational viewpoints more precise and to make checking the consistency between these viewpoints practically applicable. To achieve this goal, we apply a generic framework for relating viewpoints that includes reusable consistency rules. We implemented the consistency rules in a tool to show their applicability. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Developing QoS-aware component-based applications using MDA principles

    Page(s): 172 - 183
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (7956 KB) |  | HTML iconHTML  

    One of the great challenges in the distributed enterprise computing is providing software systems with expected quality-of-service (QoS). For this purpose, it is very important to include QoS aspects in all the phases of the system development life cycle (analysis, design, deployment, etc.). This is enforced by the new approaches to system design, such as the model-driven approach called MDA (model driven architecture). MDA is a modeling framework that improves the efficiency and decreases the complexity of the development of software system by allowing to model functional aspects independently of the underlying platform and the generation of its models in a target platform. In this context, This work studies the model-driven development of distributed component-based software applications with QoS support, which includes QoS specification and QoS monitoring. The proposal consists of applying the MDA principles to specify QoS aspects of component-based applications in parallel to the traditional design of the functional aspects. For this purpose, we define the following elements: a) a QoS catalogue to characterize a software component from the QoS point of view; b) a UML profile for modeling QoS contracts of component-based applications, and c) a UML profile for modeling the monitoring mechanisms employed to monitor that QoS. In addition to the description of all these elements, the paper introduces a real scenario in which the proposed ideas have been tested and partially validated. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Proceedings. Eighth IEEE International Enterprise Distributed Object Computing

    Save to Project icon | Request Permissions | PDF file iconPDF (268 KB)  
    Freely Available from IEEE