ppxscal/embedding_network huggingface dataset:
Use of the disk file on stretch
Authors: B. G. Carlson, E. A. Voorhees
Venue: Communications of the ACM (1963)

The paper begins by briefly describing the Stretch (IBM 7030) computer with special emphasis given to the organization and operation of its input-output equipment. Physical characteristics of the two-disk system (4,194,304 72-bit words, 8 &micro;sec-per-word transmission rate, etc.) are noted. Timing limitations due to arm motion and disk rotation are discussed. Applications of disk usage are discussed separately for problem programs and for systems programs such as compilers and the supervisory program. Approximately 260,000 words of disk storage are reserved for the storage of systems programs and the subroutine library. Problem programs, however, are not currently filed on the disk. Certain programming techniques are discussed for transmitting words between disk and core storage with minimum delaying and interruption of the arithmetic unit. Dumps on disk are considered for both recovery from computer malfunction and for mathematical or physical developments during the calculation.
Symbolic integration: the stormy decade
Authors: Joel Moses
Venue: Communications of the ACM (1971)

Three approaches to symbolic integration in the 1960's are described. The first, from artificial intelligence, led to Slagle's SAINT and to a large degree to Moses' SIN. The second, from algebraic manipulation, led to Manove's implementation and to Horowitz' and Tobey's reexamination of the Hermite algorithm for integrating rational functions. The third, from mathematics, led to Richardson's proof of the unsolvability of the problem for a class of functions and for Risch's decision procedure for the elementary functions. Generalizations of Risch's algorithm to a class of special functions and programs for solving differential equations and for finding the definite integral are also described.
The functional guts of the Kleisli query system
Authors: Limsoon Wong
Venue: Proceedings of the fifth ACM SIGPLAN international conference on Functional programming (2000)

Kleisli is a modern data integration system that has made a significant impact on bioinformatics data integration. The primary query language provided by Kleisli is called CPL, which is a functional query language whose surface syntax is based on the comprehension syntax. Kleisli is itself implemented using the functional language SML. This paper describes the influence of functional programming research that benefits the Kleisli system, especially the less obvious ones at the implementation level.
Principles for designing programming exercises to minimise poor learning behaviours in students
Authors: Angela Carbone, John Hurst, Ian Mitchell, Dick Gunstone
Venue: Proceedings of the Australasian conference on Computing education (2000)

In most introductory programming courses tasks are given to students to complete as a crucial part of their study. The tasks are considered important because they require students to apply their knowledge to new situations. However, often the tasks have not been considered as a vehicle that can direct learning behaviours in students. This paper aims to encourage academics to start thinking about the tasks they set, in particular it explores characteristics of programming tasks that affect student learning and understanding in a first year undergraduate course as part of a degree in Computer Science at Monash University. Attention is paid to features of programming tasks that led to three poor learning behaviours: Superficial Attention, Impulsive Attention and Staying Stuck. The data gathered for this study which describe the students' engagement in the tasks are provided by students and tutors. The paper concludes with a list of generic improvements to be considered when formulating programming exercises to minimise poor learning behaviours in students.
Using computers in higher education: past recommendations, status, and needs
Authors: John W. Hamblen
Venue: Communications of the ACM (1971)

Data from a survey conducted with National Science Foundation support, which was published in December 1970, is reviewed, and it is pointed out that, with regard to computers in higher education, national goals stated in the Rosser and Pierce Reports have not been attained. Quality was lacking in hardware or courses in nearly half of the associate and bachelor's degree programs in data processing, computer science, etc., offered in 1966-67. A plea is made for continuing studies on status and goals for computing in higher education, improvement of degree programs, and a national testing laboratory for educational technology.
What do users prefer?: a personalized intelligent user interface for searching information &mdash; an empirical study
Authors: Dina Goren-Bar, Tsvi Kuflik, Tali Lavie
Venue: Proceedings of the 6th international conference on Intelligent user interfaces (2001)

