ppxscal/embedding_network huggingface dataset:
A fixed-program machine for combinator expression evaluation
Authors: Neil D. Jones, Steven S. Muchnick
Venue: Proceedings of the 1982 ACM symposium on LISP and functional programming (1982)

It is our purpose here to present an alternative evaluation mechanism for combinator expressions, namely a relatively straightforward compilation algorithm which translates combinators to fixed-program code for a stack machine. The resulting code is faithful to Turner's use of non-strict functions, in that it performs normal order evaluation. We show how this code can be made more efficient by performing call-by-need evaluation (without changing the semantics of the language) and consider some flow-analysis-based optimizations, as well. The remainder of this paper is organized as follows: We first review (briefly) Turner's arguments in favor of using combinators and how to translate function definitions to combinator expressions in Section 2. Next, in Section 3, we present our translation of combinator expressions to call-by-name stack machine code and the evaluation of a simple program in our model. In Section 4 we show how to eliminate repeated evaluation of argument expressions (or, equivalently, optimize evaluation of S combinator expressions) by using call by need. In Section 5 we consider flow-analysis-based optimizations which can significantly improve the code generated by the naive algorithms of Sections 3 and 4. Finally, Section 6 presents conclusions and suggestions for further work in this area.
Improving team productivity in system software development
Authors: Brian W. Unger, Sheldon Walker
Venue: Proceedings of the fifteenth annual SIGCPR conference (1977)

System software development involves significant coordination problems. The coordination effort required to develop large operating systems can be more than 90% of the total effort (Unger, Walker, 1977), (Brooks, 1975), (Aron, 1969). A major factor in programming coordination is the interpersonal communication process within a development team. This paper describes an approach to increasing team productivity through external intervention in the communication process. Experiences with four instances of an undergraduate course which involves an operating system development project are also described. Two of these development projects involved intervention in the communication process by an external facilitator. Estimates of the resulting programmer productivity are presented for all four development projects.
The automated generation of architectural form
Authors: William J. Mitchell
Venue: Proceedings of the 8th Design Automation Workshop (1971)

A systematic framework for discussion of automation of the solution of architectural problems is established, based on an examination of the concepts of solution representation, generation, and testing. Some of the more important implications of various different techniques and principles of representation, generation, and testing are then illustrated by a discussion of procedures for solution of some simple spatial arrangement games and puzzles. It is shown that when we attempt to write procedures for solution of the rather larger and more complex problems encountered in practical architectural design, we discover some quite severe limitations on our current ideas about architectural design automation. The major limitations are outlined, and progress made towards overcoming them recounted.
An Incremental Programming Environment
Authors: Peter H. Feiler, Raul Medina-Mora
Venue: Proceedings of the 5th international conference on Software engineering (1981)

This document describes an Incremental Programming Environment (IPE) based on compilation technology, but providing facilities traditionally found only in interpretive systems. IPE provides a comfortable environment for a single programmer working on a single program. In IPE the programmer has a uniform view of the program in terms of the programming language. The program is manipulated through a syntax-directed editor and its execution is controlled by a debugging facility, which is integrated with the editor. Other tools of the traditional tools cycle (translator, linker, loader) are applied automatically and are not visible to the programmer. The only interface to the programmer is the user interface of the editor.
Real natural gas reservoir data Vs. natural gas reservoir models
Authors: Ellis A. Monash, John Lohrenz
Venue: Proceedings of the 12th annual symposium on Simulation (1979)

The gas reservoir per se model is an exceedingly simple model of a natural gas reservoir designed to develop the physical relationship between ultimate recovery and rate(s) of withdrawal for production regulation policy assessment. To be responsive, the model must be able to consider rates of withdrawal both far lower and higher than current practices which are dependent on current policies. For this model, as for every model, a reasonable question arises, "Does the model actually work as supposed?" What makes this question of great concern is that one cannot resort to replicated experiments in either real or model reservoirs to check a gas reservoir model. One can, however, challenge the model with real gas reservoir data. This is what we did and found that this exceedingly simple model fits real gas reservoir data in a very satisfying manner.
Short-term friendly and long-term hostile?
Authors: John C. Klensin
Venue: ACM SIGSOC Bulletin (1982)

