bluuebunny/crossref_metadata_2025 huggingface dataset:
A database of groups of prime‐power order
Authors: Butler G. , Iyer S. S. , O'brien E. A.
Published: November 2006

The design, implementation and performance of TwoGroups, a deductive database for the 58,761 groups of order 2n, (n ≤ 8), is described. The system is implemented in NU‐Prolog, a Prolog system with built‐in functions for creating and using deductive databases. TwoGroups has a set‐theoretic query language, which provides users with a familiar notation to access the data. The paper describes the data and its representation, the set‐theoretic query language, its translator and optimiser, and the experiments on the performance of the database.
Techniques for file system simulation
Authors: Thekkath Chandramohan A. , Wilkes John , Lazowska Edward D.
Published: November 2006

Careful simulation‐based evaluation plays an important role in the design of file and disk systems. We describe here a particular approach to such evaluations that combines techniques in workload synthesis, file system modeling, and detailed disk behavior modeling. Together, these make feasible the detailed simulation of I/O hardware and file system software. In particular, using the techniques described here is likely to make comparative file system studies more accurate.

In addition to these specific contributions, the paper makes two broader points. First, it argues that detailed models are appropriate and necessary in many cases. Second, it demonstrates that detailed models need not be difficult or time consuming to construct or execute.
Efficient binary transfer of pointer structures
Authors: Toyn Ian , Dix Alan J.
Published: November 2006

This paper presents a pair of algorithms for output and input of pointer structures in binary format. Both algorithms operate in linear space and time. They have been inspired by copying garbage collection algorithms, and make similar assumptions about the representations of pointer structures.

In real programs, the transfer of entire pointer structures is often inappropriate. The algorithms are extended to transfer partitions of a pointer structure lazily: the receiver requests partitions when it needs them.

A remote procedure call mechanism is presented that uses the binary transfer algorithms for communicating arguments and results. A use of this as an enabling mechanism in the implementation of a software engineering environment is discussed.
Design and implementation of national engineering education delivery system (NEEDS)
Authors: Schmitz Daniel C. , Wong Johnny S. , Nelson Ron M.
Published: November 2006

Educational course material is constantly being developed by professors. More and more of this course material is now on computers. It is often desirable for this material to be available through computer networks to the widest possible audience. Given a general audience, this access should be quick and simple. The National Engineering Delivery System (NEEDS) is a new courseware development and distributed system which allows faculty, students, industry and other users to easily access a large number of diverse courseware modules in an effective and efficient manner. This paper documents the design and implementation of a system that may make this idea a reality. The work includes the development of databases used to store course material information, the design of an efficient communication networking protocol for delivering courseware modules, and the development of user front‐ends for general access to the course material stored in the databases.
A comparison of object‐oriented programming in four modern languages
Authors: Henderson Robert , Zorn Benjamin
Published: November 2006

Object‐oriented programming has become a widely used, important programming paradigm that is supported in many different languages. C++ has become the most widely used object‐oriented language and many C++ programmers are unfamiliar with the different approaches taken by other languages in the paradigm. This paper is intended as an introduction to a broad range of ideas in object‐oriented programming. Specifically, we introduce four modern programming languages that support object‐oriented programming (Oberon‐2, Modula‐3, Sather and Self), and show how a simple application is coded in these languages. While each of these programming languages provide support for inheritance, dynamic dispatch, code reuse, and information hiding, they do so in very different ways and with varying levels of efficiency and simplicity. The use of a simple example, based on a common programming problem, facilitates our comparison. We have coded the application in all of these languages, including C++, and we compare the compile times, object code sizes, and run times of the available implementations. Implementations of all the languages compared and all of the programs we measure are available on the Internet. Ultimately, our goal is to encourage and facilitate programmers in understanding and exploring a variety of object‐oriented programming languages.
Kitrace: Precise interactive measurement of operating systems kernels
Authors: Kuenning Geoffrey H.
Published: November 2006

Kitrace is a software tool that allows dynamic interactive measurement of UNIX kernel performance to much greater precision than that available from kernel profiling. Developers can measure, to microsecond resolution, the time required by a complex kernel activity, including time spent waiting for I/O activity or user processes. Kitrace has also proven useful for debugging, especially in situations where traditional breakpointing would be undesirable or would change the behavior of the kernel.
A requirements capture method and its use in an air traffic control application
Authors: McCluskey T. L. , Porteous J. M. , Naik Y. , Taylor C. N. , Jones S.
Published: November 2006

