A type-level approach to component prototyping

Algebraic theories for modeling components and their interactions offer abstraction over the specifics of component states and interfaces. For example, such theories deal with forms of sequential composition of two components in a manner independent of the type of data stored in the states of the components, and independent of the number and types of methods offered by the interfaces of the combinators. General purpose programming languages do not offer this level of abstraction, which implies that a gap must be bridged when turning component models into implementations. In this paper, we present an approach to prototyping of component-based systems that employs so-called type-level programming (or compile-time computation) to bridge the gap between abstract component models and their type-safe implementation in a functional programming language. We demonstrate our approach using Barbosa’s model of components as generalized Mealy machines. For this model, we develop a combinator library in Haskell, which uses typelevel programming with two effects. Firstly, wiring between components is computed during compilation. Secondly, the well-formedness of the component compositions is guarded byHaskell’s strong type system.Fundação para a Ciência e a Tecnologia, Portugal, under grant number SFRH/BD/30231/2006

A Service-Based Component Model: Formalism, Analysis and Mechanization

Component-Based Software Engineering (CBSE) is one of the approaches to master the development of large scale software. In this setting, the verification concern is still a challenge. The objective of our work is to provide the designer of components-based systems with the methods to assist his/her use of the components. In particular, the current work adresses the composability of components and their services. A component model is presented, based on services. An associated simple but expressive formalism is introduced; it describes the services as extended LTS and their structuring as components. The composition of components is mainly based on service composition and encapsulation. The composability of component is defined from the composability of services. To ensure the correctness of component composition, we check that an assembly is possible via the checking of the composabiblity of the linked services, and their behavioral compatibility. In order to mechanize our approach, the services and the components are translated into the MEC and LOTOS formalism. Finally the MEC and LOTOS CADP toolbox is used to perform experiments

Automating reuse support in a small company

Software engineering has been facing a crisis for several years now - there is more demand for new software than there is ability to supply. Software reuse is a potential way to tackle the problems caused by the software crisis with its promises of increased productivity and cheaper development costs. Several software reuse successes have been reported, but these have been predominantly in large, well structured companies. However, there are numerous smaller companies that could also benefit from reuse if it were made available to them. This thesis addresses these issues by implementing a reuse programme in a small company. An incremental approach to reuse introduction is adopted, following the Seven Steps to Success, and 'lightweight' processes are recommended to support the reuse programme. A prototype tool set, ReThree- C++, was developed to automate support for the reuse programme. The results of the case study are presented. The reuse programme was successful, with benefits to the company including both increased speed of production and financial gains from selling reusable components. The challenges faced are also identified. Details of the tool set giving automated support for reuse are also presented. The tool set is an approach to reuse repository control which also integrates information abstraction from C++ source code to generate class hierarchy charts and software documentation automatically. It helps developers store, retrieve, understand and use reusable components. The usefulness of the tool set is shown with an experiment and as part of the case study. The purpose of the thesis is to show that small companies can implement reuse, and that the method presented supports the introduction of a reuse programme. It concludes that although challenges were faced, great benefits can be gained by using the method with automated support for reuse in a small company

An Investigation Into the Mechanisms That Allow CORBA to Preserve Strong Typing

The Common Object Request Broker Architecture (CORBA) is a middleware specification. It aims at transparently extending programming languages to enable access to objects that are situated in different address spaces. Extending strongly typed languages raises the question whether the extension happens in a type-safe way. Claims are commonly made in the popular literature that this is indeed the case. However, this is not immediately clear from the specification. This thesis is an investigation into the different mechanisms that CORBA specifies to support remote operation invocations and a discussion of whether these mechanisms preserve type-safety for cross-boundary operation invocations. Successively, the object model, the type system, the architecture and the development process are reviewed. This is followed by a detailed investigation into the communications protocol used by CORBA, the server-side request dispatching mechanism and client-side operation invocation mechanisms. Conclusions drawn from these investigations are used to discuss type equivalence and the issues around interface evolution

A specification method for the scalable self-governance of complex autonomic systems

IBM, amongst many others, have sought to endow computer systems with selfmanagement capabilities by delegating vital functions to the software itself and proposed the Autonomic Computing model. Hence inducing the so-called self-* properties including the system's ability to be self-configuring, self-optimising, self-healing and self-protecting. Initial attempts to realise such a vision have so far mostly relied on a passive adaptation whereby Design by Contract and Event-Condition-Action (ECA) type constructs are used to regulate the target systems behaviour: When a specific event makes a certain condition true then an action is triggered which executes either within the system or on its environment Whilst, such a model works well for closed systems, its effectiveness and applicability of approach diminishes as the size and complexity of the managed system increases, necessitating frequent updates to the ECA rule set to cater for new and/or unforeseen systems' behaviour. More recent research works are now adopting the parametric adaptation model, where the events, conditions and actions may be adjusted at runtime in response to the system's observed state. Such an improved control model works well up to a point, but for large scale systems of systems, with very many component interactions, the predictability and traceability of the regulation and its impact on the whole system is intractable. The selforganising systems theory, however, offers a scaleable alternative to systems control utilising emerging behaviour, observed at a global level, resulting from the low-level interactions of the distributed components. Whereby, for instance, key signals (signs) for ECA style feedback control need no longer be recognised or understood in the context of the design time system but are defined by their relevance to the runtime system. Nonetheless this model still suffers from a usually inaccessible control model with no intrinsic meaning assigned to data extraction from the systems operation. In other words, there is no grounded definition of particular observable events occurring in the system. This condition is termed the Signal Grounding Problem. This problem cannot usually be solved by analytical or algorithmic methods, as these solutions generally require precise problem formulations and a static operating domain. Rather cognitive techniques will be needed that perform effectively to evaluate and improve performance in the presence of complex, incomplete, dynamic and evolving environments. In order to develop a specification method for scalable self-governance of autonomic systems of systems, this thesis presents a number of ways to alleviate, or circumvent, the Signal Grounding Problem through the utilisation of cognitive systems and the properties of complex systems. After reviewing the specification methods available for governance models, the Situation Calculus dialect of first order logic is described with the necessary modalities for the specification of deliberative monitoring in partially observable environments with stochastic actions. This permits a specification method that allows the depiction of system guards and norms, under central control, as well as the deliberative functions required for decentralised components to present techniques around the Signal Grounding problem, engineer emergence and generally utilise the properties of large complex systems for their own self-governance. It is shown how these large-scale behaviours may be implemented and the properties assessed and utilised by an Observer System through fully functioning implementations and simulations. The work concludes with two case studies showing how the specification would be achieved in practice: An observer based meta-system for a decision support system in medicine is described, specified and implemented up to parametric adaptation and a NASA project is described with a specification given for the interactions and cooperative behaviour that leads to scale-free connectivity, which the observer system may then utilise for a previously described efficient monitoring strategy

