bluuebunny/crossref_metadata_2025_split huggingface dataset:
Object request broker: Foundation for distributed simulation
Authors: Kuhl Frederick , Neal William , Cohen Howard 
Published: November 2006

AbstractReal‐time, human‐in‐the‐loop simulation of air traffic control is naturally distributed across computing platforms because of the need for many input and display devices, the need for computing power, and the need to integrate legacy simulations that run on a variety of platforms. Object orientation has a long history of fruitful application to simulation problems, including real‐time simulation. Thus there is great interest in commercial products for distributed object management. We have examined the suitability of object request broker (ORB) technology for simulation control, i.e. applications‐as‐objects, and for supporting truly object‐oriented, distributed, real‐time simulation. Our experience with DEC's ORB shows that at present the former is feasible but the latter is probably not; however the available implementations are changing rapidly. ORB technology can also bring the distributed interactive simulation (DIS) protocol of the DoD into an object‐oriented framework.
Experiences in translating Z designs to haskell implementations
Authors: Sherrell Linda B. , Carver Doris L. 
Published: November 2006

AbstractZ is a widely used, model‐oriented specification language. Haskell is a programming language that was recently developed to serve as a standard for non‐strict, purely functional languages. Although functional languages have proved to be excellent prototyping tools, Haskell was designed as a general purpose language which could be used when building large software systems.This paper develops two designs for a computerized class roll. The development begins with a description of the requirements and initial specification. The next section delineates the designs and explains how each design targets a specific Haskell data structure: design one employs sequences to model lists, whereas design two uses a Z function to describe a Haskell array. The corresponding implementations follow, along with a critical analysis of each translation from Z notation to Haskell code. The paper demonstrates that Z design schemas map well to at least two Haskell data types, namely the list and the array. Furthermore, it includes insights into how software developers might translate similar Z designs to Haskell.
Rie, a compiler generator based on a one‐pass‐type attribute grammar
Authors: Sassa Masataka , Ishizuka Harushi , Nakata Ikuo 
Published: November 2006

AbstractWe herein describe a compiler generator, Rie, which is based on a one‐pass‐type attribute grammar. LR‐attributed grammars are one class of attribute grammars in which attribute evaluation can be performed in one pass during LR parsing without creating a parse tree. Rie was developed based on a variant of an LR‐attributed grammar called ECLR‐attributed grammar (equivalence class LR‐attributed grammar), in which equivalence relations are introduced into the LR‐attributed grammar. Rie generates a one‐pass compiler from a compiler description given in attribute grammar form. Many language processors have been developed using Rie. The generated compiler is only about 1.8 times slower than a handwritten compiler, which is fairly efficient for a compiler generated from formal descriptions.
A lift simulation prototype
Authors: Galpin V. C. , Rock S. T. 
Published: November 2006

AbstractWe present a simple simulation of lift (or elevator) operation that has been developed as a prototype to address the need for the development of such systems. We first define the type of simulation that has been developed as a discrete‐event, dynamic, stochastic simulation. To do this, we present an overview of pertinent research in computer simulation, and identify some ambiguity in the use of terminology. We then describe the system that we have developed. Next we discuss the decisions taken in its realization, which are related to our research overview, and end by identifying some areas that we feel warrant further development. We believe that such a simulation can provide an important tool for the designers of lift systems. This prototype demonstrates its feasibility.
Implementing interactive applications in C++
Authors: Jaaksi Ari 
Published: November 2006

AbstractThis paper presents an object‐oriented approach for the implementation of interactive systems. This approach applies the model‐view‐controller (MVC) paradigm, which is modified for the C++ environment. The modified paradigm is called MVC++. In this approach the design of interactive applications starts by constructing an object model that represents the key concepts of the problem domain. This object model does not contain any user interface elements. According to the MVC++ approach, the object model is called the model part of the application. Only after the model part has been created, is the user interface designed. A collection of user interface classes is called the view. The classes that connect the model and the view form the controller, which is designed to communicate with both the model and the view.The approach presented in this paper provides a number of benefits. Advantages of the original MVC approach are obtained in a standard C++ environment, the structure of applications becomes clear and stable, and reusability as well as readability of the classes increases. Reusability is achieved by employing a mechanism called ‘abstract partners’.The approach presented in this paper is being applied in the development of a large network management system with over one million lines of C++ code running in the XII environment.
CADi: An architecture for Z tools and its implementation
Authors: Toyn Ian , McDermid John A. 
Published: November 2006

