An interpreter for LOTOS,a specification language for distributed systems

LOTOS is an executable specification language for distributed systems currently being standardized within ISO as a tool for the formal specification of open systems interconnection protocols and services. It is based on an extended version of Milner's calculus of communicating systems (CCS) and on ACT ONE abstract data type (ADT) formalism. A brief introduction to LOTOS is given, along with a discussion of LOTOS operational semantics, and of the executability of LOTOS specifications. Further, an account of a prototype LOTOS interpreter is given, which includes an interactive system that allows the user to direct the execution of a specification (for example, for testing purposes). The interpreter was implemented in YACC/LEX, C and Prolog. The following topics are discussed: syntax and static semantics analysis; translation from LOTOS external format to internal representation; evaluation of ADT value expressions and extended CCS behaviour expressions. It is shown that the interpreter can be used in a variety of ways: to recognize whether a given sequence of interactions is allowed by the specification; to generate randomly chosen sequences of interactions; in a user-guided generation mode, etc.     

Patchwork: A fast interpreter for a restricted dataflow language

We have built a system, Patchwork, that allows programs to be organized according to a dataflow model. In our implementation, application programs use Patchwork to assemble complex microcode programs for a graphics processor from a library of microcode modules. We describe a simple and efficient implementation, in which the only overhead incurred is a single extra level of indirection when invoking a module or when a module accesses inputs, outputs, or local storage. The implementation depends on being able to describe a distinct execution tree for the network, which obviates the need both for run-time monitoring of the execution and for movement of data. Thus, neither dataflow hardware nor a dataflow language is needed for the implementation. Patchwork supports flow-of-control constructs such as looping and branching, the assembly of complex modules from simpler ones, modules written in a variety of languages for a variety of different devices, the interleaved execution of several programs on a single processor, and the execution of a single program on a set of processors in parallel. An analysis showed that Patchwork contributed between 2 and 5% to the total running time of sample microcode programs.     

A natural language interpreter for plate girder design

One of the major problems in developing computeraided design software is the establishment of effective man-machine communication. This paper describes a computer-aided plate girder design software package and its man-machine interface using natural language processing techniques. The natural language interpreter takes advantage of the user's communication and technical skills and accepts commands in the user's native language. The user can verify the correct interpretation of the commands from the responsive graphic display of the design.     

The benefits of posing application software as a language interpreter

Complicated and comprehensive software that is meant to execute in a non‐interactive or semi‐interactive mode needs to be configured to carry out the desired tasks, needs to carry out those tasks efficiently, needs to be extensible to take on additional ambitions, and needs to be maintainable. To reduce costs, it is helpful if experts in the discipline to which the program applies can configure and operate the program without needing to become expert software engineers and without needing to become familiar with the internal details of the program, and if software engineers who develop and maintain the program need not become experts in its target discipline. Progress toward these goals can be advanced by posing the software as a language interpreter. We describe the application of this principle to ground‐based data analysis software for the Microwave Limb Sounder instrument on the NASA Earth Observing System Aura satellite, but we believe the principle has substantially broader applicability. Copyright © 2007 John Wiley & Sons, Ltd.     

Compiler to interpreter: experiences with a distributed programming language

One interpretive approach for handling concurrency is to provide an interpreter instance for each executing language‐level process. Such an approach has mainly been applied to concurrent implementations of logic and functional languages. This paper describes the use of this approach in constructing an interpreter for an imperative, distributed programming language from an existing compiler and run‐time support system (RTS). Primary design goals were to exploit the existing compiler to the extent possible as well as to have minimal impact on the RTS used to support concurrency. We have been successful in meeting these goals. Additionally, performance results show our interpreter's execution times compare favorably to the times required for compilation, linkage, and execution of small programs or programs with a significant number of calls to the RTS; on such programs, our interpreter's performance also compares favorably to that of the standard Java implementation. However, for larger programs and programs with fewer calls to the underlying RTS, the conventional compiler‐based implementation outperforms the interpreter implementation. For many distributed programs in which network costs dominate, the performances of the two implementations differ little. Copyright © 2001 John Wiley & Sons, Ltd.     

An efficient interpreter for the lambda-calculus

A call-by-need reduction algorithm for the LAMBDA-calculus is presented. Call-by-need is as efficient as call-by-value and is equivalent to call-by-name in languages without side effects. The algorithm, which is the core of a running system, is presented by illustrating successive transformations of a straightforward implementation of the classical definition of reduction in the LAMBDA-calculus. All notions and algorithms are introduced as LISP code.     

An accumulating interpreter for cognitive vision production systems

Knowledge-based recognition and analysis of high dimensional data such as aerial images often has high computational complexity. For most applications time and computational resources such as memory are limited. Therefore approximately correct interpreters with any-time capability are proposed. In this contribution a special software architecture is published, which can handle the administration of complex knowledge-based recognition and analysis in a tractable manner.     

An accumulating interpreter for cognitive vision production systems

