Charles B. Weinstock

Durra: a structure description language for developing distributed applications

Durra is a language and runtime support system for developing distributed applications. In this paper, we describe the general nature of these applications, and the need for separating structural and behavioural details. A Durra user describes an application as a set of components (application tasks and communication channels), a set of alternative configurations showing how these components are connected at runtime, and a set of conditional configuration transitions that take place at runtime. We illustrate these features through examples drawn from the fault tolerance domain. We conclude with an illustration of the use of Durra in an incremental software development scenario.

Programming at the processor-memory-switch level

Users of networks of heterogeneous processors are concerned with allocating specialized resources to tasks of medium to large size. They need to create processes, which are instances of tasks, allocate these processes to processors, and specify the communication patterns between processes. These activities constitute processor-memory-switch (PMS)-level programming. The authors describe the use of PMS-level programming in computation-intensive, real-time applications, e.g. vision, robotics, and vehicular control, that require efficient concurrent execution of multiple tasks, e.g. sensor data collection, obstacle recognition, and global path planning, devoted to specific pieces of the application. They discuss the programming of heterogeneous machines and present the Durra language and tools, which they are developing to support PMS-level programming.<<ETX>>

An efficient algorithm for heap storage allocation

There is an old maxim that only 10% of the code is responsible for 90% of a programs execution time . This was driven home to the authors during the development of the Bliss-11 compiler [1] . Early versions o f the compiler were very slow, and timing data showed that heap allocation was the culprit . Replacing the original allocator with the one described below improved performance by nearly an order of magnitude .

Application-level programming

The use of a declarative language, called Dura, designed to support application-level programming is illustrated by distributed avionics system. The authors show how the language is used to describe the application, its components and structure; how the run-time executive provides support for fault-tolerance by reconfiguration of the application; and how an interactive interface to the executive supports debugging and monitoring of the application.<<ETX>>

Measuring assurance case confidence using Baconian probabilities

The basis for assessing the validity of an assurance case is an active area of study. In this paper, we discuss how to assess confidence in a case by considering the doubts eliminated by the claims and evidence in a case. This is an application of eliminative induction and the notion of Baconian probability as put forward by L. Jonathan Cohen.

Eliminative induction: a basis for arguing system confidence

Assurance cases provide a structured method of explaining why a system has some desired property, e.g., that the system is safe. But there is no agreed approach for explaining what degree of confidence one should have in the conclusions of such a case. In this paper, we use the principle of eliminative induction to provide a justified basis for assessing how much confidence one should have in an assurance case argument.

Building distributed Ada applications from specifications and functional components

Abstract : Durra is a language and support environment for the specification and execution of distributed Ada applications. A Durra programmer describes an application as a collection of processes and data links. More complicated application descriptions may also include a structuring of this collection that varies dynamically according to a set of reconsideration conditions. Each process defined in the application description is associated with an independently complied Ada subprogram that implements the behavior of that process. The Durra programmer specifies the distribution of application components by assigning them to virtual nodes called clusters. For each cluster, the Durra compiler generates a multithreaded Ada program that imports the code for the processes assigned to that node and manages their execution. Durra also facilitates rapid prototyping through the use of tools that interpret timing specifications associated with processes and generates Ada code to simulate their expected behavior.

Assurance Cases for Security: The Metrics Challenge

For critical systems it is important to know whether the system is trustworthy and to be able to communicate, review and debate the level of trust achieved. In the safety domain, explicit Safety Cases are increasingly required by law, regulations and standards. Yet the need to understand risks is not just a safety issue and the type of argumentation used for safety cases is not specific to safety alone. Prior workshops, beginning with one held at DSN 2004, have identified a number of technical, policy and research challenges. The focus of this workshop is on one of these challenges: metrics for assurance cases for security.