Connectors are used in component-based systems as first-class entities to abstract component interactions. In this paper, we propose a way to compose connectors by using fine-grained elements, each of them representing a single, well-defined function. We identify an experimentally proven set of connector elements, which, composed together, model four basic component interconnection types (procedure call, messaging, streaming, blackboard), and allow for connector variants to reflect distribution, security, fault-tolerance, etc. We also discuss how to generate such a connector semi-automatically. The presented results are based on a proof-of-the-concept implementation.

Abstract. The assembly of components that can handle continuously changing data results in programs that are more interactive. Unfortunately, the code that glues together such components is often difficult to write because it is exposed to many complicated event-handling details. This paper introduces the SuperGlue language where components are assembled by connecting their signals, which declaratively represent state as time-varying values. To support the construction of interactive programs that require an unbounded number of signal connections, signals in SuperGlue are scaled with object-oriented abstractions. With Super-Glue’s combination of signals and objects, programmers can build large interactive programs with substantially less glue code when compared to conventional approaches. For example, the SuperGlue implementation of an email client is around half the size of an equivalent Java implementation. 1

This dissertation presents a critical rethinking of the Java bytecode verification architecture from the perspective of a software engineer. In existing commercial implementations of the Java Virtual Machine, there is a tight coupling between the dynamic linking process and the bytecode verifier. This leads to delocalized and interleaving program plans, making the verifier difficult to maintain and comprehend. A modular mobile code verification architecture, called Proof Linking, is proposed. By establishing explicit verification interfaces in the form of proof obligations and commitments, and by careful scheduling of linking events, Proof Linking supports the construction of bytecode verifier as a separate engineering component, fully decoupled from Java's dynamic linking process. This turns out to have two additional benefits: (1) Modularization enables distributed verification protocols, in which part of the verification burden can be safely offloaded to remote sites; (2) Alternative static analyses can now be integrated into Java's dynamic linking process with ease, thereby making it convenient to extend the protection mechanism of Java. These benefits make Proof Linking a competitive verification architecture for mobile code systems. A prototype of the Proof Linking Architecture has been implemented in an open source Java Virtual Machine, the Aegis VM (http://aegisvm.sourceforge.net). On the

Evolution of software architectures is, different from architectural design, an area that only few tools have covered. We claim this is due to the lack of support for an important concept of architectural evolution: the notion of architectural design decisions. The absence of

One of the most cited benefits of component based applications is that their modular design allows them to evolve with relative ease. However, replacement of a component at runtime without stopping the application remains a difficult problem, since the state contained in the active version of the component must somehow be transferred to its successor. Existing techniques that implement live updates all require the programmer to manually implement the state transition functionality. We have developed a methodology to deal with runtime adaptation of Java-based components. Our approach is innovative since it provides a number of steps that assist the programmer with the issue of state transfer. In this paper, we first introduce our global methodology, and then continue with a detailed study of the algorithm that controls state transfer between components at runtime. Two novel aspects of our algorithm are its extensibility and its ability to keep portions of the old component in place by preventing localized changes from propagating throughout the entire component.

Due to their modular design, component-based applications are relatively well-suited to supporting run-time evolution. However, replacing a component at run time without halting the application remains a difficult task. The main cause of this complexity can be found in transferring the state between two versions of a component. We have developed a methodology to perform run-time adaptations on component-based applications. This paper briefly introduces our methodology and then continues with a detailed study of our approach to state transfer. By exploiting the strong encapsulation of components, we conduct an analysis of the (object-oriented) source code of different versions of a component. A classification is presented which introduces different categories of change, according to the impact of the change on the set of objects that make up the component. We then describe different heuristics that are used to identify equivalent data structures between different versions. We show how these techniques are implemented in a tool called DeepCompare. An evaluation of our tool using two examples (an academic toy component and a real-life application), demonstrates that our process successfully identifies the vast majority of corresponding structures in a typical evolution scenario.

An important characteristic of ubiquitous computing is that the computational services in our environment are envisioned to be far more interconnectable than today. This means it should be possible to combine them to suit the purpose at hand at any given time. However, given a particular combination of services, there are numerable combined behaviours that could be meaningful. Furthermore, ubiquitous computing is often characterized by dynamically changing, heterogeneous combinations of services. It is therefore necessary to be able to specify the desired behavior and to be able to switch dynamically and easily between several such behaviours. Assemblies, as a concept in ubiquitous computing, has been suggested as a mechanism to represent a set of services and their behavior. After summarising the use-inspired notion of an assembly, this paper (1) clarifies the concept from a software engineering perspective, arguing that an assembly is both an architectural connector and a component (2) that an assembly should have a programmatic representation (3) provides a discussion of what it should comprise, based on realistic examples grounded in participatory design (4) the challenges facing the adoption of the concept, and finally (5) shows that a particular suggestion for its implementation based on publish/subscribe is architecturally realizable. 1.

Distributed application development is overly tedious, as the dynamic composition of distributed components is hard to combine with static safety with respect to types (type safety) and data (encapsulation). Achieving such safety usually goes through specific compilation to generate the glue between components, or making use of a single programming language for all individual components with a hardwired abstraction for the distributed interaction.

This dissertation describes the design and implementation of a general-purpose object-oriented (OO) programming language, Classages. The novel object model of Classages gives programmers refined control over modeling the interactions inside OO software, with inspirations drawn from human sociology. Key innovations include the language constructs of Mixers and Connectors as encapsulation-enforceable in-terfaces for specifying bi-directional interaction behaviors, and a novel type system called Pedigree Types to help programmers organize the object heap into a hierarchy reflecting the fundamental principle of hi-erarchical decomposition. Important properties of the language, including type soundness, hierarchy shape enforcement, and alias protection, are formally established and proved. A prototype compiler is implemented. The object model of Classages sets a significant departure from the familiar one taken by Smalltalk, Java, C++, and C#. Its simple, expressive, and rigorously defined core enriches the theoretical foundations of OO languages. From the perspective of software engineering, the Classages language is particularly good at controlling software complexity, a crucial goal in modern software development.

Abstract — In this paper we describe Ensemble, a proposed language framework for sensor network programming. Our goal is to provide a programming framework to scientists and engineers that will allow them to directly code sensor network applications, without the need for expertise in low-level device programming. The key concepts in Ensemble are high-level communication protocol connectors, and the ability for systems programmers to define new communication protocols as metaprotocol extensions. I.