Support for graphs of processes in a command interpreter

Since the inception of pipes in the UNIX operating system, the standard UNIX command interpreters, or shells, have supported processes connected only in linear arrangements. This paper explains why linear pipe structures are too restrictive and how the standard UNIX shells have dictated the interface strategy of new commands. A new command interpreter is presented that supports general directed process graphs. Processes and files are considered simply as nodes and pipes as arcs in a process graph.     

The design of an object-oriented command interpreter

Object-oriented programming languages are noted for their ability to allow users quickly to construct large software systems. They achieve this ability by allowing the programmer to concentrate on what it is they want to do, ignoring details of how that functionality is achieved. Such characteristics should make the object-oriented style of programming attractive to casual or novice computer users, indeed one of the best known object-oriented programming languages, Smalltalk, was initially designed with just such novice users in mind. The Unix operating system is widely regarded as a good environment for doing software development. Nevertheless, its large number of often terse and cryptic commands make it difficult for novice or casual users to use. In this paper we argue that one solution is to create an object-oriented command interpreter, or shell, between the user and the underlying system. This paper reports on the construction of one such prototype shell, and the lessons we have learned from the use of this system.     

Wsh—a new command interpreter for unix

WSH is a window managing command language interpreter (shell) for the UNIX operating system. This interface increases a user's power to communicate with UNIX by providing a process management environment based on an integrated virtual terminal-shell design. Unlike conventional shells, WSH affords its user the ability to monitor and communicate with multiple processes within a single display context. Windows represent virtual terminals in the WSH design, and as such are device-independent abstractions of real terminals. Since the design of the virtual terminal environment is based on UNIX's TERMCAP terminal database facility, WSH is portable across all versions of UNM supporting this feature. WSH requires neither alteration of existing UNIX facilities nor special display devices. The current implementation runs on a Digital VAX 11/780 under Berkeley UNIX 4.1 environment.     

HADES—A command environment that supports structure

HADES is a command program designed to aid programmers and authors involved in writing systems with an inherently high degree of structuring. It presents the system being developed in a hierarchical fashion, encouraging a top down approach to its design, and alleviates many of the problems experienced with traditional filing systems. Unlike other programming environment systems, the utility programs and tools do not have to be ‘integrated’ into the system, which means that new and existing tools can be quickly and easily added. This results in a rich set of operations implemented at very low cost. The paper outlines some of the problems that arise with traditional filing systems from the point of view of software development, and then presents the approach adopted by HADES. This is followed by a discussion of the strengths and weaknesses of the result and some reflections on the lessons that have been learnt.     

DDA — a data definition facility for unix using awk

We discuss how the Awk language is an effective tool for interrogating sequential data files whose records consist of characters grouped into fields. This facility is used to implement a system to manage an ‘address book’ database. We then generalize the design, describing a system which allows one to interactively specify a DBMS according to one's own requirements within our general framework. We choose a wine-tasting DBMS as an example specification for further consideration and evaluation.     

The syntax of interactive command languages: A framework for design

Various qualities of simple command languages, such as ease of use and flexibility, are defined in terms of syntax. Certain design attributes—namely style, structure and level of abstraction—are described for command languages, and these attributes are shown to strongly influence the defined qualities. Commands are designed for three functions to show how the design trade-offs are made in light of the qualities and attributes discussed.     

A critique of unix

The UNIX operating system enjoys an ever increasing popularity throughout the computing community; there will be 1.4 million UNIX licences distributed by 1985, rising at a rate of about 400,000 per annum. With universal acceptance of a system comes a dangerously high degree of inertia. Consider the analogous area of programming languages, where there has been great resistance to change, despite major advancements. This paper presents a critique of UNIX, based on three areas which we consider to be of vital importance to future operating systems. These areas are operating system structures and design, programming support environments and distributed computing. The criticisms presented are in no way intended to discredit UNIX. UNIX compares favourably with most of the present generation of operating systems. The intention is to highlight deficiencies in the state of the art in operating system design.     

