ppxscal/embedding_network huggingface dataset:
Strategies for scientific prototyping in Smalltalk
Authors: S. S. Walther, R. L. Peskin
Venue: ACM SIGPLAN Notices (1989)

This paper describes the design of a scientific prototyping environment in Smalltalk and discusses implementation strategies to achieve high performance interactive modeling of computationally intensive physical problems. Classes for scientific visualization, including contour plotting and 3D surface representations which incorporate the model-view-controller paradigm are presented. Techniques for inclusion of user primitives written in C to support computationally intense methods are described in detail in their current implementation on advanced Smalltalk workstations (SUN4, Ardent Titan, Tektronix 4317).
A scientific visualization workbench
Authors: R. L. Philips
Venue: Proceedings of the 1988 ACM/IEEE conference on Supercomputing (1988)

A system for visualization of data from supercomputer simulations has been developed for use by scientists and engineers at Los Alamos National Laboratory. The scientific visualization workbench, as the system is called, is based on an industry standard workstation (a Sun 3/160C), the NeWS window system, and a video/graphics add-in card, which is supported by NeWS. Also involved is a frame buffer attached to a 48-Mbit/s Cray channel and a video link from the frame buffer to the Sun workstation. Computation and graphics preparation are performed on the Cray under the control of a NeWS client program. Images are rasterized and sent to the workstation at the rate of 25 frames/s. The workbench permits the scientist to converse with applications running on a Cray but still retain the convenience and flexibility of a personal workstation environment. Moreover, the video link allows animated graphics images to be displayed on the workstation at a much higher rate than would be possible with a conventional network connection, i.e., Ethernet. Also, NeWS affords the convenience of a modern window system. Live video can be displayed in a window anywhere on the screen, while other windows may contain conventional text or graphics.
Geometric collisions for time-dependent parametric surfaces
Authors: Brian Von Herzen, Alan H. Barr, Harold R. Zatz
Venue: Proceedings of the 17th annual conference on Computer graphics and interactive techniques (1990)

We develop an algorithm to detect geometric collisions between pairs of time-dependent parametric surfaces. The algorithm works on surfaces that are continuous and have bounded derivatives, and includes objects that move or deform as a function of time. The algorithm numerically solves for the parametric values corresponding to coincident points and near-misses between the surfaces of two parametric functions.Upper bounds on the parametric derivatives make it possible to guarantee the successful detection of collisions and near-misses; we describe a method to find the derivative bounds for many surface types. To compute collisions between new types of surfaces, the mathematical collision analysis is needed only once per surface type, rather than analyzing for each pair of surface types.The algorithm is hierarchical, first finding potential collisions over large volumes, and then refining the solution to smaller volumes. The user may specify the desired accuracy of the solution. A C-code implementation is described, with results for several non-bicubic and bicubic time-dependent parametric functions. An animation of the collision computation demonstrates collisions between complex parametric functions.
An algorithm for finding all isolated zeros of polynomial systems
Authors: Z-J. Liu
Venue: Proceedings of the international symposium on Symbolic and algebraic computation (1990)

