bluuebunny/crossref_metadata_2025_split huggingface dataset:
Finding approximate matches in large lexicons
Authors: Zobel Justin , Dart Philip 
Published: November 2006

AbstractApproximate string matching is used for spelling correction and personal name matching. In this paper we show how to use string matching techniques in conjunction with lexicon indexes to find approximate matches in a large lexicon. We test several lexicon indexing techniques, including n‐grams and permuted lexicons, and several string matching techniques, including string similarity measures and phonetic coding. We propose methods for combining these techniques, and show experimentally that these combinations yield good retrieval effectiveness while keeping index size and retrieval time low. Our experiments also suggest that, in contrast to previous claims, phonetic codings are markedly inferior to string distance measures, which are demonstrated to be suitable for both spelling correction and personal name matching.
Implementing prototype testing tools
Authors: Hamlet Dick 
Published: November 2006

AbstractTesting tools are software analyzers that use information from particular executions of a program as well as information about a specification and the program text itself. Research prototypes of such tools are essential to investigate the ideas they embody. Often, hand calculation is so tedious and error‐prone that an investigator cannot obtain any intuition about his or her ideas without an implementation to aid in experiments. Traditionally, such tools have been implemented in conventional high‐level languages (e.g., C, Pascal), a process that takes more time than a prototype should. The technology of compiler generators and logic programming, applied to the idea of self‐instrumenting programs, drastically shortens the prototype cycle.This paper describes a general method for implementing prototype tools, gives examples of several old and new testing techniques fitted into the method, and discusses the ease with which such prototypes may be changed.
The avatars of a package for calendars in ada
Authors: Gauthier Michel 
Published: November 2006

AbstractThis paper shows the evolution of components for calendars written in Ada, starting from a classic form and evolving by the effect of some choices of software engineering. The first choice is to specify separate components when they do not have to be coupled in only one. This choice transforms a one‐component form into a three‐component one. The second choice is to hide all entities that are not required by the modelling of the real world. This choice modifies many declarations into forms which are complex to specify but which introduce no additional complexity to the user.In addition to the development of this component for the current legal calendar, it is indicated how others can be defined and converted from any one to the other. The design of a deep automatic test is illustrated. Finally, the paper illustrates how the new features of Ada‐95 can be used to specify these calendars in another form, but which is not essentially different from the Ada‐83 text.
Engineering a hard real‐time system: From theory to practice
Authors: Burns A. , Wellings A. J. 
Published: November 2006

AbstractMore and more programmers find their software being used in performance critical applications. Unfortunately, they have limited techniques at their disposal to help guarantee this particular aspect of their programs. There has been considerable activity in recent years on developing analysis techniques for hard real‐time systems. Inevitably these techniques make simplifying assumptions so as to reduce the complexity of the problem to be solved. For example hard real‐time schedulability analysis techniques often assume that the timing properties of the underlying kernel can be accounted for by incorporating extra execution time into the application tasks. Furthermore, they assume that the application task structure is very simple and uniform. This paper considers the implications of using these techniques in the analysis of a typical single processor application, the attitude and orbital control system (AOCS) for the Olympus satellite. The paper outlines a common approach for estimating the response times for tasks, and then extends the scheduling equations so that they can be used in the engineering of realistic real‐time systems.
A procedural interface for program directing
Authors: Sosič Rok 
Published: November 2006

AbstractDebugging and performance measurement tools are becoming more important in the development and maintenance of increasingly complex software. These tools belong to a class of programs, called directors. Directors are programs that monitor and control other programs. Through monitoring, directors analyze program execution at runtime. Monitoring provides tracing primitives as well as access to program's variables, dynamic data structures, and its internal state. Results of the monitoring analysis can be used by the director itself to change the future program behavior or presented to a human user for an interactive review and possible feedback actions. The future program behavior is changed through controlling primitives which provide an organized way to modify data values as well as the program code.This paper presents a library of directing commands which enable the construction of powerful directors. The interface has been implemented in a Unix environment as a runtime subsystem running in the directed program's address space. The paper provides the description of the interface and the basic programming techniques in building directors. Examples of novel applications, illustrating the use of the directing interface, are demonstrated by the directors for the visualization of program control and structured snapshots.
ANTLR: A predicated‐LL(k) parser generator
Authors: Parr T. J. , Quong R. W. 
Published: November 2006

