On the Power of Name-Passing Communication

It is shown that generally higher order process calculi cannot be interpreted in name-passing calculi in a robust way

Formal Models for Concurrent Communicating Systems

This report was originally written to fulfill in part the requirements of the author\u27s WPE examinations, part of the qualifying examinations for the University of Pennsylvania\u27a Computer Science Ph.D program. The report first introduces CCS and uses it to illustrate various features of established methods of modelling concurrent, communicating systems. The report then goes on to describe and investigate two new models for such systems: The Chemical Abstract Machine, a simple yet predominant in most models for such systems; and the π-calculus, a calculus similar in many respects to CCS, but able to model mobile processes and other, more difficult phenomena

Modal Logics for Nominal Transition Systems

We define a uniform semantic substrate for a wide variety of process calculi where states and action labels can be from arbitrary nominal sets. A Hennessy-Milner logic for these systems is introduced, and proved adequate for bisimulation equivalence. A main novelty is the use of finitely supported infinite conjunctions. We show how to treat different bisimulation variants such as early, late and open in a systematic way, and make substantial comparisons with related work. The main definitions and theorems have been formalized in Nominal Isabelle

Measuring concurrency in CCS

A research report submitted to the Faculty of Science, University of the Witwatersrand, Johannesburg, in partial fulfilment of the requirements for the degree of Master of ScienceThis research report investigates the application of Charron-Bost's measure of currency m to Milner's Calculus of Communicating Systems (CCS). The aim of this is twofold: first to evaluate the measure m in terms of criteria gathered from the literature: and second to determine the feasiblllty of measuring concurrency in CCS and hence provide a new tool for understanding concurrency using CCS. The approach taken is to identify the differences hetween the message-passing formalism in which the measure m is defined, and CCS and to modify this formalism to-enable the mapping of CCS agents to it. A software tool, the Concurrency Measurement Tool, is developed to permit experimentation with chosen CCS agents. These experiments show that the measure m, although intuitively appealing, is defined by an algebraic expression that is ill-behaved. A new measure is defined and it is shown that it matches the evaluation criteria better than m, although it is still not ideal. This work demonstrates that it is feasible to measure concurrency in CCS and that a methodology has been developed for evaluating concurrency measures.Andrew Chakane 201

Design and Validation of a Context-Aware Publish-Subscribe Model

A system is said to be context-aware if it can extract, interpret and use contextual information to adapt its functionality and enhance its utility. Context awareness allows the application to gain sensitivity for many environmental parameters that are beyond the reach of conventional systems. Human factors related to context include information about the user (knowledge of habits, emotional state), the user’s social environment (co-location of others, social interaction, group dynamics), and the user’s tasks (spontaneous activity, engaged tasks, general goals). With access to this contextual information, there are many exciting possibilities for applications involving direct human interaction. Software modelling is one of the first steps in the life cycle of a software system. Software models can lead to the discovery of errors in a system, which is useful as the early discovery of such flaws can enable the designers to update the inexpensive system model. By not using system models before the development of the full scale system, we risk the discovery of major problems later on in the life cycle, which will be more expensive to fix. Validation of any software system is an essential part of the development life cycle. The validation of context-aware systems is especially challenging as the input range of the system is loosely defined. But despite this it is very important to validate context-aware systems thoroughly because it is possible that a subset of possible inputs to the system can be part of a failure-critical user interaction. Modeling and validation are important activities in the development or enhancement of all software systems. While software modelling helps check the properties of the systems before actual development, software validation is essential for ensuring the quality of the software based on the original software requirements. This thesis focuses on the modeling and the validation of formal case study design models for context-aware systems based on the event based and publish-subscribe pattern. The study validates formal case study design models against relevant properties using a model checker

A Framework for Software Component Interface Specification and Analysis

Although markets are emerging for commercial off-the-shelf components (such as Sun JavaBeans), there are many barriers to widespread component adoption. This is due to the inherent `black-box' nature of software components: developers have no knowledge or control of the component's internal characteristics. Without source or design details, developers only have the component's interface, documentation and test results to answer important questions about reliability, proper use, behavior andperformance. The current best practice of specifying a component's capabilities by providing only the syntax and informal documentation is insufficient to assemble mission or safety-critical systems successfully. To address these problems we have developed a framework forcreating and analyzing the concise specifications of components and their related interfaces. The framework extends a formal model for software architecture descriptions to support the specification of a range of terms. With formal component specifications developers can use the framework to analyze the properties of individual components or of entire systems. Unlike other approaches, the formal basis and implementation of our framework enhance understanding and automates much of thecomponent analysis process