ADA† and NIL: Two Concurrent Languages for GKS

The Graphical Kernel System (GKS) has become an international standard in graphics programming and attempts are now being made to integrate it with multiprocessing, possibly in distributed systems. It is therefore necessary to consider new programming languages able to support distributed implementations of GKS. Among them, Ada and Nil are considered here, since they are particularly suitable for concurrent programming. They are compared and evaluated in those specific tools which may provide data safety, system reconfigurability, and availability to distributed programming. The structural philosophies of the two languages are emphasized and reconfigurable implementation schemata for GKS in both of them are then suggested.     

Formal Specification in the Revision of GKS: An Illustrative Example

The first ISO/IEC standard for computer graphics, the Graphical Kernel System (GKS) was published in August 1985. In accordance with ISO/IEC procedures, GKS is now being reviewed and revised. This paper describes how formal specification techniques are being used by the authors to analyse key parts of proposals being made for changes to the framework of GKS to bring the standard into line with the requirements of applications and the operating environment likely to be found in the mid-1990's.     

Ada System Dependency Analyzer tool

A major thrust of modern software engineering methods, languages, and tools is to promote software visibility and to present information about the underlying software architecture. With large, complex software systems, automated tools are indispensable for identifying the architectural components, the structure that interconnects them, and other subtle dependencies. This article describes the construction of an Ada System Dependency Analyzer (SDA), a software architecture analysis tool that generates a quantitative snapshot of an Ada application's software architecture. The SDA can process thousands of Ada source files during a single run and report on them as a group of files comprising a single Ada system. Our SDA tool identifies Ada source code dependencies on COTS products such as operating systems, compilers, the X Window System, and on routines written in other languages, and can thus predict software portability and reliability problems. It rapidly and accurately processes 24,000 lines of code per minute (a time-consuming, if not impossible, operation if done manually) and has successfully processed more than seven million lines of code in eight complex systems. Although originally developed for Ada, our methods and the technology we adopted will let us construct analogous tools for other programming languages such as C, C++, Cobol; and PL/I     

GKS-94: an overview

A revision of the Graphical Kernel System (GKS), the first ISO standard for computer graphics programming, was completed in 1994. This summary of GKS-94 also describes an implementation of part of its new functionality. We have demonstrated that fast selection is possible with GKS-94. Thus, an application can use namesets and selection criteria as its main method of subdivision, selection and creating hierarchy within the application, and performance is acceptable given a reasonable implementation. European organizations are showing interest in implementing GKS-94, and new products are anticipated early in 1996     

Validation and language standards

The problem of certifying a programming language processor as conforming to a set of specifications is currently extending the reach of feasibility past the state of the art of computer science, except in some trivial cases. This white paper considers the problems which are currently confronting the Ada⁷ Joint Program Office (AJPO) of the U.S. Department of Defense with respect to the enforcement of the trademark for Ada and the parallel activities towards establishing the Ada Language as an American National Standard.     

PHIGS: A Standard, Dynamic, Interactive Graphics Interface

The Programmer's Hierarchical Interactive Graphics System (PHIGS) is a draft standard for computer graphics programming. PHIGS is useful for applications that manipulate complex displays of 2D or 3D data in a highly interactive environment. This is done through the hierarchical data organization and flexible editing capabilities provided in PHIGS. This article describes the goals and underlying model of PHIGS, reviews its capabilities, and provides some brief application examples. The similarities and differences of PHIGS and GKS are discussed.     

A verifier for checking the conformance of programs with the GKS standard

A software development tool is introduced which allows to check the corrections of programs using the Graphical Kernel System (GKS). Such graphical application programs are checked whether their use of GKS functions is syntactically correct and conforms with semantic rules given by the GKS definition. Like the PFORT verifier for FORTRAN programs, this tool greatly reduces development time for GKS programs.     

GKS certification—An overview

The rapid emergence of GKS implementations indicates the widespread acceptance of GKS as an international standard for computer graphics. It is essential however if the interests of the standard are to be preserved, that there be a feasible means of validating GKS implementations to ensure that adherence to the standard is maintained. This paper describes an overall methodology for GKS certification, and outlines in more detail the validation of data returned by GKS to an application program. Validation of output generated by GKS is discussed in general terms in this paper, and in more detail in other papers in this issue.     

