ppxscal/embedding_network huggingface dataset:
Supercomputing at the University of Arizona
Authors: Wendy A. Eisner, Mark E. Westergaard
Venue: Proceedings of the 15th annual ACM SIGUCCS conference on User Services (1987)

This paper discusses supercomputing at the University of Arizona. Facilities include access to a Cyber 205 at Princeton's John von Neumann Center (JVNC), and the University of Arizona's own SCS-40 mini-supercomputer. The SCS-40 is a Cray X-MP clone running the Cray Time Sharing operating system (CTSS). It offers a quarter of the computing power of the Cray X-MP for a tenth of the price. The SCS-40 is administered by a local steering committee whose functions include software and hardware acquisition decisions and allocation of supercomputing resources. The committee consists of research faculty and the manager of the Research Support group. One of the functions of the Research Support group of Academic Computing at the Center for Computing and Information Technology, is to support supercomputing at the University of Arizona. This group concentrates on assisting faculty and researchers in modeling their problems on the supercomputers. The staff members of the group have academic backgrounds in statistics, computer science, electrical engineering and information systems. To introduce the supercomputing resources to the user community, the Research Support group conducted a graduate level seminar on supercomputing. Students developed programs on both the JVNC computer and the SCS-40. We will discuss the Research Support group's unique role in supporting and promoting supercomputer use, with specific emphasis on our SCS-40.
Software engineering: the art of the user interview
Authors: Charles D. Sigwart, Gretchen L. Van Meer
Venue: Proceedings of the seventeenth SIGCSE technical symposium on Computer science education (1986)

The specification of a system is a major problem. One useful technique is to involve users in the design process. This requires considerable skill on the part of the software professionals. As one component of our software engineering course we are trying to develop this skill. We ask our students to design a system, and as a part of developing the system specification we give them an opportunity to interview a &ldquo;user.&rdquo; Since real users are often not very helpful, we deliberately arrange that our &ldquo;users&rdquo; will be obtuse regarding technical details of the system. We then conduct follow-up classroom discussion which, we hope, will leave the students with a much more realistic idea of what to expect from a user. A skillful interviewer can often gain valuable insights from users into which aspects of the system are most important to the specifications.
Shared cache multiprocessing with pack computers
Authors: Stanley Lass
Venue: ACM SIGARCH Computer Architecture News (1988)

A typical cache accesses a block, then returns a selected word. In a pack computer design, the cache accesses and returns a block to the computer. The computer selects the word from the block and also retains blocks for reuse. The retained blocks constitute a software cache.Separate block wide caches for instructions, read data, and write data provide enough bandwidth for several pack computers to execute several instructions per cache cycle time.The concept of a pack (bundle of information) is used to bridge part of the conceptual gap between blocks and high level languages.The pack computer design has parallel issue of instructions and has vector operations.
Detecting global variables in denotational specifications
Authors: David A. Schmidt
Venue: ACM Transactions on Programming Languages and Systems (TOPLAS) (1985)

Sufficient criteria are given for replacing all occurrences of the store argument in a Scott-Strachey denotational definition of a programming language by a single global variable. The criteria and transformation are useful for transforming denotational definitions into compilers and interpreters for imperative machines, for optimizing applicative programs, and for judging the suitability of semantic notations for describing imperative languages. An example transformation of a semantics of a repeat-loop language to one which uses a global store variable is given to illustrate the technique.
Normalized specifications for identifying reusable software
Authors: Luqi
Venue: Proceedings of the 1987 Fall Joint Computer Conference on Exploring technology: today and tomorrow (1987)

An approach to retrieving reusable software components by means of module specifications is described. The approach depends on normalizing specifications to reduce the variations in the representation of software concepts. The concept is illustrated in terms of both formal and informal approaches to component specifications.
Are orthogonal transformations worthwhile for least squares problems?
Authors: Richard L Branham,  Jr.
Venue: ACM SIGNUM Newsletter (1987)