1. Solving algebraic equations is desired for many problems appeared in the applied science. Sometimes, finding all isolated solutions is enough. Suppose a set of polynomials(abbr. polset), denoted by PS, to be given. As a usual convention, by Zero(PS) and ISZero(PS), we respectively denote the zeros and isolated zeros defined by PS. Recently, the homotopy continuation method was widely used to find all isolated zeros of polset. However, as [1] indicated, that method is not good enough to find the isolated zeros of any polset. Here, based on Wu's method, we introduce a new algorithm to solve this problem. 2. The Wu's method is general enough to solve any polynomial(abbr. pol) systems in any number of variables. More details about this can be found in [3] and other relevant papers. Given any PS over K[x1, &hellip;, xn]. According to Wu's method, we can construct a so-called characteristic set(abbr. char-set) CS which possess the following form I1(u1 &hellip;, ud) * yd11 + lower-degree terms in y1, I2(u1, &hellip;, ud, y1) * yd11 + lower-degree terms in y2, (1) Ie(u1, &hellip;, ud, y1, &hellip;, ye-1) * yde e + &hellip; where (u1, &hellip;, ud, y1, &hellip;, ye) is some permutation of (x1, &hellip;, xn). 3. Now, by Zero(PS/J) and ISZero(PS/J), we denote the point set which included in Zero(PS) and ISZero(PS) respectively but such that J &ne; 0. Then we have Theorem 1. Given PS, if there are n pols in CS, then ISZero(PS) = Zero(CS/J) + ISZero (PS + {J}). We can further get Corollary 1. Given PS, if there are n pols in CS, then for any given pol F, we have ISZero(PS/F) = Zero(CS/J * F) + ISZero((PS + {J})/F). By using induction, we can prove Theorem 2. Suppose AS to be an ascending set (abbr. asc-set) with the form (1). If d < 0 and Zero(AS/J) &ne; 0, then for any X &isin; Zero (AS/J), X is non-isolated w.r.t. Zero(AS/J). By using Theorem 2, we can readily deduce Corollary 2. There is an algorithm with which form (2) can be gotten from any polset PS. (2) ISZero(PS) &sube; &Sgr;l Zero (ASl/Jl). where ASl has the form (1) and d = 0. It should be remarked that 1. ISZero(PS) is finite owing to the right side of (2) is finite. 2. If Zero(PS) is finite, then we have Zero(PS) = ISZero(PS) = &Sgr;l Zero(ASl/Jl). Our algorithm to find the isolated zeros of polset has been implemented on SUN-3/50 by using REDUCE 3.3. By using this algorithm, we have solved the Lorenz equations described as below (see [2]) x2 * (x3 - x4) - x1 + c = 0, x3 * (x4 - x1) - x2 + c = 0, x4 * (x1 - x2) - x3 + c = 0, x1 * (x2 - x3) - c = 0. We indicate that Lorens equations have 11 different generic solutions.
On the design of the amoeba configuration manager
Authors: E. H. Baalbergen, K. Verstoep, A. S. Tanenbaum
Venue: ACM SIGSOFT Software Engineering Notes (1989)

The program Amoeba Make, or Amake, is being designed to fulfil the need of a make-like configuration manager capable of exploiting the potentials of the Amoeba distributed operating system. The major design goal is to create a software configuration manager that is both easy to use and efficient. The specification and maintenance of a large configuration should be easy, and should be automated as much as possible. Furthermore, the build process should exploit Amoeba's capabilities and resources when creating or updating a target. In this paper we show how a smart file server can contribute to Amake's efficiency. We also show how a declarative configuration description allows Amake to take full advantage of parallelism and to determine the commands needed for building and maintaining targets.
A microprogramming teaching environment using the Macintosh computer
Authors: E. Sanchez
Venue: Proceedings of the 22nd annual workshop on Microprogramming and microarchitecture (1989)

A microprogramming teaching environment is presented. It is composed of a hardware part (a 16 bit microprogrammable processor) and a software part, running on a Macintosh II computer. The software includes 6 modules: two microassemblers - one uses a classical approach to generate microcode from a description in a register transfer language and the other one, which is more unusual, is menu-driven -; a disassembler; a monitor allowing one to display and modify the processor resources, as well as to control the execution; a memory loader and a simulator. The interactive and convivial nature of the Macintosh computer, and especially the HyperCard application, are used thoroughly in order to facilitate a utilization of the system.
The relationship between software development environments and the software process
Authors: David Notkin
Venue: ACM SIGPLAN Notices (1989)

The program committee originally planned for this panel session (and this introduction) to provide a summary of the 4th International Workshop on the Software Process. I have taken the liberty of covering a slightly more general view of the relationship between software development environments and the software process.
Parallel Graph Algorithms Based Upon Broadcast Communications
Authors: Chang-Biau Yang, R. C. T. Lee, Wen-Tsuen Chen
Venue: IEEE Transactions on Computers (1990)

