ppxscal/embedding_network huggingface dataset:
Competing in the ACM scholastic programming contest (abstract)
Venue: Proceedings of the 1993 ACM conference on Computer science (1993)

The Scholastic Programming Contest was conceived as a vehicle to showcase the talents of some of the brightest young computer scientists in the world. Its founding precept was to provide a competition that is challenging, exciting, and most of all, enjoyable for the contestants. The recent addition of the contest sponsor, AT T EasyLink Services, has made it possible to significantly improve the quality of the contest for contestants at all levels, including the institution of a major prize structure at the Contest Finals. Many participants would agree that this has had the effect of increasing the level of competitiveness between the teams. This panel session will explore the variety of ways in which teams prepare themselves for the competition while maintaining that all-important sense of enjoyment which is at the heart of the ACM Scholastic Programming Contest. Some questions to be addressed by the panel are: How are the teams selected for the regional competition? What techniques are used to prepare those teams for the regional contest? Is preparation for the Contest Finals any different from preparing for the regionals? In what ways does teamwork play a part in the contest? What effect has lowering the size of the teams from four to three in 1991-92 had on the role of teamwork? What changes, if any, should be made in the contest competition? For instance, does the contest focus too much on &ldquo;programming-in-the-small&rdquo; and &ldquo;quick-and-dirty programming&rdquo; over current software engineering techniques? Should the contest continue emphasizing the procedure-oriented paradigm, or should other paradigms (especially object-oriented) be included in order to reflect current programming trends? This panel is a continuation of a session held at CSC '91 [1]. The panelists for this year's session will be mostly composed of advisors and competitors from the international community, reflecting the increased representation in the contest by non-USA teams (from three in 1988 to eight in 1992). Due to the timing of the regional contests, the panel participants were mostly undetermined as of press time. [1] Bagert, Donald; Chavey, Darrah; Mourey, Thomas L.; Van Brackle, David; and Werth, John. Preparing a team for the ACM Scholastic Programming Contest. Proceedings CSC '91, 5-7 March 1991, page 701.
Efficient implementation of object-oriented programming languages (abstract)
Authors: Craig Chambers, David Ungar
Venue: ACM SIGPLAN OOPS Messenger (1993)

Efficient Implementation of Object-Oriented Programming Languages Craig Chambers, University of Washington, David Ungar, Sun Labs This tutorial is for those who like to know how object-oriented languages work under the hood, why some things are expensive while other things are cheap, and why language definitions include certain restrictions. This tutorial provides that, and more. It describes features of object-oriented languages that are difficult to implement efficiently, and how this has affected language designs. It describes state-of-the-practice and state-of-the-art techniques for implementing languages like C++ and Smalltalk. Language features include dynamic binding and generic operations, inheritance, user-defined control structures, static type systems, multiple inheritance and virtual base classes, and mixing object-oriented and non-object-oriented programming. The tutorial also addresses questions like: What are the trade-offs in using the various implementation techniques? What problems remain that block more efficient object-oriented language implementations? What might be promising areas for future research?
Towards efficient partial evaluation
Authors: Karoline Malmkjær
Venue: Proceedings of the 1993 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation (1993)

In general, a partial evaluator needs to keep track of the tasks that have already been completed or initiated, so that it can recognize when to stop unfolding. In the MIX-style polyvariant specialization algorithm, this is accomplished by a global log. This is a very general technique, so it is not surprising that the algorithm is not particularly efficient. In many special cases a simpler technique would suffice. In this paper, we identify some classes of such special cases by considering the purpose of the global log. We outline how a partial evaluator can take advantage of these special cases and we propose analyses to detect them automatically. We discuss examples to illustrate the effect on specialization and to demonstrate that we can even obtain better residual programs. The work presented here is still in its early stages, and we do not have a full system incorporating the proposed improvements.
Extending cryptographic logics of belief to key agreement protocols
Authors: Paul van Oorschot
Venue: Proceedings of the 1st ACM conference on Computer and communications security (1993)

The authentication logic of Burrows, Abadi and Needham (BAN) provided an important step towards rigourous analysis of authentication protocols, and has motivated several subsequent refinements. We propose extensions to BAN-like logics which facilitate, for the first time, examination of public-key based authenticated key establishment protocols in which both parties contribute to the derived key (i.e. key agreement protocols). Attention is focussed on six distinct generic goals for authenticated key establishment protocols. The extended logic is used to analyze three Diffie-Hellman based key agreement protocols, facilitating direct comparison of these protocols with respect to formal goals reached and formal assumptions required.
Atomic incremental garbage collection and recovery for a large stable heap
Authors: Elliot K. Kolodner, William E. Weihl
Venue: Proceedings of the 1993 ACM SIGMOD international conference on Management of data (1993)