Orthogonal transformations are important in many areas of numerical analysis. Even though they may be used for the solution of large least squares systems, their suitability for this task has been exaggerated. For most problems normal equations are adequate and computationally less time consuming.
Computational algebra with APL
Authors: Aarno Hohti
Venue: ACM SIGSAM Bulletin (1988)

The main purpose of this paper is to present the abstract algebra package CLASSLIB of Charles C. Sims to a wider audience. The library consists of more than 200 procedures covering the most of basic algebra as taught at universities, and enables the user to do exact and symbolic algebraic computations, frequently in a way comparable to that of MACSYMA, REDUCE and other programs for symbolic manipulation.
On the optimal nesting order for computing N-relational joins
Authors: Toshihide Ibaraki, Tiko Kameda
Venue: ACM Transactions on Database Systems (TODS) (1984)

Using the nested loops method, this paper addresses the problem of minimizing the number of page fetches necessary to evaluate a given query to a relational database. We first propose a data structure whereby the number of page fetches required for query evaluation is substantially reduced and then derive a formula for the expected number of page fetches. An optimal solution to our problem is the nesting order of relations in the evaluation program, which minimizes the number of page fetches. Since the minimization of the formula is NP-hard, as shown in the Appendix, we propose a heuristic algorithm which produces a good suboptimal solution in polynomial time. For the special case where the input query is a &ldquo;tree query,&rdquo; we present an efficient algorithm for finding an optimal nesting order.
Adding statements to REDUCE
Authors: P van den Heuvel
Venue: ACM SIGSAM Bulletin (1986)

New REDUCE packages often require additions to the REDUCE syntax. In this note we present a detailed description of REDUCE parsing tools and step-by-step instructions of adding new statements.
One-sided recursions
Authors: J. F. Naughton
Venue: Proceedings of the sixth ACM SIGACT-SIGMOD-SIGART symposium on Principles of database systems (1987)

The performance of systems with recursive query languages can be improved by recognizing simple, easily evaluable classes of recursions and using algorithms tailored to these classes whenever possible. In this paper we identify a useful subset of recursive definitions, the one-sided recursions. We show how to detect one-sided recursions, and give two simple evaluation algorithms that cover one-sided definitions in that for any selection on a one-sided definition, at least one of the two algorithms will apply. These algorithms have simple termination conditions, maintain minimal state and use selections on the recursively defined relation whenever possible. We show that there are no similar algorithms for many-sided recursions We also prove that it is undecidable whether an arbitrary definition has an equivalent one-sided definition. However, we do present a procedure that converts many potentially one-sided recursions to one-sided form, and prove it complete for a useful class of recursions.
Mimic: a fast system/370 simulator
Authors: C. May
Venue: Papers of the Symposium on Interpreters and interpretive techniques (1987)

Software simulation of one computer on another tends to be slow. Traditional simulators typically execute about 100 instructions on the host machine per instruction simulated. Newer simulators reduce the expansion factor to about 10, by saving and reusing translations of individual instructions. This paper describes an experimental simulator which takes the progression one step further, translating groups of instructions as a unit. This approach, combined with flow analysis, reduces the expansion factor to about 4. The new simulator simulates System/370 on a RISC, namely the IBM RT PC.
Graphic interfaces for knowledge-based system development
Authors: S. E. Poltrock, D. D. Steiner, P. N. Tarlton
Venue: ACM SIGCHI Bulletin (1986)

Creating and debugging knowledge-based systems, such as expert systems, requires easy access to rules and facts in a vast, loosely-connected system. Three graphic representations were devised for a system development tool that integrates forward chaining, backward chaining, and full truth maintenance. In one representation, possible interactions among rules, determined by syntactically parsing the rules, are displayed as a directed graph. In a second representation, actual interactions among facts and rules are displayed dynamically. The third representation is a fish-eye view of the knowledge base that explains why a fact was asserted. In addition, the text of rules and facts is displayed in editing windows.
Four relational programs
Authors: B. J. MacLenna
Venue: ACM SIGPLAN Notices (1988)