This paper describes our experience in capturing, using a formal specification language, a model of the knowledge‐intensive domain of oceanic air traffic control. This model is intended to form part of the requirements specification for a decision support system for air traffic controllers. We give an overview of the methods we used in analysing the scope of the domain, choosing an appropriate formalism, developing a domain model, and validating the model in various ways. Central to the method was the development of a formal requirements engineering environment which provided automated tools for model validation and maintenance.
Statistical testing of software based on a usage model
Authors: Walton Gwendolyn H. , Poore J. H. , Trammell Carmen J.
Published: November 2006

In statistical testing, a model is developed to characterize the population of uses of the software, and the model is used to generate a statistically correct sample of all uses of the software. A software ‘usage model’ characterizes the population of intended uses of the software in the intended environment. Statistical testing based on a software usage model ensures that the failures that will occur most frequently in operational use will be found early in the testing cycle. The usage model is based on the software specification. The model can be developed in parallel with the software, thus shortening the elapsed time required to develop the deliver software.

Usage modeling has been demonstrated to be an activity that improves the specification, gives an analytical description of the specification, quantifies the testing costs and, with statistical testing, provides a basis from which inferences of software reliability may be made. This paper describes the justification for statistical testing of software using a usage model, describes procedures for developing and using a usage model and discusses several usage modeling issues and recent advances in usage model applications.
Design and implementation aspects of an experimental C++ programming environment
Authors: Sametinger J. , Schiffer S.
Published: November 2006

A good programming language alone is not sufficient for economic software production. The programming environment has a significant influence on the productivity of software engineers. Providing a programmer with information about an object‐oriented software system requires extracting information from the source code, e.g. class, method and variable names. We use separate structure files for holding this information and take advantage of proven tools such as make and the C preprocessor for keeping the structure files up to date and for processing software systems that heavily use macros.

In this paper we describe the concepts used for comfortable processing of C++ software systems, and discuss interesting design and implementation aspects, including structure files, the applied make mechanism and the exploitation of the C preprocessor.
Efficient implementation of suffix trees
Authors: Andersson Arne , Nilsson Stefan
Published: November 2006

We study the problem of string searching using the traditional approach of storing all unique substrings of the text in a suffix tree. The methods of path compression, level compression and data compression are combined to build a simple, compact and efficient implementation of a suffix tree. Based on a comparative discussion and extensive experiments, we argue that our new data structure is superior to previous methods in many practical situations.
Improving the output of the FORTRAN to C translator, f2c
Authors: Levy G. F.
Published: November 2006

The popularity of C as a computer language has meant that many Fortran 77 programs have been translated into C. Although automatic translation from Fortran 77 to C can be accomplished using the tool f2c, the generated C code is not easy to read and maintain. This article describes a set of tools developed at NAG Ltd for the automatic polishing of f2c generated C code.
An implementation of storage management in capability environments
Authors: Corsini Paolo , Lopriore Lanfranco
Published: November 2006

The exploitation of the salient features of capability‐based addressing environments leads to a high number of small objects existing in memory at the same time. It is thus necessary to enhance the efficiency of the mechanisms for object relocation, and to avoid congestion of input/output devices due to swapping. In this paper, we present an approach to the management of a large virtual memory space aimed at solving these problems. We insert partial information concerning the physical allocation of each object into the virtual identifier of this object. Objects are grouped into large swapping units, called pages. The page size is independent of the average object size. This results in enhanced efficiency in managing the relocation information both with regard to memory requirements and access times. The allocation of objects into pages, and the movement of pages through the memory hierarchy, are controlled by user processes. This means that programs which have knowledge of their own use of virtual memory can increase their locality of reference, diminish the number of swap operations and reduce fragmentation.
Myriad: Design and implementation of a federated database prototype
Authors: Lim Ee‐Peng , Hwang San‐Yih , Srivastava Jaideep , Clements Dave , Ganesh M.
Published: November 2006

A key problem in providing ‘enterprise‐wide’ information is the integration of databases that have been independently developed. An important requirement is to accommodate heterogeneity and maintain the autonomy of component databases. Myriad is a federated database prototype developed at the University of Minnesota, to provide a testbed for investigating alternatives in architecture and algorithms for database integration, query processing and optimization, and concurrency control and recovery. The system incorporates our group's research results in these areas. This paper describes our experiences in the design and implementation of Myriad, and in the project management. Special emphasis is given to discussing design alternatives and their impact on Myriad. This paper also presents the software engineering principles and the project management techniques we used in developing Myriad and the lessons we learned. We believe these lessons would be useful for practitioners who wish to develop a similar system.