Several authors have suggested, and we are hearing some additional papers on the subject at this conference, that our computer systems should be "friendly" -- that the new user, or the infrequent user, should be able to use them quickly, without any special learning, and without any resort to written materials. My colleagues and I are responsible for a large analysis system [1, 3] that has been in active use outside its development group for about five years and which has several philosophically similar predecessor systems that go back another three or four years [4, 5, 6]. It is interactive in the sense that one of its reasons for existence is to permit the user to interact with data and tease results out of them in a variety of ways -- it has never been, nor is it derived from, a front-end to a batch system or batch thinking. Its users have ranged in skill and background from the beginning student to the professional statistician developing new techniques; from the academic researcher to the clerk in commercial environments. We draw, from this experience, some differing views on what kinds of system designs are friendly and what sorts of assumptions lead to "friendly" systems.
Tree transductions and families of tree languages
Authors: Brenda S. Baker
Venue: Proceedings of the fifth annual ACM symposium on Theory of computing (1973)

Interest in the study of sets of trees, tree languages, has led to the definition of finite automata which accept trees [2,11] and transducers which map trees into other trees [7,9,10]. These generalized machines may read treesfinite automata which accept trees [2,11] and of transducers which map trees into other trees [7,9,10]. These generalized machines may read trees either &ldquo;top-down&rdquo; (from the root toward the leaves) or &ldquo;bottom-up&rdquo; (from the leaves toward the root). Here it is shown that both the class of top-down transductions and the class of bottom-up transductions can be characterized in terms of two restricted classes of tree transductions. From these ductions and the class of bottom-up transductions can be characterized in terms of two restricted classes of tree transductions. From these characterizations, it is shown that the composition of any n bottom-up transductions can be realized by the composition of n+1 top-down transductions, and similarly, the composition of any n top-down transductions can be realized by the composition of n+1 bottom-up transductions. Next, we study the families of tree languages which can be obtained from the recognizable sets (sets accepted by finite tree automata) by the composition of n top-down or bottom-up transductions, n>0. The yield operation, which concatenates the leaves of a tree from left to right to form a of string, languages from the hierarchy of families of tree languages. It is shown that each family of string languages in this hierarchy is properly contained in the family of context-sensitive languages.
Control flow analysis
Authors: Frances E. Allen
Venue: ACM SIGPLAN Notices (1970)

Any static, global analysis of the expression and data relationships in a program requires a knowledge of the control flow of the program. Since one of the primary reasons for doing such a global analysis in a compiler is to produce optimized programs, control flow analysis has been embedded in many compilers and has been described in several papers. An early paper by Prosser [5] described the use of Boolean matrices (or, more particularly, connectivity matrices) in flow analysis. The use of &ldquo;dominance&rdquo; relationships in flow analysis was first introduced by Prosser and much expanded by Lowry and Medlock [6]. References [6,8,9] describe compilers which use various forms of control flow analysis for optimization. Some recent developments in the area are reported in [4] and in [7]. The underlying motivation in all the different types of control flow analysis is the need to codify the flow relationships in the program. The codification may be in connectivity matrices, in predecessor-successor tables, in dominance lists, etc. Whatever the form, the purpose is to facilitate determining what the flow relationships are; in other words to facilitate answering such questions as: is this an inner loop?, if an expression is removed from the loop where can it be correctly and profitably placed?, which variable definitions can affect this use? In this paper the basic control flow relationships are expressed in a directed graph. Various graph constructs are then found and shown to codify interesting global relationships.
Test data as an aid in proving program correctness
Authors: Matthew Geller
Venue: Proceedings of the 3rd ACM SIGACT-SIGPLAN symposium on Principles on programming languages (1976)

Proofs of program correctness tend to be long and tedious whereas testing, though useful in detecting errors, usually does not guarantee correctness. This paper introduces a technique whereby test data can be used in proving program correctness. In addition to simplifying certification of correctness, this method simplifies the process of providing specifications for a program. The applicability of this technique to procedures, recursive programs, and modular programs is demonstrated.
Software implications on future architecture designs
Authors: Stanley Habib
Venue: Proceedings of the 1976 annual conference (1976)

It has been suggested that architecture which suits the requirements of high-level languages will relieve the difficulties. High-level languages have developed out of the current milieu and possess their own share of primitiveness and inflexibility. Moreover, they require computer users to have expert skill at rendering information-processing problems into algorithmic form. It has been suggested that all current architecture, languages, and systems be discarded in favor of new systems based on entirely different principles. At least this suggestion doesn't inherently propagate the mistakes of the past. On what new set of principles should computing be based? Before we can answer, there must be some agreement about what objectives are to be sought through new computing machinery.
A Relational Problem Definition Language For Structured Data Processing
Authors: Leland L. Beck
Venue: Proceedings of the 1978 annual conference (1978)