In this report we demonstrate the relational programming language RPL by using it to develop four programs. These programs are: (1) computing a table of word frequencies from a text; (2) a simple data processing example involving updating an employee file; (3) Gaussian elimination; and (4) minimizing deterministic finite state automata. We do not present the RPL language systematically; rather it is described incrementally through the examples.
MIDETT: Microprogrammed-system design technique and tools
Authors: M. Annunziata, L. Lisca, G. R. Sechi
Venue: Proceedings of the 19th annual workshop on Microprogramming (1986)

This paper presents a design technique for computational systems based on the concepts of Model, Abstraction, and Simulation. This technique, developed and evaluated especially in Real Time System applications, is particularly useful to design hierarchical multiprocessor microprogrammed systems. A set of tools and facilities for designing and building the system is also shown.
Enumeration of structured flowcharts
Authors: Edward A. Bender, Jon T. Butler
Venue: Journal of the ACM (JACM) (1985)

An analysis of structured flowcharts is presented, where size is measured by the number, n, of decision nodes (IF-THEN-ELSE and DO-WHILE nodes). For all classes of structured flowcharts considered, the number of charts is approximately, cn-3/2&ggr;n, for large n, where c>and &ggr; are parameters that depend on the class. It is also shown that most large flowcharts consist of a short sequence of basic charts (IF-THEN-ELSE and DO-WHILE charts). The average length of such sequences is 2.5.
Optimal reconfiguration strategy for a degradable multimodule computing system
Authors: Yann-Hang Lee, Kang G. Shin
Venue: Journal of the ACM (JACM) (1987)

A new quantitative approach to the problem of reconfiguring a degradable multimodule system is presented. The approach is concerned with both assigning some modules for computation and arranging others for reliability. Conventionally, a fault-tolerant system performs reconfiguration only upon a subsystem failure. Since there exists an inherent trade-off between the computation capacity and fault tolerance of a multimodule computing system, the conventional approach is a passive action and does not yield a configuration that provides an optimal compromise for the trade-off. By using the expected total reward as the optimal criterion, the need and existence of an active reconfiguration strategy, in which the system reconfigures itself on the basis of not only the occurrence of a failure but also the progression of the mission, are shown. Following the problem formulation, some important properties of an optimal reconfiguration strategy, which specify (i) the times at which the system should undergo reconfiguration and (ii) the configurations to which the system should change, are investigated. Then, the optimal reconfiguration problem is converted to integer nonlinear knapsack and fractional programming problems. The algorithms for solving these problems and a demonstrative example are given. Extensions of the optimal reconfiguration problem are also discussed.
Dialogue management reference model
Authors: Norwood Sisson
Venue: ACM SIGCHI Bulletin (1986)

I would like to review and extend the discussion of the layered structure model similar to the ISO Open Systems Interconnect model in the Report on the SIGCHI Workshop on Planning for User Interface Standards published in the October, 1985 SIGCHI Bulletin. First, I would like to compliment the people who worked on the report. They produced a document which I regard as correct, however incomplete. Bullinger and Faehnrich in Germany have published papers on what they regard as the User Interface Management System. I have integrated Figure 3 and Figure 4 from the CHI '85 Report with the diagrams from Bullinger et al to produce Figure 1. The layers added---semantic, syntactic and lexical---are commonly used in the implementation of compilers and interpreters and are supported by many tools referred to as compiler compilers i.e., yacc and lex from the UNIX system. In the ISO OSI reference model, interfaces exist at the vertical arrows between adjacent layers, protocols exist between peer layers. The term "user interface" conflicts with the ISO usage of "interface." I will instead refer to "human-computer dialog rules." Human-computer dialog rules are the set of peer layer protocols along with the user feedback rules, and appear as horizontal arrows on Figure 1. It is the set of human-computer dialog rules that should be standardized by SIGCHI members. Interfaces between the adjacent layers are implementation details and should be standardized by implementors.
Analytical modeling and architectural modifications of a dataflow computer
Authors: D. Ghosal, L. N. Bhuyan
Venue: Proceedings of the 14th annual international symposium on Computer architecture (1987)