Handling heterogeneity and autonomy were prime objectives throughout the prototyping effort. We are convinced that a prototype federated database is an important infrastructural requirement for the overall goal of ‘enterprise‐integration’, and believe Myriad to be a significant contribution towards this.
Parc++: A parallel C++
Authors: Tödter Kai , Hammer Carsten , Struckmann Werner
Published: November 2006

PARC++ is a system that supports object‐oriented parallel programming in C++. PARC++ provides the user with a set of predefined C++ classes that can easily be used for the construction of parallel C++ programs. With the help of PARC++ objects, the programmer is able to create and start new processes (threads), to synchronize their activities (Blocklock, Monitor) and to manage communication via message passing (Mailbox). PARC++ is written in C++ and currently runs on top of the EMEX operating system on a FORCE machine with 11 processing elements and an EDS (European Declarative System) with 28 processing elements. The paper also contains information about the run‐time system model, the implementation and some performance measurements.
Comparison of syntactic error handling in LR parsers
Authors: Degano Pierpaolo , Priami Corrado
Published: November 2006

Error recovery techniques for LR parsers presented in the literature are described and classified. The techniques considered range from the non‐correcting ones to interactive and incremental ones. Also, some of the techniques presented are compared and evaluated. An example showing the advantages and the disadvantages of each class of strategies is given and is used as a guideline for classifying syntax errors according to the recovery strategies which are more adequate to correct them.
Experiences of parallelising finite‐element problems in a functional style
Authors: Grant P. W. , Sharp J. A. , Webster M. F. , Zhang X.
Published: November 2006

Experiences are described of parallelizing a functional finite‐element program (written in Haskell) for the solution of computational fluid‐dynamics problems. A transformation prototyping approach using a system developed at the University of York, which simulates idealised parallel machines on a conventional sequential workstation, is presented. In this paper we demonstrate: (a) the relative simplicity of the functional approach for parallelizing a complex program compared with the conventional procedural approach; (b) the suitability of functional languages for prototyping parallel algorithms to improve an implementation; and (c) the considerable assistance provided by the simulator.
Type inference of SELF: Analysis of objects with dynamic and multiple inheritance
Authors: Agesen Ole , Palsberg Jens , Schwartzbach Michael I.
Published: November 2006

We have designed and implemented a type inference algorithm for the SELF language. The algorithm can guarantee the safety and disambiguity of message sends, and provide useful information for browsers and optimizing compilers.

SELF features objects with dynamic inheritance. This construct has until now been considered incompatible with type inference because it allows the inheritance graph to change dynamically. Our algorithm handles this by deriving and solving type constraints that simultaneously define supersets of both the possible values of expressions and of the possible inheritance graphs. The apparent circularity is resolved by computing a global fixed‐point, in polynomial time.

The algorithm has been implemented and can successfully handle the SELF benchmark programs, which exist in the ‘standard SELF world’ of more than 40,000 lines of code.
Using conditional execution to exploit instruction level concurrency
Authors: Adams Rod , Gray Sue
Published: November 2006

Multiple‐instruction‐issue processors seek to improve performance over scalar RISC processors by providing multiple pipelined functional units in order to fetch, decode and execute several instructions per cycle. The process of identifying instructions which can be executed in parallel and distributing them between the available functional units is referred to as instruction scheduling. This paper describes a simple compile‐time scheduling technique, called conditional compaction, which uses the concept of conditional execution to move instructions across basic block boundaries. It then presents the results of an investigation into the performance of the scheduling technique using C benchmark programs scheduled for machines with different functional unit configurations. This paper represents the culmination of our investigation into how much performance improvement can be obtained using conditional execution as the sole scheduling technique.
Interactive hypermedia applications: A model and its implementation
Authors: Wang H. K. , Wu Jean‐Lien C.
Published: November 2006

By referring to the object‐oriented efforts of the Multimedia and Hypermedia information coding Expert Group (MHEG), and the augmented Petri net model, we present a formal definition of the multimedia hypermedia Petri net (MHPN) model. Through this proposed model, issues of authoring, rendering and synchronization of multimedia information (i.e. structure authoring, spatial temporal relationships, user interaction, etc.) can all be laid to rest. We have implemented a testbed system, the Petri net object information system (POIS), which offers considerable potential for the development of distributed hypermedia applications. The testbed has been implemented on an IBM‐PC486 under Windows 3.1. We are now in the process of porting the testbed model to Windows NT.
Object‐oriented specification of user interfaces
Authors: Jaaksi Ari
Published: November 2006

