F.S. de Boer

A timed concurrent constraint language

Abstract We study a timed concurrent constraint language, called tccp , which is obtained by a natural timed interpretation of the usual ccp constructs: action-prefixing is interpreted as the next-time operator and the parallel execution of agents follows the scheduling policy of maximal parallelism. Additionally, tccp includes a simple primitive which allows one to specify timing constraints. We define the operational semantics of tccp by means of a transition system and we define a denotational model which is fully abstract with respect to the usual notion of observables (that is, the results of terminating computations). Moreover, we study the semantics and expressive power of the notion of maximal parallelism underlying the computational model of tccp : We define a fully abstract semantics for a sublanguage of tccp , called ccpm , which essentially is concurrent constraint programming, provided that we interpret the parallel operator in terms of maximal parallelism rather than of interleaving. We show that tccp is strictly more expressive than ccpm which, in its turn, is strictly more expressive than ccp .

Towards a language for coherent enterprise architecture descriptions

A coherent description of architectures provides insight, enables communication among different stakeholders and guides complicated (business and ICT) change processes. Unfortunately, so far no architecture description language exists that fully enables integrated enterprise modeling. In this paper we focus on the requirements and design of such a language. This language defines generic, organization-independent concepts that can be specialized or composed to obtain more specific concepts to be used within a particular organisation. It is not our intention to re-invent the wheel for each architectural domain: wherever possible we conform to existing languages or standards such as UML. We complement them with missing concepts, focusing on concepts to model the relationships among architectural domains. The concepts should also make it possible to define links between models in other languages. The relationship between architecture descriptions at the business layer and at the application layer (business-IT alignment) plays a central role.

A verification framework for agent programming with declarative goals

Abstract A long and lasting problem in agent research has been to close the gap between agent logics and agent programming frameworks. The main reason for this problem of establishing a link between agent logics and agent programming frameworks is identified and explained by the fact that agent programming frameworks have hardly incorporated the concept of a declarative goal. Instead, such frameworks have focused mainly on plans or goals-to-do instead of the end goals to be realised which are also called goals-to-be. In this paper, the programming language GOAL is introduced which incorporates such declarative goals. The notion of a commitment strategy—one of the main theoretical insights due to agent logics, which explains the relation between beliefs and goals—is used to construct a computational semantics for GOAL. Finally, a proof theory for proving properties of GOAL agents is introduced. Thus, the main contribution of this paper, rather than the language GOAL itself, is that we offer a complete theory of agent programming in the sense that our theory provides both for a programming framework and a programming logic for such agents. An example program is proven correct by using this programming logic.

Models and temporal logics for timed component connectors

The coordination language Reo supports compositional system construction through connectors with real-time properties that exogenously coordinate the interactions among the constituent components into a coherent collaboration. In this paper, we present an operational semantics for the channel-based component connectors of Reo in terms of Timed Constraint Automata and introduce a temporal-logic for specification and verification of their real-time properties.

Computer-aided specification and verification of annotated object-oriented programs

The main contribution of this paper consists of a description of a front-end tool which supports the computer-aided specification and verification of a class of flowcharts which capture the basic dynamics of object-oriented programs. The specific emphasis of our approach is on the automated verification of flowcharts annotated with assertions which allow one to specify properties directly in terms of the source code itself instead of some particular model of its semantics.

On programming KARO agents

After having defined the KARO logic for specifying intelligent agents (an amalgam of various modal logics to reason about both informational and motivational attitudes of agents) in earlier work we now turn to the question how to realise agents specified in the KARO framework. To this end we look at agent programming languages that we have defined, and investigate how programs in these languages can be linked to the KARO logic.

MoCha: a middleware based on mobile channels

MoCha is a middleware for distributed communication and collaboration using mobile channels as its medium. Channels allow directed, anonymous, and peer-to-peer communication among entities, while mobility ensures that the structure of their connections can change over time in arbitrary ways. MoCha provides communication mechanisms without requiring central servers or fixed network infrastructures, and it allows exogenous coordination between processes. In this paper we briefly introduce MoCha and discuss the implementation of an important channel type: the asynchronous FIFO mobile channel.

Extended Rebeca: a component-based actor language with synchronous message passing

In this paper, we propose extended Rebeca as a tool-supported actor-based language for modeling and verifying concurrent and distributed systems. We enrich Rebeca with a formal concept of components which integrates the message-driven computational model of actor-based languages with synchronous message passing. Components are used to encapsulate a set of internal active objects which react asynchronously to messages by means of methods and which additionally interact via a synchronous message passing mechanism. Components themselves interact only via asynchronous and anonymous messages. We present our compositional verification approach and abstraction techniques, and the theory corresponding to it, based on the formal semantics of Rebeca. These techniques are exploited to overcome the state explosion problem in model checking.

A logical viewpoint on architectures

We introduce a logical viewpoint on architectures. The logical viewpoint is based on the distinction between symbolic and semantic models of architectures. The core of a symbolic model consists of its signature that specifies symbolically its structural elements and their relationships. A semantic model is defined as a formal interpretation of the symbolic model. This leads to more precise characterization of the concepts introduced in IEEE standard 1471-2000, and provides a formal approach to the design of enterprise of architectural description languages and a general mathematical foundation for the use of formal methods in enterprise architectures. Additionally, we show how this logical viewpoint allows for the definition of a simple general XML language for the description of both static and dynamic aspects of an architecture. For the meta-analysis of both these aspects we introduce a new XML tool for general XML transformations based on a rule markup language.

Information-passing and belief-revision in multi-agent systems

We define a programming language for multi agent systems in which agents interact with a common environment and cooperate by exchanging their individual beliefs on the environment. In handling the information they acquire, the agents employ operations to expand remove and update their individual belief bases. The overall framework, which generalizes traditional concurrent programming concepts, is parameterized by an information system of constraints. Such a system is used to represent the environment as well as the beliefs of the agents. We give the syntax of the programming language and develop an operational semantics in terms of a transition system.