A stable heap is storage that is managed automatically using garbage collection, manipulated using atomic transactions, and accessed using a uniform storage model. These features enhance reliability and simplify programming by preventing errors due to explicit deallocation, by masking failures and concurrency using transactions, and by eliminating the distinction between accessing temporary storage and permanent storage. Stable heap management is useful for programming languages for reliable distributed computing, programming languages with persistent storage, and object-oriented database systems. Many applications that could benefit from a stable heap (e.g., computer-aided design, computer-aided software engineering, and office information systems) require large amounts of storage, timely responses for transactions, and high availability. We present garbage collection and recovery algorithms for a stable heap implementation that meet these goals and are appropriate for stock hardware. The collector is incremental: it does not attempt to collect the whole heap at once. The collector is also atomic: it is coordinated with the recovery system to prevent problems when it moves and modifies objects. The time for recovery is independent of heap size, even if a failure occurs during garbage collection.
Nonlocal Perturbation Analysis of the Schur System of a Matrix
Authors: M. M. Konstantinov, P. Hr. Petkov, N. D. Christov
Venue: SIAM Journal on Matrix Analysis and Applications (1994)

The sensitivity of the Schur system (the Schur basis and the Schur form) of a general matrix relative to perturbations, is studied. The estimates obtained are nonlocal and sharp. Asymptotic bounds (condition numbers particularly) in the form of power series are derived as a particular case.
Justifying the information technology budget within changing environments
Authors: C. Francalanci, P. Maggiolini
Venue: Proceedings of the 1994 computer personnel research conference on Reinventing IS : managing information technology in changing organizations: managing information technology in changing organizations (1994)

The paper analyzes the relationship between business performance and investments in information technologies. The present economic crisis is shouting unprecedented defiances not only at firms, but also at CIO (Chief Information Officers) and IS professionals in general: big companies are determined on cutting down the IT expense, both in absolute and related to the revenue and it is difficult for the CIO to ask top executives for further investments and even to justify the current levels of expense. In this context, the ex ante justification of single IT investments does not represent a solution to the ex ante economic justification of the IT budget: firms are interested in measuring economic and organizational results of the overall effects of IT investments. Therefore, the research is conducted by investigating the correlation between the aggregate annual expense in information technology and two indexes of firm performance, that are defined and justified in the paper. Results of experimentation conducted on the business data collected by the MIP-Nolan Norton Observatory are presented. Trends confirming theoretical hypotheses are illustrated and possible causes motivating opposite trends are discussed.
Splaying a search tree in preorder takes linear time
Authors: R. Chaudhuri, H. Höft
Venue: ACM SIGACT News (1993)

In this paper we prove that if the nodes of an arbitrary no-node binary search tree T are splayed in the preorder sequence of T then the total time is O(n). This is a special case of the splay tree traversal conjecture of Sleator and Tarjan.
Animation of geometric algorithms using GeoLab
Authors: P. de Rezende, W. Jacometti
Venue: Proceedings of the ninth annual symposium on Computational geometry (1993)

The accompanying videotape presents two animation modes provided by the Geometric Laboratory GeoLab which we have developed as a programming environment for implementation, testing and animation of geometric algorithsm. GeoLab runs on SparcStations under Sun/OS using the XView graphics library, following the OpenLook graphical user interface guidelines.
Two Remarks on Independent Sets
Authors: Hans-Gert Gräbe
Venue: Journal of Algebraic Combinatorics: An International Journal (1993)

In the first part we generalize the notion of strongly independent sets, introduced in &lsqb;10&rsqb; for polynomial ideals, to submodules of free modules and explain their computational relevance. We discuss also two algorithms to compute strongly independent sets that rest on the primary decomposition of squarefree monomial ideals.Usually the initial ideal in(I) of a polynomial ideal I is worse than I. In &lsqb;9&rsqb; the authors observed that nevertheless in(I) is not as bad as one should expect, showing that in(I) is connected in codimension one if I is prime.In the second part of the paper we add more evidence to that observation. We show that in(I) inherits (radically) unmixedness, connectedness in codimension one and connectedness outside a finite set of points from I and prove the same results also for initial submodules of free modules. The proofs use a deformation from I to in(I ).
Efficient processing of spatial joins using R-trees
Authors: Thomas Brinkhoff, Hans-Peter Kriegel, Bernhard Seeger
Venue: Proceedings of the 1993 ACM SIGMOD international conference on Management of data (1993)