This paper presents an object‐oriented approach for the specification of graphical user interfaces. Specification starts with the analysis of the end user's operations. The user interface is then designed on the basis of this analysis. Operation analysis is followed by structure and component specification which presents the dialogue structure of the application and the contents of each dialogue. Visualization produces the final screen layouts, and task specification documents the usage of the user interface for the purpose of creating user's guides.

The method presented in this paper makes it easier for a designer to take the end user's needs into account. Still, it does not automatically guarantee good quality user interfaces. The top‐down nature of the method allows the designer to concentrate on the most important aspects of the user interface and split the design procedure into manageable pieces. Also, the visibility of the process allows the designer to communicate with other people while specifying the user interface.

This paper connects the method with the object‐oriented specification of entire applications. It briefly explains the connections with object‐oriented analysis and design, and demonstrates how to implement the specified user interface in an object oriented fashion. The approach presented in this paper is being applied in the development of a large network management system with about two million lines of C++ code running in the XII environment. Still, the method does not require the specification being implemented with any specific windowing system. The only requirement is that the user interface is based on graphical elements, such as dialogues, push‐buttons and text fields.
Design and implementation of heterogeneous distributed multimedia system using mosaic GSQL
Authors: Magavi Sunil , Wong Johnny , Bodla Prakash
Published: November 2006

With more and more computer users having access to the Internet, it is important for them to access the vast amount of information in an efficient and easy manner. This project explores one of the possibilities for providing an integrated system to the user to access the different types of media like text, image, audio and video stored in different databases on remote machines without the user having to know about the underlying mechanism involved in accessing the database. Such a system must hide the location of the remote data, retrieve the information, process the results and present it to the user. We have used the National Center for Supercomputer Applications (NCSA) Mosaic's Gateway Structured Query Language (GSQL), which enables a system developer to build input forms, query to the remote database in a relatively easy manner and present the results to the user. With the help of this prototype, the development time to build such an application is considerably reduced as compared with developing the same application using the existing Graphical User Interface (GUI) tools like the X‐Window system.
Experience with logical code analysis in software maintenance
Authors: Hart Johnson M.
Published: November 2006

Formal program specification and logical analysis are often used for program derivation and proofs of correctness. The basic tools include the logic of predicate calculus and Dijkstra's weakest precondition calculations. Recent work has shown that these tools are also very useful in the maintenance phase of the software life‐cycle. This paper reports experience working with software maintenance teams to apply formal methods. Formal logical analysis is invaluable for isolating defects, determining code corrections, eliminating side‐effects, and code re‐engineering. Logical analysis works well in software maintenance because many defects can be isolated to small segments of code. These small segments can then be analyzed manually or with code analysis tools. The result is lowered software maintenance costs due to the benefits of defect prevention, reduction of code complexity metrics, productivity improvements, and better specifications and documentation. It would be beneficial to use logical code analysis in the earlier phases of the software life‐cycle, such as quality assurance and inspection.
Ropes: An alternative to strings
Authors: Boehm Hans‐J. , Atkinson Russ , Plass Michael
Published: November 2006

Programming languages generally provide a ‘string’ or ‘text’ type to allow manipulation of sequences of characters. This type is usually of crucial importance, since it is normally mentioned in most interfaces between system components. We claim that the traditional implementations of strings, and often the supported functionality, are not well suited to such general‐purpose use. They should be confined to applications with specific, and unusual, performance requirements. We present ‘ropes’ or ‘heavyweight’ strings as an alternative that, in our experience leads to systems that are more robust, both in functionality and in performance.

Ropes have been in use in the Cedar environment almost since its inception, but this appears to be neither well‐known, nor discussed in the literature. The algorithms have been gradually refined. We have also recently built a second similar, but somewhat lighter weight, C‐language implementation, which is included in our publically released garbage collector distribution. We describe the algorithms used in both, and give some performance measurements for the C version.
The Oberon System family
Authors: Brandis M. , Crelier R. , Franz M. , Templ J.
Published: November 2006

Oberon simultaneously refers to a moduar, extensible operating system and an object‐oriented programming language developed for its implementation. Although the original Oberon System had been conceived as the native operating system for a custom‐built workstation, furhter implementations for several commercial platforms were developed later and are described here. All of these implementations are based on an efficient, retargetable Oberon compiler, and each provides a complete Oberon environment and the original library interface. This paper describes the structure of the compiler, summarizes the experience gained in adapting it for various CISC and RISC processors, and presents some empirical performance data. It also sheds light on the task of grafting an operating environment onto a variety of existing operating systems.
Description of a process development methodology
Authors: Eberlein Armin , Jiang Li
Published: November 2006

