scispace - formally typeset
Search or ask a question

Showing papers on "Software portability published in 1985"


Journal ArticleDOI
Jason Gait1
TL;DR: In implementing a debugger for concurrent programs, a principal concern is the probe effect, or the possibility that the debugger itself masks synchronization errors in the program being debugged.
Abstract: This paper reports on an experimental debugger for concurrent programs. Design objectives include a showing of greatest usefulness when dealing with multiprocess interactions, creation of a simplified more approachable interface for programmers, allowance for the systematic organization (and limitation) of debugging information by programmers, reflection of a natural view of concurrency, and portability. The design responds to a perceived need for debugging techniques applicable in systems of concurrent, communicating, asynchronous processes. During debugging sessions, a user is able to dynamically explore interprocess synchronization points, parallel actions and deadlock situations. The programmer interface is based on a transparent window multiplexer providing a set of windows for each concurrent process. The window manager interactively maps interesting windows to programmer-specified viewscreen locations, while relegating temporarily uninteresting windows to the background. In implementing a debugger for concurrent programs, a principal concern is the probe effect, or the possibility that the debugger itself masks synchronization errors in the program being debugged. For the examples explored, the probe effect was not observed to limit the localization of implanted synchronization errors.

63 citations


Journal ArticleDOI
01 Apr 1985
TL;DR: The concept of generalized icons is proposed as a means to help achieve system integration in image information systems, which emphasizes program portability and modularity, self-descriptive data structures, unified image processing language and programming environment, and flexible user interface.
Abstract: Recent advances in hardware technology have made feasible the design of sophisticated image information systems. There is need for image information systems in many application areas. A survey of commercial systems that are currently available indicates the diversity of product orientations, nonuniformity, and lack of integration in their capabilities. A survey of R & D efforts indicate that many sophisticated techniques and concepts have been developed, but lack of integration again prevents their immediate applications. Based upon these considerations, an approach to software design for image information systems to achieve system integration is suggested, which emphasizes program portability and modularity, self-descriptive data structures, unified image processing language and programming environment, and flexible user interface. The concept of generalized icons is proposed as a means to help achieve such system integration.

45 citations


