Abstract. Refactoring is the process of improving the design of existing programs without changing their functionality. These notes cover refactoring in functional languages, using Haskell as the medium, and introducing the HaRe tool for refactoring in Haskell. 1

Today, CORBA architecture brings the major industrial solution for achieving the interoperability between distributed software components in heterogeneous environments. While the CORBA project attempts to federate distributed mechanisms within a unique architecture, its internal model is not very flexible and seems not to be suitable for future evolutions. In this paper, we present OpenCorba, a reflective open broker, enabling users to adapt dynamically the representation and the execution policies of the software bus. We first expose the reflective foundations underlying the implementation of OpenCorba: i) metaclasses which provide a better separation of concerns in order to improve the class reuse; ii) a protocol which enables the dynamic changing of metaclass in order to allow run-time adaptation of systems. Based on this reflective environment, OpenCorba enables the adaptability of the internal characteristics of the broker in order to change its run-time behavior (e...

One of the major progress due to component based technology is the capability to let the "infrastructure" manage some (non functional or extra functional) aspects such as persistency, distribution and so on without having to change the application code, using a wrappers technology (containers). Aspect Oriented Programming (AOP) is a technology that provides a language in which different aspects can be applied to an application using a technology that "weaves" the code implementing the aspect inside the application code.

Parameter passing is one of the main problems in distributed object-oriented applications. The two simplest solutions - passing objects by global reference and passing complete copies of the object graphs - both have significant drawbacks. Instead, an intermediate amount of copying is often best. The problem is twofold: (i) compilers and operating systems can't automatically make the best decision on how much to copy; (ii) there hasn't been a good mechanism for the programmer to express the intermediate amount of copying that should be done. The contribution of this paper is to present a new mechanism that allows programmers to express in a natural and succinct way how much of the object graph should be copied to the remote context. The specifications are done using a very simple declarative meta-language -- GOOP -- that has graphs of classes as domain. Keywords: distribution, remote invocation, pass-by-copy, open implementation, adaptiveness. Supported by the Portuguese Fo...

Abstract. Nowadays, applications must work in highly dynamic environments, where resources availability, among other factors, can evolve at runtime. To deal with this situation, applications must be self-adaptive, that is adapt themselves to their environment and its evolutions. Our goal is to enable systematic development of self-adaptive componentbased applications using the Separation of Concerns principle: we consider adaptation to a specific execution context and its evolutions as a concern which should be treated separately from the rest of an application. In this paper, we first present the general approach we propose and the corresponding development framework and tools we are developing to support it. Then, in order to validate this approach, we use it on a small component-based application to show how it can be made self-adaptive. 1

Aspect oriented programming promotes the separation of the different aspects of a system into their natural form, and synchronisation is an important aspect of concurrent object oriented systems. Treating synchronisation as a single monolithic aspect leads to inflexibility and limited possibilities for reuse. We suggest that synchronisation has a number of different aspects, and introduce the `synchronisation rings' model which allows the aspects of a synchronised object to be specified independently. By separating the different aspects of synchronisation we can provide flexible, generic implementations of common synchronisation constraints, which can be re-used in many different contexts.

Abstract The separation of concerns is important to attain object oriented systems which can be easily evolved. This paper presents a reflective architecture which enforces the separation of concerns by allocating functional, interaction and synchronization code to different levels. A variant of collaborations (CO actions) is used to capture interactions between objects and avoids spreading the description of interactions among the participating objects. Functional and interaction code are also separated from synchronization code by means of metalevel components. Introducing changes into the reflective architecture to consider evolution needs is facilitated by the loose coupling of different concerns. Hence, changing a concern often consists of modifying only one component of the reflective architecture. The paper describes the reflective architecture in terms of a case study. The evolution of the reflective implementation of the case study is compared with the evolution of an alternative implementation and the benefits of the proposed architecture are shown by using an evolution metric. 1

As the Web is becoming ubiquitous environment, Web servers are faced with a diversityof requirements. This paper addresses how Web servers can meet a wide range of requirements, and proposes an adaptive framework called AISF (Adaptive Internet Server Framework) which employs a meta-architecture to make the Web server adaptable and configurable. We are interested in applying the meta-architecture to Web servers, where it has had little acceptance to date. AISF provides a set of fine-grained metaobjects which capture and express various aspects in Web servers. Web servers can dynamically adjust itself to meet any requirement by implementing it within the AISF programmable meta model. This paper also demonstrates that AISF can be used to meet every demand placed upon Web server consistently, and includes some proof-of-concept examples. Our approach aims to create adaptive Web servers beyond a static and monolithic servers.

Abstract. In this paper we present a proposal for safely evolving a software system against run-time changes. This proposal is based on a reflective architecture which provides objects with the ability of dynamically changing their behavior by using their design information. The meta-level system of the proposed architecture supervises the evolution of the software system to be adapted that runs as the base-level system of the reflective architecture. The meta-level system is composed of cooperating components; these components carry out the evolution against sudden and unexpected environmental changes on a reification of the design information (e.g., object models, scenarios and statecharts) of the system to be adapted. The evolution takes place in two steps: first a meta-object, called evolutionary meta-object, plans a possible evolution against the detected event then another meta-object, called consistency checker meta-object validates the feasibility of the proposed plan before really evolving the system. Meta-objects use the system design information to govern the evolution of the base-level system. Moreover, we show our architecture at work on a case study.

Abstract. The configuration of smart cards is a complex multi-level process. Addressing this process efficiently is a major challenge of the smart card industry. In the context of the forthcoming evolutions of smart card systems, we are ex-perimenting new configuration methods. We propose to rely on both model-driven engineering and software product lines to formalize and automate the smart card configuration process. We are applying separation of concerns as a methodological support to implement variability management. This paper describes our approach as well as its motivations and provides a concrete example. 1