The creation of a development process is a challenging task. The most‐widely published process models, such as the Waterfall model, are very generic, and their application and customization to a specific problem domain requires major effort. Additionally, their refinement into fine‐grained process steps demands a lot of dedicated work. There is definitely a lack of aid for the customization of processes to specific domains and projects. This article first reviews a generic framework for Requirements Engineering (RE) as well as a domain‐specific framework. It then outlines a methodology and tool called (Process Development Assistant) PDA that helps the process engineer develop a process model in an iterative manner. The methodology requires as input from the developer items of major concern, constraints and priorities specific to a certain domain and a particular project. It uses mathematical definitions to generate an initial process model that is then iteratively refined using the feedback of the process designer. The PDA methodology and tool can also be used for more general systems engineering process modeling. Copyright © 2006 John Wiley & Sons, Ltd.
Software testing: A selected annotated bibliography
Authors: Roper Marc
Published: November 2006

A collection of 69 references drawn from books, papers and conference proceedings on the subject of software testing is presented. Each reference is accompanied by a paragraph describing its contents. The aim when selecting the references was to minimize the number and maximize the coverage of the subject. For this reason, the bibliography is primarily intended for the researcher or practitioner who is relatively new to the subject. The bibliography is organized according to the following sections: general introductions; background; testing methods; experimental studies; and tools.
Problems and strategies for software component testing standards
Authors: Wichmann B. A. , Cox M. G.
Published: November 2006

What does it mean to say that an item of software has been tested? Unfortunately, currently accepted standards are inadequate to give the confidence the user needs and the meaningful objective for the supplier. This paper assesses the currently available standards, mainly in the component testing area and advocates that the British Computer Society proto‐standard should be taken as a basis for a formal standard. The paper is intended for those concerned with software quality.
Classification trees for partition testing
Authors: Grochtmann Matthias , Grimm Klaus
Published: November 2006

The most important prerequisite for a thorough software test is the determination of relevant test cases. The classification‐tree method suggested in this paper supports the systematic determination and description of test cases. It is based on the idea of partition testing. By means of the classification‐tree method, the input domain of a test object is regarded under various aspects assessed as relevant by the tester. For each aspect, disjoint and complete classifications are formed. Classes resulting from these classifications may be further classified—even recursively. Test cases are formed by combining classes of different classifications. The stepwise partition of the input domain by means of classifications is represented graphically in the form of a tree. This tree is subsequently used to form a combination table in which the test cases are marked. Extensions of the graphical notation and tool support allow the use of the method even for extensive test problems.
Metrics collection in code and unit test as part of continuous quality improvement
Authors: Davey Shaun , Huxford Dave , Liddiard John , Powley Mark , Smith Alan
Published: November 2006

A policy of rigorous unit testing as a foundation for the integration of software systems has been found to be effective, resulting in rapid integration and good overall quality of the final software and systems. However, there is little detailed information on how effective individual components of the code and unit test phase of the software lifecycle are. IPL have conducted an exercise to gather and analyse detailed metrics for the module design and unit code and test phases. This will assist the improvement of estimation and planning, identify areas where quality can be improved and costs reduced, enhance project management with improvements in control over the development, and develop indicators that can be used to anticipate problem areas and facilitate risk management.
An integrated methodology for the specification, verification and testing of systems
Authors: Holcombe Mike
Published: November 2006

The practical use of formal methods in the specification and verification of software systems is an area where the U.K. and Europe have a significant competitive edge and from the point of view of research there has been much emphasis on this area. However, little of the work also addresses testing issues—there is almost an implication that testing is unnecessary when a system has been formally developed and certainly testing issues are very rarely discussed by those involved in formal methods. This position is challenged and a mechanism is proposed whereby: (a) testing is integrated more fully into the design process and, in particular, is considered at the beginning of the life cycle; (b) there is the potential that as the design is refined and transformed into an implementation, the top level abstract test strategy is similarly transformed into detailed test sets. The test strategy is based on the derivation of test sets from formal specifications (new generation functional testing).
Software testing using analysis and design based techniques
Authors: Roper Marc , Rahim Ab Rashid Bin Ab
Published: November 2006

