Showing papers on "Software portability published in 1990"

NetCDF: an interface for scientific data access

Abstract: The network common data form (NetCDF), a data abstraction for storing and retrieving multidimensional data, is described. NetCDF is distributed as a software library that provides a concrete implementation of that abstraction. The implementation provides a machine-independent format for representing scientific data. Together, the abstraction, library, and data format support the creation, access, and sharing of scientific information. NetCDF is useful for supporting objects that contain dissimilar kinds of data in a heterogeneous network environment and for writing application software that does not depend on application-specific formats. Independence from particular machine representations is achieved by using a nonproprietary standard for external data representation. The discussion covers NetCDF data abstraction and interface; dimensions, variables, and attributes; direct access and hyperslab access, the NetCDF library; the data format; ncdump and ncgen utilities; experience, usability, and performance; limitations of NetCDF; and future plans. >

Conditions That Facilitate the Implementation of Educational Technology Innovations.

Abstract: Eight conditions that facilitate the adoption, implementation, and institutionalization of educational technology innovations are described and applications to the transfer of portable software are suggested. The conditions: dissatisfaction with the status quo, knowledge and skills, resources, time, rewards, participation, commitment, and leadership. Potential outcomes for using the conditions to review the likely level of portability of an educational software product in terms of its implementation in local sites are suggested.

Experience with the Condor distributed batch system

Abstract: Condor is a distributed batch system designed to provide convenient access to unutilized workstations while preserving the rights of their owners and to meet the needs of users who are frustrated by the limitations of computing on a single workstation. Several principles have driven the design of Condor. The first is that workstation owners should always have the resources of the workstation they own at their disposal. The second is that access to remote capacity must be easy and should approximate the local execution environment as closely as possible. The third is portability, which is essential because of rapid developments in the workstations on which Condor operates. Mechanisms basic to the operation of Condor, working experience, and software support requirements are outlined. >

Design of the Mneme persistent object store

Abstract: The Mneme project is an investigation of techniques for integrating programming language and database features to provide better support for cooperative, information-intensive tasks such as computer-aided software engineering. The project strategy is to implement efficient, distributed, persistent programming languages. We report here on the Mneme persistent object store, a fundamental component of the project, discussing its design and initial prototype. Mneme stores objects in a simple and general format, preserving object identity and object interrelationships. Specific goals for the store include portability, extensibility (especially with respect to object management policies), and performance. The model of memory that the store aims at is a single, cooperatively-shared heap, distributed across a collection of networked computers. The initial prototype is intended mainly to explore performance issues and to support object-oriented persistent programming languages. We include performance measurements from the prototype as well as more qualitative results.

In Touch: a graphical user interface development tool

Abstract: In Touch is designed for the class of nondirect-manipulation graphical user interfaces, typical examples being in public access, touch-screen systems. The representation used is based on state-transition diagrams with the important enhancements of nested state hierarchies, event sharing and parallel states. These help to overcome the visual complexity encountered in state transition diagrams and help the designer to denote structured and parallel user-dialogues in a visual form. In Touch also supports the design process by providing animation and simulation facilities. It has been designed to produce code executable on a range of target hardware, implying portability of generated code and a minimal run-time kernel, which is the only component that needs to be target-specific.

Computational aspects of optics design and simulation: COSY INFINITY

Abstract: The new differential algebraic (DA) techniques allow very efficient treatment and understanding of nonlinear motion in optical systems as well as circular accelerators. To utilize these techniques in their most general way, a powerful software environment is essential. A language with structure elements similar to Pascal was developed. It has object oriented features to allow for a direct utilization of the elementary operations of the DA package. The compiler of the language is written in Fortran 77 to guarantee wide portability. The language was used to write a very general beam optics code, COSY INFINITY. At its lowest level, it allows the computation of the maps of standard beam line elements including fringe fields and system parameters to arbitrary order. The power of the DA approach coupled with an adequate language environment reveals itself in the very limited length of COSY INFINITY of only a few hundred lines. Grouping of elements as well as structures for optimization and study are readily available through the features of the language. Because of the openness of the approach, it offers a lot of power for more advanced purposes. For example, it is very easy to construct new particle optical elements. There are also many ways to efficiently manipulate and analyze the maps.

An object-oriented environment for robot system architectures

Abstract: The object-oriented Robot Independent Programming Environment (RIPE) is described. A system architecture based on hierarchies of distributed multiprocessors provides the computing platform for a layered programming structure that models the application as a set of software objects. These objects are designed to support model-based automated planning and programming, real-time sensor-based activity, error handling, and robust communication. The object-oriented paradigm provides mechanisms such as inheritance and polymorphism which allow the implementation of the system to satisfy the goals of software reusability, extensibility, reliability, and portability. By designing a hierarchy of generic parent classes and device-specific subclasses which inherit the same interface, the Robot Independent Programming Language (RIPL) is realized. Work cell tasks demonstrating robotic cask-handling operations for nuclear waste facilities are successfully implemented using this object-oriented software environment. >