Knowledge-based recognition and analysis of high dimensional data such as aerial images often has high computational complexity. For most applications time and computational resources such as memory are limited. Therefore approximately correct interpreters with any-time capability are proposed. In this contribution a special software architecture is published, which can handle the administration of complex knowledge-based recognition and analysis in a tractable manner.     

Improving multimodal web accessibility for deaf people: sign language interpreter module

The World Wide Web is becoming increasingly necessary for everybody regardless of age, gender, culture, health and individual disabilities. Unfortunately, there are evidently still problems for some deaf and hard of hearing people trying to use certain web pages. These people require the translation of existing written information into their first language, which can be one of many sign languages. In previous technological solutions, the video window dominates the screen, interfering with the presentation and thereby distracting the general public, who have no need of a bilingual web site. One solution to this problem is the development of transparent sign language videos which appear on the screen on request. Therefore, we have designed and developed a system to enable the embedding of selective interactive elements into the original text in appropriate locations, which act as triggers for the video translation into sign language. When the short video clip terminates, the video window is automatically closed and the original web page is shown. In this way, the system significantly simplifies the expansion and availability of additional accessibility functions to web developers, as it preserves the original web page with the addition of a web layer of sign language video. Quantitative and qualitative evaluation has demonstrated that information presented through a transparent sign language video increases the users’ interest in the content of the material by interpreting terms, phrases or sentences, and therefore facilitates the understanding of the material and increases its usefulness for deaf people.     

Design and coding considerations of the soil data language interpreter

A query language, named Soil Data Language (SDL), for retrieving information from a Soil. Data Bank, is part of the ARSIS (A Relational Soil Information System) system, currently being developed in Greece. The interpreter of the language accepts input programs, expressed as SDL commands, and outputs the requested information. This paper describes design principles employed during the coding of the interpreter of the language. The derived program can be modified to cover eventual alterations to the specifications of language or the content and structure of the data bank. The study may be seen as an initiative to the design of Generalized Soil and Land Information Systems that primarily are concerned with the easy adaptation to a variety of National processing requirements.     

Q'Nial: A portable interpreter for the nested interactive array language,Nial

The Q'Nial interpreter combines ideas from APL and Lisp implementations to provide a rich programming environment that supports several paradigms of programming. The interpreter is structured to reflect the division of Nial semantics into levels corresponding to zero-, first-and second-order objects. The paper describes the design of the interpreter, discusses constraints imposed by the desire to achieve portability and comments on what has been learned in building an interpreter in this style.     

Introducing a cross-layer interpreter for multimedia streams

In the context of multimedia and real-time systems, this article introduces a generic interpreter of QoS properties (xQoS-Interpreter) for the Application Data Units (ADUs) composing standard and proprietary multimedia streams. This approach is intended to make the QoS properties of ADUs publicly available to any mechanism of the underlying communication system. The use of this information allows for cross-layer QoS optimization of the communication services taking the actual per-packet requirements of the applications into account. A case study showing how the xQoS-Interpreter is used at transport layer to seamlessly optimize the perceived QoS of an end-to-end video transmission is presented. In this scenario, the xQoS-Interpreter is used to optimize a TCP-friendly Rate Control mechanism (TFRC) over congested wireless network services in order to demonstrate the feasibility and advantages of our approach.     

Design of a MUMPS interpreter

This paper describes the basic design of Comp Consultants Standards Mumps system for Tano Corporation's Outpost 11 6800 based micro computer running under the Flex 2.0 floppy disk operating system with 64K bytes of random access memory. The Mumps system consists of an executive which includes I/O device handlers, and interpreter for Standard Mumps and a floppy disk storage system for global variables based on balanced trees with key compression by indexes and with 32 K of random access memory buffers to make up for the slow floppy disk access times. Comp Consultants Mumps involves some significant departures from previous Mumps implementations. In particular local variables and routine lines are stored in the same manner as global variables. For example the storage key for a routine consists of three parts: The routine name, a label, and a line offset number. Representing local variables and routines as global variables not only increases the available buffer space by eliminating special code to handle local variable storage, routine storage, and program editing; but also increases the utilization of the buffers by keeping in memory what is most often accessed regardless whether it is a local variable, a global variable, or program code. This unified representation of local variables and routines as global variables is described in detail in this paper.     

A highly-structured interpreter for a SNOBOL4 subset

A highly-structured and conceptually simple processor, written in Algol 68, for a basic but useful subset of SNOBOL4 is presented. It provides a significant, large-scale demonstration of a particular methodology for constructing ‘master’, machine-independent implementations of programming languages. The processor is closely related to a formal operational definition of the SNOBOL4 subset in that it incorporates an abstract machine, a high-level abstract syntax (in the form of mutually recursive mode definitions) for the internal form of programs, and a set of mutually recursive interpretation procedures for programs in this internal form. The various aspects of the processor are documented in some detail. The experience of testing the processor is briefly discussed.