AbstractDespite the parsing power of LR/LALR algorithms, e.g. YACC, programmers often choose to write recursive‐descent parsers by hand to obtain increased flexibility, better error handling, and ease of debugging. We introduce ANTLR, a public‐domain parser generator that combines the flexibility of hand‐coded parsing with the convenience of a parser generator, which is a component of PCCTS. ANTLR has many features that make it easier to use than other language tools. Most important, ANTLR provides predicates which let the programmer systematically direct the parse via arbitrary expressions using semantic and syntactic context; in practice, the use of predicates eliminates the need to hand‐tweak the ANTLR output, even for difficult parsing problems. ANTLR also integrates the description of lexical and syntactic analysis, accepts LL(k) grammars for k > 1 with extended BNF notation, and can automatically generate abstract syntax trees.ANTLR is widely used, with over 1000 registered industrial and academic users in 37 countries. It has been ported to many popular systems such as the PC, Macintosh, and a variety of UNIX platforms; a commercial C++ front‐end has been developed as a result of one of our industrial collaborations.
Decompilation of binary programs
Authors: Cifuentes Cristina , Gough K. John 
Published: November 2006

AbstractThe structure of a decompiler is presented, along with a thorough description of the different modules that form part of a decompiler, and the type of analyses that are performed on the machine code to regenerate high‐level language code. The phases of the decompiler have been grouped into three main modules: front‐end, universal decompiling machine, and back‐end. The front‐end is a machine‐dependent module that performs the loading, parsing and semantic analysis of the input program, as well as generating an intermediate representation of the program. The universal decompiling machine is a machine‐ and language‐independent module that performs data and control flow analysis of the program based on the intermediate representation, and the program's control flow graph. The back‐end is a language‐dependent module that deals with the details of the target high‐level language.In order to increase the readability of the generated programs, a decompiling system has been implemented which integrates a decompiler, dcc, and an automatic signature generator, dccSign. Signatures for libraries and compilers are stored in a database that is read by the decompiler; thus, the generated programs can make use of known library names, such as WriteLn() and printf().dcc is a decompiler for the Intel 80286 architecture and the DOS operating system. dec takes as input binary programs from a DOS environment and generates C programs as output. Sample code produced by this decompiler is given.
Automatic synthesis of compression techniques for heterogeneous files
Authors: Hsu William H. , Zwarico Amy E. 
Published: November 2006

AbstractWe present a compression technique for heterogeneous files, those files which contain multiple types of data such as text, images, binary, audio, or animation. The system uses statistical methods to determine the best algorithm to use in compressing each block of data in a file (possibly a different algorithm for each block). The file is then compressed by applying the appropriate algorithm to each block. We obtain better savings than possible by using a single algorithm for compressing the file. The implementation of a working version of this heterogeneous compressor is described, along with examples of its value toward improving compression both in theoretical and applied contexts. We compare our results with those obtained using four commercially available compression programs, PKZIP, Unix compress, Stufflt, and Compact Pro, and show that our system provides better space savings.
Process scheduling and UNIX semaphores
Authors: Dunstan Neil , Fris Ivan 
Published: November 2006

AbstractSemaphores have been used extensively in programming concurrent tasks. Various extensions have been proposed for problems in which traditional semaphores turned out to be difficult to use. The extended semaphore primitives investigated here are based on the version of semaphores implemented in UNIX System V. Implementation issues are discussed and practical illustrations of their use are provided. In particular, algorithms for a variety of common process scheduling schemes are shown. These solutions are evaluated and the strengths and weaknesses of UNIX semaphores are discussed.
Software maintenance: An approach to impact analysis of objects change
Authors: Ajila Samuel 
Published: November 2006

AbstractThe maintenance of a software system requires a tool for impact analysis and the propagation of change. This paper presents a knowledge‐based model for both. This model is generic because it is not based on any language or design method. Therefore, it can be applied on the basis of ‘problem’ to be solved. It also captures four life‐cycle phases:requirement, specification, designandprogramming. We also provide a domain‐specific view that allows the dependency analysis offine‐grainobjects. Two kinds of dependencies are identified:inter‐phase dependencies, these are dependency relations between the objects of the one phase and another; andintra‐phase dependencies, these are dependency relations between the objects of the same phase. In order to validate this model, we also present a prototype based on two life‐cycle phases:designandprogramming.
Formal specification and testing: A case study
Authors: Laycock Gilbert 
Published: November 2006

