bluuebunny/crossref_metadata_2025 huggingface dataset:
Toward adaptive conversational interfaces
Authors: Oviatt Sharon , Darves Courtney , Coulston Rachel
Published: October 2004

The design of robust interfaces that process conversational speech is a challenging research direction largely because users' spoken language is so variable. This research explored a new dimension of speaker stylistic variation by examining whether users' speech converges systematically with the text-to-speech (TTS) heard from a software partner. To pursue this question, a study was conducted in which twenty-four 7 to 10-year-old children conversed with animated partners that embodied different TTS voices. An analysis of children's amplitude, durational features, and dialogue response latencies confirmed that they spontaneously adapt several basic acoustic-prosodic features of their speech 10--50%, with the largest adaptations involving utterance pause structure and amplitude. Children's speech adaptations were relatively rapid, bidirectional, and dynamically readaptable when introduced to new partners, and generalized across different types of users and TTS voices. Adaptations also occurred consistently, with 70--95% of children converging with their partner's TTS, although individual differences in magnitude of adaptation were evident. In the design of future conversational systems, users' spontaneous convergence could be exploited to guide their speech within system processing bounds, thereby enhancing robustness. Adaptive system processing could yield further significant performance gains. The long-term goal of this research is the development of predictive models of human-computer communication to guide the design of new conversational interfaces.
Modern concurrency abstractions for C#
Authors: Benton Nick , Cardelli Luca , Fournet Cédric
Published: October 2004

Polyphonic C
♯
is an extension of the C
♯
language with new asynchronous concurrency constructs, based on the join calculus. We describe the design and implementation of the language and give examples of its use in addressing a range of concurrent programming problems.
Extensible objects without labels
Authors: Stone Christopher A.
Published: October 2004

Typed object calculi that permit adding new methods to existing objects must address the problem of name clashes: what happens if a new method is added to an object already having one with the same name but a different type? Most systems statically forbid such clashes by restricting the allowable subtypings. In contrast, by reconsidering the runtime meaning of object extension, the object calculus studied in the author's previous work with Jon Riecke allowed any object to be soundly extended with any method of any name, with unrestricted width subtyping. That language permitted a simple encoding of classes as object-generators. Because of width subtyping, subclasses could be typechecked and compiled with little knowledge of the class hierarchy and without any information about superclasses' private components; this made derived classes more robust to changes in the implementations of base classes. However, the system was not well suited for encoding mixins or by-name subtyping of objects.This article addresses those deficiencies by presenting the Calculus of Objects and Indices (COI), a lower-level typed object calculus in which extensible objects are more analogous to tuples than to records. An object is simply a finite sequence of unnamed components referenced by their index in the sequence. Names are then reintroduced by allowing these indices to be first-class values (analogous to pointers to members in C++) that can be bound to variables. Since variables---unlike record labels---freely alpha-vary, difficulties caused by statically undetectable name clashes disappear.By combining COI objects with standard type-theoretic mechanisms, one can encode mixins and classes having the by-name subtyping of languages like C++ or Java but with the robustness of the object-generator encodings. Using records, more standard extensible objects with named components can also be encoded.
Modular typechecking for hierarchically extensible datatypes and functions
Authors: Millstein Todd , Bleckner Colin , Chambers Craig
Published: October 2004

One promising approach for adding object-oriented (OO) facilities to functional languages like ML is to generalize the existing datatype and function constructs to be hierarchical and extensible, so that datatype variants simulate classes and function cases simulate methods. This approach allows existing datatypes to be easily extended with both new operations and new variants, resolving a longstanding conflict between the functional and OO styles. However, previous designs based on this approach have been forced to give upmodulartypechecking, requiring whole-program checks to ensure type safety. We describe Extensible ML (EML), an ML-like language that supports hierarchical, extensible datatypes and functions while preserving purely modular typechecking. To achieve this result,EML's type system imposes a few requirements on datatype and function extensibility, but EML is still able to express both traditional functional and OO idioms. We have formalized a core version of EML and proven the associated type system sound, and we have developed a prototype interpreter for the language.
Assembly instruction level reverse execution for debugging
Authors: Akgul Tankut , Mooney III Vincent J.
Published: October 2004

