ppxscal/embedding_network huggingface dataset:
Refactoring: improving the design of existing code
Venue:  (1999)

As the application of object technology--particularly the Java programming language--has become commonplace, a new problem has emerged to confront the software development community. Significant numbers of poorly designed programs have been created by less-experienced developers, resulting in applications that are inefficient and hard to maintain and extend. Increasingly, software system professionals are discovering just how difficult it is to work with these inherited, "non-optimal" applications. For several years, expert-level object programmers have employed a growing collection of techniques to improve the structural integrity and performance of such existing software programs. Referred to as "refactoring," these practices have remained in the domain of experts because no attempt has been made to transcribe the lore into a form that all developers could use. . .until now. In Refactoring: Improving the Design of Existing Code, renowned object technology mentor Martin Fowler breaks new ground, demystifying these master practices and demonstrating how software practitioners can realize the significant benefits of this new process.With proper training a skilled system designer can take a bad design and rework it into well-designed, robust code. In this book, Martin Fowler shows you where opportunities for refactoring typically can be found, and how to go about reworking a bad design into a good one. Each refactoring step is simple--seemingly too simple to be worth doing. Refactoring may involve moving a field from one class to another, or pulling some code out of a method to turn it into its own method, or even pushing some code up or down a hierarchy. While these individual steps may seem elementary, the cumulative effect of such small changes can radically improve the design. Refactoring is a proven way to prevent software decay.In addition to discussing the various techniques of refactoring, the author provides a detailed catalog of more than seventy proven refactorings with helpful pointers that teach you when to apply them; step-by-step instructions for applying each refactoring; and an example illustrating how the refactoring works. The illustrative examples are written in Java, but the ideas are applicable to any object-oriented programming language. 0201485672B04062001
Evaluation of Java thread performance on two different multithreaded kernels
Authors: Yan Gu, B. S. Lee, Wentong Cai
Venue: ACM SIGOPS Operating Systems Review (1999)

Modern programming languages and operating systems encourage the use of threads to exploit concurrency and simplify program structure. An integral and important part of the Java language is its multithreading capability. Despite the portability of Java threads across almost all platforms, the performance of Java threads varies according to the multithreading support of the underlying operating system and the way Java Virtual Machine maps Java threads to the native system threads. In this paper, a well-known compute-intensive benchmark, the EP benchmark, was used to examine various performance issues involved in the execution of threads on two different multithreaded platforms: Windows NT and Solaris. Experiments were carried out to investigate thread creation and computation behavior under different system loads, and to explore execution features under certain extreme situations such as the concurrent execution of very large number of Java threads. Some of the experimental results obtained from threads were compared with a similar implementation using processes. These results show that the performance of Java threads differs depending on the various mechanisms used to map Java threads to native system threads, as well as on the scheduling policies for these native threads. Thus, this paper provides important insights into the behavior and performance of Java threads on these two platforms, and highlights the pitfalls that may be encountered when developing multithreaded Java programs.
Snowball: extracting relations from large plain-text collections
Authors: Eugene Agichtein, Luis Gravano
Venue: Proceedings of the fifth ACM conference on Digital libraries (2000)

Text documents often contain valuable structured data that is hidden Yin regular English sentences. This data is best exploited infavailable as arelational table that we could use for answering precise queries or running data mining tasks.We explore a technique for extracting such tables from document collections that requires only a handful of training examples from users. These examples are used to generate extraction patterns, that in turn result in new tuples being extracted from the document collection.We build on this idea and present our Snowball system. Snowball introduces novel strategies for generating patterns and extracting tuples from plain-text documents.At each iteration of the extraction process, Snowball evaluates the quality of these patterns and tuples without human intervention,and keeps only the most reliable ones for the next iteration. In this paper we also develop a scalable evaluation methodology and metrics for our task, and present a thorough experimental evaluation of Snowball and comparable techniques over a collection of more than 300,000 newspaper documents.
Jacobi--Davidson Style QR and QZ Algorithms for the Reduction of Matrix Pencils
Authors: Diederik R. Fokkema, Gerard L. G. Sleijpen, Henk A. Van der
Venue: SIAM Journal on Scientific Computing (1998)