Some common guidelines that can be used to design parallel algorithms under the single-channel broadcast communication model are presented. Several graph problems are solved, including topological ordering, the connected component problem, breadth-first search, and depth-first search. If an ideal conflict resolution scheme is used, all of the algorithms require O(n) time by using n processors. Under such a situation, the algorithms are all optimal. If a realistic conflict resolution is used, the algorithms require O(n log n) time by using n/log n processors. For both cases, all of the algorithms achieve optimal speedups.
Spacefilling curves and the planar travelling salesman problem
Authors: Loren K. Platzman, John J. Bartholdi,  III
Venue: Journal of the ACM (JACM) (1989)

To construct a short tour through points in the plane, the points are sequenced as they appear along a spacefilling curve. This heuristic consists essentially of sorting, so it is easily coded and requires only O(N) memory and O(N log N) operations. Its performance is competitive with that of other fast methods.
Modeling and Performance Analysis of Single-Bus Tightly-Coupled Multiprocessors
Authors: B. L. Bodnar, A. C. Liu
Venue: IEEE Transactions on Computers (1989)

A hierarchical stochastic queuing model is presented that consists of a set of processing elements (PEs) and a single queue/server pair representing the shared memory. The model takes into account not only global system behavior but also behavior of tasks on each processing element and probabilistic task migration among the PEs. It is shown that through the use of repeated aggregation each PE can be treated as a queue/state-dependent server pair. This reduction results in an immense simplification of the model. A CPU sensitivity analysis of this reduced model shows that at high CPU service rates, varying the CPU speed has a negligible effect on the server's state-dependent service rate, whereas at low CPU service rates, varying the CPU speed has an effect that depends on the local branching probabilities. Global performance metrics are then obtained on the basis of this reduction.
Parameterization: a case study
Authors: Will Tracz
Venue: ACM SIGAda Ada Letters (1989)

This paper describes the parameterization of a simple Ada program. Ada was designed to include many programming language constructs that facilitate the development of parameterized software abstractions. By presenting parameterization as a series of incremental steps that separate and refine data abstractions, this paper illustrates certain Ada language features, programming design decisions, and tradeoffs that need to be taken into consideration when developing adaptable, reusable software. Once the parameterization process is quantified, a description of how existing programs can be automatically parameterized is presented.
A Gracefully Degradable VLSI System for Linear Programming
Authors: A. A. Bertossi, M. A. Bonuccelli
Venue: IEEE Transactions on Computers (1989)

The use of a fault-tolerant VLSI system for storing and solving linear programming problems is presented. The system can bear multiple faults in processing elements and/or links and still function with an acceptable performance degradation. It is based on an interconnection pattern consisting of a complete binary tree in which spare links between cousin nodes are added so as to reconfigure it as a ternary tree. At any given time of a computation, faulty processing elements and/or links are circumvented by using such spare links. It is shown that the total silicon area required by this structure is only a constant factor higher than that of a complete binary tree. The result is used to give an efficient implementation of the simplex algorithm in which the time required to perform a single pivot step matches a previously established lower bound for tree machines in spite of faults.
An exercise in the formal derivation of parallel programs: maximum flows in graphs
Authors: Edgar Knapp
Venue: ACM Transactions on Programming Languages and Systems (TOPLAS) (1990)

We apply a new method for the development of parallel programs to the problem of finding maximum flows in graphs. The method facilitates concurrent program design by separating the concerns of correctness from those of hardware and implementation. It uses predicate transformer semantics to define a set of basic operators for the specification and verification of programs. From an initial specification program development proceeds by a series of refinement steps, each of which constitutes a strengthening of the specification of the previous refinement. The method is completely formal in the sense that all reasoning steps are performed within predicate calculus. A program is viewed as a mathematical object enjoying certain properties, rather than in terms of its possible executions. We demonstrate the usefulness of the approach by deriving an efficient algorithm for the Maximum Flow Problem in a top-down manner.
The design of very fast portable compilers
Authors: A. S. Tanenbaum, M. F. Kaashoek, K. G. Langendoen, C. J. H. Jacobs
Venue: ACM SIGPLAN Notices (1989)