Assembly instruction level reverse execution provides a programmer with the ability to return a program to a previous state in its execution history via execution of a "reverse program." The ability to execute a program in reverse is advantageous for shortening software development time. Conventional techniques for recovering a state rely on saving the state into a record before the state is destroyed. However, state-saving causes significant memory and time overheads during forward execution.The proposed method introduces a reverse execution methodology at the assembly instruction level with low memory and time overheads. The methodology generates, from a program, a reverse program by which a destroyed state is almost always regenerated rather than being restored from a record. This significantly reduces state-saving.The methodology has been implemented on a PowerPC processor with a custom made debugger. As compared to previous work, all of which heavily use state-saving techniques, the experimental results show from 2X to 2206X reduction in run-time memory usage, from 1.5X to 403X reduction in forward execution time
overhead
and from 1.2X to 2.32X reduction in forward execution time for the tested benchmarks. Furthermore, due to the reduction in memory usage, our method can provide reverse execution in many cases where other methods run out of available memory. However, for cases where there is enough memory available, our method results in 1.16X to 1.89X slow down in reverse execution.
Classifying data dependences in the presence of pointers for program comprehension, testing, and debugging
Authors: Orso Alessandro , Sinha Saurabh , Harrold Mary Jean
Published: October 2004

Understanding data dependences in programs is important for many software-engineering activities, such as program understanding, impact analysis, reverse engineering, and debugging. The presence of pointers can cause subtle and complex data dependences that can be difficult to understand. For example, in languages such as C, an assignment made through a pointer dereference can assign a value to one of several variables, none of which may appear syntactically in that statement. In the first part of this article, we describe two techniques for classifying data dependences in the presence of pointer dereferences. The first technique classifies data dependences based on definition type, use type, and path type. The second technique classifies data dependences based on span. We present empirical results to illustrate the distribution of data-dependence types and spans for a set of real C programs. In the second part of the article, we discuss two applications of the classification techniques. First, we investigate different ways in which the classification can be used to facilitate data-flow testing. We outline an approach that uses types and spans of data dependences to determine the appropriate verification technique for different data dependences; we present empirical results to illustrate the approach. Second, we present a new slicing approach that computes slices based on types of data dependences. Based on the new approach, we define an incremental slicing technique that computes a slice in multiple steps. We present empirical results to illustrate the sizes of incremental slices and the potential usefulness of incremental slicing for debugging.
Risks to the public in computers and related systems
Authors: Neumann Peter G.
Published: October 2004

