Brian Warboys

ArchWare: Architecting evolvable software

This paper gives an overview of the ArchWare European Project. The broad scope of ArchWare is to respond to the ever-present demand for software systems that are capable of accommodating change over their lifetime, and therefore are evolvable. In order to achieve this goal, ArchWare develops an integrated set of architecture-centric languages and tools for the model-driven engineering of evolvable software systems based on a persistent run-time framework. The ArchWare Integrated Development Environment comprises: (a) innovative formal architecture description, analysis, and refinement languages for describing the architecture of evolvable software systems, verifying their properties and expressing their refinements; (b) tools to support architecture description, analysis, and refinement as well as code generation; (c) enactable processes for supporting model-driven software engineering; (d) a persistent run-time framework including a virtual machine for process enactment. It has been developed using ArchWare itself and is available as Open Source Software.

Elements of a business process management system: theory and practice

Purpose – To construct, test and illustrate a sophisticated and theory-based architecture for analyzing business process management systems (BPMS) used for business process change. Design/methodology/approach – Exploration of business process modeling-based BPMS via a meta-survey of academic and business literatures. Two main dimensions are used based upon semiotics and a block-based BPMS pyramid architecture. Each block is a core technology required for the functioning of the BPMS and include: the subject being modeled; the software formalism; the IT infrastructure; the modeling language and notation; and the underlying technical infrastructure. Findings – Theoretically explains and empirically illustrates each core technology in the proposed architecture then does the same for the architecture, its arrangement as a whole and its interrelationships. Recognizes the lack of a theoretical basis for business process modeling constructs and the dangers that this generates. Explains why automatic BPMS require formal construct transmission from subject modeled to modeling hardware and software. Research limitations/implications – The architecture’s core technologies span numerous disciplines so each set of literatures introduces the component concepts and their bases but is not exhaustive. Originality/value – This paper proposes a considerably more sophisticated framework for BPMS analysis than is currently available; it is theoretically and not just empirically based; it uses a novel method of theoretical justification concerned with the transmission of modeled properties and characteristics between several technological media; and it illustrates the innovative analytical use of this architecture and the practical use of BPMS with three different case vignettes.

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.

On the use of agents in a BioInformatics grid

My Grid is an e-Science Grid project that aims to help biologists and bioinformaticians to perform workflow-based in silico experiments, and help them to automate the management of such workflows through personalisation, notification of change and publication of experiments. In this paper, we describe the architecture of my Grid and how it will be used by the scientist. We then show how my Grid can benefit from agents technologies. We have identified three key uses of agent technologies in my Grid: user agents, able to customize and personalise data, agent communication languages offering a generic and portable communication medium, and negotiation allowing multiple distributed entities to reach service level agreements.

On the architecture and form of flexible process support

The ability of businesses to develop is frequently hampered by difficulties in changing underlying software systems. An example is the need to change when business partnerships are formed, or dissolved. This article is concerned with the architecture of business process support systems in the context of change, and particularly with the need for such systems to facilitate software change. The viable system model (VSM) is a cybernetic model of organisations that change. It provides an inclusive architecture in which both operational and development components are described within an organisation. This article illustrates, through a business supply chain example, the use of the VSM as an architecture for flexible process support systems. This architecture is systemic and inclusive: it incorporates the ongoing development of both the business and its underlying software. Copyright � 2006 John Wiley & Sons, Ltd.

Cooperating evolving components: a rigorous approach to evolving large software systems

Large software systems have a large number of components and are developed over a long time period frequently by a large number of people. We describe a framework approach to evolving such systems based on an integration of product and process modelling. The evolving system is represented as a Product Tower, a hierarchy of components which provides views of the product at multiple levels of refinement. The evolution process is component based with the cooperation between components being mediated by the Product Tower. This ensures that the evolution process is scaleable and that it maintains, and evolves, the design model. We illustrate our approach with an example, outlining an evolution both of the product and of the process. The reflexive facilities of the process are shown to be key in ensuring the frameworks ability to evolve.

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.

Architecture-driven software engineering: specifying, generating, and evolving component-based software systems

The paper outlines the /spl pi/-SPACE architecture description language and its approach to architecture based software system synthesis and evolution. It addresses support for the composition of architectural elements, architecture evolution and the incremental synthesis of process models using the ProcessWeb process modelling language (PML). The full /spl pi/-SPACE machine aims to support the dynamic evolution of software systems through the regeneration of components according to changes in the process architecture in which they operate. Thus, generated components remain compliant as their framework architecture evolves. The /spl pi/-SPACE architecture-driven approach for software engineering is presented through a case study.

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.

Facilitating Technology Transfer through Partnership

The worldsfirst computer designed and used primarily as a business computer was built by a British food manufacturing and catering company at the beginning of the 1950s. The paper tells the story of how the decisions to make a computer were taken and sets out an analysis of the characteristics of the enterprise which made such an action not as surprising as it may seem at first glance.