Method of analyzing computer source code

Abstract: A method of analyzing computer source code provides a determination of the extent to which the source code complies with guidelines relating to, for example, style, maintainability, and portability. The method includes defining a Boolean expression (12) that is assigned a TRIGGER logic state in accordance with the presence in the source code of a condition relating to a particular guideline. A guideline support computer program is also defined (14) and is executed whenever the Boolean expression is assigned the TRIGGER logic state. The guideline support program can perform a variety of operations including notification of noncompliance with the predefined guideline.

VSearch: Macintosh software for experiments in visual search

Abstract: In this paper, we describe software that turns a Macintosh computer into an off-the-shelf tool for experiments on visual search. Our design goals included portability (between members of the Macintosh computer family and between various research settings), user-friendliness (equivalent to Macintosh programming standards), flexibility (to allow replication and extension of important experiments on visual search), and adaptability (very short design-to-data and data-to-analysis turnaround times). We describe how the software meets these goals in three major phases of an experiment: stimulus construction, experimental control, and statistical analysis. We then list several landmark studies of visual search that can be easily designed and extended with the software. Finally, we outline plans for expanding the experimental variations that will be supported in future versions of the software.

High-level language debugging for concurrent programs

Abstract: An integrated system design for debugging distributed programs written in concurrent high-level languages is described. A variety of user-interface, monitoring, and analysis tools integrated around a uniform process model are provided. Because the tools are language-based, the user does not have to deal with low-level implementation details of distribution and concurrency, and instead can focus on the logic of the program in terms of language-level objects and constructs. The tools provide facilities for experimentation with process scheduling, environment simulation, and nondeterministic selections. Presentation and analysis of the program's behavior are supported by history replay, state queries, and assertion checking. Assertions are formulated in linear time temporal logic, which is a logic particularly well suited to specify the behavior of distributed programs.The tools are separated into two sets. The language-specific tools are those that directly interact with programs for monitoring of and on-line experimenting with distributed programs. The language-independent tools are those that support off-line presentation and analysis of the monitored information. This separation makes the system applicable to a wide range of programming languages. In addition, the separation of interactive experimentation from off-line analysis provides for efficient exploitation of both user time and machine resources. The implementation of a debugging facility for OCCAM is described.

A case for make

Abstract: The make command has been a central part of the Unix programming environment for over fifteen years. An excellent example of a Unix system software tool, it has a simple model and delegates most of its work to other commands. By dealing with general relationships between files and commands, make easily adapts to diverse applications. This generality, however, has become a handicap when compared with specialized integrated programming environments. Integrated environments are collections of tightly coupled (seamless) programs that can take advantage of programming language details not available to the loosely coupled (tool-based) make model. There are limitations to both approaches, but it would seem that the make model, at least for software construction, is reaching the breaking point. make can be revitalized by abandoning restrictive implementation details and by extending the basic model to meet modern software construction demands. This paper explores these demands and changes and their effects on the Unix system tool-based programming style.

NEWEUL — Software for the Generation of Symbolical Equations of Motion

Abstract: In this contribution the theoretical background of the software NEWEUL is presented, the necessary input information is given and the output generated by the program is discussed. Two examples, a mechanism and a robot, are included for demonstration of the program. NEWEUL is written in FORTRAN 77 resulting in an excellent portability to all kinds of computers from personal computers to main frames.

Strategies for supporting application portability

Abstract: A range of system-design strategies that can be used to support portability and the ways in which these strategies have been employed by past and present systems are examined. The strategies are grouped into three categories: (1) strategies that maintain identical execution-time interfaces by porting system components that form the interface, (2) strategies that maintain identical or nearly identical interfaces for different system components by adhering to appropriate standards, and (3) strategies that assist in the adaptation of programs to a target environment. The principal emphasis is on operating-system issues. User interface portability, dynamic portability in a network, and international exchange of programs are briefly considered. >

The TOPSYS architecture

Abstract: A survey on the TOPSYS (TOols for Parallel SYStems) project at the Department of Computer Science at Technical University of Munich is presented. Within this project, an integrated tool environment for increasing programmer productivity when using and programming parallel computers is developed. The TOPSYS tool environment offers tools for specification, mapping, debugging, testing, performance analysis, graphical program animation and dynamic loadbalancing of parallel programs. In addition to these tools a distributed operating system kernel and a synthetic workload generator has been developed. Apart from the integrated hierarchical architecture, the major features of the TOPSYS environment are the support of different monitoring techniques, easy adaptability, high portability and a common graphic user interface for all tools. After the description of the project goals, the major design concepts and the state of the project we describe a first application of the TOPSYS tools.

