Scenarios as partial behavior description, are used more and more to represent users requirements, and to conduct software engineering. The paper examines automatic generation of specifications from requirements. This is a crucial step when accuracy is desired in the requirement engineering process. Automatic construction of specifications from scenarios reduces to the merging of partial behaviors into global specifications, such that these specifications can reproduce them. The paper presents an incremental algorithm that synthesizes timed automata from scenarios with timing constraints. The algorithm is based on a formalism developed for scenarios. It uses operations semantics, and a mapping between concepts of scenarios, and those of the theory of timed automata.

Users of a given information retrieval system may have different requirements at various times (sometimes emphasizing precision, sometimes recall), and the corpus may have different degree of emphasis regarding subjects.Therefore, a general purpose system should have parameters to allow adjustable performance.This article investigates the integration of several evaluation methods into a single system so that a user may choose an appropriate method or a combination of methods for his query evaluation.

Abstract Prolog is a relatively new programming language that has proved excellent for symbolic computation. However, Prolog was not specifically designed for industrial scale work and it lacks some standard features that are useful for reading, maintaining and debugging large programs. In particular, Prolog has no record mechanism, and programs often require major changes when data structures are modified. The record is a standard data abstraction concept that improves the robustness of programs. The main advantage in using records is that data structures can be modified and extended with minimal repercussion to program code. Furthermore, the use of significant names to access data fields means that the intent of code is generally clearer. We present a set of primitive operators that support a readable and robust programming style for the manipulation of record data structures in standard Prolog. The proposal covers both simple and imbricated record types and handles selective modification of records cleanly. We also treat property lists and records in a uniform way. These benefits are achieved with minimal overhead while retaining the traditional Prolog non‐deterministic style.

Abstract A pleasing layout of printed tree structures is difficult to achieve automatically. The paper points out three main problems. First, the horizontal position of a node on the printed page depends on global consideration of the position of other nodes; secondly, the physical characteristics of printers require scanning the tree in left‐to‐right top‐to‐bottom sequence; finally, page overflow for wide trees must be handled. These problems are illustrated by analysing the shortcomings of a simple printing algorithm. A suitable general binary tree printing algorithm is presented and its adaptation to other types of trees is shown.

Abstract Sequence checking is such a common operation in commercial data processing that one assumes it no longer presents any programming problems; however, many examples presented in the current literature are either incorrect or misleading in as much as they do not state the necessary conditions for proper operation. Checking algorithms generally detect sequence errors and decide which record is in error based on a comparison between two successive record key values (current and previous). We show that identification of the record in error with any degree of certainty requires at least four successive key values and suggest that simplistic recovery in the face of sequence errors should not be attempted.

In this correspondence, a new circuit structure is proposed which basically supresses the possibility of hazards and critical races in asynchronous sequential machines. In contrast to many approaches which try to solve these problems by changing the form of the automaton model, we suggest a more general "hardware" solution. This configuration provides performance extremely close to that of classical circuits while allowing substantial reduction in circuit cost.

Because of dramatic reductions in cost of mini-computers, peripherals and logic modules, it is becoming evident that many problems confronting the computer system designer will be solved in the future by hybrid designs involving not only software but also specialized computers with architectures best suited to each application. Accordingly, hardware research must no longer be considered as a separate discipline by system programmers but as a tool in exactly the same way as languages. To illustrate this philosophy, a hardware laboratory has been set up at the University of Montreal. The primary interest of the founders was in designing and building small specialized computing systems.