This paper presents a way of generating acceptance and systems test data from documents produced as part of the traditional structured approaches to systems analysis and design. Entity‐relationship diagrams are analysed in a fashion similar to boundary‐value analysis to generate combinations of entities that should be supported by the system. Data flow diagrams are analysed in a way that generates tests to exercise the passage of each data item through the system. This information is augmented with details from the process specifications to ensure, firstly, that the specifications themselves are tested to branch coverage level and secondly, that no infeasible tests are generated. Finally, the ‘entity life histories’ are examined and tests generated to evaluate the full range of possible states experienced by the entities within the system. The result is a common pool of test data requirements and expected results that may be used to test the corresponding development stage (typically, system or acceptance testing) or may be fed into the next development stage as walkthrough or review data. The paper concludes by presenting the results of an initial evaluation of the methods.
A metric‐based software evaluation method
Authors: Welzel Dieter , Hausen Hans‐Ludwig , Bøsegh Jøsrgen
Published: November 2006

Based on a set of case studies in eight European countries a method of software evaluation has been designed within ESPRIT Project SCOPE (Software Certification Programme Europe). This method deals with several types of information: software characteristics and metrics, product and process information, and evaluation techniques. In order to be applicable, the method is supported by a five‐step procedure that analyses the quality requirements, specifies, designs and conducts the evaluation, and, finally, reports on the collection of all documents produced in an evaluation report. The thoroughness of software evaluation is expressed by evaluation levels; encapsulations of evaluation techniques, in order to measure a quality attribute and manage the whole process more easily, are described by evaluation modules. Two guides have been produced and have been submitted to the responsible ISO/IEC JTC1 sub‐committee for review and inclusion in normative documents being developed for the application of ISO/IEC 9126. The method proposed can work with customized models as well as with standards.
The automated generation of test cases for compilers
Authors: Burgess Colin J.
Published: November 2006

The testing of a compiler is a difficult process, since often a very high quality product is expected by the user, particularly with respect to the compiler's correctness. This paper seeks to review the main methods that have been proposed for the automation of part of this process, using the automatic generation of test cases and the automatic checking of the results. It then summarizes the advantages and disadvantages of the general approach and highlights several areas for further research.
Inspecting module interface specifications
Authors: Jackson Ann , Hoffman Daniel
Published: November 2006

Despite dramatic changes in computing in the two decades since the term software engineering was coined, problems of deficient quality and unmanageable costs continue to afflict the software industry. Improvements in the software engineering process are vital to bringing software quality and costs under control. Module interface specification is a mature software engineering technology that, like many other proposed methodological improvements, has not significantly penetrated industrial practice. The inspection technique is well accepted for dealing with program code and pseudo‐code, but its potential for application to other work products is largely unrealized. This paper describes a successful pilot project in jointly transferring these two technologies to the software workplace. A central theme of the project was purposeful customization of the technology to a particular industrial setting. Such adaptation is important for success in the notoriously difficult process of diffusing software engineering methodology in industry.
Using compiler optimization techniques to detect equivalent mutants
Authors: Offutt A. Jefferson , Craft W. Michael
Published: November 2006

Mutation analysis is a software testing technique that requires the tester to generate test data that will find specific, well‐defined errors. Mutation testing executes many slightly differing versions, called mutants, of the same program to evaluate the quality of the data used to test the program. Although these mutants are generated and executed efficiently by automated methods, many of the mutants are functionally equivalent to the original program and are not useful for testing. Recognizing and eliminating equivalent mutants is currently done by hand, a time‐consuming and arduous task. This problem is currently a major obstacle to the practical application of mutation testing.

This paper presents extensions to previous work in detecting equivalent mutants; specifically, algorithms for determining several classes of equivalent mutants are presented, an implementation of these algorithms is discussed, and results from using this implementation are presented. These algorithms are based on data flow analysis and six compiler optimization techniques. Each of these techniques is described together with how they are used to detect equivalent mutants. The design of the tool and some experimental results using it are also presented.
Determining the reliability of prolog programs
Authors: Azem Alireza , Belli Fevzi
Published: November 2006

In this paper an approach to reliability prediction and estimation of Prolog programs is proposed. Two complexity measures describing Prolog programs are introduced. Values of the two measures are used, subsequently, to predict the reliability of Prolog programs before testing and in the early testing stages, and further, to estimate the reliability as a function of time, in order to determine whether the reliability objective is achieved. The proposed reliability determination approach is based on previous work (Azem et al., 1993), extending the prediction approach used therein through modification of the complexity measures and providing an estimation approach. It leads to improvements in the quality of predictions and estimations with respect to software reliability characteristics. The proposed approach is implemented in a reliability assessment environment, which also includes several well‐known software reliability models for comparison purposes.
Fault coupling in finite bijective functions
Authors: Wah K. S. How Tai
Published: November 2006