GKS-9x: Some Implementation Considerations

The Graphical Kernel System (GKS) was published as an ISO standard for computer graphics programming in August 1985. GKS is now undergoing revision in ISO/IEC and at the time of writing the text of the Draft International Standard of GKS-9x was being finalized. This paper presents a way in which a key part of the new functionality in GKS-9x, namely namesets and selection criteria, can be implemented effectively.     

Experiences with implementing GKS on a PERQ and other computers

Driven by a need for a graphics system that would provide a wider range of functions than is common and that would require less support effort when installed on about 50 mainframes, Rutherford Appleton Laboratory has implemented the Graphical Kernel System (GKS). The development project has used PERQ and VAX computers equally. This paper describes some of the design decisions and their effect on the resulting package. In particular, it describes the philosophy of the “workstation interface” and how this provides for devices and systems of greater complexity in the future. The way in which the facilities of the PERQ are matched to GKS concepts is outlined.     

A complete axiomatic semantics of spawning

Summary In modern imperative languages there are two commonly occurring ways to activate concurrently running tasks,splitting (cobegin...coend) andspawning. The programming language Ada makes use of both forms of task activation. We present a formal system for verifying partial correctness specifications of Ada tasks activated by spawning. The system is based upon a view of tasks as histories of events. We show how the mindset of splitting may be applicable when developing a formal system for reasoning about spawning. The resultant proof system is compositional, and a robust extension of partial correctness proof systems for sequential constructs. A transition model is given for spawning, and the proof system is proven complete in the sense of Cook [10] relative to this model, under certain reasonable assumptions. The specific proof rules given apply to a subset of Ada without real-time and distributed termination. Our approach to task verification applies to other imperative languages besides Ada, and the essential parts of our methodology are applicable to other formal systems besides those based on partial correctness reasoning. Sigurd Meldal is professor of informatics at the University of Bergen. He is interested in techniques and tools based on formal methods for development of concurrent software. His current foci are the investigation of algebraic approaches to nondeterminism, and the participation in the design of a concurrent specification, prototyping and implementation language. The latter supplements formal proof with support for run time control of consistency between concurrent systems as specified and as implemented. Meldal received his cand. real. (1982) and dr. scient. (1986) degrees in informatics from the University of Oslo.This research was supported by a grant from the Norwegian Research Council for Science and the Humanities, by the Defense Advanced Research Projects Agency/Information Systems Technology Office under the office of Naval Research contract N00014-90-J1232, by the Air Force Office of Scientific Research under Grant AFOSR83-0255 and by a Fulbright Scholarship from the US Educational Foundation in Norway     

Interactive graphic systems design on the GKS-standard and unified language processor basis

This paper presents an implementation experience in interactive graphic systems on the Graphical Kernel System basis (GKS) in language processor for one class of dialogue graphic languages in graphic drivers and special spanned processor. These processors allow development of interactive graphic systems with an allocated structure. Application task is included in the system as a semantic definition processor for dialogue graphic language. For communication between separate processors, the graphic interfaces, arranged in two levels, as well as a language processor interface are applied.

Functions and principles of constructing a language interface with a GKS-Kernel for allocated systems as well as design methods for interactive programs based on two-language concept are made more precise.     

Better Understanding through Formal Specification

The Graphical Kernel System (GKS) is now registered as an ISO International Standard for computer graphics programming. One of the major innovations of the Standard is the bundled specification of aspects, a mechanism which gives the applications programmer the ability to tailor the appearance of a picture independently on each of the workstations on which it is displayed, using the capabilities of the workstations. GKS also incorporates the traditional method of individual specification of aspects in which each workstation does the best it can to represent global aspect values. In this paper a formal specification technique, the Vienna Development Method (VDM), is used to describe aspect specification. The GKS model of aspect specification is progressively constructed from simpler models. Properties of these simpler models are formulated and the specifications are proved to conform to these. The properties are then traced through the more complex models. The paper demonstrates the applicability of formal specification to the design of graphics software and the ability of formal techniques to catalyse the deeper understanding of designs.     

The evolution of standards for computer graphics