A relational problem definition language for transaction-oriented data processing systems is described and is shown to be relationally complete. Methods are given for converting a problem statement written in this language into a network of processes and files; this network representation can be optimized to produce an efficient implementation of the problem using any available data management software. In effect, this approach allows the automatic reorganization of application programs to provide efficient operation in a changing environment; no alteration of the original problem statement is required.
Distributed software personnel when, how and why?
Authors: Roger Webster
Venue: ACM SIGOA Newsletter (1984)

It is obvious that as computer technology moves more and more towards distributed processing - a centralized EDP support structure will not be effective. The future of computer processing will utilize distributed microcomputing technology. As depicted in Figures 1, 2, and 3, the future computer processing environments will have microcomputers connected to minicomputers and minis connected to mainframes. Complete computer networking, microcomputers on every executive's desk, relational data structures and office automation will dominate the business environment. The majority of the action in computer information processing will be taking place on the desk tops of executives in the &ldquo;interactive office&rdquo;. The imminent question will not be &ldquo;Should EDP distribute software personnel&rdquo; - but, &ldquo;When do I distribute and how do I divide the information systems responsibilities?&rdquo;
George Forsythe memorial lecture (Panel Session)
Authors: Donald G.M. Anderson, W. Kahan
Venue: Proceedings of the ACM annual conference - Volume 2 (1972)

The first annual George Forsythe Memorial Lecture will be presented by W. Kahan, University of California at Berkeley, on the topic of dealing with ill-defined numerical problems.
Subband image coding using a fixed-rate lattice vector quantizer
Authors: Z. Mohdyusof, T. R. Fischer
Venue: Proceedings of the 1995 International Conference on Image Processing (Vol. 1)-Volume 1 - Volume 1 (1995)

We present a fixed-rate lattice VQ (FRLVQ) for subband image coding. The fixed-rate lattice VQ is an extension of the entropy-coded lattice vector quantizer (ECLVQ) [Mohdyusof and Fischer, 1994]. For an error-free channel, image coding using ECLVQ provides competitive performance with other methods. ECLVQ is a variable length coder, hence a single bit error in the encoded bit stream could lead to error propagation resulting in severe degradation in image quality. A fixed-rate lattice VQ is constructed from the ECLVQ by grouping together several vectors as a "macroblock". The macroblock is encoded at a fixed rate, while allowing a variety of encoding rates for each vector in the macroblock. In the event of a transmission error, error propagation is confined to that particular macroblock. In this work we assume the encoded bit stream is transmitted over a binary symmetric channel. The simulation results show that the FRLVQ subband image coding provides competitive performance with other fixed-rate image coding systems. The simulation results also indicate FRLVQ performance degrades gracefully in the presence of channel noise.
Measurement and analysis of instruction use in the VAX-11/780
Authors: Douglas W. Clark, Henry M. Levy
Venue: Proceedings of the 9th annual symposium on Computer Architecture (1982)

This paper reports measurements of instruction set use on the VAX-11/780 computer. A hardware monitor was used to measure the frequency and time taken by each VAX instruction. Data from benchmark programs, a compiler, a linker, and a synthetic timesharing workload are reported. Results show that although some programs rely on a small set of instructions, different applications use the instruction set in different ways.
Serving the needs of administrative users: Pressure for change in traditional user services and administrative data processing roles and methods
Authors: Janis Rogainis, Andrew M. Smith
Venue: Proceedings of the 10th annual ACM SIGUCCS conference on User services (1982)

This paper will be a joint presentation on an issue for both Academic Computing Support (ACS, the user services group at Clemson) and the Division of Administrative Programming Services (DAPS, the administrative data processing group at Clemson): the expansion of user services to the university's administrative staff. We will consider how each organization approached this problem, how the activities of ACS had an impact on DAPS, and how the problem was tentatively resolved. The question of increased user service support by DAPS was raised about a year and a half ago when the Computer Center initiated the idea of a report-writing/data-retrieval group for administrative personnel. A coordinating committee was formed and included representatives from ACS, DAPS, and the Computer Center administrative staff. While a program for university personnel was within the role of a user services group such as ACS, it created a dilemma for DAPS: how to adhere to the priority of system development set by the university management but also meet the needs of the staff who requested specialized services and reports. While ACS did not have to reassess its role in order to provide service to the administrative user community, it did have to modify its traditional methods in order to serve that community's specialized needs. The areas most subject to change were those of education and consulting. In addition, ACS found it necessary to work closely with DAPS in order to be effective in serving the administrative users. The methods and activities described in this paper will also serve as an example of how a cooperative effort between a user services group and an administrative data processing group can lead to the formation of the nucleus of an Information Center.
Automation techniques for Large Scale Integration system design
Authors: M. T. McMahon, R. Waxman, D. Borecki, R. Preuss
Venue: Proceedings of the 1969 24th national conference (1969)

