To take advantage of the various high performance computer (HPC) architectures for multithreaded and distributed computing, this paper parallelizes the dynamic programming algorithm for multiple sequence alignment (MSA). A novel definition of a hyper-diagonal through a tensor space is used to reduce the search space. Experiments demonstrate that scoring less than 1% of the search space produces the same optimal results as scoring the full search space. The alignment scores are often better than other heuristic methods and are capable of aligning more divergent sequences.

We present a software development approach that aligns a requirements elicitation technique with a formal method of software specification abstraction. The goal/strategy modeling technique Map augmented with Jackson's context diagrams (representing environment) is used to elicit requirements and the B-method is used to translate Map requirements into formal specifications. Comprehensive tool support allows the B-method to refine and implement the specification correctly. Our approach brings improvement to an approach that uses generic requirements for rigorous software development. The resulting specification model bridges the gap between software requirements and formal specifications and supports automatic refinement of strategic requirements into software code. To illustrate how our approach bridges this gap, we discuss the Point of Sale (PoS) requirements model of Seven Eleven Japan (SEJ).

Representation exposure is a well-known problem in the object-oriented realm. Object encapsulation mechanisms have established a tradition for solving this problem based on a principle of reference containment. This paper proposes a novel type system which is based on a different principle, we call effect encapsulation, which confines side effects, rather than object references, according to an ownership structure. Compared to object encapsulation, effect encapsulation liberates us from the restriction on object referenceability and offers more flexibility. In this paper, we show that effect encapsulation can be statically type checked.

The specification of constraint languages for access control models has proven to be difficult but remains necessary for safety and for mandatory access control policies. While the authorisation relation $(Subject \times Object \rightarrow \pow Right)$ defines the authorised permissions an authorisation schema defines how the various concepts (such as subjects, users, roles, labels) are combined to form a complete access control model.

Designing concurrent object-oriented programs is hard. Correct programs must coordinate multiple threads accessing composite objects, using low-level mechanisms such as locks and read-write sets. Efficient programs must balance the complexity and overhead of the coordination mechanisms against the increased performance possible through concurrency. A method-level algebra of exclusion provides a succinct description of the conditions under which a thread must be excluded from a component of a composite object. Using the algebra, programmers can check whether their programs meet their exclusion requirements, can eliminate redundant exclusion controls, and can remove synchronisation overhead by reducing concurrency.

Object-oriented programming languages allow inter-object aliasing. Although necessary to construct linked data structures and networks of interacting objects, aliasing is problematic in that an aggregate object's state can change via an alias to one of its components, without the aggregate being aware of any aliasing.Ownership types form a static type system that indicates object ownership. This provides a flexible mechanism to limit the visibility of object references and restrict access paths to objects, thus controlling a system's dynamic topology. The type system is shown to be sound, and the specific aliasing properties that a system's object graph satisfies are formulated and proven invariant for well-typed programs.

A common problem in distributed systems is the selection of a particular service instance from a set of possible services. In this paper, we identify the kinds of information required to select services within enterprise distributed systems and present a flexible mechanism for selecting services. This mechanism enables clients to build complex queries that are able to utilise script-based interaction with service instances. The use of scripts allows the selection of particular services based on their internal state and permits services to tailor their responses based on the particular client.

Current general purpose operating systems are unable to support a new class of applications that have the same requirements as conventional applications but with additional real-time constraints. We introduce a new real-time process abstraction to model such applications. We show how an operating system can support these processes by having an admission policy to ensure that all of the processes' timing requirements can be met, by monitoring the behavior of the processes to ensure that one process cannot interfere with another by exceeding its allocated resources, and by scheduling the processes to meet their requirements. We also introduce a model for managing processes that overrun. Many of the issues involved in the design and implementation of these components are discussed in this paper.

Software engineering is particularly concerned with the construction of large systems. Existing software engineering tools tend to be adequate for medium-sized systems, but not as useful for large and very large systems. This paper presents a model viewing system as the basis for graph-based CASE tools which overcomes this lack of scalability. With existing commercial tools the number of user steps to browse or edit a model increases with the size of the model. With the approach of this paper, the number of steps remains constant regardless of the model size. In fact, only one step is required for operations such as adding a flow between two processes anywhere in the model, or moving a submodel to a new parent. This paper outlines the approach with a structured analysis example, provides a formal description of the model viewing system, and discusses some limitations.

Software engineering is particularly concerned with the construction of large systems. Existing software engineering tools tend to be adequate for medium size systems, but not as useful for large and very large systems. This paper presents a model viewing system as the basis for graph based CASE tools which overcomes this lack of scalability. With existing commercial tools the number of user steps to browse or edit a model increases with the size of the model. With the approach of this paper the number of steps remains constant regardless of the model size. In fact, only one step is required for operations such as adding a flow between two processes anywhere in the model, or moving a submodel to a new parent. This paper outlines the approach with a structured analysis example, provides a formal description of the model viewing system, and discusses some limitations.>