Journal ArticleDOI
TL;DR: This paper presents a discussion of the techniques developed and problems encountered during the design, implementation, and experimental use of a portable natural language processor, Datalog, designed to achieve a maximum degree of portability and extendibility.
Abstract: This paper presents a discussion of the techniques developed and problems encountered during the design, implementation, and experimental use of a portable natural language processor. Datalog (for “database dialogue") is an experimental natural language query system, which was designed to achieve a maximum degree of portability and extendibility. Datalog uses a three-level architecture to provide both portability of syntax to new and extended tasks and portability of semantics to new database applications. The implementation of each of the three levels, the structures and conventions that control the interactions among them, and the way in which different aspects of the design contribute to portability are described. Finally, two specific, implemented examples are presented, showing how it was possible to transport or extend Datalog by changing only one “layer” of the system's knowledge and achieve correct processing of the extended input by the entire system.

27 citations


Proceedings ArticleDOI
22 Apr 1985
TL;DR: The paper examine the integrity-lock retrofit at a high level of abstraction and concentrates on changes that need to be made at the process level and in terms of the functionality that needs to reside in the various functions.
Abstract: This paper is a design overview document, intended to aid in the implementation of an integrity-lock database management system. The authors believe that the paper is a realistic overview of the changes that need to be made to a commercial database management system in order that may support the integrity-lock architecture. The paper examine the integrity-lock retrofit at a high level of abstraction. In particular it concentrates on changes that need to be made at the process level and in terms of the functionality that needs to reside in the various functions. It hoped that this high level view will aid in the portability of the integrity-lock architecture to other systems. While the authors' work has involved retrofitting the integrity-lock onto a specific system, we believe that many of the lessons learned in this exercise can be applied to other commercial database management systems.

23 citations



Book
Michael Metcalf1
01 Jan 1985
TL;DR: This highly readable survey offers a concise but thorough description of the whole of Fortran 77, including practical advice on program portability, design, testing and documentation.
Abstract: An easy-to-use handbook for experienced programmers and scientists, this highly readable survey offers a concise but thorough description of the whole of Fortran 77, including practical advice on program portability, design, testing and documentation. The book benefits from the author's long association with the Fortran standardization committee (X3J3), and his extensive experience with large-scale processing in high-energy physics. Since Fortran 77 is the only practical choice for sizable scientific numerical and engineering applications, this will be an invaluable handbook for computer scientists working with engineers and physicists engaged in large-scale computation.

13 citations


Journal ArticleDOI
TL;DR: A rather comprehensive set of computational experiments for the instruction of senior students in the field of power systems based on a program package called FORCEPS (FORtran Codes for Education in Power Systems), providing theoretical background for all experiments.
Abstract: The paper describes a rather comprehensive set of computational experiments for the instruction of senior students in the field of power systems. The experiments are based on a program package called FORCEPS (FORtran Codes for Education in Power Systems). These replace previous laboratory experiments which were only partially adequate to demonstrate the problems of power system operation. Their need stems from the recognition that modern power system planning and operation is extensively computerized and this must be reflected in the teaching process. The experiments cover the major topics of power system steady state and dynamics. Of these, the instructor selects a subset which is-most appropriate for his lecture course. The student obtains a working program in Fortran as well as data for an experimental system, performs tests and comparisons, makes assessments on the capabilities of the program and modifies it if necessary. Only lineprinter plots and printouts are used for output, to permit the use of simple terminals and thus assure maximum portability of the programs. For the same purpose, FORCEPS has in addition to the Instruction Guide for the students, a Reference Section providing theoretical background for all experiments. Since FORCEPS is basically only a collection of useful programs, their full educational value is obtained only by applying the package as a tool for engineering problem solving in a variety of realistic power system problems formulated as projects or assignments.

7 citations


Journal ArticleDOI
01 Jun 1985
TL;DR: A programming methodology for multiprocessors that leads to well-structured code, ease of debugging, and, most important, portability among multipROcessors offering different synchronization primitives is described.
Abstract: We describe here a programming methodology for multiprocessors that leads to well-structured code, ease of debugging, and, most important, portability among multiprocessors offering quire different synchronization primitives. The emphasis in this paper is on the implementation of this methodology for the Lemur, an eight-processor machine built at Argonne National Laboratory. Included are several complete programs illustrating the methodology.

7 citations


Journal ArticleDOI
TL;DR: The Blaise system implements a full programming language working on a data basis adapted to control problems that has been designed to achieve extensibility, portability and numerical efficiency.

6 citations


Journal ArticleDOI
01 Dec 1985
TL;DR: The subsystem can considerably speed up the firmware development process and when incorporated into the design as a permanent feature, it provides a very low-cost facility for register-level diagnostics during the life of the system.
Abstract: This paper discusses the design and implementation of a debugging/diagnostic subsystem for a bit-slice processor. The subsystem uses serial shadow registers under the control of a single chip microcomputer both to observe and to control processor behavior. Serial lines link the microcomputer to a diagnostic host which provides the user with a comprehensive set of interactive diagnostic commands. Using these commands, the user is able to load the writable control store, verify its contents, load mapping facilities, set breakpoints and examine registers during single-stepping sequences. The subsystem can considerably speed up the firmware development process and when incorporated into the design as a permanent feature, it provides a very low-cost facility for register-level diagnostics during the life of the system. Portability of the diagnostic subsystem across a number of processors is also possible and is conducive to the efficient management of machine diagnosis in the field.

5 citations


Journal ArticleDOI
Nathan Ida1
TL;DR: This work presents an overview of the work done to date on electromagnetic field modeling on supercomputers, using some very large eddy current problems, and the need for new algorithms, specifically designed for vector computing is presented.
Abstract: The relatively new area of problem solving on supercomputers offers exciting new possibilities for numerical solution of 3-D electromagnetic field problems. The solution of systems of equations with tens of thousands of unknowns and bandwidths in the thousands is all but impossible on conventional computers. The availability of new vector supercomputers such as the CRAY 1 and the CYBER 205 brings both hope and new challenges. The faster machine cycle, vector instructions and parallel computing combined with advanced I/O devices promises to speed up the solution of large problems considerably. On the other hand, efficient programming on such machines is far from being trivial and in most cases, one has to compromise portability of the code. In addition, these machines require a front end computer and are not interactive, complicating and lenghtening the program development process. This work presents an overview of the work done to date on electromagnetic field modeling on supercomputers. Some data on field solution on an attached array processor is also included since array processors are a special class of supercomputers and for comparison purposes. Using some very large eddy current problems the various aspects of computing are presented together with results showing dramatic improvements in solution times. The problem of code portability, vector complex computation and program conversion are also addressed and, finally, the need for new algorithms, specifically designed for vector computing is presented.

Journal ArticleDOI
TL;DR: A portable software tool used for the processing and maintenance of data flow diagrams which form the basis of structured analysis techniques and the facilities it provides for the maintenance programmer are described.
Abstract: This paper describes a portable software tool used for the processing and maintenance of data flow diagrams which form the basis of structured analysis techniques. The tool itself is based on the idea that data flow diagrams can be modelled by means of semantic nets and can be manipulated by a semantic net processor. A major feature of the tool is the facilities it provides for the maintenance programmer.

Proceedings ArticleDOI
01 Mar 1985
TL;DR: An approach to natural language query translation is presented that is driven mainly by the semantics contained in an extended database scheme that has the advantage of ease of implementation and thus portability since the scheme can easily be extended to interface with the translation system's natural language understanding modules.
Abstract: An approach to natural language query translation is presented that is driven mainly by the semantics contained in an extended database scheme. This approach has the advantage of ease of implementation and thus portability since the scheme can easily be extended to interface with the translation system's natural language understanding modules. The required extensions consist of adding domain specific routines to recognize and classify literals and a lexicon to recognize context keywords. The results from these recognizers are then presented to a domain independent translator for further analysis. A prototype system has been implemented and some initial experimentation has been done. Observations about the effectiveness of the translator and its efficiency are reported.

Proceedings ArticleDOI
Alan Filipski1
01 May 1985
TL;DR: It is argued that there are really two distinct types of software portability problems, namely host dependencies and target dependencies and that the difference between this two is often obscured.
Abstract: The widespread use of high-level languages and portable operating systems such as the UNIX operating system has greatly facilitated the development of portable utilities and application programs. The activity of “porting” software from one environment to another differs from both maintenance and implementation activities and raises a different set of considerations. This paper discusses the porting of the UNIX symbolic debugger (SDB) from the VAX 11/780 to the M68000 based EXORmacs® development system. This was done as part of the first complete AT&T-sanctioned UNIX System V port which was performed by Motorola Microsystems. We first present a brief discussion of the objectives and methods of the UNIX port in which we participated, followed by a short description of the functionality and operation of SDB. We then describe some of the most significant problems as well as our most useful techniques for porting this highly machine-dependent utility. It is argued that there are really two distinct types of software portability problems, namely host dependencies and target dependencies and that the difference between this two is often obscured. We conclude with several recommendations for building more portability into a program such as a symbolic debugger.

Journal ArticleDOI
TL;DR: The goal of this article is to show the converse implementation described by Herbert Mayer, the transportation problems are somewhat similar but are also caused by differing implementations of the language --- FORTRAN 77.
Abstract: Writing transportable code is always desireable. Using extensions and enhancements implemented by the manufacturer does not help portability, nor does the use of specific system calls unique to that particular environment.The goal of this article is to show the converse implementation described by Herbert Mayer[1]. The transportation problems are somewhat similar but are also caused by differing implementations of the language --- FORTRAN 77.The two versions described are PRIME FORTRAN 77 (the host language running on a PRIME 750) and Microsoft MS-FORTRAN 77 version 3.1 (and later version 3.2) for the target machine, IBM PC.

Journal ArticleDOI
TL;DR: The tools available at CERN for preparing and testing programs for the Motorola 68000 microprocessor extend from cross compilers running in host computers to aniteractive debugging monitor running in 68000s under test.

Proceedings ArticleDOI
H. De Man1
01 Sep 1985
TL;DR: In this paper, the future of CAD tools for custom design of system VLSI chips is discussed and it is shown that a complete separation of system and silicon design is necessary, whereby silicon reusability is of prime concern in a continuously evolving technology environment.
Abstract: In this contribution the future of CAD tools for custom design of system VLSI chips will be discussed. In 7 propositions and 7 problem statements it will be shown that a complete separation of system and silicon design is necessary, whereby silicon reusability is of prime concern in a continuously evolving technology environment. Knowledge based synthesis techniques implemented on expert systems will substitute for much of the simulation and verification presently dominating manual design. Silicon module layout and assembly as wall as system design will evolve into programming techniques in an advanced software environment. This will be based on very high level languages such as LISP, PROLOG and SMALLTALK in combination with more traditional algorithmic oriented languages such as C. Workstations with hardware dedicated to this environment will replace the actual emerging 32 bit UNIX-C oriented workstations within a time span of 4 years... Design of CAD tools will then be indistinguisible from the chip design itself... Both will be exclusively programming activities. Some of the major bottlenecks on the road towards this era are : lack of good silicon compilers for analog circuit design, acceptability of new software environments by the designer community, knowledge acquisition for VLSI, portability of module generator environments, chip performance optimization and standardization. All of the latter present a challenge to Europe which, by tradition, has a lot of experience in advanced software. Will it use these capabilities by merging software and VLSI design knowledge ?

Book ChapterDOI
01 Jan 1985
TL;DR: The paper presents the first three levels of a hierarchical system aimed to intelligent assembly robot programming, covering the complete scale from effector level to objective level.
Abstract: The paper presents the first three levels of a hierarchical system aimed to intelligent assembly robot programming. The hierarchy covers the complete scale from effector level to objective level. The purposes which promoted such an attempt were: — the complexity growth of industrial robot applications; — the capability to respond adequately to external stimuli; — the possibility to generate plans based on stored knowledge; — programming efficiency enhancement; — portability.

Journal ArticleDOI
TL;DR: In this article, a program system for a microcomputer that permits the implementation of a laboratory-specific database and information system is described, and a short description of the background and fundamentals is described.
Abstract: After a short description of the background and fundamentals, a program system for a microcomputer is described that permits the implementation of a laboratory-specific database and information system. Due to standardized program and data structures and compatibility with different hardware, as well as portability, similar laboratories have the potential of carrying out cooperative studies on a national and international basis.

Journal ArticleDOI
C. H Smedema1
TL;DR: This article compares both languages with respect to their standardization aspects and discusses the problems of the description of programming language standards and the related issues of portability and re-usability of programs.

Journal ArticleDOI
TL;DR: In particular, considerable care is needed to understand and counter a number of major weaknesses in c that render it incomplete and unfinished as a programming language.

ReportDOI
01 Jan 1985
TL;DR: The study was undertaken with the specific objective of supporting the selection of a runtime environment for the JINTACCS Automated Message Preparation System (JAMPS) program, but provides results useful in any real-time system acquisition program.
Abstract: : The study is intended to define the characteristics of an Ada Runtime Environment that effectively supports the development of real-time applications The study was undertaken with the specific objective of supporting the selection of a runtime environment for the JINTACCS Automated Message Preparation System (JAMPS) program, but provides results useful in any real-time system acquisition program A major goal of the JAMPS Ada software acquisition is to develop highly portable and reusable implementation that can be used in many different military systems This goal impacts the selection and use of the runtime environment, as dependence on particular features of the runtime environment (either for functionality or performance) limits portability to only those systems providing the same features This results in the concept of a minimal set of runtime environment features necessary to support JAMPS Implementing JAMPS with dependence only on these features will allow portability within the class of systems providing those features This report identifies such a minimal set of environment features Keywords: fault tolerant computing; input output processing; data storage systems

Journal ArticleDOI
TL;DR: This paper is concerned with choosing a subset of FORTRAN which will make it possible to write portable programs on medium‐sized microcomputers.
Abstract: This paper is concerned with choosing a subset of FORTRAN which will make it possible to write portable programs on medium-sized microcomputers. To achieve this, some restrictions are placed on ANSI 1966 Standard FORTRAN after studying and analysing a collection of FORTRAN manuals for medium-sized microcomputers. Some assumptions are made concerning machine dependent constants after a careful observation. By combining these restrictions with those made in compatible Fortran1 and making use of the assumptions, portable programs can be written.

Journal ArticleDOI
TL;DR: The effectiveness of the method for developing efficient and portable software for 8‐bit microprocessors used in real‐time applications is shown by comparing the code generated by the ILL approach with the code available for a sample real-time application written directly in assembly level language.
Abstract: This paper discusses a method for developing efficient and portable software for 8-bit microprocessors used in real-time applications. The technique used is to design an ‘intermediate level language’ (ILL) which defines low-level primitives to support the real-time application programming and the constructs of high level languages. Thus, the high level language (HLL) program goes through two stages of translation; first to the ILL code and then to the machine code of a microprocessor. The ILL instruction set developed bridges the gap between high level languages and the poor instruction set of microprocessors. This allows the development of optimized and portable code for the microprocessors. The ILL operations, data types, data organization, control structures, synchronization, communication and multi-tasking facilities are described. The effectiveness of this technique is shown by comparing the code generated by the ILL approach with the code available for a sample real-time application written directly in assembly level language.

Journal ArticleDOI
TL;DR: The classical tools of high-level language analysis have been adapted so that a machine independent analyzer is provided and each phase consists of a number of table-based modules that lead to storage minimization as well as system reliability and maintainability.

Journal ArticleDOI
01 Sep 1985
TL;DR: The problems posed by the design and implementation of a command-language interpreter for a subset of the UNIX shell on the PULSE distributed operating system are described and it is concluded that the overall structure is not greatly different, but that the use of tasks nevertheless requires careful appreciation of their allocation and termination.
Abstract: The problems posed by the design and implementation of a command-language interpreter for a subset of the UNIX shell on the PULSE distributed operating system are described. The design of a command processor is addressed as the problem of transferring a user-perceived model of system behaviour from one physical system to another. The major differences between PULSE and UNIX are considered, and next how the shell language may be implemented in terms of the facilities of each system. An important discussion concerns the use of Ada tasks in PULSE and how this affects both the structure and the readability of the resulting program, in this case the shell. It is concluded that the overall structure is not greatly different, but that the use of tasks nevertheless requires careful appreciation of their allocation and termination.

Journal ArticleDOI
TL;DR: Although substantial variety exists among small programming environments, common points‐of‐choice in their design suggest the following structural characterization, which provides a rough framework that is useful in evaluating programming environments.
Abstract: Although substantial variety exists among small programming environments, common points-of-choice in their design suggest the following structural characterization: real or virtual hardware; message-passing or procedure-calling; static or dynamic binding; horizontal or vertical organization; abstract or concrete structures; fixed or extensible language. Often these dimensions must support a very focused programming idiom, which combined with other requirements such as portability or performance, establishes structural dependencies, precludes features and forces exceptions. The characterization provides a rough framework that is useful in evaluating programming environments.

Journal ArticleDOI
TL;DR: Certain ambiguities in the definition of Pascal imperil the portability of Pascal programs and context‐free grammars augmented with guarded commands are demonstrated as a notation for specifying the static context‐sensitive constraints of programming languages.
Abstract: Certain ambiguities in the definition of Pascal imperil the portability of Pascal programs. Specifications and an implementation of alternative interpretations are presented. Context-free grammars augmented with guarded commands are demonstrated as a notation for specifying the static context-sensitive constraints of programming languages. Most of the advantages of context-free grammars are preserved and yet the potential range of the syntactic definition component has been extended to encompass all static constraints. Context-sensitive syntax typically tends to either clutter the semantic definition component or (as with type equivalence in Pascal) result in undesirable implementor-dependent decisions. An implementation of a CFG-based parser that automatically checks for the defined context-sensitive constraints is also described. In addition stepwise abstraction is introduced as a practical technique for communicating formal programming language definitions.

Dissertation
01 Jan 1985
TL;DR: The concept of quality translation, in the first phase of a Bliss-to-C translator, is explored and a scheme is presented for transforming the original source to a more abstract form, resulting in aefew abstract functions which can be translated by hand, and an improved source which is easier to translate by machine.
Abstract: A major problem created by diversity in computing tools is the portability of software Programs written on one machine cannot be used on others unless a compiler for the original source is present Many solutions to the problem have been proposed, but none have been universally accepted One solution, which allows programs to be maintained in their new environment, is source-to-source translation In this thesis the concept of quality translation, in the first phase of a Bliss-to-C translator, is explored A quality translation is one which produces comprehensible, as well as semantically correct code For a Bliss-to-C system, preservation of quality must first come through the translation of data structures Bliss is an untyped language with access algorithms for defining structures, while C is a typed language using data aggregates Heuristics have been developed for both deriving type form context, and building data aggregates from the definition and usage of access algorithms A scheme is presented for transforming the original source to a more abstract form, resulting in aefew abstract functions which can be translated by hand, and an improved source which is easier to translate by machine

Book ChapterDOI
01 Jan 1985
TL;DR: There are many factors that determine the quality of software, but the ELLPACK system and its modules are concentrated on only three here: accuracy, speed, and memory use.
Abstract: There are many factors that determine the quality of software, but we concentrate on only three here: accuracy, speed, and memory use. Other important qualities like ease of use, reliability, portability, documentation, etc. are ignored. (The latter are much more difficult to quantify, but we hope that the ELLPACK system and its modules perform well in all these respects).