Vasu S. Alagar

Automated generation of test suites from formal specifications of real-time reactive systems

Real-time reactive systems are among the most difficult systems to test because of their size and complex time-dependent functionality. The number of test experiments for such systems is very large, if not infinite. Often such systems arise in safety-critical contexts. Hence, such systems require a rigorous analysis and thorough testing before they are deployed. This paper addresses test case generation methods and a metric-based test case selection algorithm for sufficient testing of real-time reactive systems. The methods are rigorous, and based on the formal specifications of the system and its fault models. The test generation and execution of algorithms are implemented in TROMLAB, a formal framework for developing real-time reactive systems. The methods are applied to the formal specification of the Train-Gate-Controller (TGC) example, a bench-mark case study in the real-time systems community. A brief description of the experimental results obtained on the case study is given.

TADL - An Architecture Description Language for Trustworthy Component-Based Systems

Existing architecture description languages mainly support the specification of the structural elements of the system under design with either only a limited support or no support to specify non-functional requirements. In a component-based development of trustworthy systems, the trustworthiness properties must be specified at the architectural level. Analysis techniques should be available to verify the trustworthiness properties early at design time. Towards this goal we present in this paper a meta-architecture and TADL, a new architecture description language suited for describing the architecture of trustworthy component-based systems. The TADL is a uniform language for specifying the structural, functional, and nonfunctional requirements of component-based systems. It also provides a uniform source for analyzing the different trustworthiness properties.

An architecture for developing context-aware systems

This paper proposes a component-based architecture and development methodology for context-aware systems. A context is formally defined from relational point of view. The architecture of a context-aware system is conceived as a composition of the two components context constructor and context adapter. To process dynamically changing contextual information, we introduce context calculus as the formal basis of context manipulation. The information and its sources are abstracted within this formal definition. As an illustration of the principles involved in developing a context-aware system, we discuss the Anti-lock Braking System problem.

An Intensional Functional Model of Trust

Computers have been in use for many years to build high confidence systems in safety-critical domains such as aircraft control, space transportation and exploration, and nuclear power plant management. However, due to the recent rush in developing ubiquitous and pervasive computing applications and a demand from across the world to access information from shared sources, the mosaic of computing ecosystem has undergone a radical change. It is in this context that computing has to be made trustworthy. To build and manage a trustworthy system it is necessary to blend and harmonize socially acceptable and technically feasible norms of trust. This in turn requires a generic formal model in which trust categories can be specified, trusted communication can be enabled, and trustworthy transactions can be specified and reasoned about. In this paper we introduce a formal intensional model of trust and suggest how it can be integrated into a trust management system.

Intensional programming for agent communication

This article investigates the intensional programming paradigm for agent communication by introducing context as a first class object in the intensional programming language Lucid. For the language thus extended, a calculus of contexts and a logic of contexts are provided. The paper gives definitions, syntax, and operators for context, and introduces an operational semantics for evaluating expressions in extended Lucid. It is shown that the extended Lucid language, called Agent Intensional Programming Language(AIPL), has the generality and the expressiveness for being an Agent Communication Language(ACL).

Real time reactive programming in lucid enriched with contexts

We present a synchronous approach to real-time reactive programming in Lucid enriched with contexts as first class objects. The declarative intensional approach allows real-time reactive programs to manipulate both events and state-based representations of complex systems. We show the formal specification of the Train-Gate-Controller problem, a standard case study in real-time systems community, and formally verify the safety property.

A Context-Aware Trust Model for Service-Oriented Multi-Agent Systems

Service-oriented systems offer the potential for minimizing the development time of business applications within an enterprise while promoting collaborative joint ventures among enterprisers distributed geographically. Service-oriented applications assembled from services obtained from different vendors, sometimes anonymous, should be trustworthy. In this paper we investigate context-aware multi-agent systems (MAS) which can dynamically form coalitions of trusted partners as an effective mechanism to act on behalf of service requestors, find services requested by them, determine trusted services, and provide services to the requestors without violating the privacy of the partners involved in such transactions. The MAS is open with respect to external agents requesting and receiving services, but closed with respect to other activities initiated by external agents. The agents in MAS may have different trust models. We explain how trust models of different agents should be composed into a web of trust for trusted transactions in MAS.

Security Contexts in Autonomic Systems

Autonomic computing systems (ACS) are expected to achieve the same level of self-regulation and pervasiveness as human autonomic systems. Because of the features of ACS, the traditional security model can not be applied to ACS any more. The goal of our research is to develop a context-based security model and architecture for ACS. Our focus is on self-protection feature of ACS. The self-protection feature is enforced through security contexts that we define. By taking security contexts into account, security policies can dynamic change in order to cope with new environment

An intensional programming approach to multi-agent coordination in a distributed network of agents

We explore the suitability of Intensional Programming Paradigm for providing a programming model for coordinated problem solving in a multi-agent system. We extend our previous work on Lucx, an Intensional Programming Language extended with context as first class object, to support coordination activities in a distributed network of agents. We study coordination constructs which can be applied to sequential programs and distributed transactions. We give formal syntax and semantics for coordination constructs. The semantics for transaction expressions is given on top of the existing operational semantics in Lucx. The extended Lucx can be used for Internet-based agent applications.

A Context-Based Analysis of Intrusion Detection for Policy Violation

Existing intrusion detection systems (IDS) operate inde- pendently from security policy enforcement mechanism. In current IDS the functionality has been restricted to detect- ing only anomaly in system behavior and system misuse. In order to assist system administrators in restoring and strengthening system security after an intrusion is detected this paper proposes a method that will link the security vi- olation to a non-empty subset of the policy base. A multi- agent system is proposed to automate the intrusion detec- tion and analysis. Keywords: Intrusion detection, security context, policy base