Betsy - A BPEL Engine Test System

More than five years have passed since the final release of the long-desired OASIS standard of a process language for web service orchestration, the Web Services Business Process Execution Language (BPEL). The aim of this standard is to establish a universally accepted orchestration language that forms a core part of current service-oriented architectures and, because of standardisation, avoids vendor lock-in. High expectations, in academia and practice alike, have been set on it. By now, several fully conformant and highly scalable engines should have arrived in the market. The perception of many however, is that standard conformance in current engines is far from given. It is our aim to shed light on this situation. In this study, we present the tool betsy, a BPEL Engine Test System that allows for a fully-automatic assessment of the standard conformance of a given BPEL engine. We use it to examine the five most important open source BPEL engines available today. Betsy comes with a large set of engineindependent conformance test cases for assessing BPEL standard conformance. This enables us to give a view of the state of the art in BPEL support

A Generic Feedback Mechanism for Component-Based Systems

Computers have been integrated into all spheres and occupations and the need for users to easily understand how to use each computer application has become paramount. The end-user should not be expected to decipher cryptic messages or to understand the inner functioning of the computer itself. With computer-users spanning all walks of life, there is a need for a change in the mind-set of software developers in making their product more user-friendly. In addition, software systems of the future will increasingly be built from independent encapsulated software components and will often be distributed over various sites. This new paradigm brings a new realm of complexity for the end-user, especially with respect to the increased possibility of failure, so that in addition to the nontrivial task of interpreting the general functioning of an application, the user will be expected to deal with the results of perplexing errors too. The nature of component- based systems makes the provision of support for handling errors far more difficult due to the independent and diffuse nature of the creators of the individual parts making up these systems. Other factors with respect to application use also need to be addressed. For example, it is a rare user who is able to spend 100% of his or her time concentrating on interaction with the computer, without distractions of some sort interrupting. It is even rarer to find an application which is not prone to occasionally unintelligible error messages or breakdowns. Few applications are designed with these realities in mind and when problems do occur, or users are interrupted, they often find it difficult to recover and to resume their primary task. It is also difficult for applications to tailor the provided feedback according to the specific needs of different end-users or the differing roles within which they function. This dissertation will highlight the role of feedback in increasing the interpretability of an application and in alleviating the effects of interruptions, errors and breakdowns. Rather than expecting feedback to be provided by programmers, this dissertation will argue that feedback can be enhanced in a distributed component-based system by separating the feedback concern from the basic functional concern of the application and executing the application within a generic feedback enhancing framework. The feedback concept is examined in depth and the role of feedback in enhancing understanding of applications, and in alleviating the effects of disturbances in our working day, is explored. The concept of a generic framework for enhancing feedback has been developed and a prototype implemented. The design and implementation of this prototype are described, as is the evaluation of the feedback thus produced

Grounding Synchronous Deterministic Concurrency in Sequential Programming

In this report, we introduce an abstract interval domain I(D; P) and associated fixed point semantics for reasoning about concurrent and sequential variable accesses within a synchronous cycle-based model of computation. The interval domain captures must (lower bound) and cannot (upper bound) information to approximate the synchronisation status of variables consisting of a value status D and an init status P. We use this domain for a new behavioural definition of Berry’s causality analysis for Esterel. This gives a compact and uniform understanding of Esterel-style constructiveness for shared-memory multi-threaded programs. Using this new domain-theoretic characterisation we show that Berry’s constructive semantics is a conservative approximation of the recently proposed sequentially constructive (SC) model of computation. We prove that every Berry-constructive program is sequentially constructive, i.e., deterministic and deadlock-free under sequentially admissible scheduling. This gives, for the first time, a natural interpretation of Berry-constructiveness for main-stream imperative programming in terms of scheduling, where previous results were cast in terms of synchronous circuits. It also opens the door to a direct mapping of Esterel’s signal mechanism into boolean variables that can be set and reset arbitrarily within a tick. We illustrate the practical usefulness of this mapping by discussing how signal reincarnation is handled efficiently by this transformation, which is of complexity that is linear in progra