Searching the web for information becomes a tedious task. As a result of any query, the user gets large numbers of responses, most of them irrelevant. Existing search tools fail to cope with this information overload, mainly due to lack of personalization. Current developments emphasize better representation of user interests and dynamic adaptation based on relevance feedback, but personalization is much more then just that. The present study examines the impact of search tools adaptation to their users. A significant preference toward user-oriented search method over the conventional content-based method was found. The results clearly demonstrate the need for self-adapting personalized interfaces as mediators between users and information repositories of all kinds.
On the expected gain from adjusting matched term retrieval systems
Authors: R. H. Shumway
Venue: Communications of the ACM (1967)

A file adjustment procedure based on maximizing the Bayes expected gain is proposed for matched term retrieval systems. The expected gain and its probability distribution are derived as a function of: (1) the prior proportion of omitted terms, and (2) the coefficient of separation between two distributions corresponding to values of an adjustment statistic. An example evaluates the gain parameters for a typical information retrieval system.
Logic and programming languages
Authors: Dana S. Scott
Venue: Communications of the ACM (1977)

Logic has been long interested in whether answers to certain questions are computable in principle, since the outcome puts bounds on the possibilities of formalization. More recently, precise comparisons in the efficiency of decision methods have become available through the developments in complexity theory. These, however, are applications to logic, and a big question is whether methods of logic have significance in the other direction for the more applied parts of computability theory. Programming languages offer an obvious opportunity as their syntactic formalization is well advanced; however, the semantical theory can hardly be said to be complete. Though we have many examples, we have still to give wide-ranging mathematical answers to these queries: What is a machine? What is a computable process? How (or how well) does a machine simulate a process? Programs naturally enter in giving descriptions of processes. The definition of the precise meaning of a program then requires us to explain what are the objects of computation (in a way, the statics of the problem) and how they are to be transformed (the dynamics). So far the theories of automata and of nets, though most interesting for dynamics, have formalized only a portion of the field, and there has been perhaps too much concentration on the finite-state and algebraic aspects. It would seem that the understanding of higher-level program features involves us with infinite objects and forces us to pass through several levels of explanation to go from the conceptual ideas to the final simulation on a real machine. These levels can be made mathematically exact if we can find the right abstractions to represent the necessary structures. The experience of many independent workers with the method of data types as lattices (or partial orderings) under an information content ordering, and with their continuous mappings, has demonstrated the flexibility of this approach in providing definitions and proofs, which are clean and without undue dependence on implementations. Nevertheless much remains to be done in showing how abstract conceptualizations can (or cannot) be actualized before we can say we have a unified theory.
An axiomatic basis for computer programming
Authors: C. A. R. Hoare
Venue: Communications of the ACM (1983)

In this paper an attempt is made to explore the logical foundations of computer programming by use of techniques which were first applied in the study of geometry and have later been extended to other branches of mathematics. This involves the elucidation of sets of axioms and rules of inference which can be used in proofs of the properties of computer programs. Examples are given of such axioms and rules, and a formal proof of a simple theorem is displayed. Finally, it is argued that important advantages, both theoretical and practical, may follow from a pursuance of these topics.
An Adaptive Algorithm for Tolerating Value Faults and Crash Failures
Authors: Yansong Ren, Michel Cukier, William H. Sanders
Venue: IEEE Transactions on Parallel and Distributed Systems (2001)

The AQuA architecture provides adaptive fault tolerance to CORBA applications by replicating objects and providing a high-level method that an application can use to specify its desired level of dependability. This paper presents the algorithms that AQuA uses, when an application's dependability requirements can change at runtime, to tolerate both value faults in applications and crash failures simultaneously. In particular, we provide an active replication communication scheme that maintains data consistency among replicas, detects crash failures, collates the messages generated by replicated objects, and delivers the result of each vote. We also present an adaptive majority voting algorithm that enables the correct ongoing vote while both the number of replicas and the majority size dynamically change. Together, these two algorithms form the basis of the mechanism for tolerating and recovering from value faults and crash failures in AQuA.
Run-Time defect tolerance using JBits
Authors: Prasanna Sundararajan, Steven A. Guccione
Venue: Proceedings of the 2001 ACM/SIGDA ninth international symposium on Field programmable gate arrays (2001)