Recently the Jacobi--Davidson subspace iteration method has been introduced as a new powerful technique for solving a variety of eigenproblems. In this paper we will further exploit this method and enhance it with several techniques so that practical and accurate algorithms are obtained. We will present two algorithms, JDQZ for the generalized eigenproblem and JDQR for the standard eigenproblem, that are based on the iterative construction of a (generalized) partial Schur form. The algorithms are suitable for the efficient computation of several (even multiple) eigenvalues and the corresponding eigenvectors near a user-specified target value in the complex plane. An attractive property of our algorithms is that explicit inversion of operators is avoided, which makes them potentially attractive for very large sparse matrix problems.We will show how effective restarts can be incorporated in the Jacobi--Davidson methods, very similar to the implicit restart procedure for the Arnoldi process. Then we will discuss the use of preconditioning, and, finally, we will illustrate the behavior of our algorithms by a number of well-chosen numerical experiments.
New Constructions of Disjoint Distinct Difference Sets
Authors: Wende Chen, Zhi Chen, Torleiv Klove
Venue: Designs, Codes and Cryptography (1998)

New constructions of regular disjoint distinct difference sets (DDDS) are presented. In particular, multiplicative and additive DDDS are considered.
An alternative way of drawing
Authors: Roope Raisamo
Venue: Proceedings of the SIGCHI conference on Human factors in computing systems: the CHI is the limit (1999)

Current object-oriented drawing programs have an established way of drawing in which the shape of an object is controlled by manipulating control points. While the control points are intuitive in their basic use, it is not clear whether they make more complex drawing tasks manageable for the average user. In this paper we describe an alternative way of drawing and editing a drawing using new direct manipulation tools. Our approach resembles sculpting in two dimensions: the user begins with a large block and uses different tools to give it the desired shape. We also present a user evaluation in which the users could try our new tools and compare them to their previous experience of control points, The users claimed to understand the operations better with our tools than if they had needed to use curves and control points. However, our tools were better suited for sketching the artwork than for making very detailed drawings.
Trust in systems development: a model of management and developer interaction research in progress
Authors: Mark A. Serva, Mark A. Fuller, Roger C. Mayer
Venue: Proceedings of the 2000 ACM SIGCPR conference on Computer personnel research (2000)

Systems analysis and design (SAD) is often considered to be a technical task; indeed, in many cases exposure to SAD at the college level is an extension of a programming and database management course. Most information systems (IS) professionals would agree, however, that SAD requires communication skills, management skills, and organizational skills in addition to analytical and technical abilities. Further complicating the social dynamics of the situation, many systems are now developed by outsourcing partners, who work with management in virtual team environments. The authors recently met with the CIO of a major financial services firm, who stated that &ldquo;Vendor management is the single most important skill &hellip; (my) IS management teams need to develop&rdquo;. This research presents a theoretical framework for examining the relationship between management and systems developers, in particular applying a model of trust to explain behaviors from both party's perspectives. In addition, this research tests that framework within the context of a controlled setting.
A Time-Recursive Algorithm for the Computation of Auto-AmbiguityFunction and the Wigner Distribution
Authors: Chao Lu, Ning Ma, Joel M. Morris
Venue: Multidimensional Systems and Signal Processing (1998)

In this paper, a time-recursive algorithm for the computation of discrete-time, discrete-frequency, auto-ambiguity function is given, which in turn is used to compute the Wigner time-frequency distribution. We use the Richman-Parks-Shenoy&lsquo;s definition of the discrete-time, discrete-frequency, auto-ambiguity function for finite data sequences. Block diagram implementation of the time-recursive algorithm is described, computational complexity with respect to increasing block size is compared with straight forward computation, and the proper time-recursive block size is suggested.
Energy estimation for 32-bit microprocessors
Authors: C. Brandolese, W. Fornaciari, F. Salice, D. Sciuto
Venue: Proceedings of the eighth international workshop on Hardware/software codesign (2000)

Estimation of software power consumption is becoming one of the major problems for many embedded applications. The paper presents a novel approach to compute the energy of an Instruction Set, through a suitable functional decomposition of the activities involved during instruction execution. One of the main advantages of this approach is the capability to predict the power figures of the overall Instruction-Set starting from a small subset. A formal discussion on the statistical properties of the model is included, together with its application on five commercial 32-bit microprocessors.
A Modified Cholesky Algorithm Based on a Symmetric Indefinite Factorization
Authors: Sheung Hun Cheng, Nicholas J. Higham
Venue: SIAM Journal on Matrix Analysis and Applications (1998)

Given a symmetric and not necessarily positive definite matrix A, a modified Cholesky algorithm computes a Cholesky factorization P(A+E)PT = RT R, where P is a permutation matrix and E is a perturbation chosen to make A+E positive definite. The aims include producing a small-normed E and making A+E reasonably well conditioned. Modified Cholesky factorizations are widely used in optimization. We propose a new modified Cholesky algorithm based on a symmetric indefinite factorization computed using a new pivoting strategy of Ashcraft, Grimes, and Lewis. We analyze the effectiveness of the algorithm, both in theory and practice, showing that the algorithm is competitive with the existing algorithms of Gill, Murray, and Wright and Schnabel and Eskow. Attractive features of the new algorithm include easy-to-interpret inequalities that explain the extent to which it satisfies its design goals, and the fact that it can be implemented in terms of existing software.
A heuristic approach of bandwidth management for video sources in ATM networks
Authors: Yen-Wen M. Chen, Jean-Lien C. Wu
Venue: International Journal of Network Management (2000)

