Abstract. During an architectural evolution of a component-based software, certain quality attributes may be weakened. This is due to the lack of an explicit definition of the links between these non-functional characteristics and the architectural decisions implementing them. In this paper, we present a solution that aims at assisting the software maintainer during an evolution activity on his demand. It requires the definition of a documentation during development, organized in the form of bindings between formal descriptions of architectural decisions and their targeted quality attributes. Through an assistance algorithm, the approach uses this documentation in order to notify the maintainer of the possible effects of architectural changes on quality requirements. We also present a prototype tool which automates our proposals. This tool and the overall approach has been experienced on a real-world software in order to validate them.

The increased popularity of web services is accompanied with an increase in both provider and service number. This fairly large service number causes a deficiency in the selection of the most pertinent service, and makes it an effortful and time-consuming task. We propose the WSPAB (Web Service Personal Address Book) tool that aims at defining a complete solution for facilitating the task of finding the most pertinent web service. This includes two sub tasks, discovering and selecting. In this paper, we present the first part of the tool concerning the automation of the selection process, taking into consideration the quality of service (QoS) and user preferences. The WSPAB accomplishes the automatic selection of a service by filtering web services according to certain aspects of QoS and certain user requirements; then classifying these services using the formal concept analysis (FCA) approach, enabling users to easily select their needed service, identify its potential substitutes and keep trace of them either for future use, or to be shared with others.

During software development, architecture decisions should be documented so that quality attributes guaranteed by these decisions and required in the software specification could be persisted. An important part of these architectural decisions is often formalized using constraint languages which differ from one stage to another in the development process. In this paper, we present a family of architectural constraint languages, called ACL. Each member of this family, called a profile, can be used to formalize architectural decisions at a given stage of the development process. An ACL profile is composed of a core constraint language, which is shared with the other profiles, and a MOF architecture metamodel. In addition to this family of languages, this paper introduces a transformation-based interpretation method of profiles and its associated tool.

Abstract-In SOA, composite applications can be developed on the basis of collections of interacting web services. A service's functionality is exposed to the external world by an abstract interface, described by the standard WSDL language, which must be published by service providers to public registries where service consumers can find them. Nowadays, web service discovery has become a real problem, because of the lack of public registries to publish and organize the fairly huge number of existing services. In this paper, we propose an approach based on formal concept analysis (FCA) for classifying and browsing web services. Using this approach, the web services are organized into a lattice structure, to facilitate their browse and selection. A service lattice reveals the invisible relations between the services, enabling the discovery of a needed service as well as the identification of its possible alternatives. Thus, service discovery may be achieved more easily using the service lattice. This facilitates the construction of service compositions and supports them with backup services to ensure a continuous functionality.

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 (AI) planning to optimization algorithms. However no approach so far has focused on handling three composition dimensions simul

It is argued that architecture comprehension and regression testing of a software system are the most expensive maintenance activities. This is mainly due to the fact that architectural choices are either not explicit, at every stage of the software development process, or not preserved from one stage to another. In this paper, we present an Architectural Constraint Language (ACL) as a means to formally describe architectural choices at all the stages. This language is based on the UML's Object Constraint Language and on a set of MOF-compliant metamodels. We also present a prototype which validates the proposed approach. It allows the evaluation of ACL expressions at two stages and ensures, by using a transformation mechanism, that the constraints stated at one stage are subsequently preserved.

Abstract-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.

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 objectoriented applications to component-based ones will contribute to improve these characteristics (maintainability and reuse). In this paper, we propose an approach to automatically transform objectoriented 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.