AbstractCADi began as a type‐checker for Z specifications, which were embedded within troff documents. In adding other functionality, such as expansion of schema calculus expressions, and alternative functionality, such as an embedding within LATEX documents, a more open architecture was created into which new tools can be added and alternative tools substituted. This paper gives an overview of CADiZ and describes its open architecture. Many of the ideas used in implementing CADiZ would be applicable to other language processing systems.
Implementation of the sentry system
Authors: Chodrow Sarah E. , Gouda Mohamed G. 
Published: November 2006

AbstractThe sentry of a concurrent program P is a program that observes the execution of P, and issues a warning if P does not behave correctly with respect to a given set of logical properties (owing to a programming error or a failure). The synchronization between the program and sentry is such that the program never waits for the sentry, the shared storage between them is very small (in fact linear in the number of program variables being observed), and the snapshots read by the sentry are consistent. To satisfy these three requirements, some snapshots may be overwritten by the program before being read by the sentry. We develop a family of algorithms that preserve these requirements for properties involving scalar variables, then extend the algorithms to permit the observation of large data structures without additional overhead. We describe in detail the annotation language with which the properties can be expressed, and a prototype system that we have implemented to generate the sentry automatically for any given concurrent C program. Finally, we present experimental results that show that the overhead incurred by the sentry is on average no worse than ten per cent for snapshots of up to six variables, and that the loss of snapshots prevents the sentry's detection of an single violation in less than four per cent of the cases. Recurring errors are detected at a rate of 100 per cent.
Hermes language experiences
Authors: Korfhage Willard , Goldberg Arthur P. 
Published: November 2006

AbstractWe recount and examine experiences with Hermes, an experimental language for programming distributed systems. Hermes has several unusual language features, including compile‐time checking of data initialization, representation independent data aggregates, and an integrated process model. To facilitate compile‐time initialization checking, Hermes stores data in tables and does not expose pointers. We study these features in light of the experiences of Hermes users around the world, analyzing the strengths and weaknesses of the language.
Performance measurement, visualization and modeling of parallel and distributed programs using the AIMS toolkit
Authors: Yan Jerry , Sarukkai Sekhar , Mehra Pankaj 
Published: November 2006

AbstractWriting large‐scale parallel and distributed scientific applications that make optimum use of the multiprocessor is a challenging problem. Typically, computational resources are underused due to performance failures in the application being executed. Performance‐tuning tools are essential for exposing these performance failures and for suggesting ways to improve program performance. In this paper, we first address fundamental issues in building useful performance‐tuning tools and then describe our experience with the AIMS toolkit for tuning parallel and distributed programs on a variety of platforms. AIMS supports source‐code instrumentation, run‐time monitoring, graphical execution profiles, performance indices and automated modeling techniques as ways to expose performance problems of programs. Using several examples representing a broad range of scientific applications, we illustrate AIMS' effectiveness in exposing performance problems in parallel and distributed programs.
Experimental results on string matching algorithms
Authors: Lecroq Thierry 
Published: November 2006

AbstractWe present experimental results for string matching algorithms which are known to be fast in practice. We compare these algorithms through two aspects: the number of text character inspections and the running time. These experiments show that for large alphabets and small patterns the Quick Search algorithm of Sunday is the most efficient and that for small alphabets and large patterns it is the Reverse Factor algorithm of Crochemore et al. which is the most efficient.
Migration in object‐oriented database systems—A practical approach
Authors: Huemer C. , Kappel G. , Vieweg S. 
Published: November 2006

AbstractObject‐oriented database systems are designed to meet the requirements of advanced database applications such as computer‐integrated manufacturing. These requirements may evolve in the course of time and may require the migration of the database application from one object‐oriented database system to another. Traditional migration approaches for relational database systems fail when applied to object‐oriented database systems. The goal of this paper is to fill this gap. The paper describes a framework for the migration of object‐oriented database applications. Our approach is based on a detailed analysis of the involved database systems, of the application's database requirements, and of the resources available for the database migration. We illustrate our framework by means of a case study, which is migrating an electronic planning board system from the object‐oriented database system ONTOS to ObjectStore.
A tool for visualizing the execution of interactions on a loosely‐coupled distributed system
Authors: Ashton Paul , Penny John 
Published: November 2006

AbstractThe paper describes in detail the implementation of INMON, a prototype monitor for recording and displaying interaction networks. The interaction network is designed to show the interrelationships between significant events that occur during the processing of an interaction on a loosely‐coupled distributed system. By being directed at analysing what happens in an interaction, this approach is fundamentally different from other graphical representations that show what happens during the execution of a single program on a distributed system. Examples are given of interaction networks recorded by INMON. The approach is based on very general models of a distributed system and of an interaction, and could be widely applied. We conclude by summarizing what is needed to provide facilities within any operating system for recording interaction networks.
Control flow and data flow oriented integration testing methods
Authors: Spillner Andreas 
Published: November 2006

