UNIX Programs Research Articles

A general UNIX interface for biocomputing and network information retrieval software.

We describe a UNIX program, HYBROW, which can integrate without modification a wide range of UNIX biocomputing and network information retrieval software. HYBROW works in conjunction with a separate set of ASCII files containing embedded hypertext-like links. The program operates like a hypertext browser featuring five basic links: file link, execute-only link, execute-display link, directory-browse link and field-filling link. Useful features of the interface may be developed using combinations of these links with simple shell scripts and examples of these are briefly described. The system manager who supports biocomputing users should find the program easy to maintain, and useful in assisting new and infrequent users; it is also simple to incorporate new programs. Moreover, the individual user can customize the interface, create dynamic menus, hypertext a document, invoke shell scripts and new programs simply with a basic understanding of the UNIX operating system and any text editor. This program was written in C language and uses the UNIX curses and termcap libraries. It is freely available as a tar compressed file (by anonymous FTP from nuscc.nus.sg).

Synthesis of UNIX Programs Using Derivational Analogy

The feasibility of derivational analogy as a mechanism for improving problem-solving behavior has been shown for a variety of problem domains by several researchers. However, most of the implemented systems have been empirically evaluated in the restricted context of an already supplied base analog or on a few isolated examples. In this paper we describe a derivational analogy based system, APU, that synthesizes UNIX shell scripts from a high-level problem specification. APU uses top-down decomposition of problems, employing a hierarchical planner and a layered knowledge base of rules, and is able to speed up the derivation of programs by using derivational analogy. We assume that the problem specification is encoded in the vocabulary used by the rules. We describe APU's retrieval heuristics that exploit this assumption to automatically retrieve a good analog for a target problem from a case library, as well as its replay algorithm that enables it to effectively reuse the solution of an analogous problem to derive a solution for a new problem. We present experimental results to assess APU's performance, taking into account the cost of retrieving analogs from a sizable case library. We discuss the significance of the results and some of the issues in using derivational analogy to synthesize programs.

Synthesis of UNIX programs using derivational analogy

The feasibility of derivational analogy as a mechanism for improving problem-solving behavior has been shown for a variety of problem domains by several researchers. However, most of the implemented systems have been empirically evaluated in the restricted context of an already supplied base analog or on a few isolated examples. In this paper we describe a derivational analogy based system, APU, that synthesizes UNIX shell scripts from a high-level problem specification. APU uses top-down decomposition of problems, employing a hierarchical planner and a layered knowledge base of rules, and is able to speed up the derivation of programs by using derivational analogy. We assume that the problem specification is encoded in the vocabulary used by the rules. We describe APU's retrieval heuristics that exploit this assumption to automatically retrieve a good analog for a target problem from a case library, as well as its replay algorithm that enables it to effectively reuse the solution of an analogous problem to derive a solution for a new problem. We present experimental results to assess APU's performance, taking into account the cost of retrieving analogs from a sizable case library. We discuss the significance of the results and some of the issues in using derivational analogy to synthesize programs.

Electronic mail for geophysicists

Electronic mail (e‐mail for short) originated as a way for computer users to send message files to other users on the same computer system. E‐mail’s usefulness has greatly increased today because so many of the world’s computers are connected to networks. A network can be as humble as one between two machines in a room, or as big as a globe‐spanning behemoth linking tens of thousands of machines at US military bases around the world. Whatever their size, more and more local networks are now interconnected with other networks. The link can be as inexpensive as the Unix program UUCP, a simple‐minded automatic program that uses a modem to call up other computers on the telephone, or as fancy as special‐purpose gateway hardware linking multiple fiber‐optic networks.

Domain-based program synthesis using planning and derivational analogy

In this thesis, I propose a domain-based, integrated framework for program synthesis that emphasizes the reuse of software components and past experience in solving problems. A crucial component of the framework is a concept dictionary that contains a description of domain related components. This forms a basis for communicating with a user in a high-level, application-oriented terms; for constructing generic, problem-solving rules, and for reasoning by analogy. The other components of the framework include a library of reusable subroutines, cliches, and derivation histories of previously solved problems, a layered rulebase, a hierarchical planner, and an analogical reasoner based on Carbonell's derivational analogy paradigm. The planner uses the rulebase and the library to decompose a given problem in a top-down manner and synthesize a plan for solving it. The layered structure of the rule-base ensures that efficient plans are preferred over inefficient ones, and the changes needed to synthesize programs for a different domain are minimal. The analogical reasoner complements the role of the planner. It uses a set of heuristics to retrieve a problem from the derivation history library that is analogous to a current problem, and replays the derivation of the retrieved problem to synthesize a program for the current problem. A solved problem is stored back into the derivation history library, and may be used to solve a different problem in a future context. A prototype system, APU, based on the above framework has been implemented for the domain of UNIX programming. We describe a set of experiments designed to test the performance of APU, and provide empirical results demonstrating the feasibility and usefulness of the approach.

A case for make