Yacc in sasl — an exercise in functional programming

Among the advantages claimed for a purely functional programming style is ease of designing and implementing large programs. However, little experience of actually doing so has been gained so far. The experience of writing a particular medium sized program in a functional language is described here, with particular emphasis on the differences in programming style that were appropriate. This is compared with the experience of writing a very similar program in an imperative language. The main conclusions appear to be that the functional version was significantly easier to write, and was considerably smaller, though not by as large a factor as is sometimes claimed; that strong typing is, if anything, more desirable than in imperative systems; and that the question of debugging functional programs needs further research attention.     

Interactive programs in a functional language: A functional implementation of an editor

The transition from imperative programming to functional programming for problems whose mathematical nature is not immediately obvious raises two questions. First, how can the function concept be applied to such problems, and, secondly, what language concepts are most suited in this situation. This paper shows that an existing functional programming language is very well suited for the elegant implementation of interactive programs. As an example, a text editor is described. The implementation of the editor has once more demonstrated the benefits of functional programming: fast generation of short and reliable programs. This indicates that it is worth while to investigate the application fields of functional programming languages as well as their implementation, in order to try to make them into general-purpose programming languages that can be used in a production environment.     

A graphical user interface server for unix

The UNIX operating system has attained widespread popularity because of its power, flexibility and elegance. However, the common user interfaces (shells) have been criticized as being cryptic and difficult to use, especially for novices. In this paper, we present a user interface server that can be used to provide a graphical shell for UNIX. This shell helps to overcome a number of difficulties faced by both novices and experts. Although it is largely intended to assist novices, it is also designed not to become a hindrance for expert users and does not sacrifice the basic power and flexibility of UNIX. The server is designed to augment rather than replace text-based interfaces and can be used from a variety of different interactive programs in addition to shells.     

Solo—system for on-line optimization

SOLO (system for on-line optimization) is a system of interactive computer programs for solving problems of optimization. It exists in two forms, one of which uses a teletypewriter exclusively for both input and output. The other retains the teletypewriter for input but presents outputs mainly on a cathode ray tube display. The optimization problem is expressed as the maximization of a function of an arbitrary bumber of parameters. Optimization problems often occur in engineering design, where it is often a matter of fitting a computed output, response or performance curve to the one desired. SOLO can be regarded as a tool for computer-aided design in this sense. SOLO does not make use of any methods of numerical analysis, but relies instead on organized interactive searching. No function derivatives are computed, so that SOLO can be applied to any type of function. Experience so far suggests that SOLO is much more efficient with functions possessing many local optima than it is with functions which have just one maximum.     

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.     

The new mexico state university ring-star system: A distributed unix environment

A distributed version of the UNIX operations system is currently under development through a joint effort of New Mexico State University and the Hebrew University of Jerusalem. A microprocessor version of the UNIX kernel has been developed which will run on any PDP-11 or LSI-11 based processing element and allows processes to run in a UNIX ‘look-alike’ environment. Each process is fully transportable among all processors in the system. Although the preliminary version of the system was built in a star configuration, the system is currently being upgraded by the addition of a communication ring with 8-bit microprocessors as ring interface units. The current paper describes the software structure, the hardware structure and the communication protocol of the system.     

A visual shell interface to a database

This paper describes a visual command language for a workstation with a bit-mapped display and a mouse that can be used to create different user interfaces. Primitive interface components can be combined into more complex user interfaces. The user specifies interconnections between these components over which data and commands can be sent by pointing with a mouse. Primitive interface components are described for creating several different database user interfaces. The design and implementation of the software architecture is described, including the primitives for database interfaces and the communication protocols used by the system.     

A text editing interface: Definition and use

