bluuebunny/crossref_metadata_2025_split huggingface dataset:
A distributed graphics library system
Authors: Adelstein Frank , Richard Golden , Schwiebert Loren , Parent Rick , Singhal Mukesh 
Published: November 2006

AbstractWe present a set of library routines that allow easily parallelized graphics rendering routines that require no communication between each parallel task, such as ray‐tracing, to be run efficiently in an environment of distributed workstations. The presentation of the paper focuses on the problems encountered in implementing a distributed system under Unix and proposes solutions to each problem. Specifically, we discuss the challenges involved in overcoming the limits of communicating with a large number of processes in Unix and in providing fault tolerance when using sockets. Technical aspects of the implementation and some additional problems that were encountered are discussed. Finally, we compare the rendering times for a complex image with a renderer using the library and show that the library routines are able to exploit much of the existing parallelism. The library is presented using a graphics application, though the concepts are generic enough to be of use in designing any distributed system under Unix.
Visualizing program dependencies: An experimental study
Authors: Linos Panagiotis K. , Aubet Philippe , Dumas Laurent , Helleboid Yann , Lejeune Patricia , Tulula Philippe 
Published: November 2006

AbstractThis paper addresses the problem of visualizing program dependencies (i.e. entities and their relations). A code visualization tool that maintains a repository of structural and functional dependencies for C programs is described. Visualization of such dependencies is accomplished by using a presentation model which combines data and control flow information. Moreover, transformation mechanisms and partitioning techniques used by the tool provide the means for managing large graphical representations. The quantitative results from an experimental study using this tool indicate that the productivity of its users was increased and that the quality of changes made during a program modification exercise was improved. Furthermore, the qualitative results have shown that its presentation model, transformation mechanisms and partitioning techniques constitute a promising platform for the comprehension and maintenance of C programs. Finally, the outcome of an empirical evaluation of the tool and the enhancement of its functionality and user interface are also discussed in this paper.
Synthetic‐perturbation techniques for screening shared memory programs
Authors: Snelick Robert , Jájá Joseph , Kacker Raghu , Lyon Gordon 
Published: November 2006

AbstractThe synthetic‐perturbation screening (SPS) methodology is based on an empirical approach; SPS introduces artificial perturbations into the MIMD program and captures the effects of such perturbations by using the modern branch of statistics called design of experiments. SPS can provide the basis of a powerful tool for screening MIMD programs for performance bottlenecks. This technique is portable across machines and architectures, and scales extremely well on massively parallel processors. The purpose of this paper is to explain the general approach and to extend it to address specific features that are the main source of poor performance on the shared memory programming model. These include performance degradation due to load imbalance and insufficient parallelism, and overhead introduced by synchronizations and by accessing shared data structures. We illustrate the practicality of SPS by demonstrating its use on two very different case studies: a large image understanding benchmark and a parallel quicksort.
Experience realising a meta‐model for wide system understanding: The global system model
Authors: Freeman M. J. , Layzell P. J. 
Published: November 2006

AbstractThe Esprit DOCKET project seeks to reduce the problems associated with software maintenance through enhancing traditional, reverse engineering tools with other sources of knowledge, enabling mainters to produce more accurate system models. To produce accurate system models, knowledge about an information system, obtained from different sources, must be interpreted and integrated into a single model (known as the global system model in DOCKET). The definition and implementation of such a model involves the resolution of many issues. These include multiple views of a system at different levels of abstraction, handling inconsistency, incompleteness and system description evolution. This paper reports on the implementation of the Global System Model using the language SML. SML enabled design and implementation problems to be surmounted at a high level of abstraction and facilitated the rapid implementation and testing of the global system model, greatly reducing the effort required to implement it compared to more conventional facilities.
An interactive tool for design, simulation, verification, and synthesis of protocols
Authors: Chao Daniel Y. , Wang David T. 
Published: November 2006

AbstractWe have developed a user‐friendly CAD graphical tool for the design, verification, simulation, and synthesis of protocols based on an interactive tool for Petri net and state diagram designs. Special features of this tool are: the capability of modeling both control and data flows, reduction and analysis, simulation of network behavior and performance, coding (parametrized protocols and automatic implementation), synthesis (two party protocol and ordinary Petri nets), animation and flexible design. Since it is Petri‐net based, it allows simulation during all design phases and has extensive applications such as parallel debugging and simulation, expert systems, etc. Future enhancements of this tool are also discussed.
Parallel context‐sensitive compilation
Authors: Asthagiri Chandra R. , Potter Jerry L. 
Published: November 2006