Spatial joins are one of the most important operations for combining spatial objects of several relations. The efficient processing of a spatial join is extremely important since its execution time is superlinear in the number of spatial objects of the participating relations, and this number of objects may be very high. In this paper, we present a first detailed study of spatial join processing using R-trees, particularly R*-trees. R-trees are very suitable for supporting spatial queries and the R*-tree is one of the most efficient members of the R-tree family. Starting from a straightforward approach, we present several techniques for improving its execution time with respect to both, CPU- and I/O-time. Eventually, we end up with an algorithm whose total execution time is improved over the first approach by an order of magnitude. Using a buffer of reasonable size, I/O-time is almost optimal, i.e. it almost corresponds to the time for reading each required page of the relations exactly once. The performance of the various approaches is investigated in an experimental performance comparison where several large data sets from real applications are used.
Database system issues in nomadic computing
Authors: Rafael Alonso, Henry F. Korth
Venue: Proceedings of the 1993 ACM SIGMOD international conference on Management of data (1993)

Mobile computers and wireless networks are emerging technologies that will soon be available to a wide variety of computer users. Unlike earlier generations of laptop computers, the new generation of mobile computers can be an integrated part of a distributed computing environment, one in which users change physical location frequently. The result is a new computing paradigm, nomadic computing. This paradigm will affect the design of much of our current systems software, including that of database systems. This paper discusses in some detail the impact of nomadic computing on a number of traditional database system concepts. In particular, we point out how the reliance on short-lived batteries changes the cost assumptions underlying query processing. In these systems, power consumption competes with resource utilization in the definition of cost metrics. We also discuss how the likelihood of temporary disconnection forces consideration of alternative transaction processing protocols. The limited screen space of mobile computers along with the advent of pen-based computing provides new opportunities and new constraints on database interfaces and languages. Lastly, we believe that the movement of computers and data among networks potentially belonging to distinct, autonomous organizations creates serious security problems.
Performance evaluation of hybrid hardware and software distributed shared memory protocols
Authors: Rohit Chandra, Kourosh Gharachorloo, Vijayaraghavan Soundararajan, Anoop Gupta
Venue: Proceedings of the 8th international conference on Supercomputing (1994)

Hardware distributed shared memory (DSM) systems efficiently support fine grain sharing of data by maintaining coherence at the level of individual cache lines and providing automatic replication in processor caches. Software DSM systems, on the other hand, amortize high communication costs by maintaining coherence at coarser granularities and replicating data at the level of local main memories. Even though software DSM systems have traditionally been targeted towards loosely coupled environments, some of the techniques are potentially useful in the context of tightly coupled multiprocessors. In particular, communicating data at a coarse grain can sometimes be more efficient than transferring the data as individual cache lines. Furthermore, replication in local memories can accommodate applications with larger working sets as compared to replication in processor caches only. Therefore, combining the two techniques in a hybrid protocol can potentially exploit the benefits of each approach. This paper proposes one such hybrid protocol and evaluates its performance in the context of the FLASH multiprocessor architecture. The hybrid system allows the programmer to optionally identify regions of data shared at a coarse granularity. Coherence for such data is maintained at the grain of the entire region using a software-DSM-style protocol. We evaluate the performance gains of this approach through a detailed simulation study of several parallel applications. Our preliminary results show that the hybrid protocol can eliminate a substantial fraction of remote cache misses through bulk transfer of coarse grain data regions and replication of such data in local memories. The performance gains over hardware cache coherence are modest at low network latencies, but increase substantially at higher network latencies and processor speeds. Finally, we show that similar to cache-only memory architectures, the hybrid protocol is insensitive to data placement issues.
Efficient software-based fault isolation
Authors: Robert Wahbe, Steven Lucco, Thomas E. Anderson, Susan L. Graham
Venue: Proceedings of the fourteenth ACM symposium on Operating systems principles (1994)

One way to provide fault isolation among cooperating software modules is to place each in its own address space. However, for tightly-coupled modules, this solution incurs prohibitive context switch overhead. In this paper, we present a software approach to implementing fault isolation within a single address space.Our approach has two parts. First, we load the code and data for a distrusted module into its own fault do main, a logically separate portion of the application's address space. Second, we modify the object code of a distrusted module to prevent it from writing or jumping to an address outside its fault domain. Both these software operations are portable and programming language independent.Our approach poses a tradeoff relative to hardware fault isolation: substantially faster communication between fault domains, at a cost of slightly increased execution time for distrusted modules. We demonstrate that for frequently communicating modules, implementing fault isolation in software rather than hardware can substantially improve end-to-end application performance.
Avoidance and suppression of compensation code in a trace scheduling compiler
Authors: Stefan M. Freudenberger, Thomas R. Gross, P. Geoffrey Lowney
Venue: ACM Transactions on Programming Languages and Systems (TOPLAS) (1994)