A simple yet flexible method of editing text is described which is applicable to all forms of character based command processing applications. The technique greatly increases the friendliness of a text driven interface but does not interfere with most existing command conventions; it can also be generalised to form the basis of a powerful and easy to use text editor. This paper describes the details and basic philosophy of the editing interface and describes its successful use in two applications (command processor and calculator) which are not normally associated with text editing requirements.     

Interfaces as functors, programs as coalgebras—A final coalgebra theorem in intensional type theory

In [P. Hancock, A. Setzer, Interactive programs in dependent type theory, in: P. Clote, H. Schwichtenberg (Eds.), Proc. 14th Annu. Conf. of EACSL, CSL’00, Fischbau, Germany, 21–26 August 2000, Vol. 1862, Springer, Berlin, 2000, pp. 317–331, URL citeseer.ist.psu.edu/article/hancock00interactive.html; P. Hancock, A. Setzer, Interactive programs and weakly final coalgebras in dependent type theory, in: L. Crosilla, P. Schuster (Eds.), From Sets and Types to Topology and Analysis. Towards Practicable Foundations for Constructive Mathematics, Oxford Logic Guides, Clarendon Press, 2005, URL www.cs.swan.ac.uk/csetzer/] Hancock and Setzer introduced rules to extend Martin-Löf's type theory in order to represent interactive programming. The rules essentially reflect the existence of weakly final coalgebras for a general form of polynomial functor. The standard rules of dependent type theory allow the definition of inductive types, which correspond to initial algebras. Coalgebraic types are not represented in a direct way. In this article we show the existence of final coalgebras in intensional type theory for these kind of functors, where we require uniqueness of identity proofs () for the set of states and the set of commands which determine the functor. We obtain the result by identifying programs which have essentially the same behaviour, viz. are bisimular. This proves the rules of Setzer and Hancock admissible in ordinary type theory, if we replace definitional equality by bisimulation. All proofs [M. Michelbrink, Verifications of final coalgebra theorem in: Interfaces as Functors, Programs as Coalgebras—A Final Coalgebra Theorem in Intensional Type Theory, 2005, URL www.cs.swan.ac.uk/csmichel/] are verified in the theorem prover agda [C. Coquand, Agda, Internet, URL www.cs.chalmers.se/catarina/agda/; K. Peterson, A programming system for type theory, Technical Report, S-412 96, Chalmers University of Technology, Göteborg, 1982], which is based on intensional Martin-Löf type theory.     

Implementing an extended functional data model using PS-algol

A number of data models have been proposed in the literature to improve the usability of database systems. Most of these proposals have not been implemented. It is felt that a working implementation is a necessary prerequisite for a serious study of these proposals. So far, implementing data models has been a daunting task, requiring a large team. We report here on a simple implementation technique using the persistent algorithmic language. PS-algol, which promises to make the task of implementing data models a manageable one. The feasibility of the approach is demonstrated by implementing an entity-based functional data model (extended function data model) using PS-algol.     

A new generic scheme for functional logic programming with constraints

In this paper we propose a new generic scheme CFLP풟, intended as a logical and semantic framework for lazy Constraint Functional Logic Programming over a parametrically given constraint domain 풟. As in the case of the well known CLP풟 scheme for Constraint Logic Programming, 풟 is assumed to provide domain specific data values and constraints. CFLP풟 programs are presented as sets of constrained rewrite rules that define the behavior of possibly higher order and/or non-deterministic lazy functions over 풟. As a main novelty w.r.t. previous related work, we present a Constraint Rewriting Logic CRWL풟 which provides a declarative semantics for CFLP풟 programs. This logic relies on a new formalization of constraint domains and program interpretations, which allows a flexible combination of domain specific data values and user defined data constructors, as well as a functional view of constraints. This research has been partially supported by the Spanish National Projects MELODIAS (TIC2002-01167), MERIT-FORMS (TIN2005-09207-C03-03) and PROMESAS-CAM (S-0505/TIC/0407).