grasp: an executable specification language for ada tasking  problems involving ada tasking can be difficult to specify because there are few existing methods for visualizing them. currently, software engineers must specify tasking problems by hand using informal data flow diagrams [4] or booch diagrams [1]. several attempts have been made at providing a workstation environment for the specification of programs: notable examples are the tags (technology for the automated generation of systems) environment with iorl ® (input/output requirements language) [5], and the adagraph environment with pamela (process abstraction method for embedded large applications)[3].  these methods are useful for the specification of tasking problems, but they do have some drawbacks. while data flow diagrams, warnier-orr diagrams, and booch diagrams have been commonly used for specification, they are not directly executable, and must be rewritten as source code by a programmer. design errors may creep in all too easily during the translation. the automated tools also have their problems. iorl provides a good model for decomposing a system into concurrent processes, but it utilizes an unstructured, flowchart-like tool for the specification of process logic. a system is represented in iorl using a simple symbology of boxes and arrows that is not as refined as those of yourdon or gane and sarson. pamela is based on data flow diagram techniques, but uses additional symbols that may not be intuitive to those unfamiliar with the language. and, although pamela allows the overall structure of a system to be developed graphically, the logic associated with each procedural component must be developed as text: graphical representations of procedural logic are not supported.  a graphical specification language (grasp: graphical approach to the specification of programs) for tasking problems is proposed to overcome these problems. the current version of the language utilizes two presently existing software engineering tools, the data flow diagram [4] and the warnier-orr diagram [2,7], with some modifications. (early in the research effort, it was determined that the data flow depicted in standard data flow diagrams was not sufficient for the specification of tasking programs, so this data flow was elaborated.) a grasp specification is first developed using grasp/g, a graphical language that incorporates data flow diagrams and warnier-orr diagrams. this specification may be automatically mapped into grasp/t, a textual variant of grasp/g that serves as an intermediate language. a grasp translator can then map this grasp/t specification into ada source code. the two-tiered approach allows the graphics-intensive grasp/g tools to be isolated for development on various machines, while leaving the grasp/t tools in an easily portable state.  at present, a prototype of the grasp language [6] is being tested with grasp graphics and translation tools written in pascal for the apple macintosh computer. the prototype has been used to specify small problems such as the dining philosophers. while the prototype does not yet address the needs of complex i/o or elements unique to ada (generic instantiation, private units), it does handle the decomposition of a system into concurrent processes well, and "hooks" have been provided in the language for further work.  kelly i. morrison