Fault‐based testing attempts to show that particular faults cannot exist in software by using test sets that differentiate between the original program (hypothesized to be correct) and faulty alternate programs. The success of this approach depends on a number of assumptions, notably that programmers are competent insofar as they only commit relatively trivial faults, and that faults only couple infrequently. Fault coupling occurs when test sets are able to differentiate between the original program and faulty alternate programs when faults occur in isolation, but not when they occur in combination; it is a complicating factor in fault‐based testing. Fault coupling is studied here within the context of finite bijective functions. A complete mathematical solution of the problem is possible in this simplified case; the results indicate that fault coupling does indeed occur infrequently, and are thus in agreement with the empirical results obtained by others in the field. One surprising result is that certain kinds of test set are able to avoid fault coupling altogether.
Error masking in computer programs
Authors: Laski Janusz , Szermer Wojciech , Luczycki Piotr
Published: November 2006

Programming faults are defined in the framework of a program proof outline. A component C in program P is faulty if P cannot be proved correct with the current implementation of C but it can be proved using the design specification for C, which defines the role of C in the overall design of P. A programming error is a state that violates the implementation specification of C. The error is masked if the design specification is satisfied by the incorrect state. Given a passing test t, the probability of error masking is 1–s(t), where s(t) is the sensitivity of t. Dynamic mutation testing (DMT), a Monte Carlo method, is used to estimate s(t). DMT is extended to estimate the probability of the existence of a hidden fault in C for a passing test suite. That probabillity can be viewed as a metric that measures the quality of the passing test suite.
Techniques for the verification and validation of knowledge‐based systems: A survey based on the symbol/knowledge level distinction
Authors: Vermesan Anca I. , Bench‐Capon Trevor
Published: November 2006

Verification and validation are terms that have been used for several years in software engineering, and there are now many verification and validation techniques, plus considerable experience and expertise in using them. However, applying these techniques to knowledge‐based system is not straightforward. The essential differences between conventional systems and knowledge‐based systems suggest that these techniques must be expanded and adapted, but new techniques are also needed. This article has two major goals: first, it makes some comparisons between verification and validation as found in traditional software engineering and knowledge‐based systems, pointing out what is special about the latter as compared with the former; second, it provides a framework for a discussion of the various European work on verification and validation of knowledge‐based systems. The perspective put forward in this article allows for a vast amound of work to be surveyed and analysed beyond the implementation level, by differentiating the symbol level and the knowledge level within a knowledge‐based system.
Spatial arrangement of metal nanoparticles supported by porous polymer substrates studied by transmission electron microtomography
Authors: Jinnai Hiroshi , Kaneko Takeshi , Nishioka Hideo , Hasegawa Hirokazu , Nishi Toshio
Published: November 2006

Fine metal particles (nanoparticles) stabilized on porous (polymeric) substrates can be considered as a model system of a high‐performance catalyst. In the present study, the substrate was made using the periodic microphase‐separated structure of a block copolymer as the template, and the Pd nanoparticles were formed inside the porous material by reduction of the Pd2+ ions with 1‐propanol as the reductant. The three‐dimensional morphology of such a polymer‐Pd hybrid material was studied by transmission electron microtomography. The characteristic structural parameters of the hybrid, e.g., the penetration of the Pd nanoparticles into the polymer substrate, number density of the Pd nanoparticles, and size distribution of the Pd nanoparticles, were measured for the first time. © 2006 The Japan Chemical Journal Forum and Wiley Periodicals, Inc. Chem Rec 6: 267–274; 2006: Published online in Wiley InterScience (www.interscience.wiley.com) DOI 10.1002/tcr.20095
Perception‐based animation rendering
Authors: Parke Frederic I.
Published: November 2006

In most currently produced computer generated animation there is significant visual information that is literally never seen because of the characteristics of the human visual system. By tailoring the rendering of animation images to match the characteristics of human visual perception, significant computational and image storage savings can be obtained while retaining perceived animation quality.

Vision research indicates that the human visual system processes two information channels. The transient channel rapidly processes low spatial resolution full colour information. The sustained channel processes high spatial resolution luminance information at a much slower rate.

This paper discusses how the rendering of animation images can be accomplished to match these perception characteristics and achieve significant savings while maintaining animation quality. Computation and storage savings of up to 80 per cent are possible. Several animation segments have been produced to demonstrate the viability of this approach.
Visualizing functions on a surface
Authors: Pottmann Helmut , Hagen Hans , Divivier Andreas
Published: November 2006