A compiler-assisted approach to SPMD execution

Abstract: The two prevailing styles of scientific parallel programming are discussed. In the SPMD (single program, multiple data) style, all processors execute the same program, with sequential code executed redundantly and parallel code executed cooperatively. In the fork-join style, a sequential thread of control spawns multiple threads to execute a portion of the code concurrently. The authors describe an automatic method for approaching the efficiency of SPMD-style execution for programs written in the more-structured fork-join style. Analysis at compile-time and proper support at run-time yield execution efficiency that approaches the SPMD model. Moreover, a greater degree of portability is achieved by regulating the burden of deciding what should be in an SPMD parallel region to the compiler, which is probably more familiar with architectural detail than most programmers. >

The portability of computer-related educational resources : an overview of issues and directions

Abstract: The portability of educational software is defined as the feasibility of software usage, with or without adaptation, in an educational environment different from that for which the software was originally designed and produced Portability is a desirable characteristic of educational software from scientific, practical, and economic considerations. Many factors can affect portability; an overview of clusters of technical and human factors is given. The factors are further organized in a way that shows their interdependence. Research questions relating to educational software portability are given and illustrated with a seven-level analytical model. The chapter serves as an overview to this Special Issue in that the research questions and factors influencing portability that are defined within it are taken up, in various ways, by the authors of the following chapters. The concluding chapter of the Special Issue refers again to this opening chapter, as well as to a synthesis of the intervening work.

Implementation benefits of C++ language mechanisms

Abstract: C + + was designed by Bjarne Stroustrup at AT&T Bell Laboratories in the early 1980s as an extension to the C language, providing data abstraction and object-oriented programming facilities. C + + provides a natural syntactic extension to C, incorporating the class construct from Simula. A design principle was to remain compatible and comparable with C in terms of syntax, performance and portability Another goal was to define an object-oriented language that significantly increased the amount of static type checking provided, with user-defined types (classes) and built-in types being part of a single unified type system obeying identical scope, allocation and naming rules. These aims have been achieved, providing some underlying reasons why C + + has become so prevalent in the industry. The approach has allowed a straightforward evolution from existing C-based applications to the new facilities offered by C + + , providing an easy transition for both software systems and programmers. The facilities described are based on Release 2.0 of the language, the version on which the ANSI and IS0 standardization of C + + is being based.

VMMP: A Practical Tool for the Development of Portable and Efficient Programs for

Abstract: Abstmct-VMMP (A Virtual Machine for MultiProcessors) is a software package, which provides a coherent set of services for parallel application programs running on diverse MlMD multiprocessors, both shared memory and message passing. It is intended to simplify parallel program writing and to promote portable and efficient programming. VMMP ensures high portability of application programs by implementing the same services on all target multiprocessors. It may also serve as a common intermediate language between very high level language compilers and various multiprocessors. VMMP supports two programming models: a virtual tree machine and a cooperating set of processes. Shared objects memory provides a flexible communication mechanism in addition to parameters and message passing. The combination of VMMP services allows one to express many parallel algorithms naturally and easily. VMMP has been implemented on two shared memory multiprocessors and on several uniprocessors. Implementation on a message passing multiprocessor is sketched. VMMP may be easily ported to other uniprocessors and MlMD multiprocessors. Some performance measurements demonstrate the feasibility of this approach to portable parallel programming.

Golf putting and swing aid for practice

Abstract: An improved golf practice device that is able to train all aspects of the golf game. It is a simple tubular structure that can hold and guide the different parts of the body to get the proper feel of putting, chipping, pitching, full swing and bunker shots. The practice aid is of lightweight construction and capable of easy disassembly for portability.

Experiments in MIMD parallelism

Abstract: The paper reviews the problems inhibiting the widespread use of parallel processing by both industry and by software houses. The two key issues of portability of code and of generality of parallel architectures are discussed. An overview of useful computational models and programming paradigms for parallel machines is presented along with some detailed case studies implemented on transputer arrays. Valiant's results on optimally universal parallel machines are reviewed along with the prospects of building truly general-purpose parallel computers. Some remarks on language and software tool developments for parallel programming form the conclusion to the paper.

Adaptable Educational Courseware: An Antidote to Several Portability Problems

Abstract: The concepts of adaptability and portability of educational software and courseware seem to be interwoven in several respects. This article explores these interrelationships in some detail, based upon the presumption that adaptable educational products are also more portable. A conceptual framework is offered for discussing adaptability of tutorial software products. Relationships between this framework and several portability-limiting factors are discussed and aspects of a methodology for the development and use of adaptable (tutorial) products are formulated. As an illustration, the research approach of the USE project is described.