Trace scheduling is an optimization technique that selects a sequence of basic blocks as a trace and schedules the operations from the trace together. If an operation is moved across basic block boundaries, one or more compensation copies may be required in the off-trace code. This article discusses the generation of compensation code in a trace scheduling compiler and presents techniques for limiting the amount of compensation code: avoidance (restricting code motion so that no compensation code is required) and suppression (analyzing the global flow of the program to detect when a copy is redundant). We evaluate the effectiveness of these techniques based on measurements for the SPEC89 suite and the Livermore Fortran Kernels, using our implementation of trace scheduling for a Multiflow Trace 7/300. The article compares different compiler models contrasting the performance of trace scheduling with the performance obtained from typical RISC compilation techniques.There are two key results of this study. First, the amount of compensation code generated is not large. For the SPEC89 suite, the average code size increase due to trace scheduling is 6%. Avoidance is more important than suppression, although there are some kernels that benefit significantly from compensation code suppression. Since compensation code is not a major issue, a compiler can be more aggressive in code motion and loop unrolling. Second, compensation code is not critical to obtain the benefits of trace scheduling. Our implementation of trace scheduling improves the SPEC mark rating by 30% over basic block scheduling, but restricting trace scheduling so that no compensation code is required improves the rating by 25%. This indicates that most basic block scheduling techniques can be extended to trace scheduling without requiring any complicated compensation code bookkeeping.
Several unsolved problems in large-scale discrete event simulations
Authors: Boris D. Lubachevsky
Venue: ACM SIGSIM Simulation Digest (1993)

Several mathematical and algorithmic problems that have arisen in discrete event simulations of large systems are described. The simulated systems belong to the areas of computational physics, queueing networks, and econometric models.
An approach to scalability study of shared memory parallel systems
Authors: Anand Sivasubramaniam, Aman Singla, Umakishore Ramachandran, H. Venkateswaran
Venue: Proceedings of the 1994 ACM SIGMETRICS conference on Measurement and modeling of computer systems (1994)

The overheads in a parallel system that limit its scalability need to be identified and separated in order to enable parallel algorithm design and the development of parallel machines. Such overheads may be broadly classified into two components. The first one is intrinsic to the algorithm and arises due to factors such as the work-imbalance and the serial fraction. The second one is due to the interaction between the algorithm and the architecture and arises due to latency and contention in the network. A top-down approach to scalability study of shared memory parallel systems is proposed in this research. We define the notion of overhead functions associated with the different algorithmic and architectural characteristics to quantify the scalability of parallel systems; we isolate the algorithmic overhead and the overheads due to network latency and contention from the overall execution time of an application; we design and implement an execution-driven simulation platform that incorporates these methods for quantifying the overhead functions; and we use this simulator to study the scalability characteristics of five applications on shared memory platforms with different communication topologies.
A CSA-based robot plan generator
Authors: Van King Tan, Eugeniusz Eberbach
Venue: Proceedings of the 1993 ACM conference on Computer science (1993)

The Calculus of Self-Modifiable Algorithms (CSA) is a universal theory that integrates different programming styles and may be applied to a wealth of domains and applications. This paper presents aspects of the Calculus of Self-Modifiable Algorithms and how it can be used in one area of Artificial Intelligence: Robot Plan Generation.
Modular logic programming
Authors: Antonio Brogi, Paolo Mancarella, Dino Pedreschi, Franco Turini
Venue: ACM Transactions on Programming Languages and Systems (TOPLAS) (1994)

Modularity is a key issue in the design of modern programming languages. When designing modular features for declarative languages in general, and for logic programming languages in particular, the challenge lies in avoiding the superimposition of a complex syntactic and semantic structure over the simple structure of the basic language. The modular framework defined here for logic programming consists of a small number of operations over modules which are (meta-) logically defined and semantically justified in terms of the basic logic programming semantics. The operations enjoy a number of algebraic properties, thus yielding an algebra of modules. Despite its simplicity, the suite of operations is shown capable of capturing the core features of modularization: information hiding, import/export relationships, and construction of module hierarchies. A metalevel implementation and a compilation-oriented implementation of the operations are provided and proved sound with respect to the semantics. The compilation-oriented implementation is based on manipulation of name spaces and provides the basis for an efficient implementation.
Preparing IS professionals for a rapidly changing world: the challenge for IS educators
Authors: Jeanne Ross, Karen Ruhleder
Venue: Proceedings of the 1993 conference on Computer personnel research (1993)

IS professionals must possess a broad range of skills in order to contribute to organizations experiencing rapid changes in both organizational structures and processes and information systems technologies. This paper considers the kinds of skills provided by traditional approaches to IS education and discusses the shortcomings of those approaches. It proposes a model for IS teaching to support the needs of future IS professionals, focusing on the process by which we deliver IS education.