We describe techniques for the visualization of a scalar‐valued function defined over a surface. The main interest focuses on a 4D graph of such a function and projections of this graph into 3‐space. The paper also contains methods for testing the smoothness of interpolants over surfaces and a short tutorial on fundamental ideas of multidimensional descriptive geometry which can be helpful in several areas of scientific visualization.
Branching object generation and animation system with cubic hermite interpolation
Authors: de Leon Midori Kitagawa
Published: November 2006

This paper presents geometric modelling methods for branching object generation and animation with cubic Hermite curves. The procedure for creating a branching object involves two steps. First, the skeleton of an object is constructed. The skeleton consists of geometrical and topological information about the segments of the object. Secondly, cubic Hermite curves are used to deform and join consecutive segments in the skeleton in order to form the body of the object with C1 continuity. Cubic Hermite curves are also used to deform partial segments which allow an object to grow with desirable continuity in space and time. The techniques are easily implemented on any computer and allow the user to create a branching object using objects which have diverse shapes as segments.
A modelling system for complex deformable bodies suited to animation and collision processing
Authors: Gascuel Marie‐Paule , Verroust Anne , Puech Claude
Published: November 2006

We propose an integrated set of methods for designing and animating bodies whose deformable flesh coats an articulated skeleton. The proposed methods provide good automatic positioning of the ‘skin’ after movements, and automatic deformation after collisions with rigid or deformable objects (dynamic or static). The response to collisions includes a feedback from the flesh to the skeleton, whose movement is adequately modified. Moreover, coating the skeleton gives an easy solution to closed loop collisions and angle constraints control. Our model is modular and gives some high level control to the user.
The virtues and the vertigo of the virtual
Authors: Quéau Philippe
Published: November 2006

From ‘virtual worlds’ to ‘artificial realities’, from ‘cyberspace’ to ‘multisensory sythetic environments’, there is no lack of colourful expressions to describe one of the most recent and the most promising developments of computer graphics. Indeed, this is a radically new tool for representing the world, capable of permanently changing our way of looking at things and the way we work, as well as the familiar concept of a show. What is the definition of a ‘virtual environment’? It is an artificial space, visualized through techniques of synthetic imagery, and in which we can ‘physically’ move about. This impression of ‘physical movement’ is produced by the concurrence of two sensory stimuli, one based on fully stereoscopic vision and the other on the so‐called ‘proprioceptive’ sensation of muscular correlation between real bodily movements and apparent changes in the artificial space in which we are ‘immersed’.
Modelling and animating faces using scanned data
Authors: Waters Keith , Terzopoulos Demetri
Published: November 2006

This paper extends a physically‐based approach to the realistic modelling and animation of human heads using scanned data. A three‐step procedure is proposed which begins with geometry and colour data acquired from a subject's head using a radial laser scanner, continues with the construction of a 3D model of the head with complete colour texture mapping, and culminates in real‐time, interactive facial animation. First, an adaptive meshing technique is described that creates non‐uniform facial meshes from the densely sampled data. These geometrically accurate facial meshes adapt to features of interest in the data, increasing polygon density over articulate face regions and areas of high curvature. Secondly, the mesh is transformed into a physically‐based head model of the subject. This incorporates a physical approximation to facial tissue and a set of anatomically‐motivated facial muscle actuators. Finally, these components are integrated in a facial modelling and animation system.
Creative parameter selection for volume visualization
Authors: Giertsen Christopher
Published: November 2006

Most of the available algorithms for scalar volume visualization offer predefined techniques such as display of volumetric regions defined by scalar threshold values. The regions can usually be drawn opaque or transparent or appear in combinations. This paper presents an implementation of a volume visualization concept where several modelling and rendering techniques can be applied in any combination, mainly bounded by the creativity of the user.

The concept is based on the use of a model for light scattering in a field of varying density emitters, and the use of fixed visual references to improve readability and disambiguate interpretation. An image is computed by means of an interval‐based mapping from scalar range to visual parameters. Each interval has a set of associated parameters, such as colour and attenuation. In addition, each interval of the scalar range must be mapped into relative density by means of a transfer function which is selected in a ‘natural way’ depending on application. A methodology is suggested which enable the piecewise transfer functions to be easily determined.

A prototype user‐interface for the mapping from scalar values to visual parameters is demonstrated. The interface is easy to use for the beginner, while it also encourages creativity and intuition in the process of selecting parameters.