Although work towards international standards for computer graphics was started in 1976, it is in the last 2 years that real agreement and progress have been achieved. The first target, the functional specification of a graphics system, is satisfied by the graphical kernel system (GKS), which is now being processed as an International Organization for Standardization (ISO) draft international standard. GKS provides a reference model for two-dimensional graphics and an agreed vocabulary of terms covering the field. Many implementations of GKS as a package are now being produced. In addition to such a functional specification, two forms of communication are appropriate for graphics: a metafile and a virtual device interface. ISO is now reviewing a proposal for a metafile standard developed by the American National Standards Institute and closely related to GKS. Standards for a graphics virtual device interface and for three-dimensional graphics systems are also being actively developed. All these efforts and their interrelationships are described and examined.     

A Multi-Microprocessor GKS Workstation

Implementers of graphical application sytems hesitate to interface their applications to the GKS standard not only because GKS functionality seems to be less suffcient for a particular application but also because the use of GKS-as it is offered in portable software implementions-uaually means a loss of system performance. This article describes an installation of GKS on a multi-microprocessor that is based on functional distribution principles as well as on the object-oriented distribution of a graphics system. The main concepts and advantages of a GKS workstation using more than one processing unit with at least one output pipeline are described. The flexibility of this approach opens a perspective view to a GKS workststion that is configurable to application requirements.     

A VLSI Implementation of the Graphics Standard GKS

The main advantage when using a standardized graphics system is quite obvious: the application programs become portable. Integrating such a system - and GKS (Graphical Kernel System) is the only one being standardized internationally - into VLSI (Very Large Scale Integration) chips, this graphics system may become an integral part of graphical devices. This guarantees a uniform interface of such devices to GKS applications. Devices of many different kinds will become compatible not only with respect to plugging but even in their logical behaviour, eliminating all device dependencies from the host software.
We have started to design the GKS-chip which will be able to be used in a great variety of devices (vector and raster type). The GKS-chip will bring the computational power to support real time picture updates, limited only by the maximally attainable output data rate.     

A Methodology And Tool Set For Supporting The Development Of Graphical User Interfaces

A methodology and tool set for building application (assumed to be inherently non-graphical) software with graphical user interface is described. Initially, pure application software is built from a set of basic building blocks; subsequently, graphical representations for application objects are defined without direct coding and then the graphical user interface is generated automatically. This paper concentrates on the graphical representation aspects of the user interface. Portability, configurability and sound software engineering principles are major considerations in the design of the overall system architecture. The prototype implementation is based on VDM (Vienna Development Method), Object-based Design, GKS (Graphical Kernel System) and the programming language ADA. An example from CIM (Computer Integrated Manufacturing) is used to illustrate the methodology presented here.     

Ada programming language standardization

The need for software management and standardization of programming languages used in military systems was first identified by DoD in 1975. DoD at that time supported many limited use languages for what are now called embedded computer applications. This diversity of languages contributed to high software costs. In November 1976, DoD first established seven approved , , , -J3, -J73, , -2, -1. Eventually the number of approved DoD languages may be reduced to three, Ada, , and . Ada was established as Military Standard 1815, on 10 December 1980. The ANSI standardization process for Ada is in progress. The Ada concept places restrictions on what may be called an Ada compiler. Compilers may not be called Ada compilers until they have passed validation tests. Up to 80% of software costs are incurred after the software has been put into service. Ada can promote a programming style that leads to maintainable software. It is in the program maintenance phase of the software life cycle where large savings will be achieved through the use of Ada.     

An interactive FORTRAN 77 program using GKS graphics for 2.5 D modeling of gravity and magnetic data

An interactive 2.5 D gravity and magnetics modeling program has been written for an ICL PERQ 2 workstation using FORTRAN 77 and GKS graphics. All of the available hardware and software input devices are utilized through GKS to produce an easy-to-use menu-driven program. A large number of functions are controlled by the software in order than the user can concentrate on the model. A range of options also are provided for manipulating the observed anomaly. The use of FORTRAN 77 and GKS should make the program easily portable to other computer systems and graphics devices. The modular form of the program should facilitate readily further development including optimization and real time modeling, given a more powerful computer with high-speed graphics.