Chouki Tibermacine

Selection of Composable Web Services Driven by User Requirements

Building a composite application based on Web services has become a real challenge regarding the large and diverse service space nowadays. Especially when considering the various functional and non-functional capabilities that Web services may afford and users may require. In this paper, we propose an approach for facilitating Web service selection according to user requirements. These requirements specify the needed functionality and expected QoS, as well as the composability between each pair of services. The originality of our approach is embodied in the use of Relational Concept Analysis (RCA), an extension of Formal Concept Analysis (FCA). Using RCA, we classify services by their calculated QoS levels and composability modes. We use a real case study of 901 services to show how to accomplish an efficient selection of services satisfying a specified set of functional and non-functional requirements.

Software architecture constraint reuse-by-composition

Architecture constraints are specifications which enable developers to formalize design rules that architectures should respect, like the topological conditions of a given architecture pattern or style. These constraints can serve as a documentation to better understand an existing architecture description, or can serve as invariants that can be checked after the application of an architecture change to see whether design rules still hold. Like any specifications, architecture constraints are frequently subject to reuse. Besides, these constraints are specified and checked during architecture design time, when component descriptions are specified or selected from repositories, then instantiated and connected together to define architecture descriptions. These two facts (being subject to reuse and instantiation/connection) make architecture constraints good candidates for component-based design within a unified environment. In this paper, we propose a component model for specifying architecture constraints. This model has been implemented as an extension to an ADL that we have developed, which is called CLACS. The obtained process advocates the idea of specifying architecture constraints using the same paradigm of component-based development as for architecture description. To evaluate the component model, we conducted an experiment with a catalog of constraints formalizing the topological conditions of architecture patterns. The results of this experiment showed that constraint specification is improved by this reuse-by-composition model. Design choices in architecture description can be formalized as constraints.Architecture constraints are reusable and customizable specifications.A component model for enabling reusability in constraint specification.Specifying architecture models & constraints with the same concept: component.An empirical evaluation of the model by considering architecture patterns.

Migrating large object-oriented Applications into component-based ones: instantiation and inheritance transformation

Large object-oriented applications have complex and numerous dependencies, and usually do not have explicit software architectures. Therefore they are hard to maintain, and parts of them are difficult to reuse. Component-based development paradigm emerged for improving these aspects and for supporting effective maintainability and reuse. It provides better understandability through a high-level architecture view of the application. Thereby migrating object-oriented applications to component-based ones will contribute to improve these characteristics (maintainability and reuse). In this paper, we propose an approach to automatically transform object-oriented applications to component-based ones. More particularly, the input of the approach is the result provided by software architecture recovery: a component-based architecture description. Then, our approach transforms the object-oriented source code in order to produce deployable components. We focus in this paper on the transformation of source code related to instantiation and inheritance dependencies between classes that are in different components. We experimented the proposed solution in the transformation of a collection of Java applications into the OSGi framework. The experimental results are discussed in this paper.

QoS-aware optimal and automated semantic web service composition with user's constraints

Automated semantic web service composition is one of the critical research challenges of service-oriented computing, since it allows users to create an application simply by specifying the inputs that the application requires, the outputs it should produce, and any constraints it should respect. The composition problem has been handled using a variety of techniques, from artificial intelligence planning to optimization algorithms. However no approach so far has focused on handling three composition dimensions simultaneously, producing solutions that are: (1) fully functional (i.e., fully executable) by using a mechanism of semantic matching between the services involved in the solutions, (2) are optimized according to non-functional quality-of-service (QoS) measurements, and (3) respect global QoS constraints. This paper presents a novel approach based on a Harmony Search algorithm that addresses these three dimensions simultaneously through a fitness function, to select the optimal or near-optimal solution in semantic web service composition. In our approach, the search space is modeled as a planning-graph structure which encodes all the possible composition solutions for a given user request. To improve the selection process we have compared the original Harmony Search algorithm with its recently developed variants Improved Harmony Search (IHS) algorithm and Global Best Harmony Search (GHS) algorithm. An experimentation of the approach conducted with an extended version of the Web Service Challenge 2009 dataset showed that: (1) our approach is efficient and effective to extract the optimal or near-optimal composition in diverse scenarios; and (2) both variants IHS and GHS algorithms have brought improvements in terms of fitness and execution time.

Building the presentation-tier of rich web applications with hierarchical components

Nowadays information systems are increasingly distributed and deployed within the Internet platform. Without any doubt, the World Wide Web represents the de facto standard platform for hosting such distributed systems. The use of a multi-tiered architecture to develop such systems is often the best design decision to reach scalability, maintainability and reliability quality goals. Software in the presentationtier of this architecture needs in practice to be designed with structured and reusable library modules. In this paper, we present a hierarchical component model which allows developers to build (model, generate code and then reuse) this software level of rich Web applications. In this model, components can be connected via their interfaces to build more complex components. These architecture design models can be reused together with their corresponding code using an association mechanism. As shown in this paper this is a valuable feature in assisting developers to position their developed documents within the overall software design and thus enable maintaining the consistency between artifacts of these two stages of the development process.