Dataflow computers are an alternative to the von Neumann architectures and are capable of exploiting large amount of parallelism inherent in many computer applications. This paper deals with the performance analysis of the Manchester dataflow computer based on queueing network models. The model of the dataflow computer has been validated by comparing the analytical results with those obtained from the prototype Manchester dataflow computer. The bottleneck centers in the prototype machine have been identified through the model and various architectural modifications have been investigated both from performance and reliability viewpoints.
On hiding information from an oracle
Authors: M. Abadi, J. Feigenbaum J. Kilian
Venue: Proceedings of the nineteenth annual ACM symposium on Theory of computing (1987)

We consider the problem of computing with encrypted data. Player A wishes to know the value &fnof;(x) for some x but lacks the power to compute it. Player B has the power to compute &fnof; and is willing to send &fnof;(y) to A if she sends him y, for any y. Informally, an encryption scheme for the problem &fnof; is a method by which A, using her inferior resources, can transform the cleartext instance x into an encrypted instance y, obtain &fnof;(y) from B, and infer &fnof;(x) from &fnof;(y) in such a way that B cannot infer x from y. When such an encryption scheme exists, we say that &fnof; is encryptable. The framework defined in this paper enables us to prove precise statements about what an encrypted instance hides and what it leaks, in an information-theoretic sense. Our definitions are cast in the language of probability theory and do not involve assumptions such as the intractability of factoring or the existence of one-way functions. We use our framework to describe encryption schemes for some natural problems in NP &Cap; CoNP. We also consider the following generalization of encryption schemes. Player A, who is limited to probabilistic polynomial time, wishes to guess the value &fnof;(x) with probability at least 1/2 + 1/|x|c of being correct, for some constant c. Player B can compute any function and generate arbitrary probability distributions. Players A and B can interact for a polynomial number of rounds by sending polynomial-sized messages. We prove a strong negative result: there is no such generalized encryption scheme for SAT that leaks no more than the size of x (unless the polynomial hierarchy collapses at the second level).
Dimensions of object-based language design
Authors: Peter Wegner
Venue: ACM SIGPLAN Notices (1987)

The design space of object-based languages is characterized in terms of objects, classes, inheritance, data abstraction, strong typing, concurrency, and persistence. Language classes (paradigms) associated with interesting subsets of these features are identified and language design issues for selected paradigms are examined. Orthogonal dimensions that span the object-oriented design space are related to non-orthogonal features of real languages. The self-referential application of object-oriented methodology to the development of object-based language paradigms is demonstrated. Delegation is defined as a generalization of inheritance and design alternatives such as non-strict, multiple, and abstract inheritance are considered. Actors and prototypes are presented as examples of classless (delegation based) languages. Processes are classified by their degree of internal concurrency. The potential inconsistency of object-oriented sharing and distributed autonomy is discussed, suggesting that compromises between sharing and autonomy will be necessary in designing strongly typed object-oriented distributed database languages.
A visual language compiler
Authors: S. K. Chang, M. J. Tauber, B. Yu
Venue: Proceedings of the 1987 Fall Joint Computer Conference on Exploring technology: today and tomorrow (1987)

In this paper, the design of a visual language compiler, the SIL-ICON Compiler is described. The SIL-ICON Compiler is a software system for the specification, interpretation, prototyping, and generation of icon-oriented systems. An application example to design a text editor using the Heidelberg Icon Set is presented in detail.
A data-driven model for a subset of logic programming
Authors: Lubomir Bic, Craig Lee
Venue: ACM Transactions on Programming Languages and Systems (TOPLAS) (1987)