The ability to tolerate defects in semiconductor devices has the potential for both increasing yields of devices being manufactured and making it economically feasible to manufacture even larger devices. While FPGA devices appear to be well suited to providing defect tolerance, practical application of existing research and techniques has been somewhat elusive. One barrier to acceptance is that existing defect tolerance techniques for FPGAs have tended to rely on either modifications to device architectures or modifications to design tools. We describe a software-based technique for providing defect tolerance which requires neither changes to device hardware or software tools. This approach uses the Xilinx JBits$^{(tm)}$ toolkit and operates at the core library level. Addressing defect tolerance locally using core library elements rather than taking a global approach helps provide direct support for run-time reconfiguration. Circuits may be configured and reconfigured rapidly in the presence of these defects. This rapid configuration also provides a path for practical use in more traditional manufacturing environments.
The &ldquo;Plankalk&uuml;l&rdquo; of Konrad Zuse: a forerunner of today's programming languages
Authors: F. L. Bauer, H. Wössner
Venue: Communications of the ACM (1972)

Plankalk&uuml;l was an attempt by Konrad Zuse in the 1940's to devise a notational and conceptual system for writing what today is termed a program. Although this early approach to a programming language did not lead to practical use, the plan is described here because it contains features that are standard in today's programming languages. The investigation is of historical interest; also, it may provide insights that would lead to advancements in the state of the art. Using modern programming terminology, the Plankalk&uuml;l is presented to the extent it has been possible to reconstruct it from the published literature.
Explicit Formulae for Some Kazhdan-Lusztig Polynomials
Authors: Francesco Brenti, Rodica Simion
Venue: Journal of Algebraic Combinatorics: An International Journal (2000)

We consider the Kazhdan-Lusztig polynomials P_u, v(q) indexed by permutations u, v having particular forms with regard to their monotonicity patterns. The main results are the following. First we obtain a simplified recurrence relation satisfied by P_u, v(q) when the maximum value of v &isin; S_n occurs in position n &minus; 2 or n &minus; 1. As a corollary we obtain the explicit expression for P_e, 3 4 &hellip; n 1 2(q) (where e denotes the identity permutation), as a q-analogue of the Fibonacci number. This establishes a conjecture due to M. Haiman. Second, we obtain an explicit expression for P_e, 3 4 &hellip; (n &minus; 2) n (n &minus; 1) 1 2(q). Our proofs rely on the recurrence relation satisfied by the Kazhdan-Lusztig polynomials when the indexing permutations are of the form under consideration, and on the fact that these classes of permutations lend themselves to the use of induction. We present several conjectures regarding the expression for P_u, v(q) under hypotheses similar to those of the main results.
A new solution of Dijkstra's concurrent programming problem
Authors: Leslie Lamport
Venue: Communications of the ACM (1974)

A simple solution to the mutual exclusion problem is presented which allows the system to continue to operate despite the failure of any individual component.
Multidimensional Index Structures in Relational Databases
Authors: Christian Böhm, Stefan Berchtold, Hans-Peter Kriegel, Urs Michel
Venue: Journal of Intelligent Information Systems (2000)

Efficient query processing is one of the basic needs for data mining algorithms. Clustering algorithms, association rule mining algorithms and OLAP tools all rely on efficient query processors being able to deal with high-dimensional data. Inside such a query processor, multidimensional index structures are used as a basic technique. As the implementation of such an index structure is a difficult and time-consuming task, we propose a new approach to implement an index structure on top of a commercial relational database system. In particular, we map the index structure to a relational database design and simulate the behavior of the index structure using triggers and stored procedures. This can be easily done for a very large class of multidimensional index structures. To demonstrate the feasibility and efficiency, we implemented an X-tree on top of Oracle8. We ran several experiments on large databases and recorded a performance improvement up to a factor of 11.5 compared to a sequential scan of the database.
Multiple exits from a loop without the GOTO
Authors: G. V. Bochmann
Venue: Communications of the ACM (1973)