AbstractThe testing of modular software systems can be divided into a module testing phase and an integration testing phase. While module testing checks the modules separately, integration testing examines the use of interfaces in a modular system. Integration testing allows errors to be found which cannot be found by module testing. The aim of this paper is to propose a new approach to integration testing. The main principle is to transfer and adapt module testing methods to the level of integration testing. The approach is described for control flow and data flow oriented testing methods. To decrease the testing effort and increase the probability of finding errors, integration testing can be limited to statically detectable anomalous applications of interfaces. This is accomplished by the combination of static analysis with dynamic execution and by the possibility of using information already provided by the module tests. To find further test data to execute interfaces, symbolic execution is applied. One great advantage here is to prove whether statically determined interface anomalies can be dynamically executed and can therefore occur at all.
Systematic testing: A means for validating reactive systems
Authors: Müllerburg Monika 
Published: November 2006

AbstractThe validity of the first (formal) model of a system to be developed is crucial for the whole development process. Systematically checking this validity helps avoid costs that could arise if it were discovered too late that the system does not satisfy the customer's needs and expectations.This paper addresses how to validate synchronous reactive programs using the technique of systematic testing. Testing reactive systems differs from testing sequential systems: instead of checking simple pairs of inputs and outputs, sequences of inputs and outputs have to be checked. Thus, testing cannot be based on a simple function model, mapping input values onto output values nor on a control flow graph model (where a path from the start node to the final node represents one execution through the represented program). The model widely used instead is that of a finite‐state machine.A systematic testing approach is presented that is both effective and efficient for validating reactive systems. It uses an additional specification based on a finite‐state machine model. The approach is demonstrated for the well‐known lift example. It is shown how to use the specification for carefully choosing a set of test criteria that address different types of fault; a procedure for selecting test cases and test data that satisfy the chosen criteria is presented.
Can professional development make the vision of the standards a reality? The impact of the national science foundation's local systemic change through teacher enhancement initiative
Authors: Banilower Eric R. , Heck Daniel J. , Weiss Iris R. 
Published: November 2006

AbstractProfessional development is seen as one of the major levers for aligning science instruction in the USA with the vision put forth by national standards documents. Although there is a growing consensus regarding what constitutes effective professional development, there is little empirical evidence to support this consensus. This study examines the impact of professional development that is content‐based, situated in classroom practice, and sustained over time on teacher attitudes, perceptions of preparedness, and classroom practices. It utilizes longitudinal data from the National Science Foundation's Local Systemic Change through Teacher Enhancement Initiative (LSC), collected from 42 projects over a span of 7 years. The professional development model used in the LSCs differed from previous initiatives in that it targeted all teachers in a jurisdiction and emphasized preparing teachers to implement project‐designated instructional materials. Analyses of the data provide evidence that this model for professional development has an impact on teachers and their classroom practices. In addition, the analyses found that teachers' perception of principal support for Standards‐based science instruction is an important predictor of these outcomes. © 2006 Wiley Periodicals, Inc. J Res Sci Teach 44: 375–395, 2007
Interactive visualization of three‐dimensional magnetic fields
Authors: Yamashita Hideo , Johkoh Tatsuya , Takita Shinichi , Nakamae Eihachiro 
Published: November 2006

AbstractIn order to observe the physical values (magnetic flux density and eddy current) in 3D magnetic field analysis, an interactive and highly manipulative visualization system depicting stereo images is intalled in a graphics workstation with high functional graphic processors. The system has the following characteristics:

An interactive and highly manipulative menu window with many functions: it enables visualization of complex phenomena in a 3D field through observation of various combinations of physical values from various viewpoints.
Simultaneous display of both magnetic flux density and eddy current by using the appropriate use of two colour display methods for stream lines and distribution maps of density: this function facilitates observation of the mutual relations between two physical values in a 3D field.
Animations and stereo displays: since they give extremely distinct images, observers can easily understand even highly complex 3D phenomena.
In this paper, the calculation method of density vectors, their display methods, and interactive functions are described. Some examples are also illustrated.
A high‐speed integrated renderer for interpreting multiple 3D volume data
Authors: Miyazawa Tatsuo , Koyamada Koji 
Published: November 2006

