Abstract 1 Domain-specific generators will increasingly rely on graphical languages for declarative specifications of target applications. Such languages will provide front-ends to generators and related tools to produce customized code on demand. Critical to the success of this approach will be domain-specific design wizards, tools that guide users in their selection of components for constructing particular applications. In this paper, we present the P3 ContainerStore graphical language, its generator, and design wizard. 1

Increasingly, software should dynamically adapt its behavior at run-time in response to changing conditions in the supporting computing and communication infrastructure, and in the surrounding physical environment. In order for an adaptive program to be trusted, it is important to have mechanisms to ensure that the program functions correctly during and after adaptations. Adaptive programs are generally more difficult to specify, verify, and validate due to their high complexity. Particularly, when involving multithreaded adaptations, the program behavior is the result of the collaborative behavior of multiple threads and software components. This paper introduces an approach to create formal models for the behavior of adaptive programs. Our approach separates the adaptation behavior and nonadaptive behavior specifications of adaptive programs, making the models easier to specify and more amenable to automated analysis and visual inspection. We introduce a process to construct adaptation models, automatically generate adaptive programs from the models, and verify and validate the models. We illustrate our approach through the development of an adaptive GSM-oriented audio streaming protocol for a mobile computing application.

For several different reasons, such as changes in the business or technological environment, the configuration of a system may need to evolve during execution. Support for such evolution can be conceived in terms of a language for specifying the dynamic reconfiguration of systems. In this paper, continuing our work on the development of a formal platform for architectural design, we present a high-level language to describe architectures and for operating changes over a configuration (i.e., an architecture instance), such as adding, removing or substituting components or interconnections. The language follows an imperative style and builds on a semantic domain established in previous work. Therein, we model architectures through categorical diagrams and dynamic reconfiguration through algebraic graph rewriting. 1.

We use the double-pushout graph transformation approach for the specication of run-time reconguration of software architectures.

Abstract. We propose a meta-framework called ‘Plastik ’ which i) supports the specification and creation of runtime component-framework-based software systems and ii) facilitates and manages the runtime reconfiguration of such systems while ensuring integrity across changes. The meta-framework is fundamentally an integration of an architecture description language (an extension of ACME/Armani) and a reflective component runtime (OpenCOM). Plastikgenerated component frameworks can be dynamically reconfigured either through programmed changes (which are foreseen at design time and specified at the ADL level); or through ad-hoc changes (which are unforeseen at design time but which are nevertheless constrained by invariants specified at the ADL level). We provide in the paper a case study that illustrates the operation and benefits of Plastik. 1

The application of formal methods to the development of software depends on the availability of adequate models and formalisms for each of the stages of the development process. In this work, we focus on the level of design called Software Architecture. At this level, the system is described as a collection of interrelated components, and it is here where the properties derived from system’s structure can be naturally analyzed. Our approach uses process algebras as a formal basis for the description and analysis of software architectures. Process algebras are widely accepted for the specification of software systems. In particular π-calculus addresses the description of systems with a dynamic or evolving topology, and permits their analysis for bisimilarity and other interesting properties. Though bisimilarity determines the equivalence of behavior, more flexible relations are needed in the context of Software Engineering, in order to support formally the notions of conformance and refinement of behavior. In this paper we present a relation of compatibility in the context of π-calculus which formalizes the notion of conformance of behavior between software components. Our approach is enhanced with the definition of a relation of inheritance among processes. This relation preserves compatibility and indicates whether a process can be considered as a specialization or extension of another one. The suitability of our approach is shown by its application to the field of Software Architecture 1.

Applications on a Computational Grid must meet stringent performance requirements even when the performance characteristics of the underlying systems and networks vary significantly at runtime. Runtime adaptation can be used to tolerate such changes, but adaptive codes can be challenging to design and debug. This papers propose a language called Program Control Language (PCL) that provides a novel means of specifying adaptations in distributed applications. PCL is based on an abstract, global representation of the distributed program that enables one to reason about and describe application-specific adaptation strategies at a high level, using a few key mechanisms. The global representation enables distributed performance metrics and adaptations to be specified in simple, global terms and implemented transparently by the compiler and runtime system. The paper describes the conceptual adaptation framework, the PCL language, and our implementation of the PCL compiler and runtime system. The paper uses two examples to illustrate the capabilities and benefits of PCL, and to show experimentally that the performance overheads of using PCL for implementing an adaptive application are negligible.

Architectural styles play an important role in software engineering as they convey codified principles and experience which help the construction of software systems with high levels of efficiency and confidence. We address the problem of formalizing and analyzing architectural styles in an operational setting by introducing the intermediate abstraction of architectural type. We develop the concept of architectural type in a process algebraic framework because of its modeling adequacy and the availability of means, such as Milner's weak bisimulation equivalence, which allow us to reason compositionally and eciently about the well formedness of architectural types.

Producing high quality software, on time, and keeping costs within reasonable bounds have been three major goals from the very beginning of software engineering as an engineering science. Hardly ever are deployed systems either error-free or fully functionally satisfactory. The result is that, once brought into operation, systems undergo a series of "patches", "fixes", modifications, and changes. At the same time, increasingly many functions dependent on software in business, industry, and at home depend on being immediately available. Having these services unavailable due to updating the software is annoying for users. And there are other types of systems -- real-time systems -- that cannot afford to be taken down, for instance, telecommunication systems, command-andcontrol systems, and any other systems requiring continuous operation. This paper presents the Java Distributed Run-time Up- date Management System (JDRUMS). JDRUMS is meant to deal with the above mentioned problems, specifically for Java. It provides functionality for the introduction of new versions of existing Java classes on the fly, while pre- serving the internal state of objects.

Explicit behavioural interface description languages (BIDLs, protocols) are now recognized as a mandatory feature of component languages in order to address component reuse, coordination, adaptation and verification issues. Such protocol languages often deal with synchronous communication. However, in the context of distributed systems, components communicating asynchronously through mailboxes are much more relevant. In this paper, we advocate for the use of Symbolic Transition Systems as a protocol language which may deal also with this kind of communication. We then present how this generic formalism, specialized with different mailbox protocols, may be used to address verification issues related to the component mailboxes. 1