Computer Languages最新文献

Types in current programming languages specify constant sets of messages always acceptable throughout the lifetime of the types’ instances. However, especially in concurrent object-oriented systems, the acceptability of messages often changes with the objects’ states. We propose a typed concurrent object calculus where static type checking ensures that users send only acceptable messages although message acceptability may change dynamically. The programmer specifies in types predictable state changes and dependences of message acceptance on states; a compiler infers the needed state information. This state inference has polynomial time complexity and can be used together with subtyping.

The last decade has seen the advent of the agent paradigm as a reference model in several fields of research, mainly but not limited to artificial intelligence and distributed systems. In open and distributed environments, where most facts are not known at all, the agent metaphor proves particularly useful if agents are able to autonomously perform some form of reasoning, possibly obviating knowledge incompleteness by means of hypotheses assumed on the unknown facts. A suitable mechanism to deal with incomplete and multiple knowledge is abductive reasoning.

The aim of this paper is to describe LAILA, a language that can be used by logic-based agents capable of abductive reasoning, by enabling them to express at a high level several ways to join and coordinate with one another. In particular, we considered collaboration and competition as possible interaction patterns in the abductive reasoning that must be carried out by multiple agents. Syntax and operational semantics of the LAILA language are given along with a clarifying example; a section is also devoted to a brief description of the current LAILA implementation.

Graphical representations of business process models are an important means for business architects to grasp the inherent complexity of business processes. This paper reports on the visualisation features of AMBER, the graphical and formal business process language of the Testbed project, and Testbed Studio, its toolkit. Visualisation features fulfill explicit requirements, which are based on an investigation of a business architect's main activities. The paper presents the three main visualisation areas in Testbed: (1) the graphical representation of the language itself, (2) representation conventions, and (3) a set of business process views.

Industry is facing a crisis in the design of complex hardware/software systems. Due to the increasing complexity, the gap between the generation of a product idea and the realisation of a working system is expanding rapidly. To manage complexity and to shorten design cycles, industry is forced to look at system-level languages towards specification and design. The (formal) system-level modelling language called POOSL is very expressive and is able to model dynamic hard real-time behaviour and to (visually) capture static (architecture and topology) structure in an object-oriented fashion. The language integrates a process part, based on the process algebra CCS, with a data part, based on the concepts of traditional object-oriented programming languages and it is equipped with a formal semantics. Currently, a number of automated software tools (model editing, simulator and compiler tools) are available in an environment called SHESim. These tools allow visual entry of structure and topology of the system, whereas dynamic behaviour of individual processes is expressed in an expressive imperative language. The formal semantics of POOSL provides a solid basis for the application of verification and performance analysis techniques and establishing a rigorous connection to existing analysis tools.

Wider adoption of formal specification languages in industry is impeded by the lack of support for early development phases and for integration with older, legacy software. Methodology aimed at improving this situation is presented. The methodology uses message sequence charts as a “front-end” specification language and systematically applies an automatic synthesis technique to produce executable specifications in the telecommunications standard Specification and Description Language. Applications of the automatic synthesis technique for both forward and reverse engineering are demonstrated.

In this paper we describe languages for formalizing, visualizing and verifying software architectures. This helps us in solving two related problems: (1) the reconstruction of architectures of existing systems, and (2) the definition and verification of architectures of new systems. We define an expression language for formulating architectural rules, a graph language for visualizing various structures of design, and a dialogue language for interactively exercising the former two languages. We have applied these languages in a number of industrial cases.

Within this survey article, we explain real-time symbolic timing diagrams and the ICOS tool-box supporting timing-diagram-based requirements capture and rapid prototyping. Real-time symbolic timing diagrams are a full-fledged metric-time temporal logic, but with a graphical syntax reminiscent of the informal timing diagrams widely used in electrical engineering. ICOS integrates a variety of tools, ranging from graphical specification editors over tautology checking and counterexample generation to code generators emitting C or VHDL, thus bridging the gap from formal specification to rapid prototype generation.

Argos belongs to the family of synchronous languages, designed for programming reactive systems: Lustre (Proceedings of the 14th Symposium on Principles of Programming Languages, Munich, 1987; Proc. IEEE 79(9) (1999) 1305), Esterel (Sci. Comput. Programming 19(2) (1992) 87), Signal (Technical Report, IRISA Report 246, IRISA, Rennes, France, 1985). Argos is a set of operators that allow to combine Boolean Mealy machines, in a compositional way. It takes its origin in Statecharts (Sci. Comput. Programming 8 (1987) 231), but with the Argos operators, one can build only a subset of Statecharts, roughly those that do not make use of multi-level arrows. We explain the main motivations for the definition of Argos, and the main differences with Statecharts and their numerous semantics. We define the set of operators, give them a perfectly synchronous semantics in the sense of Esterel, and prove that it is compositional, with respect to the trace equivalence of Boolean Mealy machines.

We give an overview of the work related to the definition and implementation of Argos (code generation, connection to verification tools, introduction of non-determinism, etc.). This paper also gives a set of guidelines for building an automaton-based, Statechart-like, yet perfectly synchronous, language.