AbstractZ is a formal notation for writing system specifications that has been growing in popularity over recent years. This paper examines some of the issues involved in applying a ‘partition based’ testing method to a system specified in Z. Details of an extensive case study are given, from specification and implementation of the system to the development and execution of test cases. The strategy is found to have benefits compared to those based on less formal specifications, but there are limitations to the approach, and difficulties that need addressing.
The revealing power of a test case
Authors: Voas Jeffrey M. , Miller Keith W. 
Published: November 2006

Abstract‘Propagation, infection, and execution analysis’ (termed PIE) is used for predicting where faults can more easily hide in software. To make such predictions, programs are dynamically executed with test cases, and information concerning the test cases is collected into a histogram, each bin of which represents a single test case. The score in a bin predicts the likelihood that the test case will reveal a fault through the production of a failure (if a fault exists in the set of program locations that the test case executes). Preliminary experiments using program mutations suggest that the histogram technique presented in this paper can rank test cases according to their fault revealing ability.
Employing accumulated knowledge to refine test descriptions
Authors: Wild Christian , Zeil Steven , Feng Gao , Chen Ji 
Published: November 2006

AbstractMost testing methods generate test descriptions which define the desired characteristics of the input data in a test case. This paper describes the use of accumulated knowledge about a problem domain to refine these test descriptions, with the goal of increasing the probability that the input data generated from the refined test descriptions will reveal faults in a software system. A knowledge base is introduced to hold information about object semantics and object class/subclass relationships. Knowledge accumulates with experience in a particular domain and can be focused on those objects and relationships in that domain which experience has shown to be error‐prone. This paper also defines a knowledge‐driven functional testing (KDFT) method which derives test descriptions from a formal specification and refines these descriptions using that knowledge base. A case study of the KDFT method using data from a previous study of the launch intercept control problem is described. These preliminary results indicate that knowledge‐based refinement of test descriptions can dramatically improve their ability to detect certain classes of faults.
Inductive inference and software testing
Authors: Zhu Hong , Hall Patrick , May John 
Published: November 2006

AbstractThe term ‘inductive inference’ denotes the process of hypothesizing a general rule from examples. It can be considered as the inverse process of program testing, which is a process of sampling the behaviour of a program and gathering confidence in the quality of the software from the samples. As one of the fundamental and ubiquitous components of intelligent behaviour, much effort has been spent on both the theory and practice of inductive inference as a branch of artificial intelligence. In this paper, software testing and inductive inference are reviewed to illustrate how the rich and solid theory of inductive inference can be used to study the foundations of software testing.
A relationship between software coverage metrics and reliability
Authors: Veevers Alan , Marshall Adam C. 
Published: November 2006

AbstractSoftware engineers have tacitly assumed that there exists a link between coverage and reliability. An argument is presented which leads to an inverse logarithmic relationship which depends upon the structure of the software and on a parameter called the strength of the coverage metric. The relationship is developed by considering reliability as a function of an idealized coverage metric and then interpreting the result for a range of actual coverage metrics.
An empirical comparison of data flow and mutation‐based test adequacy criteria
Authors: Mathur Aditya P. , Wong W. Eric 
Published: November 2006

AbstractEvaluation of the adequacy of a test set consisting of one or more test cases is a problem oftes encountered in software testing environments. Two test adequacy criiteria are considered, namely the data flow based all‐uses criterion and a mutation based criterion. An empirical study was conducted to compare the ‘difficulty’ of satisfying the two criteria and their costs. Similar studies conducted in the past are discussed in the light of this study. A discussion is also presented of how and why the results of this study, when viewed in conjunction with the results of earlier comparisons of testing methods, are useful to a software test team.
Validating functional equivalence of re‐engineered programs via control path, result, and data flow comparison
Authors: Sneed Harry M. 
Published: November 2006

AbstractA combination of three approaches is proposed here to validate the functional equivalence of re‐engineered programs. These are: control path comparison; data result comparison; and data flow comparison. Two of the three approaches are based on the theory of program slicing. The third approach is based on the theory of data invariance, i.e. the same input must produce the same output. Together, these techniques can provide a cost effective regression test environment for large scale re‐engineering projects.
Using program slicing to simplify testing
Authors: Harman Mark , Danicic Sebastian 
Published: November 2006

