Novel Approach to Confront Electroweak Data and Theory

A novel approach to study electroweak physics at one-loop level in generic ${\rm SU(2)_L \times U(1)_Y}$ theories is introduced. It separates the 1-loop corrections into two pieces: process specific ones from vertex and box contributions, and universal ones from contributions to the gauge boson propagators. The latter are parametrized in terms of four effective form factors $\bar{e}^2(q^2)$, $\bar{s}^2(q^2)$, $\bar{g}_Z^2(q^2)$ and $\bar{g}_W^2 (q^2)$ corresponding to the $\gamma\gamma$, $\gamma Z$, $ZZ$ and $WW$ propagators. Under the assumption that only the Standard Model contributes to the process specific corrections, the magnitudes of the four form factors are determined at $q^2=0$ and at q^2=\mmz by fitting to all available precision experiments. These values are then compared systematically with predictions of ${\rm SU(2)_L \times U(1)_Y}$ theories. In all fits \alpha_s(\mz) and \bar{\alpha}(\mmz) are treated as external parameters in order to keep the interpretation as flexible as possible. The treatment of the electroweak data is presented in detail together with the relevant theoretical formulae used to interpret the data. No deviation from the Standard Model has been identified. Ranges of the top quark and Higgs boson masses are derived as functions of \alpha_s(\mz) and \bar{\alpha}(\mmz). Also discussed are consequences of the recent precision measurement of the left-right asymmetry at SLC as well as the impact of a top quark mass and an improved $W$ mass measurement.Comment: 123 pages, LaTeX (33 figures available via anonymous ftp), KEK-TH-375, KEK preprint 93-159, KANAZAWA-94-19, DESY 94-002, YUMS 94-22, SNUTP 94-82, to be published in Z.Phys.

Implementing Fault-Tolerant Distributed Applications Using Objects and Multi-Coloured Actions

This paper develops some control structures suitable for composing fault-tolerant distributed applications using atomic actions (atomic transactions) as building blocks, and then goes on to describe how such structures may be implemented using the concept of multicoloured actions. We first identify the reasons why other control structures in addition to - by now well known - nested and concurrent atomic actions are desirable and then propose three new structures: serializing actions, glued actions and top-level independent actions. A number of examples are used to illustrate their usefulness. A novel technique, based on the concept of multi- coloured actions, is then presented as a uniform basis for implementing all of the three action structures presented here

The Design and Implementation of a Framework for Configurable Software

Software systems are typically composed of numerous components, each of which is responsible for a different function, e.g., one component may be responsible for remote communication, while another may provide a graphical user interface. Different implementations of a component may be possible, with each implementation tailored for a specific set of applications or environments. Being able to reconfigure software systems to make use of these different implementations with the minimum of effect on existing users and applications is desirable. Configurable software systems are also important for a number of other reasons: additional components or modifications to those currently available, may be required. For example, new versions of software components may be necessary due to the discovery of design flaws in a component; a RPC which provides unreliable message delivery may be suitable for an application in a local area network, but if the application is to be used in a wide area network, a different RPC implementation, which guarantees message delivery, may be necessary. Therefore, software is often required to be configurable, enabling modifications to occur with minimal effect on existing users. To allow this configurability, components should only be available through interfaces that are clearly separated from their implementations, allowing users to be isolated from any implementation changes. Objectoriented programming techniques offer a good basis upon which this separation can be provided. This paper describes a model for constructing configurable software based upon this separation, and illustrates this with a software development system we have implemented which supports these ideas in C++

The Design and Implementation of a Framework for Extensible Software, Broadcast Project Technical Report, University of Newcastle upon Tyne

Software systems are composed of numerous software components. These components could be developed as a part of the system, or provided by a separate software development environment (e.g., a library which provides a graphical user interface). However, over the lifetime of the software, additional components or modifications to those currently available, may be required. For example, new versions of software components may be necessary due to bug fixes. Therefore, software is often required to be extensible, enabling modifications to occur with minimal effect on existing users. To allow this extensibility, components should only be available through interfaces that are clearly separated from their implementations, allowing users to be isolated from any implementation changes. Object-oriented programming techniques offer a good basis upon which this separation can be provided. This paper describes a model for constructing extensible software based upon this separation, and illustrates this with a software development system we have implemented which supports these ideas in C++. This software development system has been designed so that no modifications are required to either the compiler or operating system, hence making it portable.

A Language for Specifying the Composition of Reliable Distributed Applications

Abstract: This paper describes the design of a scripting language aimed at expressing task (unit of computation) composition and inter-task dependencies of distributed applications whose execution could span arbitrary large durations. This work is motivated by the observation that an increasingly large number of distributed applications are constructed by composing them out of existing applications, and are executed in an heterogeneous environment. The resulting applications can be very complex in structure, containing many notification and dataflow dependencies between their constituent applications. The language enables applications to be structured with the properties of modularity, interoperability, dynamic reconfigurability and fault-tolerance.

A System for Specifying and Coordinating the Execution of Reliable Distributed Applications

An increasing number of distributed applications are being constructed by composing them out of existing applications. The resulting applications can be very complex in structure, containing many temporal and dataflow dependencies between their constituent applications. An additional complication is that the execution of such an application may take a long time to complete, and may contain long periods of inactivity, often due to the constituent applications requiring user interactions. In a distributed environment, it is inevitable that long running applications will require support for fault-tolerance and dynamic reconfiguration: machines may fail, services may be moved or withdrawn and application requirements may change. In such an environment it is essential that the structure of applications can be modified to reflect these changes. This paper describes the design and implementation of a coordination language and the supporting execution environment for expressing the run-time co..

A Language for Specifying the Composition of Reliable Distributed Applications

This paper describes the design of a scripting language aimed at expressing task (unit of computation) composition and inter-task dependencies of distributed applications whose execution could span arbitrary large durations. This work is motivated by the observation that an increasingly large number of distributed applications are constructed by composing them out of existing applications, and are executed in an heterogeneous environment. The resulting applications can be very complex in structure, containing many notification and dataflow dependencies between their constituent applications. The language enables applications to be structured with the properties of modularity, interoperability, dynamic reconfigurability and faulttolerance. 1. Introduction A scripting language (co-ordination language) is a very useful application building tool for specifying the composition of applications. The scripting language to be described here has been specifically designed to express task compo..