The Amsterdam Compiler Kit is a widely used compiler building system. Up until now, the emphasis has been on producing good object code. In this paper we describe recent work that has focused on reducing compile time. The techniques described in this paper have resulted in C compilers for the Sun-3 and VAX that are 3 to 4 times faster than the native compilers provided by the manufacturers.
A Planning Model with Problem Analysis and Operator Hierarchy
Authors: K.-H. Chang, W. G. Wee
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1988)

A planning model described in terms of its goal analysis and hierarchical operator representation is presented. With this system, successful plans have been made for nonlinear problems that are described as a conjunction of subgoals. The system uses heuristic rules to analyze the problem, and thus achieves an ordered sequence of subgoals and constraints that can be achieved successively without interfering with each other. The operators are designed in a goal-oriented fashion and are stored in operator hierarchies. During the plan generation phase, each subgoal is mapped into a goal operator, which is further refined to meet details and specific conditions of the problem. As the generation phase follows the analysis, conflicts among subgoals are eliminated implicitly.
An example of application of symbolic computation in solid state physics
Authors: S. A. Vorontsov
Venue: Journal of Symbolic Computation (1989)

A system of symbolic computation is applied to the calculation of rather lengthy and cumbersome polynomial which is a sum of traces of different matrix products. The polynomial is the essential part of a formula for the magnetic susceptibility of electrons. The output file of a symbolic computation program is included as a Fortran routine into the main program for the calculation of the magnetic susceptibility. A numerical test of the routine in comparison with a routine made by straightforward programming of the formula for the polynomial was carried out.
Electron beam tester a tool for VLSI components analysis
Authors: Gérard Bourgeon
Venue: Microelectronic Engineering (1988)

The increasing complexity of VLSI components requires the use of more powerful tools to verify them. One of these tools, the electron beam tester can bring a new powerful help in various ways during the life of an integrated circuit. The purpose of this paper is to present briefly CAMECA works about electron beam tester.
Strong typing of object-oriented languages revisited
Authors: Ole Lehrmann Madsen, Boris Magnusson, Birger Mølier-Pedersen
Venue: Proceedings of the European conference on object-oriented programming on Object-oriented programming systems, languages, and applications (1990)

This paper is concerned with the relation between subtyping and subclassing and their influence on programming language design. Traditionally subclassing as introduced by Simula has also been used for defining a hierarchical type system. The type system of a language can be characterized as strong or weak and the type checking mechanism as static or dynamic. Parameterized classes in combination with a hierarchical type-system is an example of a language construct that is known to create complicated type checking situations. In this paper these situations are analyzed and several different solutions are found. It is argued that an approach with a combination of static and dynamic type checking gives a reasonable balance also here. It is also concluded that this approach makes it possible to base the type system on the class/subclass mechanism.
Using concept expansion and level integration in an introductory computer science course
Authors: Barry L. Kurtz, J. Mack Adams
Venue: ACM SIGCSE Bulletin (1988)

An introduction to computer science is supposed to teach problem solving and programming skills, but far too often only the latter is emphasized. One reason for this is the organization of texts by syntactic categories for a particular programming language. We report on an approach that uses concept expansion (expanding a concept from its simple form to more complex forms as needed to aid in problem solving) and level integration (combining several concepts at the same level of difficulty). Three detailed examples are given: flow of control, recursion, and information hiding. We have been using this approach at New Mexico State for the last two years and have found it to be helpful in restoring the intended balance between problem solving and acquiring programming skills.
System structure and software maintenance performance
Authors: Virginia R. Gibson, James A. Senn
Venue: Communications of the ACM (1989)