One of the most important properties in the ATM network is that the resource of the network, including buffer and bandwidth, can be flexibly managed according to different demands of various applications. The network bandwidth can be effectively allocated and utilized if the data volume of the arrival traffic can be predicted precisely. In this paper, we study the bandwidth management schemes for variable bit rate &lpar;VBR&rpar; pre&hyphen;coded MPEG video sources. The proposed bandwidth allocation method, which predicts the bandwidth by the frame correlation, demonstrates a quite good performance when comparing with a previous scheme, especially for the video scenes with the combination of intraframes and interframes. Bandwidth allocation of a multiplexer connected to several video sources is also studied by using heuristic information. The experimental results show that the proposed method is much better than that of the fixed bandwidth allocation and is suitable for the application of MPEG video services. Copyright &copy; 2000 John Wiley Sons, Ltd.
Migration Issues and Strategies for Token Ring
Authors: Bengt Beyer-Ebbesen, Mark Cowtan, Sharam Hakimi, Robert D. Love
Venue: International Journal of Network Management (1997)

This article considers the problems caused by ever increasing traffic on Token Ring LANs. It shows how the new IEEE&thinsp;802.5 standard for DTR addresses this problem, outlining scenarios and providing a migration strategy for evolving networks, using this new standard. &copy; 1997 John Wiley Sons, Ltd.
DENIM: finding a tighter fit between tools and practice for Web site design
Authors: James Lin, Mark W. Newman, Jason I. Hong, James A. Landay
Venue: Proceedings of the SIGCHI conference on Human factors in computing systems (2000)

Through a study of web site design practice, we observed that web site designers design sites at different levels of refinement&mdash;site map, storyboard, and individual page&mdash;and that designers sketch at all levels during the early stages of design. However, existing web design tools do not support these tasks very well. Informed by these observations, we created DENIM, a system that helps web site designers in the early stages of design. DENIM supports sketching input, allows design at different refinement levels, and unifies the levels through zooming. We performed an informal evaluation with seven professional designers and found that they reacted positively to the concept and were interested in using such a system in their work.
Adaptively sampled distance fields: a general representation of shape for computer graphics
Authors: Sarah F. Frisken, Ronald N. Perry, Alyn P. Rockwood, Thouis R. Jones
Venue: Proceedings of the 27th annual conference on Computer graphics and interactive techniques (2000)

Adaptively Sampled Distance Fields (ADFs) are a unifying representation of shape that integrate numerous concepts in computer graphics including the representation of geometry and volume data and a broad range of processing operations such as rendering, sculpting, level-of-detail management, surface offsetting, collision detection, and color gamut correction. Its structure is uncomplicated and direct, but is especially effective for quality reconstruction of complex shapes, e.g., artistic and organic forms, precision parts, volumes, high order functions, and fractals. We characterize one implementation of ADFs, illustrating its utility on two diverse applications: 1) artistic carving of fine detail, and 2) representing and rendering volume data and volumetric effects. Other applications are briefly presented.
Adaptive and efficient mutual exclusion (extended abstract)
Authors: Hagit Attiya, Vita Bortnikov
Venue: Proceedings of the nineteenth annual ACM symposium on Principles of distributed computing (2000)

A distributed algorithm is adaptive if its performance depends on k, the number of processes that are concurrently active during the algorithm execution (rather than on n, the total number of processes). This paper presents adaptive algorithm for mutual exclusion using only read and write operations. The worst case step complexity cannot be a measure for the performance of mutual exclusion algorithms, because it is always unbounded in the presence of contention. Therefore, a number of different parameters are used to measure the algorithm's performance: The remote step complexity is the maximal number of steps performed by a process where a wait is counted as one step. The system response time is the time interval between subsequent entries to the critical section, where one time unit is the minimal interval in which every active process performs at least one step. The algorithm presented here has O(k) remote step complexity and O(log k) system response time, where k is the point contention. The space complexity of this algorithm is O(nN), where N is the range of processes' names. The space complexity of all previously known adaptive algorithms for various long-lived problems depends on N. We present a technique that reduces the space complexity of our algorithm to be a function of n, while preserving the other performance measures of the algorithm.
Memory sharing predictor: the key to a speculative coherent DSM
Authors: An-Chow Lai, Babak Falsafi
Venue: Proceedings of the 26th annual international symposium on Computer architecture (1999)