Edited by Peter G. Neumann (Risks Forum Moderator and Chairman of the ACM Committee on Computers and Public Policy), plus personal contributions by others, as indicated. Opinions expressed are individual rather than organizational, and all of the usual disclaimers apply. We address problems relating to software, hardware, people, and other circumstances that affect computer systems. To economize on space, we tersify most items and include pointers to items in the online Risks Forum: (R i j) denotes RISKS vol i number j. Cited RISKS items generally identify contributors and sources, together with URLs. Official RISKS archives are available at www.risks.org (which redirects to Newcastle and gets you nice html formatting and a search engine courtesy of Lindsay Marshall; http://catless.ncl.ac.uk/Risks/i.j.html gets you (R i j); and at ftp://www.sri.com/risks.A cumulative summary of
RISKS
and
SEN
items is available at http://www.CSL.sri.com/neumann/illustrative.html as well as ftp://ftp.csl.sri.com/illustrative.ps and pdf. Please send RISKS-related items to risks@CSL.sri.com. Read RISKS as a newsgroup (comp.risks), or subscribe via the automated list server at risks-request@CSL.sri.com. "Inside Risks" columns from the
Communications of the ACM
are also online (http://www.csl.sri.com/neumann/insiderisks.html).
Surfing the net for software engineering notes
Authors: Doernhoefer Mark
Published: October 2004

Agile methods are one of the most controversial topics in the software development community today. The homepage for this year's Agile Development Conference remarked that one of the purposes of this year's conference was to dispel the notion that agile development methods are "a bunch of hot air". And indeed, the amount of hype surrounding this new approach to writing software would lead one to believe that agile methods are long on promises and short on rigor. Even some of the terms surrounding agile methods; Extreme Programming (XP), Crystal, Scrum, etc., seem like they were developed by an advertising agency instead of a software process improvement group.
Global software development
Authors: Hargreaves Elizabeth , Damian Daniela , Lanubile Filippo , Chisan James
Published: October 2004

While the field of global software development (GSD) remains in its relative infancy, a group of GSD researchers are on the brink of building a stronger research community that will be able to collectively address many of the current challenges in the field. This paper details emerging issues in the GSD community while discussing contributions made at the latest GSD workshop held at ICSE 2004. These issues include: the need for community building and increased collaboration between researchers, the importance of more systematic application and documentation of research techniques, and the opportunity to build defined models and theories, and, in doing so, define the state of the practice. Brief summaries of workshop papers are incorporated, along with discussions of the topics addressed during the workshop. These topics include: Feasibility of GSD, Strategies for Success of GSD, and Research Methods and Challenges in GSD.
1
st
international workshop on advances and applications of problem frames - summary
Authors: Cox Karl , Hall Jon G. , Rapanotti Lucia
Published: October 2004

Problem Frames are about describing real world problems in the context of known software solutions. The 1
st
International Workshop on Advances and Applications of Problem Frames (IWAAPF) was held at the 26
th
International Conference on Software Engineering in Edinburgh on 24
th
May 2004. IWAAPF was the first opportunity for researchers and practitioners to gather and discuss Michael Jackson's Problem Frames ideas. The goals of the workshop were,• to provide a forum for the discussion of advances and applications of Problem Frames in a software engineering context;• to identify the main challenges that Problem Frames face in the wider Software Engineering community.The richness of the advances and applications presented shows that the scope of application of Jackson's work is going beyond any original boundaries. This is a report of the workshop, its papers, discussions and findings.
Software engineering for large-scale multi-agent systems - SELMAS 2004
Authors: Choren Ricardo , Garcia Alessandro , Lucena Carlos , Griss Martin , Kung David , Minsky Naftaly , Romanovsky Alexander , Castro Jaelson , de Lemos Rogério , Weyns Danny
Published: October 2004

This paper is intended to sum up the results of the Third International Workshop on Software Engineering for Large-Scale Multi-Agent System (SELMAS 2004) held in Edinburgh, Scotland, May 24--25, 2004, as part of the International Conference on Software Engineering (ICSE 2004). The main purpose of this workshop was to share and pool the collective experience of people, both academics and practitioners, who are actively working on software engineering for large-scale multi-agent systems. The call for papers elicited some 24 submissions, of which 14 papers were accepted for presentation. A set of selected workshop and invited papers are to appear in a Lecture Notes in Computer Science (LNCS, Springer) volume. The workshop consisted of an opening presentation, two keynote talks, four technical sessions of paper presentations, and two panels. During the workshop we informally reviewed ongoing and previous work and debated a number of important issues. The SELMAS 2004 website can be found at . We begin by presenting an overview of our goals and the workshop structure, and then focus on the workshop technical program.
ICSE 2004 workshop summary second international workshop on dynamic analysis (WODA 2004)
Authors: Evans David , Lencevicius Raimondas
Published: October 2004

Dynamic analysis techniques reason over program executions and show promise in aiding the development of robust and reliable large-scale systems. WODA 2004 brought together researchers in many different dynamic analysis areas.
Workshop on directions in software engineering environments (WoDiSEE)
Authors: Grundy John , Welland Ray , Stoeckle Hermann
Published: October 2004

This report gives an overview of the Workshop on Directions in Software Engineering Environments WoDiSEE 2004) held at the 26th International Conference on Software Engineering (ICSE 2004). The goal of this workshop was to bring together researchers and practitioners with an interest in developing, extending, deploying and using software engineering tools. The workshop provided an interactive forum for the exchange of ideas and discussion about current research and future trends in software engineering environment research and development. The workshop proceedings contain fourteen short papers, giving a snapshot of current research in this area, which provided the framework for presentations at the workshop. This report summarises the presentations given at the workshop and the discussions that took place.
Code coverage based technique for prioritizing test cases for regression testing
Authors: Aggrawal K. K. , Singh Yogesh , Kaur A.
Published: October 2004

Test case prioritization involves scheduling test cases in an order that increases their effectiveness in meeting some performance goals. One of the common performance goals is to run those test cases that achieve total code coverage at the earliest. In this work we propose a model that achieves 100% code coverage optimally during version specific regression testing.
Software size prediction before coding
Authors: Gill Nasib S. , Grover P. S.
Published: October 2004

There have been many empirical studies conducted for the purpose of objective measurement of software systems. As a result, various 'Software Metrics' have been introduced by various researchers. At present, efforts are being made by software researchers to get qualitatively good software developed within a reasonable cost. The quality of a software product is codetermined be several factors. Most of these factors directly or indirectly depend on the objective measurement of the software characteristics.In this paper, we have applied one of our program length estimator (N
g
) on a set of about 200 programs of varying complexities coded in four different programming languages for determining the language level, program volume and programming effort. The results of this program length estimator have also been used to find out the value of constant parameter used in Conte's software size equation for the respective languages for the purpose of estimating size of programs before coding.Further, these results have been used to estimate the size of the programs written in different languages. The estimated program size has then been comparatively analysed with that of the actual program size, which has been computed using our program length estimator (N
g
).
Object oriented software quality prediction using general regression neural networks
Authors: Kanmani S. , Uthariaraj V. Rhymend , Sankaranarayanan V. , Thambidurai P.
Published: October 2004