AbstractThe searching power of massively parallel associative computers is an under used and under investigated capability that can be used to facilitate software development. This paper describes the development of a context sensitive compiler for pattern‐matching languages using that searching power. The described compiler was implemented on the STARAN parallel computer and the compiled OPS5 programs were also executed on the STARAN obtaining an estimated throughput of 6000 rules per second. The described compilation of production rules into equivalent procedural rules is completely data parallel, with the degree of parallelism depending on the number of tokens in the program being compiled. During any one step of the context‐sensitive analysis, the entire program is processed in constant time.
Compiler‐assisted full checkpointing
Authors: Li Chung‐Chi Jim , Stewart Elliot M. , Fuchs W. Kent 
Published: November 2006

AbstractThis paper describes a compiler‐based approach to checkpointing for process recovery. The implementation is transparent to both the programmer and the hardware. The compiler‐generatedsparse potential checkpointcode maintains the desired checkpoint interval.Adaptive checkpointingreduces the size of the checkpoints.Trainingis used to select low‐cost, high‐coverage potential checkpoints. The problem of selecting potential checkpoints is shown to be NP‐complete, and a heuristic algorithm is introduced that determines a quick suboptimal solution. These compiler‐assisted checkpointing techniques have been implemented in a modified version of the GNU C (GCC) compiler. Experiments involving the modified version of the GCC compiler on a Sun SPARC workstation are summarized.
Distributed process creation within a shared data space framework
Authors: Robinson Patrick G. , Arthur James D. 
Published: November 2006

AbstractThis paper describes the design and implementation of a remote process instantiation mechanism which is consistent with the Linda paradigm and semantics of the EVAL operation, and which uses shared data space as the medium for passing process and environment parameters. The motivation for such an implementation stems from our effort to rehost a uniprocessor version of the Linda computational system to a network of workstations. The baseline version of the Linda system relies on the semantics of the UNIX fork() system call to create processes and to pass the proper execution parameters to them. In creating a distributed version of the Linda environment, two major issues are addressed: (1) how to instantiate a remote process that knows where, among several possibilities, to begin its execution, and (2) how to communicate the proper run‐time values of relevant variables to each new remote Linda process. Guiding our implementation was a desire to employ existing interprocess communication facilities, i.e. shared data space, to pass process creation and execution parameters.
An operating system independent WORM archival system
Authors: Russo Guido , Russo Stefano , Pirenne Benǒit 
Published: November 2006

AbstractWe describe the organization of a general purpose data archival system for Write‐Once, Read‐Many (WORM) optical disks. The system has been designed for large‐scale and long‐term data storage and retrieval. The archival system is independent of the operating system, flat, self‐consistent, does not use any write cache on magnetic disk, and allows the exploitation of auxiliary information on magnetic disk, which can be rebuilt immediately in case of a crash, to speed up file retrieval. A library in C language, called pODLIB, has been implemented as a portable interface to the archival system.
Adding graphics to a high‐level programming language
Authors: Jeffery Clinton L. , Griswold Ralph E. , Townsend Gregg M. 
Published: November 2006

AbstractWhen graphics input/output capabilities are added to a programming language originally designed with a text stream input/output model, various design decisions affect the ease with which the graphics facilities are learned and used by applications programmers. In adding window system facilities to the Icon programming language, some design decisions were made very differently from the conventional wisdom, resulting in substantial benefits for programmers. In addition, some pre‐existing Icon language features have proved to be useful in graphics programming.
CBack: A simple tool for backtrack programming in C
Authors: Helsgaun Keld 
Published: November 2006

AbstractBacktrack programming is such a powerful technique for problem solving that a number of languages, especially in the area of artificial intelligence, have built‐in facilities for backtrack programming. This paper describes CBack, a simple, but general tool for backtrack programming in the programming language C. The use of the tool is illustrated through examples of a tutorial nature. In addition to the usual depth‐first search strategy, CBack provides for the more general heuristic best‐first search strategy. The implementation of CBack is described in detail. The source code, shown in its full length, is entirely written in ANSI C and highly portable across diverse computer architectures and C compilers.
On tuning recursive procedures
Authors: Yehudai Amiram , Libedinsky Fernando 
Published: November 2006

AbstractWe propose a methodology of reducing the space requirements of recursive procedures without destroying their fundamental recursive structure. This technique is quite general, and seems to apply to most recursive procedures, particularly those dealing with recursive data structures. A recursive procedure is transformed into three procedures — a shell which is called from the outside, and has the same interface as the original, a recursive procedure with a minimum number of parameters, and no local variables, and a procedure that performs the operations but has no recursive calls. Our methodology was successfully employed in an implementation of a decision support system. The paper also includes results of experiments, in which space was reduced by a factor of up to seven, and run time was also improved.
Using protean for verifying a complex protocol — A case study
Authors: Lai R. 
Published: November 2006