An experiment is designed to investigate the relationship between system structure and maintainability. An old, ill-structured system is improved in two sequential stages, yielding three system versions for the study. The primary objectives of the research are to determine how or whether the differences in the systems influence maintenance performance; whether the differences are discernible to programmers; and whether the differences are measurable. Experienced programmers perform a portfolio of maintenance tasks on the systems. Results indicate that system improvements lead to decreased total maintenance time and decreased frequency of ripple effect errors. This suggests that improving old systems may be worthwhile and may yield benefits over the remaining life of the system. System differences are not discernible to programmers; apparently programmers are unable to separate the complexity of the systems from the complexity of the maintenance tasks. This finding suggests a need for further research on the efficacy of subjectively based software metrics. Finally, results indicate that a selected set of automatable, objective complexity metrics reflected both the improvements in the system and programmer maintenance performance. These metrics appear to offer potential as project management tools.
The international standardization of Modula-2
Authors: K. N. King
Venue: Proceedings of the 17th conference on ACM Annual Computer Science Conference (1989)

The process of creating an international standard for the Modula-2 programming language is now well underway. This paper (an updated and expanded version of [12]) describes current standardization efforts and sketches a number of changes being planned for the language.
Developmental scenario analysis of Smalltalk programming
Authors: Robert L. Campbell
Venue: Proceedings of the SIGCHI conference on Human factors in computing systems: Empowering people (1990)

In order to understand long-term learning and the acquisition of expertise, human-computer interaction needs to take a developmental turn. Adopting a developmental approach means using longitudinal research methods, building developmental sequence models of the acquisition of expertise, and analyzing tasks as scenarios specific to developmental levels. The psychology of programming seems particularly amenable to a developmental approach because of the length of time that it takes to become an expert. We propose a model of seven developmental levels for Smalltalk/V programming, and provide sample scenarios for each level. We conclude that developmentally ordered scenarios convey valuable design information that would be lost in the standard &ldquo;average user&rdquo; approach to scenarios.
CTDNet-A Mechanism for the Concurrent Execution of Lambda Graphs
Authors: J. P. Gupta, S. C. Winter, D. R. Wilson
Venue: IEEE Transactions on Software Engineering (1989)

The authors describe CTDNet, a data-driven reduction machine for the concurrent execution of applicative functional programs in the form of lambda calculus expressions. Such programs are stored as binary-tree-structured process graphs in which all processes maintain pointers to their immediate neighbors (i.e. ancestor and two children). Processes are of two basic types: master processes, which represent the original process graph, and slave processes, which carry out the actual executional work and are dynamically created and destroyed. CTDNet uses a distributed eager evaluation scheme with a modification to evaluate conditional expressions lazily, together with a form of distributed string reduction with some graphlike modifications.
Tietze transformations with weighted substring search
Authors: Edmund F. Robertson
Venue: Journal of Symbolic Computation (1988)

We describe how, by generalizing the notion of the length of words in a group presentation, we have developed a computer program which can be directed by the user towards finding relators of a certain type. We present evidence to show that the user can direct the program, by choosing a suitable length function, towards finding the order of a specified generator. Evidence also suggests that simpler final presentations are obtained if the length function is chosen so that the program is positively directed towards increasing occurrences of certain generators that the elimination routine is directed to retain.
User-interface design for a clinical neurophysiological intensive monitoring system
Authors: T. F. Collura, E. C. Jacobs, R. C. Burgess, G. H. Klem
Venue: Proceedings of the SIGCHI conference on Human factors in computing systems: Wings for the mind (1989)

We describe the functional requirements and design reasoning leading to a user-interface for an automated clinical neurophysiological monitoring system. The design provides a versatile, high-performance system in which computer-naive users have access to functions typically requiring dedicated training.The system provides real-time data acquisition, signal processing, and graphical output, specifically tailored for the diagnosis and characterization of cases of epilepsy. The development of a user-interface was based on a collaborative effort, in which designers and users worked with a common functional model, and developed working metaphors for system operations. In addition, an interactive screen was designed to facilitate the management of multiple concurrent operations in an intuitive and easy to learn fashion.