For several years, there has been discussion about the use of the goto statement in programming languages [1, 2]. It has been pointed out that goto free programs tend to be easier to understand, allow better optimization by the compiler, and are better suited for an eventual proof of correctness. On the other hand, the goto statement is a flexible tool for many programmers. Most programming languages have constructs which allow the programmer to write control flows that occur frequently without the use of a goto. In particular, the language Pascal [3] contains, besides the goto, the following control structures: if-then-else, case, while-do, repeat-until, stepping loop. Wulf [4] has described the use of the construct &ldquo;leave &lpargt;label&rpargt;&rdquo; in the language Bliss, where &lpargt;label&rpargt; is the name of a program section which is exited when the statement is executed. It is important to note that these constructs are invented to describe control flows that occur frequently in programs. They describe the flow on a higher level [5] than an equivalent construction using a goto would do.
Using Hilbert curve in image storing and retrieving
Authors: Zhexuan Song, Nick Roussopoulos
Venue: Proceedings of the 2000 ACM workshops on Multimedia (2000)

In this paper, we present a method to accelerate the speed of retrieving subset of uncompressed images in a database without using extra disk space. First we change the storing method: pixels of an image are saved in Hilbert order instead of Row-wise order in traditional method. After studying the property of Hilbert curve, we give a new algorithm which greatly reduces the data segment numbers on the disk. Although we have to retrieve more data than necessary, because the speed of sequential readings is much faster than the speed of random readings, our method spends about 10% less elapsed time which is showed in our simulation experiments. In some systems, the saving can be as high as 90%.
Rapidly convergent expressions for evaluating ex
Authors: A. Berin
Venue: Communications of the ACM (1960)

Rapidly converted subject expressions for ex can be derived by utilization of existing infinite series for log. The ACM Portal is published by the Association for Computing Machinery. Copyright © 2010 ACM, Inc. Terms of Usage Privacy Policy Code of Ethics Contact Us Useful downloads: Adobe Acrobat QuickTime Windows Media Player Real Player
Learning Polynomials with Queries: The Highly Noisy Case
Authors: Oded Goldreich, Ronitt Rubinfeld, Madhu Sudan
Venue: SIAM Journal on Discrete Mathematics (2000)

Given a function f mapping n-variate inputs from a finite field F into F, we consider the task of reconstructing a list of all n-variate degree d polynomials that agree with f on a tiny but nonnegligible fraction, $\delta$, of the input space. We give a randomized algorithm for solving this task. The algorithm accesses f as a black box and runs in time polynomial in ${\frac{n}\d}$ and exponential in d, provided $\delta$ is $\Omega(\sqrt{d/|F|})$. For the special case when d = 1, we solve this problem for all $\epsilon\eqdef\delta - \frac1{|F|} >0$. In this case the running time of our algorithm is bounded by a polynomial in $\frac1\e$ and $n$. Our algorithm generalizes a previously known algorithm, due to Goldreich and Levin [in Proceedings of the 21st Annual ACM Symposium on Theory of Computing, Seattle, WA, ACM Press, New York, 1989, pp. 25--32.], that solves this task for the case when F = GF(2) (and d = 1).In the process we provide new bounds on the number of degree $d$ polynomials that may agree with any given function on $\d \geq \sqrt{d/|F|}$ fraction of the inputs. This result is derived by generalizing a well-known bound from coding theory on the number of codewords from an error-correcting code that can be "close" to an arbitrary word; our generalization works for codes over arbitrary alphabets, while the previous result held only for binary alphabets.
A New CMOS Buffer Amplifier Design Used in Low Voltage MEMSInterface Circuits
Authors: Yajun Ha, M. F. Li, Ai Qun Liu
Venue: Analog Integrated Circuits and Signal Processing (2001)