AbstractCommunication protocols used in the field have always suffered from failures. Some of these faults are the result of design errors; others are the result of implementation errors. These errors dramatically increase maintenance cost and decrease software reliability. The best time to maintain software is during its design stage. A formal approach to developing a protocol is deemed necessary to improve the quality of communication software and to reduce maintenance costs. Protocol verification plays a major role in achieving these objectives; a protocol is first specified formally and then this formal specification is analysed using a computer‐aided tool. PROTEAN is a software tool that verifies a protocol specified formally in Numerical Petri Nets. This paper describes the experience and practice of using PROTEAN to verify a complex protocol and then presents an evaluation of PROTEAN and its associated techniques in the light of protocol software development. The ISO FTAM protocol is used as a case study.
An approach to automatic display layout using combinatorial optimization algorithms
Authors: Lüders Peter , Ernst Rolf , Stille Stefan 
Published: November 2006

AbstractThe introduction of automatic display layout (ADL), i.e. the automatic placing and sizing of windows in a window‐oriented graphical user interface, is a major contribution towards an improved user interface. Our approach to ADL is to treat this problem as a combinatorial optimization problem. In this article we describe the concepts we used for implementing an experimental system which controls the computer screen contents and its layout. We give two examples of different standard applications into which we included ADL successfully, namely hypertext for a window layout problem and graph‐browser for a hierarchical graph layout problem within a particular window. The results show that automatic (and tool independent) display layout will be possible in the near future even in an interactive environment.
Using formalized temporal message‐flow diagrams
Authors: Citrin Wayne , Cockburn Alistair , Kanel Jurg Von , Hauser Rainer 
Published: November 2006

AbstractTemporal message‐flow diagrams (TMFDs), alternatively called sequence charts, interaction diagrams, event traces, or actor diagrams, are illustrations of a system's global message‐passing activity over time, and a pictorial aid to understanding the system's behavior. They are widely used for requirements and documentation for network protocols and object‐oriented applications. We present a general formalism for TMFDs, describe a suite of tools we have designed that employs this formalism, and present our experiences with these tools. The formalism and tools described serve to support and broaden the use of TMFDs in developing communicating systems.
Preparation and Characterization of Annealed‐Enzymatically Hydrolyzed Tapioca Starch and the Utilization in Tableting
Authors: Tukomane Tuangporn , Leerapongnun Prakan , Shobsngob Sujin , Varavinit Saiyavit 
Published: November 2006

AbstractTapioca starch was annealed at 60°C for 90 min followed by hydrolysis with α‐amylase at 60°C at various lengths of time (30, 60 and 120 min) to obtain high‐crystalline starches. The reaction products were subjected to spray drying to obtain annealed–enzymatically hydrolyzed–spray dried tapioca starch (SANET) in the form of spherical agglomerated granules. The properties of SANET were compared with those of annealed–spray dried tapioca starch without enzymatic treatment (SANT) and native–spray dried tapioca starch (SNT). Scanning electron micrographs of the starch samples were used to study the morphological changes and to suggest the mode of enzyme attack during hydrolysis. The á‐amylase preferentially attacked the interior of the starch granules, leaving a deep round hole on the starch granule surface. It was found by X‐ray diffraction that both annealing and amylolysis did not alter the A type diffraction pattern. The% relative crystallinity of SANET was raised with increasing hydrolysis time and with decreasing amylose content. High performance size exclusion chromatography (HPSEC) demonstrated the decrease of the degree of polymerization (DP) of the amylose fraction of SANET after prolonged hydrolysis. For the utilization of SANET as tablet filler, it was directly compressed by a tablet compression machine at 4 kN to obtain tablets. The increased relative crystallinity of starch resulted in increased crushing strength and disintegration time, but in a decreased tablet friability.
Structured inspections of code
Authors: Van Emden Maarten H. 
Published: November 2006

AbstractCleanroom programming and code inspections independently provide evidence that it is more efficient to postpone the testing of code to a later stage than is usually done. This paper argues that an additional gain in quality and efficiency of development can be obtained by structuring inspections by means of an inspection protocol. The written part of such a protocol is prepared by the programmer before the inspection. It is modelled on Floyd's method for the verification of flowcharts. However, the protocol differs from Floyd's method in being applicable in practice. Structured inspections gain this advantage by not attempting to be a proof; they are no more than an articulation of existing forms of inspection. With the usual method of structured programming it may be difficult to prepare the inspection protol. On the other hand, ‘assertion‐driven programming’ (of which an example is included in this paper) not only facilitates protocol preparation, but also the coding itself.
Dynamic method for software test data generation
Authors: Korel Bogdan 
Published: November 2006

