bluuebunny/crossref_metadata_2025_split huggingface dataset:
Ropes: An alternative to strings
Authors: Boehm Hans‐J. , Atkinson Russ , Plass Michael 
Published: November 2006

AbstractProgramming 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

AbstractOberon 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

AbstractThe 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

AbstractA 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

AbstractWhat 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

AbstractThe 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

AbstractA 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

AbstractThe 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

AbstractThis 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

AbstractBased 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

AbstractThe 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

AbstractDespite 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

AbstractMutation 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

AbstractIn 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

AbstractFault‐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

AbstractProgramming 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

AbstractVerification 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

AbstractFine 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

AbstractIn 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

AbstractWe 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

AbstractThis 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

AbstractWe 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

AbstractFrom ‘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’.