AbstractThis paper proposes an integrated rendering algorithm for visualizing 3D volumetric and geometric data, such as surfaces, lines and points, simultaneously with depth information, and other algorithms for improving the performance of the rendering process of the first. The first algorithm extends a volume rendering algorithm based on ray‐tracing so that it can handle both 3D volumetric and geometric data. It processes these data in accordance with their original representation formats to eliminate conversion artefacts such as spurious or missing surfaces, and also gives special treatment to volume segments so as to avoid errors in visibility at the intersections between volume segments and geometric data. The other algorithms employ adaptive termination of ray‐tracing, elimination of rays that do not intersect the volume, and adaptive undersampling over an image plane. These improve the performance by three to seven times over the brute‐force approach. The cost and versatility of the algorithm are evaluated by using data from the results of 3D computational fluid dynamics.
The visualization of knots and braids
Authors: Bates L. , Wyvill B. , Yao C. 
Published: November 2006

AbstractWe describe a new method for modelling braids and certain classes of knots and links, and how they may be visualized. The method uses generalized cylinders built around a bicubic spline centre line. We also show how multi‐stranded, recursive, hawser laid ropes can be modelled using related techniques.
Small steps for mankind: Towards a kinematically driven dynamic simulation of curved path walking
Authors: Van Overveld C. W. A. M. , Ko Hyeongseok 
Published: November 2006

AbstractA simple approach for the simulation of bipedal locomotion is presented. It is based on a kinematically driven rigid body dynamics simulation. As inputs, our system uses a 14‐DOF simplified human body model, and the instantaneous walking direction and the gait length. From these parameters, the trajectories of the left and right feet are computed over time, using a purely kinematical recipe. Optionally, trajectories of other body parts (head, shoulders, hips, hands, knees, etc.) may be derived from a simple kinematic body model. Using these additional trajectories provides for increased control over the motion, adding extra kinematic constraints to the dynamical system. The trajectories, together with optional force fields (gravity etc.), serve to drive the motion of the articulated human body model. This means that for those points in the body that have not been specified kinematically, a rigid body dynamics calculation is used to describe their motion over time. An implementation of these ideas turns out to allow a frame update rate of about 20 Hz on a personal IRISTM workstation, which is sufficiently fast for real‐time interaction.
Deformed cross‐dissolves for image interpolation in scientific visualization
Authors: Ruprecht Detlef , Müller Heinrich 
Published: November 2006

AbstractDeformed cross‐dissolves are methods for inconspicuous interpolation between images. We describe methods for deformation based on scattered data interpolation methods using correspondence points in the images to be interpolated and an algorithm for automatic establishment of these correspondence points. We also describe efficient cross‐dissolve algorithms for the computation of intermediate images. Results for interpolation in the field of medical visualization are presented.
Estimation of the potential speed of range expansion of an introduced species: characteristics and applicability of the gamma model
Authors: Yamamura Kohji , Moriya Seiichi , Tanaka Koichi , Shimizu Toru 
Published: November 2006

AbstractThe potential speed at which the range of an introduced species expands in its optimal environment can be predicted by using the gamma model proposed by Yamamura (Popul Ecol 46:87–101, 2004). In this paper we first clarify the difference between the gamma model and Einstein's Brownian motion model. We then apply the model to the ragweed beetle,Ophraella communaLeSage that rapidly expanded its distribution in Japan after it was first found in 1996. The parameters of the model are estimated by conducting a field experiment. The species’ net reproductive rate is examined in the laboratory. By combining these estimates, we estimate the potential speed of range expansion to be 82 km per generation and 329 km per year, while the observed speed is estimated to be 77 km per year, the observed speed being considerably slower than the potential speed. This discrepancy may be due to the low reproductive rate caused by mortality in the actual field. The applicability of the gamma model to the econometric data is also briefly discussed.
Synthesis and surface properties of chemodegradable anionic surfactants: Sodium carboxylates of cis‐1,3‐dioxane derivatives
Authors: Piasecki Andrzej , Burczyk Bogdan , Ruchała Piotr 
Published: November 2006

AbstractThe 2‐n‐alkyl‐5‐carboxy‐5‐methyl‐1,3‐dioxanes were obtained in good yield from the reaction of aliphatic aldehydes with 2,2‐bis(hydroxymethyl)propionic acid in dichloromethane solution, catalyzed by p‐toluenesulfonic acid monohydrate. Nuclear magnetic resonance analysis indicated that they were pure cis‐isomers with the axial configuration of the carboxylic group at the C‐5 carbon atom of the 1,3‐dioxane ring. The acids were converted, with retention of the configuration, to their sodium salts by reaction with sodium methoxide or sodium hydroxide in methanol. The physicochemical properties of the acids and sodium salts, as well as their surface properties at the aqueous solution‐air interface, were determined. Critical micelle concentration, surface excess concentration, surface area demand per molecule of sodium salts at the monomolecular surface layer, and standard free energy of micellization were determined based on surface tension measurements.