This paper discusses the application of General Regression Neural Network (GRNN) for predicting the software quality attribute -- fault ratio. This study is carried out using static Object-Oriented (OO) measures (64 in total) as the independent variables and fault ratio as the dependent variable. Software metrics used include those concerning inheritance, size, cohesion and coupling. Prediction models are designed using 15 possible combinations of the four categories of the measures. We also tested the goodness of fit of the neural network model with the standard parameters. Our study is conducted in an academic institution with the software developed by students of Undergraduate/Graduate courses.
Sorting non-key fields in the distributed result set iterator pattern
Authors: Long Brad
Published: October 2004

In previous work a design pattern for solving the issues of handling results from queries that return large amounts of data from remote data sources was presented. This paper presents a solution to the problem of sorting non-key fields that was raised in previous work but left for a future time to solve. That time is now.
Is "Factory Method" really a pattern?
Authors: Rost Johann
Published: October 2004

The paper gives reasons for which the term "Design Pattern" should be used in a stricter manner. The definition of "Design Pattern" should include the highest degree of generalization and ensure that the solution offered covers the invariable of
all
solutions to this kind of problems. The main conclusion to be drawn from this paper is that "Factory Method" ((GoF (107)) should not be considered a pattern since the solution it provides is too narrow. Budgen's arced bridge [1] is not really a pattern either because the problem can be stated in a more general manner.
Assessment methodologies for public contractors
Authors: Rotondi Guido
Published: October 2004

In recent years, the penalty costs involved in project failures have become a serious issue for the Public Administration budget. The reason of such escalation in contract management costs is twofold: first, the increased application complexity demands for systems with an underlying evolutionary technology; on the other side, the administrative procedures inertia fails to guarantee a sufficient preliminary investigation to design projects. The contract management mechanism adopted in the Public Administration is stiff and subject to strict procedures with bounded requirements. However, the effectiveness of such procedures limits to the extent of preliminary analysis by setting the rules for the competition notice. Very little control is left to the refinement of technical aspects after a tender for contracts has been entrusted. In order to respond to the increased complexity of today computing applications, we propose the introduction of an assessment procedure, which spans the project life cycle, as whole: from the very beginning, to the administrative inquiry, up to the official testing.
Measuring Z specifications
Authors: Wu Fangjun , Yi Tong
Published: October 2004

Software metrics are useful quantitative indicators to assess and predict software quality attributes; a commonly measured attribute is software complexity. The main drawbacks are: they can only be calculated after a major development effort has been committed to produce the source codes; they cannot provide early feedback during the specification phase; and subsequently it is expensive to make changes to the system, if so indicated by the metrics. To date, there is hardly any work done on measuring the complexity of a system early in its specification phase. In this paper, we describe how the complexity of a Z specification can be measured. We also found that there is a significant correlation between the specification metrics proposed and the widely adopted OO metrics, thus demonstrating that our proposed metrics are a reliable means of measuring the system early in the specification phase.
Modelling and verifying web service orchestration by means of the concurrency workbench
Authors: Koshkina Mariya , van Breugel Franck
Published: October 2004

Verification techniques like model checking, preorder checking and equivalence checking are shown to be relevant to web service orchestration. The Concurrency Workbench of the New Century (CWB) is a verification tool that supports these verification techniques. By means of the Process Algebra Compiler (PAC), the CWB is modified to support the BPE-calculus. The BPE-calculus is a small language, based on BPEL4WS, to express web service orchestration. Both the syntax and the semantics of the BPE-calculus are formally defined. These are subsequently used as input for the PAC. As output, the PAC produces modules that are incorporated into the CWB so that it supports the BPE-calculus and, hence, provides a verification tool for web service orchestration.
Model interchange and integration for web services
Authors: Hall Robert J. , Zisman Andrea
Published: October 2004

Large distributed systems are normally developed by combining various nodes that are produced by different stakeholders, using different technologies, languages, and formalisms. An example of this situation is found when developing web services applications. However, the heterogeneity and diversity of existing languages to express behavioral specifications (models) of systems do not support integration, sharing and reuse of models between different validation tools. In this paper we present an XML-based behavioral model interchange format called OpenModel Modeling Language (OMML). OMML is a function rich procedural language in which the functionality and control of the models are expressed procedurally in terms of domain-specific function/object theories. OMML is composed of 5 different document types describing executable specification models of the services running at the nodes, information about connections between the various nodes, information about the (abstract) state of the services, and domain specific information to allow standardisation of the terminology used by model developers. We describe how OMML can be used to support interchange of models in web services applications. We present prototype tools that we have developed to support translation between models expressed in P-EBF, OMML, and SCR and evaluate our approach by validating a web service book finder application composed of models expressed in different languages in the GSTView validation tool.
A software engineering research repository
Authors: Alexander Roger T. , Bieman James M. , France Robert B.
Published: October 2004

Software developers lack objective information to assess the effectiveness of current and proposed technologies and practices. We are developing a Software Engineering Research Repository (SERR), a widely-accessible repository of software development artifacts. The core artifacts of SERR are development artifacts, for example, code, models, and test cases, organized by projects. These raw materials provide a base for carrying out analyses and the results can be stored as related artifacts in the repository. In this way, the knowledge content of the repository can be built incrementally, providing a rich support base for other research activities. Research programs can thus build upon the results produced by other programs that utilize the repository. Software developers will be able to access objective data from the repository to assess software engineering tools and techniques.
A generic instrumentation framework for collecting dynamic information
Authors: Chawla Anil , Orso Alessandro
Published: October 2004

Performing empirical research in software testing involves executing a set of subjects against one or more test suites and measuring some characteristics of these executions. Such measures are often collected using ad-hoc instrumentation, by inserting probes in the code that collect and report dynamic information at run-time. Another possible approach is to collect the needed information by leveraging capabilities of the runtime system. Both these approaches usually result in measurement tools that are not flexible and are, thus, hard to reuse and modify. To address this problem, we present a generic framework for collecting information on the runtime behavior of a Java program. The framework allows for easily collecting different kinds of dynamic information for a set of executions of the program, such as coverage and profiling of various code entities and program traces at different levels. The framework also lets users easily define how to process the collected information. In the paper, we also present a case study that we performed to evaluate the framework, and that shows its effectiveness and efficiency.
Building an infrastructure to support experimentation with software testing techniques
Authors: Do Hyunsook , Elbaum Sebastian , Rothermel Gregg
Published: October 2004

Experimentation is necessary to provide advances in research on software testing, but without infrastructure to support that experimentation, progress cannot occur. To help with this problem, we have been designing and constructing infrastructure to support controlled experimentation with software testing techniques. This position paper describes our efforts, and the challenges faced in creating infrastructure and making it available.
Using an existing suite of test objects
Authors: Lindström B. , Grindal M. , Offutt J.
Published: October 2004

This workshop paper presents lessons learned from a recent experiment to compare several test strategies. The test strategies were compared in terms of the number of tests needed to satisfy them and in terms of faults found. The experimental design and conduct are discussed, and frank assessments of the decisions that were made are provided. The paper closes with a summary of the lessons that were learned.
An experimental mutation system for Java
Authors: Offutt Jeff , Ma Yu-Seung , Kwon Yong-Rae
Published: October 2004

Mutation is a powerful but complicated and computationally expensive testing method. Mutation is also a valuable experimental research technique that has been used in many studies. Mutation has been experimentally compared with other test criteria, and also used to support experimental comparisons of other test criteria, by using mutants as a method to create faults. In effect, mutation is often used as a "gold standard" for experimental evaluations of test methods. This paper presents a publicly available mutation system for Java that supports both traditional statement-level mutants and newer inter-class mutants. MUJAVA can be freely downloaded and installed with relative ease under both Unix and Windows. MUJAVA is offered as a free service to the community and we hope that it will promote the use of mutation analysis for experimental research in software testing.
SEEWeb
Authors: Offutt Jeff , Yang Yuan , Hayes Jane Huffman
Published: October 2004

This position paper suggests that some of the technical and methodological challenges facing software testing researchers can be addressed by establishing a repository of experimental software artifacts, in particular, artifacts that are related to software testing empirical research. We introduce the Software Engineering Experiments on the Web (SEEWEB) project, a Web site that is created to be a convenient and usable infrastructure for gathering, organizing, and distributing experimental software artifacts. A common problem in designing software engineering and software testing experiments is finding experimental artifacts that are appropriate for the experiment, convenient to gather and use, and will fit with other experimental artifacts. SEEWEB was initially funded by the NSF and is offered as a service to the community and provides access to experimental artifacts through an interface that allows browsing, searching and downloading. SEEWEB loosely follows the open-source philosophy; experimental artifacts are provided by researchers on an as-is basis with the only payment being citations and acknowledgments to the contributing researchers. SEEWEB can be accessed online through the URL http://www.ise.gmu.edu/seeweb/.
Relevant empirical testing research
Authors: Andrews James H.
Published: October 2004

Empirical research on software testing that aims to be relevant to industry faces important challenges. In this position paper, we review the background on software testing research and discuss some of the most important challenges. We then give suggestions on how to respond to these challenges.
The (Im)maturity level of software testing
Authors: Bertolino Antonia
Published: October 2004

A large gap exists between the state-of-the-art in software testing literature, and the state of software testing practice. Empirical research should (and could) play a first class role for bridging this gap. Empirical studies in software testing have focused mainly on the evaluation of techniques for test case selection. But effective selection of test cases by itself is not sufficient to warrant successful testing: we need also empirical studies to start collecting proven patterns that test practitioners can use to predictably solve software testing problems.
Empirical studies of software testing techniques
Authors: Briand Lionel , Labiche Yvan
Published: October 2004

This position paper aims at discussing a number of issues that typically arise when performing empirical studies with software testing techniques. Though some problems are general to all empirical disciplines, software testing studies face a number of specific challenges. Some of the main ones are discussed in sequence below.
A flexible environment to evaluate state-based test techniques
Authors: Hierons R. M.
Published: October 2004

In this position paper we argue that the presence of a flexible test environment, that allows the rapid prototyping of test techniques, would facilitate empirical research in software testing. Such an environment could be combined with a set of benchmark systems and specifications in order to allow researchers to rapidly prototype and evaluate new techniques. In this paper we focus on some of the requirements for a description language to be used by such an environment.
Towards building a solid empirical body of knowledge in testing techniques
Authors: Juristo N. , Moreno A. M. , Vegas S.
Published: October 2004

Testing technique-related empirical studies have been performed for 25 years. We have managed to accumulate a fair number of experiments in this time, which might lead us to think that we now could have a sizeable empirically backed body of knowledge (BoK) on testing techniques. However, the experiments in this field have some flaws, and, consequently, the empirical BoK we have on testing techniques is far from solid. In this paper, we use the results of a survey that we did on empirical testing techniques studies to identify and discuss solutions that could lead to the formation of a solid empirical BoK. The solutions are related to two fundamental experimental issues: (1) the rigorousness of the experimental design and analysis, and (2) the need for a series of community-wide agreements to coordinate empirical research and assure that studies ratify and complement each other.
Experiences evaluating the effectiveness of JML-JUnit testing
Authors: Tan Roy Patrick , Edwards Stephen H.
Published: October 2004

This paper reports on the issues the authors encountered while evaluating the JML-JUnit unit testing strategy. Given a predefined set of parameter values, JML-JUnit can automatically provide unit tests for Java programs that have specifications. We present a mutation testing experiment that evaluates the effectiveness of this testing strategy, and the lessons learned from doing this experiment. We conclude that a benchmark will enable the testing research community to meaningfully assess testing approaches.
On the need for a process for making reliable quality comparisons with industrial data
Authors: Williams Laurie
Published: October 2004

Many factors influence quality data obtained from industrial case studies making comparisons difficult. In this paper, two longitudinal industrial case study experiences are shared which illustrate the complications that can arise. The first is a case study of an IBM team that transitioned to the use of test-driven development. The primary quality measure was functional verification test defects normalized by lines of code. The second case study was performed with an Extreme Programming team at Sabre Airline Solutions. Both test defects and field defects were compared. In both case studies, differences existed which made the comparisons indicative but not absolute.
ACM statement on voting systems
Authors: Grove Jeff
Published: October 2004

The Association recommends more attention to integrity, security, and usability in the design and use of all voting systems.
Evaluating e-commerce functionality with a focus on customer service
Authors: Lightner Nancy J.
Published: October 2004

B2C Web sites allow companies to present their unique advantages, as long as they provide the necessary customer service. This checklist will help developers create more effective B2C sites.
Portals
Authors: Smith Michael Alan
Published: October 2004

A common portal definition, universal client, and application-support infrastructure would turn the portal concept on its head, eventually shifting control from the information providers to the information consumers.
A survey of online e-banking retail initiatives
Authors: Southard Peter B. , Siau Keng
Published: October 2004

Customer demand is forcing banks to provide their services online. There are two successful paths they can take: to grow, or to specialize in providing localized services and information.
Not-defect
Authors: Armour Phillip G.
Published: October 2004

Taking a deliberate, measured approach to software development and testing.
Voluntary collective licensing for music file sharing
Authors: von Lohmann Fred
Published: October 2004

Why can't American peer-to-peer file sharers have the same deal the broadcast radio industry has had for almost 100 years?
Implementing voting systems
Authors: Williams Brit J. , King Merle S.
Published: October 2004

Sharing the experiences of the first statewide adoption of a computerized election process.
Small vote manipulations can swing elections
Authors: Di Franco Anthony , Petro Andrew , Shear Emmett , Vladimirov Vladimir
Published: October 2004

Considering the effects and implications of changing only a single vote per machine.
The code of elections
Authors: Mercuri Rebecca T. , Camp L. Jean
Published: October 2004

The disparity between the code of election law and the code that comprises election equipment reflects inherent problems in the translation of social policies into computer procedures and overseeing processes.
Analyzing internet voting security
Authors: Jefferson David , Rubin Aviel D. , Simons Barbara , Wagner David
Published: October 2004

An extensive assessment of a proposed Internet-based voting system.
A numerical evaluation of HSL packages for the direct solution of large sparse, symmetric linear systems of equations
Authors: Gould Nicholas I. M. , Scott Jennifer A.
Published: October 2004

In recent years, a number of new direct solvers for the solution of large sparse, symmetric linear systems of equations have been added to the mathematical software library HSL. These include solvers that are designed for the solution of positive-definite systems as well as solvers that are principally intended for solving indefinite problems. The available choice can make it difficult for users to know which solver is the most appropriate for their use. In this study, we use performance profiles as a tool for evaluating and comparing the performance of the HSL solvers on an extensive set of test problems taken from a range of practical applications.
Block tridiagonalization of "effectively" sparse symmetric matrices
Authors: Bai Yihua , Gansterer Wilfried N. , Ward Robert C.
Published: October 2004

A block tridiagonalization algorithm is proposed for transforming a sparse (or "effectively" sparse) symmetric matrix into a related block tridiagonal matrix, such that the eigenvalue error remains bounded by some prescribed accuracy tolerance. It is based on a heuristic for imposing a block tridiagonal structure on matrices with a large percentage of zero or "effectively zero" (with respect to the given accuracy tolerance) elements. In the light of a recently developed block tridiagonal divide-and-conquer eigensolver [Gansterer, Ward, Muller, and Goddard, III,
SIAM J. Sci. Comput. 25
(2003), pp. 65--85], for which block tridiagonalization may be needed as a preprocessing step, the algorithm also provides an option for attempting to produce at least a few very small diagonal blocks in the block tridiagonal matrix. This leads to low time complexity of the last merging operation in the block divide-and-conquer method. Numerical experiments are presented and various block tridiagonalization strategies are compared.
A column approximate minimum degree ordering algorithm
Authors: Davis Timothy A. , Gilbert John R. , Larimore Stefan I. , Ng Esmond G.
Published: October 2004

Sparse Gaussian elimination with partial pivoting computes the factorization
PAQ
=
LU
of a sparse matrix
A
, where the row ordering
P
is selected during factorization using standard partial pivoting with row interchanges. The goal is to select a column preordering,
Q
, based solely on the nonzero pattern of
A
, that limits the worst-case number of nonzeros in the factorization. The fill-in also depends on
P
, but
Q
is selected to reduce an upper bound on the fill-in for any subsequent choice of
P
. The choice of
Q
can have a dramatic impact on the number of nonzeros in
L
and
U
. One scheme for determining a good column ordering for
A
is to compute a symmetric ordering that reduces fill-in in the Cholesky factorization of

A
T
A

. A conventional minimum degree ordering algorithm would require the sparsity structure of

A
T
A

to be computed, which can be expensive both in terms of space and time since

A
T
A

may be much denser than
A
. An alternative is to compute
Q
directly from the sparsity structure of
A
; this strategy is used by MATLAB's COLMMD preordering algorithm. A new ordering algorithm, COLAMD, is presented. It is based on the same strategy but uses a better ordering heuristic. COLAMD is faster and computes better orderings, with fewer nonzeros in the factors of the matrix.
Algorithm 836
Authors: Davis Timothy A. , Gilbert John R. , Larimore Stefan I. , Ng Esmond G.
Published: October 2004

Two codes are discussed, COLAMD and SYMAMD, that compute approximate minimum degree orderings for sparse matrices in two contexts: (1) sparse partial pivoting, which requires a sparsity preserving column pre-ordering prior to numerical factorization, and (2) sparse Cholesky factorization, which requires a symmetric permutation of both the rows and columns of the matrix being factorized. These orderings are computed by COLAMD and SYMAMD, respectively. The ordering from COLAMD is also suitable for sparse QR factorization, and the factorization of matrices of the form

A
T
A

and

AA
T

, such as those that arise in least-squares problems and interior point methods for linear programming problems. The two routines are available both in MATLAB and C-callable forms. They appear as built-in routines in MATLAB Version 6.0.
Algorithm 837
Authors: Amestoy Patrick R. , Davis Timothy A. , Duff Iain S.
Published: October 2004

AMD is a set of routines that implements the approximate minimum degree ordering algorithm to permute sparse matrices prior to numerical factorization. There are versions written in both C and Fortran 77. A MATLAB interface is included.
A case for resource-conscious out-of-order processors
Authors: Cristal Adrián , Martínez José F. , Llosa Josep , Valero Mateo
Published: October 2004

Modern out-of-order processors tolerate long-latency memory operations by supporting a large number of in-flight instructions. This is achieved in part through proper sizing of critical resources, such as register files or instruction queues. In light of the increasing gap between processor speed and memory latency, tolerating upcoming latencies in this way would require impractical sizes of such critical resources.To tackle this scalability problem, we make a case for resource-conscious out-of-order processors. We present quantitative evidence that critical resources are increasingly underutilized in these processors. We advocate that better use of such resources should be a priority in future research in processor architectures. In particular, we present some of our research having such observations as a basis to deal with future resource conscious processors.
A case for shared instruction cache on chip multiprocessors running OLTP
Authors: Kundu Partha , Annavaram Murali , Diep Trung , Shen John
Published: October 2004

Due to their large code footprint, OLTP workloads suffer from significant I-cache miss rates on contemporary microprocessors. This paper analyzes the I-stream behavior of an OLTP workload, called the Oracle Database Benchmark (ODB), on Chip-Multiprocessors (CMP). Our results show that, although, the overall code footprint of ODB is large, multiple ODB threads running concurrently on multiple processors tend to access common code segments frequently, thus exhibiting significant constructive sharing. In fact, in a CMP system, an I-cache shared between multiple processors incurs similar miss rate as a dedicated I-cache per processor where the per processor I-cache has the same capacity as the shared I-cache. Based on these observations, this paper makes the case for a shared I-cache organization in a CMP, instead of the traditional approach of using a dedicated I-cache per processor.Furthermore, this paper shows that OLTP code stream exhibits good spatial locality. Adding a simple dedicated Line Buffer per processor can exploit this spatial locality effectively, to reduce latency and bandwidth requirements on the shared cache. The proposed shared I-cache organization results in an improvement of at least 5X in miss rate over a dedicated cache organization, for the same total capacity.
Memory in processor
Authors: Venkateswaran N. , Foundation Waran Research , Krishnan Aditya , Kumar S. Niranjan , Shriraman Arrvindh , Sridharan Srinivas
Published: October 2004

The Von-Neumann bottleneck is a major impediment towards attaining higher performance. Novel merged logic-memory architectures such as the Processor In Memory (PIM) approach seek to delay the Von-Neumann bottleneck. This paper introduces the concept of Memory In Processor (MIP) architecture, which overcomes this bottleneck by providing a logical and physical integration of the memory into the functional units of the processor thereby creating a memory like organization. This is unlike the PIM, which purely involves physical integration. The MIP node employs High-Level Functional Units (HLF units) like matrix multipliers, matrix inverters, sorter units and graph algorithm solvers all of which are designed to be memory like. This integration has led to the equivalence of functional unit density with the SRAM, initiating a new memory-based metric for quantifying the HLF unit capability in terms of bytes. The 2 MB MIP node operates on 128 bit data, and has been shown to be equivalent to the performance of a uniprocessor 3D torus cluster of 5*5*4 nodes. Thereby achieving supercomputing on a multi billion-device chip. The MIP cluster markedly deviates from conventional approaches of cluster based supercomputing and attains high performance while maintaining a smaller node count.
A workload characterization of elliptic curve cryptography methods in embedded environments
Authors: Branovic I. , Giorgi R. , Martinelli E.
Published: October 2004

Elliptic Curve Cryptography (ECC) is emerging as an attractive public-key system for constrained environments, because of the small key sizes and computational efficiency, while preserving the same security level as the standard methodsWe have developed a set of benchmarks to compare standard and corresponding elliptic curve public-key methods. An embedded device based on the Intel XScale architecture, which utilizes an ARM processor core was modeled and used for studying the benchmark performance. Different possible variations for the memory hierarchy of such basic architecture were considered. We compared our benchmarks with MiBench/Security, another widely accepted benchmark set, to provide a reference for our evaluation.We studied operations and impact on memory of Diffie-Hellman key exchange, digital signature algorithm, ElGamal, and RSA public-key cryptosystems. Elliptic curve cryptosystems are more efficient in terms of execution time, but their impact on memory subsystem has to be taken into account when designing embedded devices in order to achieve better performance.
HIBRID-SOC
Authors: Moch S. , Bereković M. , Stolberg H. J. , Friebe L. , Kulaczewski M. B. , Dehnhardt A. , Pirsch P.
Published: October 2004

The HiBRID-SoC multi-core architecture targets a wide range of application fields with particularly high processing demands, including general signal processing applications, video de-encoding, image processing, or a combination of these tasks. For this purpose, the HiBRID-SoC integrates three fully programmable processor cores and various interfaces on a single chip, all tied to a 64-Bit AMBA AHB bus. Its memory subsystem is particularly adapted to the high bandwidth demands of the multi-core architecture by providing several DMA capabilities and multiple data transfer paths. The processor cores are individually optimized to the particular computational characteristics of different application fields, complementing each other to deliver high performance levels with high flexibility at reduced system costs. The HiBRID-SoC is fabricated in a 0.18 μm 6LM standard-cell technology, occupies about 82 mm
2
, operates at 145 MHz, and comsumes 3.5 Watts.