Dharini Balasubramaniam

Support for evolving software architectures in the ArchWare ADL

Software that cannot evolve is condemned to atrophy: it cannot accommodate the constant revision and re-negotiation of its business goals nor intercept the potential of new technology. To accommodate change in software systems, we have defined an active software architecture to be: dynamic in that the structure and cardinality of the components and interactions are changeable during execution; updatable in that components can be replaced; decomposable in that an executing system may be (partially) stopped and split up into its components and interactions; and reflective in that the specification of components and interactions may be evolved during execution. Here we describe the facilities of the ArchWare architecture description language (ADL) for specifying active architectures. The contribution of the work is the unique combination of concepts including: a /spl pi/-calculus based communication and expression language for specifying executable architectures; hyper-code as an underlying representation of system execution that can be used for introspection; a decomposition operator to incrementally break up executing systems; and structural reflection for creating new components and binding them into running systems.

A framework for supporting dynamic systems co-evolution

Abstract Businesses and their supporting software evolve to accommodate the constant revision and re-negotiation of commercial goals, and to intercept the potential of new technology. We have adopted the term co-evolution to describe the concept of the business and the software evolving sympathetically, but at potentially different rates. More generally, we extend co-evolution to accommodate wide-informatics systems, that are assembled from parts that co-evolve with each other and their environment, and whose behavior is potentially emergent. Typically these are long-lived systems in which dynamic co-evolution, whereby a system evolves as part of its own execution in reaction to both expected and unexpected events, is the only feasible option for change. Examples of such systems include continuously running business process models, sensor nets, grid applications, self-adapting/tuning systems, peer-to-peer routing systems, control systems, autonomic systems, and pervasive computing applications. The contribution of this paper comprises: a study of the intrinsic nature of dynamic co-evolving systems; the derivation of a set of intrinsic requirements; a description of a model and a set of technologies, new and extant, to meet these intrinsic requirements; and illustrations of how these technologies may be implemented within an architecture description language (ArchWare ADL) and a conventional programming language (Java). The model and technologies address three topics: structuring for dynamic co-evolution, incremental design, and adapting dynamic co-evolving systems. The combination yields a framework that can describe the system’s specification, the executing software and the reflective evolutionary mechanisms within a single computational domain in which all three may evolve in tandem.

A software architecture approach for structuring autonomic systems

Autonomic systems manage themselves given high-level objectives by their administrators. They utilise feedback from their own execution and their environment to self-adapt in order to satisfy their goals. An important consideration for such systems is a structure which is conducive to self-management. This paper presents a structuring methodology for autonomic systems which explicitly models self-adaptation while separating functionality and evolution. Our contribution is a software architecture-based framework combining an architecture description language based on π-calculus for describing the structure and behaviour of autonomic systems, a development methodology for evolution and mechanisms for feedback and change.

Towards Verifying Correctness of Wireless Sensor Network Applications Using Insense and Spin

The design and implementation of wireless sensor network applications often require domain experts, who may lack expertise in software engineering, to produce resource-constrained, concurrent, real-time software without the support of high-level software engineering facilities. The Insense language aims to address this mismatch by allowing the complexities of synchronisation, memory management and event-driven programming to be borne by the language implementation rather than by the programmer. The main contribution of this paper is an initial step towards verifying the correctness of WSN applications with a focus on concurrency. We model part of the synchronisation mechanism of the Insense language implementation using Promela constructs and verify its correctness using Spin . We demonstrate how a previously published version of the mechanism is shown to be incorrect by Spin , and give complete verification results for the revised mechanism.

A Component-Based Model and Language for Wireless Sensor Network Applications

Wireless sensor networks are often used by experts in many different fields to gather data pertinent to their work. Although their expertise may not include software engineering, these users are expected to produce low-level software for a concurrent, real-time and resource-constrained computing environment. In this paper, we introduce a component-based model for wireless sensor network applications and a language, Insense, for supporting the model. An application is modelled as a composition of interacting components and the application model is preserved in the Insense implementation where active components communicate via typed channels. The primary design criteria for Insense include: to abstract over low-level concerns for ease of programming; to permit worst-case space and time usage of programs to be determinable; to support the fractal composition of components whilst eliminating implicit dependencies between them; and, to facilitate the construction of low footprint programs suitable for resource-constrained devices. This paper presents an overview of the component model and Insense, and demonstrates how they meet the above criteria.