There is a direct correspondence between semantic networks and a subset of logic programs, restricted only to binary predicates. The advantage of the latter is that it can describe not only the nodes and arcs comprising a semantic net, but also the data-retrieval operations applied to such nets. The main objective of this paper is to present a data-driven model of computation that permits this subset of logic programs to be executed on a highly parallel computer architecture. We demonstrate how logic programs may be converted into collections of data-flow graphs in which resolution is viewed as a process of finding matches between certain graph templates and portions of the data-flow graphs. This graph fitting process is carried out by messages propagating asynchronously through the data-flow graph; thus computation is entirely data driven, without the need for any centralized control and centralized memory. This permits a potentially large number of independent processing elements to cooperate in solving a given query.
A simple and efficient implementation of a small database
Authors: A. Birrell, M. Jones, E. Wobber
Venue: Proceedings of the eleventh ACM Symposium on Operating systems principles (1987)

This paper describes a technique for implementing the sort of small databases that frequently occur in the design of operating systems and distributed systems. We take advantage of the existence of very large virtual memories, and quite large real memories, to make the technique feasible. We maintain the database as a strongly typed data structure in virtual memory, record updates incrementally on disk in a log and occasionally make a checkpoint of the entire database. We recover from crashes by restoring the database from an old checkpoint then replaying the log. We use existing packages to convert between strongly typed data objects and their disk representations, and to communicate strongly typed data across the network (using remote procedure calls). Our memory is managed entirely by a general purpose allocator and garbage collector. This scheme has been used to implement a name server for a distributed system. The resulting implementation has the desirable property of being simultaneously simple, efficient and reliable.
Productivity through automated tools
Authors: P O Bobbie
Venue: ACM SIGSOFT Software Engineering Notes (1987)

Of late, there have been several discussions of various methodologies and techniques for improving software development productivity. Current methodologies include executable specification languages, integrated software environments, and Artificial Intelligence (AI) based shells. The following discussion addresses various contexts in which advanced software tools can promote software productivity.
The SIGMA-1 dataflow computer
Authors: T. Yuba, K. Hiraki, T. Shimada, S. Sekiguchi, K. Nishida
Venue: Proceedings of the 1987 Fall Joint Computer Conference on Exploring technology: today and tomorrow (1987)

SIGMA-1 is the most exciting practical computer prototype with dataflow architecture. The project aims to outperform conventional von Neumann computers. This large-scale dataflow computer, for scientific and technological computations, is in the final stage of the design and construction phase at the Electrotechnical Laboratory, Ministry of International Trade and Industry. This paper overviews the system architecture of the SIGMA-1, and discusses the performance measurements made recently. The architectural issues in dataflow computing machines and the design decisions made in the SIGMA-1 project in achieving 100 MFLOPS performance are presented. The history of the SIGMA-1 project is also outlined.
A multi-purpose language processing laboratory
Authors: Karen A. Lemone
Venue: Proceedings of the eighteenth SIGCSE technical symposium on Computer science education (1987)

This paper describes the design and implementation of a tool for creating language processors, in particular, translator generators. The purpose of this tool is to allow the fast implementation of (non-production quality) translators for any language, however exotic, for which a grammar can be written, and to generate compiler phases with &ldquo;hooks&rdquo; which show the compiling process in action for use in compiler construction courses. The emphasis is on a user-friendly metalanguage which is consistent for the various phases of the parameterized tool. Use of the tool in a graduate compiler construction course revealed the strengths of this metalanguage as well as providing a test site for other improvements and further development of the tool.
Symbolic integration of expressions involving unspecified functions
Authors: Graham H. Campbell
Venue: ACM SIGSAM Bulletin (1988)

The problem of determining an expression whose derivative is a specified expression when that expression involves unspecified functions is analyzed. An algorithm is presented which reduces this problems to that of integration of specified functions.