The make command has been a central part of the Unix programming environment for over fifteen years. An excellent example of a Unix system software tool, it has a simple model and delegates most of its work to other commands. By dealing with general relationships between files and commands, make easily adapts to diverse applications. This generality, however, has become a handicap when compared with specialized integrated programming environments. Integrated environments are collections of tightly coupled (seamless) programs that can take advantage of programming language details not available to the loosely coupled (tool-based) make model. There are limitations to both approaches, but it would seem that the make model, at least for software construction, is reaching the breaking point. make can be revitalized by abandoning restrictive implementation details and by extending the basic model to meet modern software construction demands. This paper explores these demands and changes and their effects on the Unix system tool-based programming style.

Interacting with the field environment

This paper describes the ideas behind and the use of the FIELD programming environment. FIELD is an integrated environment that is based on UNIX programming tools and that runs on top of the X11 windowing system. It provides a consistent and complete interface to its tools. In addition, FIELD provides a variety of tools for program and data visualization. The key concepts behind FIELD are an integration mechanism based on a simple, central message server, an annotation editor for integrating access to the source file with the other tools, and the use of a high-level user interface toolset.

Forward semantic: a compiler-assisted instruction fetch method for heavily pipelined processors

A new instruction fetch method, forward semantic , is offered to enable the deeply pipelined processors to fetch one useful instruction every cycle. Forward semantic is an improved alternative to the delayed branching (with or without squashing), with five major advantages. Fist, no restriction is imposed on the type of instructions filling the branch slots, which allows a large number of slots to be filled. Second, no modification to the offsets and displacements is necessary when an instruction is copied to fill a branch slot, which simplifies the linker implementation. Third, an interrupted program can resume execution with a single program counter, eliminating the need for reloading the instruction pipeline before resuming execution. Fourth, programs compiled with N slots can execute on pipelines requiring K (K ≤ N) slots, which makes family architecture compatibility possible . Lastly, the filling of branch slots is totally transparent to code compaction and software interlocking schemes. These advantages combine to provide an efficient instruction fetch mechanism and to eliminate artificial penalties on branch cost. At the cost of 11% static code expansion, forward semantic achieves an instruction fetch cost of 1.2 cycles for pipelines requiring 10 slots for each taken branch. This level of instruction fetch efficiency has never been achieved before with conventional instruction fetch methods. The branch cost is dictated by the accuracy of the compile-time branch prediction rather than artificial limitations, such as data dependencies, which prevent the slots from being filled. These results are measured from the execution of real UNIX and CAD programs with complex control structures.

Unix system programming [Book Review

Unix system programming [Book Review

UNIX programming: methods and tools

This text is written especially for undergraduates and designed to provide them with a thorough grounding in the UNIX technology. The text provides complete coverage of AT&T's System V UNIX and shell programming with both Bourne Shell and the C Shell. It features an in-depth introduction to ASK (a pattern scanning and processing language) and sed (stream editor). Procedure design is emphasized throughout. Reflecting its origin as a text written expressly for undergraduates, the text has exceptionally strong and diverse pedagogy and exercises. As a reference tool for users, the book is invaluable, a rich and diverse source of information in one convenient volume.

FRAMES: Software tools for modeling, rendering and animation of 3D scenes

FRAMES is a set of flexible software tools, developed for the UNIX programming environment, that can be used to generate images and animation of 3D scenes. In FRAMES, each stage of the image-rendering pipeline is assigned to a UNIX System filter. The following is a typical FRAMES pipe sequence where each filter performs a task implied by its name:cat scene.frm|euclid|mover|shade|camera|abufFRAMES was designed to be easy to use, to permit flexible experimentation with new ideas in image rendering and geometric modeling, to allow distribution of different parts of the rendering pipeline to different processors, and to specify images in a common format for display on a variety of devices.The user communicates with FRAMES via a command language. This language is extended whenever a software developer needs to incorporate a new idea into the system by adding new commands. Data flowing through the pipeline is modified by a collection of filter programs and passed through the pipe in text or binary format.The modular and pipe-based nature of FRAMES allows for multi/parallel processor implementations and device independence. FRAMES has generated images on a local-area network of minicomputers (each filter runs on a different processor) and on a 64-processor hypercube machine (one filter runs on 64 processors). Applications of FRAMES have ranged from reconstruction of neurons from serial sections to rendering of antialiased octree objects with subpixel detail.

Running 7th edition UNIX programs on a VAX in compatibility mode

Running 7th edition UNIX programs on a VAX in compatibility mode

The unix programming environment

The unix programming environment

UNIX Time-Sharing System: UNIX Implementation

This paper describes in high-level terms the implementation of the resident uNIX∗ kernel. This discussion is broken into three parts. The first part describes how the UNIX system views processes, users, and programs. The second part describes the I/O system. The last part describes the UNIX file system.

UNIX Time-Sharing System: Statistical Text Processing

Several studies of the statistical properties of English text have used the UNIX∗ system and UNIX programming tools. This paper describes several of the useful UNIX facilities for statistical studies and summarizes some studies that have been made at the character level, the character-string level, and the level of English words. The descriptions give a sample of the results obtained and constitute a short introduction, by case-study, on how to use UNIX tools for studying the statistics of English.