An active architecture approach to dynamic systems co-evolution

The term co-evolution describes the symbiotic relationship between dynamically changing business environments and the software that supports them. Business changes create pressures on the software to evolve, and at the same time technology changes create pressures on the business to evolve. More generally, we are concerned with systems where it is neither economically nor technologically feasible to suspend the operation of the system while it is being evolved. Typically these are long-lived systems in which dynamic co-evolution, whereby a system evolves as part of its own execution in reaction to both predicted and emergent events, is the only feasible option for change. Examples of such systems include continuously running business process models, sensor nets, grid applications, self-adapting/tuning systems, routing systems, control systems, autonomic systems, and pervasive computing applications. Active architectures address both the structural and behavioural requirements of dynamic co-evolving software by modelling software architecture as part of the on-going computation, thereby allowing evolution during execution and formal checking that desired system properties are preserved through evolution. This invited paper presents results on active architectures from the Compliant System Architecture and ArchWare projects. We have designed and constructed the ArchWare-ADL, a formal, well-founded architecture description language, based on the higher-order typed &pi-calculus, which consists of a set of layers to address the requirements of active architectures. The ArchWare-ADL design principles, concepts and formal notations are presented together with its sophisticated reflective technologies for supporting active architectures and thereby dynamic co-evolution.

Process support for evolving active architectures

Long-lived, architecture-based software systems are increasingly important. Effective process support for these systems depends upon recognising their compositional nature and the active role of their architecture in guiding evolutionary development. Current process approaches have difficulty with run-time architecture changes that are not known a priori, and dealing with extant data during system evolution. This paper describes an approach that deals with these issues. It is based on a process-aware architecture description language (ADL), with explicit compose and decompose constructs, and with a hyper-code representation for dealing with extant data and code. An example is given to illustrate the ease-of-use benefits of this approach.

Support for feedback and change in self-adaptive systems

Self-adaptive systems modify their own behaviour in response to stimuli from their operating environments. The major policy considerations for such systems are determining what, when and how adaptations should be carried out. This paper presents mechanisms for feedback and change that support policy decisions for self-adaptation within a computationally complete architecture description language based on the π-calculus. Our contribution is support for feedback through software-encoded probes, gauges and an event distribution network together with support for change through decomposition, reification, reflection, recomposition and hyper-code.

A composition-based approach to the construction and dynamic reconfiguration of wireless sensor network applications

Wireless sensor network (WSN) applications are often characterised by close coupling between their software and hardware components, which may result in ad-hoc, platform-specific software, together with the loss of portability and evolvability. We introduce a fractal composition-based approach for constructing and dynamically reconfiguring WSN applications. The approach uses π-calculus semantics to unify the models of interaction for both software and hardware components, on both local and remote nodes. Applications are constructed by forming compositions of interacting components, and can be decomposed and reconfigured into different topologies. The advantages of the approach are that it reduces the complexity of WSN programming; results in portable and evolvable software; and allows changes to be managed during execution without having to take the system off-line. We present an outline of the approach, and illustrate it with an example specified in the Insense language.

Instances and Connectors: Issues for a Second Generation Process Language

Over the past decade a variety of process languages have been defined, used and evaluated. It is now possible to consider second generation languages based on this experience [1, 3,4]. Rather than develop a second generation wish list this position paper explores two issues: instances and connectors. Instances relate to the relationship between a process model as a description and the, possibly multiple, enacting instances which are created from it. Connectors refers to the issue of concurrency control and achieving a higher level of abstraction in how parts of a model interact. We believe that these issues are key to developing systems which can effectively support business processes, and that they have not received sufficient attention within the process modelling community. Through exploring these issues we also illustrate our approach to designing a second generation process language.1