To achieve low voltage high driving capability with quiescent current control, a class-AB CMOS buffer amplifier using improved quasi-complementary output stage and error amplifiers with adaptive loads is developed. Improved quasi-complementary output stage enables it more suitable for low voltage applications, while adaptive load in error amplifier is used to increase the driving capability and reduce the sensitivity of the quiescent current to fabrication process variation. The circuit has been fabricated in 0.8 &mu;m CMOS process. With 300 &OHgr; load in a &plusmn;1.5 V supply, its output swing is 2.42 V. The mean value of quiescent current for eight samples is 204 &mu;A, with the worst deviation of 17%.
An efficient data structure for random walk algorithms in faceted porous media
Authors: Jean-François Delesse, Bertrand Le Saëc, Gérard Vignoles
Venue: Proceedings of the sixth ACM symposium on Solid modeling and applications (2001)

Modern X-ray Computerized Micro-Tomography (CMT) facilities allow researchers interested in composite materials and porous media to image their samples in 3D with micrometer resolution. The datasets obtained for representative samples are frequently very large (10243 voxels in gray-scale levels). Performing a tessellation on such datasets would produce hundreds millions facets, which would be impossible to handle in memory on rather powerful computers. Various numerical methods are classical for the prediction of some effective properties of porous and other composite media from the phase properties and the micro-structure (diffusivities, conductivities). The choice of a Monte-Carlo random walk scheme is justified by its minimal memory cost in addition to image storage. In order to employ it, one must be able to perform ray-tracing in large and precise 3D images. The new framework we present allows that feature by using a memory-sparing data structure dedicated to such algorithms. We only store in memory the vertices provided by the marching cube algorithm. So, since the facets are not stored, the needed memory size is divided by a factor of five, without any significant increasing of the computation time: the extraction of properties from very large micro-porous media samples is now possible. This study allows us to claim that a simulation making an intensive use of ray-tracing in tessellated media obtained with the marching-cube algorithm is not as expensive (in terms of memory and time cost) as it could seem. We show that the marching-cube algorithm, when it is used dynamically to connect vertices upon request, is still a very powerful mesh generator since it consumes then very few memory, and that it can be trivially implemented.
Pipelining in multi-query optimization
Authors: Nilesh N. Dalvi, Sumit K. Sanghai, Prasan Roy, S. Sudarshan
Venue: Proceedings of the twentieth ACM SIGMOD-SIGACT-SIGART symposium on Principles of database systems (2001)

Database systems frequently have to execute a set of related queries, which share several common subexpressions. Multi-query optimization exploits this, by finding evaluation plans that share common results. Current approaches to multi-query optimization assume that common subexpressions are materialized. Significant performance benefits can be had if common subexpressions are pipelined to their uses, without being materialized. However, plans with pipelining may not always be realizable with limited buffer space, as we show. We present a general model for schedules with pipelining, and present a necessary and sufficient condition for determining validity of a schedule under our model. We show that finding a valid schedule with minimum cost is NP-hard. We present a greedy heuristic for finding good schedules. Finally, we present a performance study that shows the benefit of our algorithms on batches of queries from the TPCD benchmark.
Teaching fundamentals for web programming and e-commerce in a liberal arts computer science curriculum
Authors: Adrienne Bloss
Venue: Journal of Computing Sciences in Colleges (2001)

Web programming and e-commerce are popular topics, but it is not clear how they should be supported in an undergraduate computer science curriculum. This paper presents experience with a course that used Java and Perl/CGI to provide some fundamentals for web programming, and plans for a related upcoming course that should cover material more efficiently and provide fundamentals for e-commerce. Topics covered in the course are compared to skills required for e-commerce as described by Ge and Sun [Ge and Sun 2000].