VMMP: a practical tool for the development of portable and efficient programs for multiprocessors

Abstract: The VMMP (virtual machine for multiprocessors) software package is presented. It provides a coherent set of services for parallel application programs running on diverse multiple input multiple data (MIMD) multiprocessors, including shared memory and message passing multiprocessors. The communication, synchronization, and data distribution requirements of parallel algorithms are analyzed. Related languages and tools are described. VMMP services are identified. VMMP implementation, coding and portability are discussed. Some measurements of the performance of VROMP application programs and VMMP overhead are given. Several hints for improving the performance of application programs are described. >

Retrospective on DACNOS

Abstract: Heterogeneity of hardware and software is a fact in most distributed computing environments. The DACNOS prototype is a network operating system that enables resource sharing in such environments. It extends the local operating systems without interfering with existing programs. It provides comprehensive system level support for distributed applications.

Software for personal instruments

Abstract: When a personal computer (PC) is used as the computing system of an intelligent instrument, software devoted to measurement process control and to measurement process outputting can be specially developed to assist the operator throughout the measurement process in a friendly way. When these conditions are met, the intelligent instrument is called a personal instrument (PI). The main features of a PI are discussed, and the requirements for PI software are given. The performance of an original software package for PI is illustrated, showing how all the requirements are satisfied. This software, coupled to a good commercial data acquisition system, features high-precision measurement and a high level of friendliness and can be useful for lab tests and educational purposes. For lab tests, this software is a good basis for an automatic test station with extended help facilities. It ensures better performances than that of a digital scope because it allows dedicated measurement routines to be developed and executed. The software is effective for educational applications, since it allows direct application of all capabilities offered by computers in instrumentation, when associated with suitable A/D (analog/digital) conversion hardware. >

A System Independent Graphing Package for Mathematical Functions

Abstract: SIG is a compact graphics system for the display of curves and surfaces defined by mathematical formulas in a symbolic system. It is available from Kent State University. SIG consists of two parts: xgraph and mgraph that run as concurrent processes. Xgraph is a stand-alone graphics facility written in C to work with the X Window System. Mgraph is the part that is symbolic system dependent. SIG achieves display device independence through X and portability through mgraph. Capabilities of SIG, its design and implementation, as well as plans for further development are presented.

Cultural and Social Constraints on Portability.

Abstract: Although people most often think of portability of software as the possibility of running a computer program in a machine different from the type for which it was written, the objective of educational software is not its output, but a change in conduct of the learner. Thus it is very important to take into consideration the social and cultural (i.e., human) factors affecting the use of educational software. Based on Nielsen’s seven-level virtual protocol model of human-computer interaction, this paper discusses 12 constraints imposed by culture on educational software portability. These constraints are: language, curriculum differences, tone and style of educational interactions and communication, educational level of teachers, economic considerations, social organization of the learning environment, instructional approach, cultural and national identity, technological considerations in the society, geopolitical and commercial considerations, attitudes toward copyright and ownership, and instituti...

The Army Secure Operating System

Abstract: The Army Secure Operating System (ASOS) is a family of operating systems intended to serve the tactical needs of the US Army. It currently comprises two systems designed to be certifiable to classes C2 and A1 of the DoD Trusted Computer System Evaluation Criteria (TCSEC). Both operating systems provide a common user interface, support real-time applications written in Ada, and are configurable and easily portable to alternate hardware architectures. A brief overview of the development is presented, including a description of the hardware/software architecture, the current status of the project, and a review of lessons learned during the three year development. >

Design of an end-user data visualization system

Abstract: The authors describe the architecture of an end-user visualization system that supports interactive analysis of three-dimensional scalar and vector data in a heterogeneous hardware environment. The system supports a variety of visualization methods with applicability in disciplines such as computational fluid dynamics, earth, and space sciences, and finite-element analysis. The authors discuss how design goals and hardware constraints lead to a simple, cohesive paradigm for implementing a powerful, flexible, and portable visualization system. To assure efficient operation across a broad range of hardware platforms, the tools were implemented so that their interactivity is largely independent of data complexity. To gain portability, the system was built on a platform-independent graphics layer and user interface management system. The authors outline general concerns with current visualization methods and show how the approach simplifies the visualization process. >

Portable video-photo machine

Abstract: A portable video-photo machine for permitting a person being photographed to see how he or she will appear the photograph prior to the printing thereof. The machine comprises a collapsible housing having a video camara, video monitor, a still-frame apparatus, and photograph printing device associated therewith. The machine also comprises transporting means and a stand alone power source to facillitate its portability.