AbstractTest data generation in program testing is the process of identifying a set of test data which satisfies a given testing criterion. Existing pathwise test data generators proceed by selecting program paths that satisfy the selected criterion and then generating program inputs for these paths. One of the problems with this approach is that unfeasible paths are often selected; as a result, significant computational effort can be wasted in analysing those paths. In this paper, an approach to test data generation, referred to as a dynamic approach for test data generation, is presented. In this approach, the path selection stage is eliminated. Test data are derived based on the actual execution of the program under test and function minimization methods. The approach starts by executing a program for an arbitrary program input. During program execution for each executed branch, a search procedure decides whether the execution should continue through the current branch or an alternative branch should be taken. If an undesirable execution flow is observed at the current branch, then a real‐valued function is associated with this branch, and function minimization search algorithms are used to locate values of input variables automatically, which will change the flow of execution at this branch.
Replay‐based debugging of occam programs
Authors: Cimitile A. , De Carlini U. , Villano U. 
Published: November 2006

AbstractParallel programs are intrinsically non‐deterministic, and therefore the techniques of cyclical debugging that are commonly used for sequential programs are not suitable for parallel ones. This paper proposes a method to reproduce Occam program behaviour. Saving information on the timer values input by the program and the guards selected at run‐time on alternative commands allows program replay, i.e. it makes it possible to re‐execute the program deterministically with the same inputs following the same instruction path. This enables the software developer to use tools such as debuggers and intrusive monitors to help identify program faults. After discussing possible implementations of the proposed technique, IRD (an interactive replay debugger for Occam programs) is described. Finally, the use of the IRD in a sample debug session is presented as an example.
Using symbolic execution and data flow criteria to aid test data selection
Authors: Girgis Moheb R. 
Published: November 2006

AbstractThe utilization is described of a data flow path selection criterion in a symbolic execution system. The system automatically generates a subset of program paths according to a certain control flow criterion. This subset is called the ZOT‐subset, since it requires paths that traverse loops zero, one and two times. Experience indicates that traversing this subset of program paths is enough to cover most control flow and data flow components of the program. The problem with the ZOT‐subset is that it might contain, for large programs, a large number of paths. The number of paths in this subset can be reduced by concentrating on executable paths that cover vital components of programs such as data flow components. This object is achieved by employing a data flow path selection criterion in the system. The system symbolically executes the paths of the ZOT‐subset, and creates a system of branch conditions for each one. The user determines infeasible paths by checking the consistency of each system of conditions. The system selects feasible paths from the ZOT‐subset that cover the data flow criterion. Solving the systems of conditions of the selected paths provides the user with test data to fulfil the given data flow criterion.
Algebraic specifications and sequencing: A defect detection method
Authors: Olender Kurt M. , Bieman James M. 
Published: November 2006

AbstractOne class of program defects results from illegal sequences of otherwise legal operations in software implementations. Explicit statement of sequencing constraints, however, is not a common activity when specifying software even when using formal specification methods. This paper shows that constraints on program execution sequences can be derived directly from algebraic specifications. Results include heuristic methods for generating sequencing constraints and a generalization of these methods into automatable rules. The heuristics can be integrated into a specification methodology such as Larch. Engineers can use the generated sequencing constraints to detect sequencing defects in software even before dynamic testing begins. The method can be used to increase the reliability of software that is specified using algebraic methods.
Decision tables: Formalisation, validation, and verification
Authors: Murrell Stephen , Plant Robert 
Published: November 2006

AbstractThe decision table is one of the simplest representations of the rules underlying a systematic decision‐making process, and is especially valuable in the development of knowledge‐based systems. A two dimensional table links all relevant combinations of input conditions to the desired combinations of output actions in a very intuitive way. This simplicity belies the complex considerations involved in verifying, validating, formulating or interpreting this (or any other) representation of machine‐based knowledge. In this paper, the common styles of decision table representation are reviewed, a formulation of their meaning is presented, construction methods are reviewed, and an algorithm for ensuring consistency is suggested. The problems that may occur in imperfectly constructed tables are discussed, detection methods reviewed, and some implementation methods are presented.
Developing a sustained interest in science among urban minority youth
Authors: Basu Sreyashi Jhumki , Barton Angela Calabrese 
Published: November 2006

AbstractThis study draws upon qualitative case study to investigate the connections between the “funds of knowledge” that urban, high‐poverty students bring to science learning and the development of a sustained interest in science. We found that youth developed a sustained interest in science when: (1) their science experiences connected with how they envision their own futures; (2) learning environments supported the kinds of social relationships students valued; and (3) science activities supported students' sense of agency for enacting their views on the purpose of science. © 2006 Wiley Periodicals, Inc. J Res Sci Teach 44: 466–489, 2007