Integrated Circuit technology has placed many new demands on logic packaging techniques. In order for Large Scale Integration to succeed, additional computer design concepts must be developed. Designers must move away from unit logic and towards dense packages where many integrated circuits are contained in extremely small areas. This implies optimum utilization of input/output connections, since the package size is strongly dependent on the number of I/O's. This paper describes highly-automated computer techniques which may be applied to selected logical graphs to generate the Boolean functions representing the logical graphs. These functions are cataloged into discrete classes. A set of logic functions are then selected from the complete list of discrete classes. Each logical function can cover one or more of the classes in the list. Thus, a small set of logical functions may be utilized to represent a large list of discrete classes obtained from the original partitioning. These functions can be automatically imposed on the original logic graph for evaluation. The automated system is set up to allow rapid evaluation of parameter changes such as function size, and number of function types. The evaluation of functions leads to a set that may be used as the building blocks for implementation of a machine. The designer is free to implement these building blocks in a way that best fits the given technology. This is so because the automated system did not impose any circuit constraints on the logical design. The variable parameters which are included in the system are the number of logical circuits per function, number of I/O's per function, the logic function size allowed, and true and complement available or not available at the output. Reimplementing the machines with the selected function set the packaging parameters that may be varied include the number of functions in a package, the total number of logical circuits in a package, and the number of input and output ports in that assembly. With these freedoms allowed, a designer is in a position to help determine the technology that should be used for his machine design. He can evaluate the amount of redundancy he is willing to allow, and evaluate whether the redundancy actually saves him money or costs him more. He is able to evaluate the effect of the functional density on the wiring complexity since the computer generates the interconnection count between the packaged functions. In this paper, a large high-performance machine and small low-performance machine were analyzed. A function set was chosen for each machine. Results are shown in terms of function usage, logic circuit usage, and wiring complexity.
A hierarchical controller for concurrent accessing of distributed databases
Authors: Mohamed G. Gouda
Venue: Proceedings of the fourth workshop on Computer architecture for non-numeric processing (1978)

An access controller for a distributed database is a (central or distributed) structure which routes access requests to the different components of the database. Such a controller is also supposed to resolve the conflicts between concurrent requests, if any, such that deadlock situations never arise. In this paper, some architectures for distributed access controllers of distributed databases are investigated. In particular, three controllers with hierarchical architectures are considered. The controllers are evaluated based on three criteria: (i) freedom of deadlocks, (ii) robustness, and (iii) parallelism. The third criterion implies that the added redundancy to increase the controller robustness against failure conditions should also contribute to the amount of achieved parallelism during the no-failure periods. We then define a controller architecture which satisfies all the three criteria.
The MACSYMA system for formula manipulation
Authors: J. Moses
Venue: ACM SIGAPL APL Quote Quad (1979)

MACSYMA is a large LISP system which performs symbolic manipulations such as differentiation, simplification, integration and solution of equations with parametric coefficients. After exhibiting various examples of the system, we shall present some of the data representations used by MACSYMA to model abstract algebraic structures such as polynomial rings. Two references are given for those wishing more introductory information about MACSYMA.
Mental models and problem solving in using a calculator
Authors: Frank G. Halasz, Thomas P. Moran
Venue: Proceedings of the SIGCHI conference on Human factors in computing systems (1983)

It has often been suggested that users understand and reason about complex systems on the basis of a mental model of the system's internal mechanics. This paper describes an empirical study of how mental model knowledge is used in operating a stack calculator. One group of naive users were taught step-by-step procedures for solving typical problems on the calculator. A second group of naive users were taught the same procedures in conjunction with an explicit model of the calculator's stack mechanism. The users then solved problems on the calculator while thinking aloud. Analysis of the performance of these two groups indicates that the model had little effect in routine problem solving situations, but significantly improved performance for novel problems. Analyses of the think-aloud protocols indicate that the users employed five distinct modes of problem solving: skilled methods, problem reduction strategies, a conversion algorithm, model-based problem space search, and methods-based problem space search. Skilled methods, problem reduction strategies and the conversion algorithm were used for solving more routine problems and did not necessarily depend on mental model knowledge. Problem space search was used in the novel problems. For the model users, the states and operations of the stack mechanism served as the problem space to be searched for a problem solution. In contrast, the no-model users employed a less effective search strategy based on the recombination of pieces of known procedures. These results indicate that explicitly teaching naive users an appropriate mental model of a system can provide a psychologically effective and robust basis for operating the machine.