Recent research advocates using general message predictors to learn and predict the coherence activity in distributed shared memory (DSM). By accurately predicting a message and timely invoking the necessary coherence actions, a DSM can hide much of the remote access latency. This paper proposes the Memory Sharing Predictors (MSPs), pattern-based predictors that significantly improve prediction accuracy and implementation cost over general message predictors. An MSP is based on the key observation that to hide the remote access latency, a predictor must accurately predict only the remote memory accesses (i.e., request messages) and not the subsequent coherence messages invoked by an access. Simulation results indicate that MSPs improve prediction accuracy over general message predictors from 81% to 93% while requiring less storage overhead.This paper also presents the first design and evaluation for a speculative coherent DSM using pattern-based predictors. We identify simple techniques and mechanisms to trigger prediction timely and perform speculation for remote read accesses. Our speculation hardware readily works with a conventional full-map write-invalidate coherence protocol without any modifications. Simulation results indicate that performing speculative read requests alone reduces execution times by 12% in our shared-memory applications.
TICER: realizable reduction of extracted RC circuits
Authors: Bernard N. Sheehan
Venue: Proceedings of the 1999 IEEE/ACM international conference on Computer-aided design (1999)

TIme Constant Equilibration Reduction (TICER) is a novel RC reduction method tailored for extract/reduce CAD tools. Geometry-minded extraction tools fracture nets into parasitics based on local changes in geometry. The resulting RC circuits can have a huge dynamic range of time-constants; by eliminating the extreme time-constants, TICER produces smaller, less-stiff RC networks. It produces realizable RC circuits; can retain original network topology; scales well to large networks (~107 nodes); preserves dc and ac behavior; handles resistor loops and floating capacitors; has controllable accuracy; operates in linear time on most nets.
A Smoothing Newton Method for Extended Vertical Linear Complementarity Problems
Authors: Hou-Duo Qi, Li-Zhi Liao
Venue: SIAM Journal on Matrix Analysis and Applications (1999)

In this paper, we reformulate the extended vertical linear complementarity problem (EVLCP(m,q)) as a nonsmooth equation H(t,x)=0, where $H: \mbox{\smallBbb R}^{n+1} \to \mbox{\smallBbb R}^{n+1}$, $t \in \mbox{\smallBbb R}$ is a parameter variable, and $x \in \mbox{\smallBbb R}$ is the original variable. H is continuously differentiable except at such points (t,x) with t=0. Furthermore H is strongly semismooth. The reformulation of EVLCP(m, q) as a nonsmooth equation is based on the so-called aggregation (smoothing) function. As a result, a Newton-type method is proposed which generates a sequence {wk=(tk,xk)} with all tk >0. We prove that every accumulation point of this sequence is a solution of EVLCP(M, q) under the assumption of row ${\cal W}_0$-property. If row ${\cal W}$-property holds at the solution point, then the convergence rate is quadratic. Promising numerical results are also presented.
Correlation-Immune and Resilient Functions Over a FiniteAlphabet and Their Applications in Cryptography
Authors: Paul Camion Anne Canteaut
Venue: Designs, Codes and Cryptography (1999)

We extend the notions of correlation-immune functions and resilient functions to functions over any finite alphabet. A previous result due to Gopalakrishnan and Stinson is generalized as we give an orthogonal array characterization, a Fourier transform and a matrix characterization for correlation-immune and resilient functions over any finite alphabet endowed with the structure of an Abelian group. We then point out the existence of a tradeoff between the degree of the algebraic normal form and the correlation-immunity order of any function defined on a finite field and we construct some infinite families of t-resilient functions with optimal nonlinearity which are particularly well-suited for combining linear feedback shift registers. We also point out the link between correlation-immune functions and some cryptographic objects as perfect local randomizers and multipermutations.
An evaluation of computing paradigms for N-body simulations on distributed memory architectures
Authors: Collin McCurdy, John Mellor-Crummey
Venue: ACM SIGPLAN Notices (1999)

The efficiency of HPF with respect to irregular applications is still largely unproven. While recent work has shown that a highly irregular hierarchical n-body force calculation method can be implemented in HPF, we have found that the implmentation contains inefficiencies which cause it to run up to a factor of three times slower than our hand-coded, explicitly parallel implementation. Our work examines these inefficiencies, determines that most of the extra overhead is due to a single aspect of the communication strategy, and demonstrates that fixing the communication strategy can bring the overheads of the HPF application to within 25% of those of the hand-coded version.