From web components to web services: opening development for third parties

One of the main advantages of the Web component-based development paradigm is the ability to build customizable and composable web application modules as independent units of development, and to share them with other developers by publishing them in libraries as COTS (Commercial Off The Shelf) or free components. Besides this, since many years, Web services confirmed their status of the most pertinent solution for a given service provider, like Google, Amazon or FedEx, to open its solutions for third party development. In this paper, we present an approach to build web services starting from existing web component-based applications and deploy them on a web service provider. This transformation helps server-side web application developers in transforming their user interface-based web components into a set of web services intended for remote code extensions. We implemented our solution on a collection of Java EE technologies.

Generating reusable, searchable and executable architecture constraints as services

A process for generating reusable and executable architecture constraints.Automatically creating components that embed architecture constraints.Deploying architecture constraints as services published in a registry.Experimentation of the process on a set of architecture patterns and in a real-life scenario. Architecture constraints are components of design documentation. They enable designers to enforce rules that architecture descriptions should respect. Many systems make it possible to associate constraints to models at design stage but very few enable their association to code at implementation stage. When possible, this is done manually, which is a tedious, error prone and time consuming task. Therefore, we propose in this work a process to automatically generate executable constraints associated to programs code from model-based constraints. First, the process translates the constraints specified at design-time into constraint-components described with an ADL, called CLACS. Then, it creates constraint-services which can be registered and later invoked to check their embedded constraints on component- and service-based applications. We chose to target components and services in order to make architecture constraints reusable, searchable in registries, customizable and checkable at the implementation stage. The generated constraint-services use the standard reflective (meta) layer provided by the programing language to introspect elements of the architecture. We experimented our work on a set of 15 architecture constraints and on a real-world system in order to evaluate the effectiveness of the process.

Integrating quality requirements in engineering web service orchestrations

We propose a method to integrate quality requirements in Web service orchestrations.The method is based on a SOA patterns catalog used to satisfy quality requirements.Patterns are selected and applied with minimal negative effect on other qualities.To evaluate our method, we apply it on real-word orchestrations (BPEL processes).The obtained results showed that our method is promising and cost effective. Todays Web services are considered as one of the leading technologies for implementing components of service-oriented software architectures for desktop, Web or mobile applications. When designing workflows of activities that involve the invocation of these Web Services, we build either orchestrations or choreographies. The engineering of such applications is an emerging research topic with many challenges. Among them, we can stress out the crucial question of how to answer quality requirements in such engineering processes. This paper, presents a method which aims at assisting software architects of Web Service orchestrations in integrating quality requirements in their artifacts. In order to satisfy a quality requirement, this method suggests a list of service-oriented patterns. We base our work on the postulate stating that quality can be implemented through patterns, which can be specified with checkable/processable languages. This method helps architects to reach concrete architecture changes that can be automatically performed on the orchestration in order to apply a pattern, and thus integrate its associated quality. We experimented our method on a set of real-world orchestrations (BPEL processes) to measure the overhead of using it in engineering such service-oriented applications. The obtained results showed that our method brings a significant gain of time.

A process to identify relevant substitutes for healing failed WS-* orchestrations

Our proposal is an identification process of substitutes for failed services.The original contribution is the identification of complex service substitutes.We use in this process an efficient and complete similarity measurement method.The proposed process has been experimented on real world Web services. Orchestrating web services aims to compose multiple services into workflows that answer complex user requirements. Web services are software components which are exposed to errors and failures that can occur during web service orchestration execution. Thus, many error-handling and healing approaches have been proposed to guarantee reliable orchestrations. Some of these approaches rely on the identification of relevant service substitutes to heal (by substitution) the defected services. In this paper, we propose an identification process of web service substitutes for healing failed web service orchestrations based on the measurement of similarity between service interfaces. The process reveals both simple and complex (compositions of) substitutes. We validated the approach via a set of experiments conducted on a collection of real web services.

Software architecture constraints as customizable, reusable and composable entities

One of the major advantages of component-based software engineering is the ability for developers to reuse and assemble software entities to build complex software. Whereas decomposition of software into components has been and is largely addressed for what concerns the business (functional) part of applications, this is not yet the case for what concerns their documentation (non-functional) part. In this paper, we propose a new and original solution to express componentbased software non-functional documentation, and we will focus more especially on architecture constraints, which formalize parts of architecture decisions, as executable, customizable, reusable and composable building blocks represented by components. Component-based applications using business and constraint components can be modeled with CLACS, a dedicated ADL which is also introduced in the paper. Architecture constraints can be executed at design-time within CLACS. CLACS is implemented as a plugin in the Eclipse IDE.