AbstractProgram slicing is a technique for automatically identifying the statements of a program which affect a selected subset of its variables. A large program can be divided into a number of smaller program (its slices), each constructed for different variable subsets. The slices are typically simpler than the original program, thereby simplifying the process of testing a property of the program which only concerns the corresponding subset of its variables. However, some aspects of a program's computation are not captured by a set of variables, rendering slicing inapplicable. To overcome this difficulty a program can be rewritten in a self‐checking form by the addition of assignment statements to denote these ‘implicit’ computations. Initially this makes the program longer. However, slicing can now be applied to the introspective program, forming a slice concerned solely with the implicit computation. The simplification power of slicing is then improved using program transformation. To illustrate this approach, the implicit computation which dictates whether or not a program is robust is taken as an example. Whether or not a program is robust is not generally decidable making the approach described here particularly appealing because the slices constructed are approximate answers to the undecidable question ‘Is the program p robust?’.
Evaluating the reliability of the software of a switching system with a multi‐variable model
Authors: Bondi Patrizia , Simonetti Guido 
Published: November 2006

AbstractIn recent years reliability growth models have gained a dominant role in the evaluation of the reliability of software products. However, their application to the quality assurance process of the software of a highly complex system such as a telecommunications switching system often shows that it is then possible to get accurate results only when some months of operation have elapsed. It is then impossible to give an answer to the typical questions which arise during the quality assurance phase: ‘Is the software ready for release? How long will it take before it is ready?’. This paper describes a multi‐variable (MV) model which was developed to overcome the above limitation by providing a better model of the quality assurance process. A case study is presented, and a comparison is made between the results obtained by applying existing reliability growth models and the MV‐model to it. Besides attaining surprising accuracy in its predictions and in measuring the reliability of the product, the MV‐model also tries to tackle a different kind of question: ‘How is it possible to improve the effectiveness of testing?’.
Teaching nature of science through inquiry: Results of a 3‐year professional development program
Authors: Akerson Valarie L. , Hanuscin Deborah L. 
Published: November 2006

AbstractThis study assessed the influence of a 3‐year professional development program on elementary teachers' views of nature of science (NOS), instructional practice to promote students' appropriate NOS views, and the influence of participants' instruction on elementary student NOS views. Using the VNOS‐B and associated interviews the researchers tracked the changes in NOS views of teacher participants throughout the professional development program. The teachers participated in explicit–reflective activities, embedded in a program that emphasized scientific inquiry and inquiry‐based instruction, to help them improve their own elementary students' views of NOS. Elementary students were interviewed using the VNOS‐D to track changes in their NOS views, using classroom observations to note teacher influences on student ideas. Analysis of the VNOS‐B and VNOS‐D showed that teachers and most grades of elementary students showed positive changes in their views of NOS. The teachers also improved in their science pedagogy, as evidenced by analysis of their teaching. Implications for teacher professional development programs are made. © 2006 Wiley Periodicals, Inc. J Res Sci Teach 44: 653–680, 2007
An annotated bibliography of scientific visualization. Part 2
Authors: Nielson Gregory M. , Voegele Keith 
Published: November 2006

AbstractThis bibliography evolved as a network using the papers in the volume Visualization of Scientific Computing edited by Gregory M. Nielson and Bruce Shriver and published by IEEE Computer Society Press, 1990 as the root nodes. From there, the supplied reference lists were recursively traversed until a closure resulted either from the common links or from the effective grounding by the highly technical literature of application specializations.As usual, the standard disclaimers apply; so, for example, this collection is hopefully complete (in the sense that subsets of papers form research vectors that span the space of scientific visualization), but obviously not exhaustively comprehensive. Some of the entries are of a general survey nature, whereas others are quite specific and technical. Pivotal and often quoted works comprise the bulk of the material, but works of historical and developmental significance are also included especially where they point to researchers, research centres and journals where important work has been, and is being, performed and recorded. The annotations accompanying the references tend to be impressionistic and apologies to the authors are hereby noted for those instances where omissions, misunderstandings and whimsy have resulted in misinterpretations. The support of the U.S. Department of Energy is appreciated.
The generalized display processors as an approach to real‐time interactive 3‐D computer animation
Authors: van Overveld C. W. A. M. 
Published: November 2006

AbstractThe concept of the display processor unit (DPU; see Reference 1, p. 94) is extended to arrive at a generalized display processor (GDP) which is able not only to produce a static screen image given the descriptions of a list of graphics elements but which allows for these graphics elements to show an autonomous kinematic (motion‐)behaviour. A language to program such a GDP is presented, and a software implementation of an interpreter/processor for this language is discussed. The application of a GDP both in computer animation and in interactive process control applications is sketched.