META-LANGUAGE BASED ENVIRONMENTS for INTEGRATED SOFTWARE DEVELOPMENT Ogan Gurel Adams House I-31 Computer Science 91r 24 May 1984 Prof. T.E. Cheatham, Jr., faculty advisor Gordon McKay Professor of Computer Science Division of Applied Sciences Harvard UniversityABSTRACT An important issue in the design and implementation of Program development support environments involves the role of development control languages and abstract specification languages during the program development life-cycle. Both from the author's research and from other sources, some typical examples of these meta-language systems are presented. In abstract terms, these meta-languages are thus incorporated within a refined theoretical structure of a generalized software development support environment. Some implementation manifestations of this comprehensive theoretical structure are considered. Finally, the ramifications of this theoretical structure towards the effective and integrated design of these meta-languages within the construct of such software development support environments are considered.TABLE OF CONTENTS In. TIL. Iv. vr. Introduction: Meta-Languages Software Development Command and Control Languages 1. Dynamics of the Software Development Process 2. Command Language Functions 3. APLSIMUL - Development Control Language (DCL) 4. RPD/System ~ DESIGN/AML 5. ARGUS - DYNA Abstract Languages and Program Specifications 1. Hierarchical/Structured Design 2. RPD/System ~ RMTM 3. ARCTARUS 4. Program Design Language (MCAUTO) Theoretical Structure of a Generalized Software Development Support Environment -- Summary, Refinements and Problems 1. Structured Integration of Tools 2. Hierarchical Language System Support 3. Domains and Contexts Implementation Considerations of a Meta-Language Based Software Development Support Environment. 1. Domain Control -- Command Language 2. Context Control -- Abstract Language Concluding Remarks and Future Research ProblemsI. INTRODUCTION The power of a program development support environment can often be measured by the range and scope of the development tools that it offers to the programmer. These tools, and the various contexts they are used in, allow programmers to perform typical activities such as editing, compiling, interpreting, linking, simulating, testing, documenting, and otherwise processing their Programs. Most program development support environments incorporate at least some of these tools which may or may not be integrated together with the other components of the development system. Previous research by the author has addressed, in part, the integration of such development tools within a theoretical structure of a generalized software development system supporting dynamic, modular, and hierarchical programming. This theoretical structure will form the basis of the present paper which while focusing on some specific issues (namely meta-languages), will greatly enhance the power and usefulness of such a theoretical structure. Preliminary application of this generalized structure was illustrated with the Robot Program Development System (RPD/System) developed by the author at IBM.However, the most important and undoubtedly most Powerful tools that we can use towards the effective development of software are development command languages (C) and abstract specification languages (A). Both these languages are distinct in function from the implementation language (I) in which the programmer writes the application. The relationships between these command languages, abstract languages and implementation languages are illustrated in figure 1. Although, conceivably, all these languages may be the same, their functions within the development systems are very different. Most development command languages are nothing other than simple interactive command interpreters and processors, with more complicated versions involving macro facilities, input/output control, and complex control constructs. Such languages can be implemented either in specification form or interactive form and are basically intended to allow complicated interaction with the development system and the user to be effectuated easily and powerfully. In a sense, such command control languages allows one to systematically and algorithmically develop the application program in a predetermined fashion. A major question addressed in this paper is how such development command controlFigure 1. pS A — I | Abstract languages are transformed into implementation programs which are both controlled under a development command control language.languages fit in with the systematic theoretical structure which we have proposed. Furthermore, the question arises as to how such a language can be designed in this light to complement standard programming methodologies such as structured/modular programming. Abstract specification languages are a more complicated issue as research in such advanced systems is still in its beginning stages. Fundamentally, such abstract languages are based ultimately on a philosophy ef top-down programming in that programs and algorithms are expressed in a very high-level form and in a series of transformations are translated into machine executable instructions. This has been the motivating force behind the development of such systems as assembly and higher-level languages. Today, the notion of abstract languages incorporate problem and algorithm oriented systems that approach the English language in ease of expression. Consequently, a major question that must be answered is how, in turn, these abstract language systems fit logically within this theoretical structure and how they interact with the tools provided by the program development support environment. In the initial section of this paper we will describe some typical implementations of such development commandcontrol languages and abstract specification languages. In doing so some of the critical issues that concern such languages and their role in software development systems will be exposed. While we might consider development command languages and abstract specification languages to be merely fancy and powerful development tools (which essentially they are, as we have defined such tools to be within the construct of the theoretical development system), it is of value to consider them as unique elements of the program development system. Together we will designate these two language systems as meta-languages implying that they are separate from the implementation language which the programmer is using to develop his/her applications. Thus, these meta-languages will play an important role in a new and refined theoretical ‘structure for a generalized software development support environment. Finally, in this paper, we will describe how such meta-languages can be designed with regard to this theoretical structure and what considerations have to be taken in implementations of meta-language based software development support environments.References: Gurel,0. "Integrated Support Environments for Hierarchical Software Development", Computer Science 91r Report, Harvard University, 1984. Van Leer, P., "Top-down development using a program design language", IBM Systems Journal, Vol. 15, No. 2, 1976, 155-170. Liskov, B., "Modular Program Construction Using Abstraction", In: Bjorner, D., ed. Abstract Software Specifications, Springer-Verlag, Berlin, 1980. Myers, G.J., Composite/Structured Design. Van Nostrand Reinhold Company, New York, 1978.TI. SOFTWARE DEVELOPMENT COMMAND AND CONTROL LANGUAGES Dynamics of the Software Development Process In a "dynamic development environment" one has the flexibility of following any sequence of programming activities in order to develop the application program. This reflects the fact that most programming is not a linear process but rather an iterative one in which Programming is conceived of as a process of refinement. In a sense, the programmer has virtually unlimited access to any and all of the programming activities available during any phase of the program development life-cycle. As a result, one is not confined to developing the program in a linear step-wise fashion that may include (in order): editing, compiling, testing, debugging, revising, and documenting. Instead, one can "jump" from programming activity to programming activity which is an especially critical requirement in development systems that support hierarchical language systems. While this concept may be said to encourage an unstructured approach to the program development process,