visual dataflow language
Dennis Koelma, Richard van Balen, Arnold Smeulders
University of Amsterdam
The environment enables a mixture of visual and textual programming. The visual programming interface is generated at runtime from information in a command description file. As a consequence the library of functions is easy to extend, even by laymen. The data objects are also extensible but this requires elementary programming skills. The setup of extensibility makes the environment independent of an application domain. It also opens the way to the combination of different application domains. Extract: Survey
The use of computers through specialized software packages is increasing rapidly to such a degree that a typical end-user is no longer able to make the step to programming a computer. Programming a computer in a conventional programming language, i.e. a textual one, requires a precise sense for logic which may not suit every end-user. Visual programming may help to bridge the gap by making programming easier. Experienced programmers may also benefit from the advantages visual programming has over conventional textual programming. It enables them to concentrate more on solving the problem and less on writing the program.
Visual programming languages can be classified according to different taxonomies [1--3]. We will stay away from such a discussion but use the operational definition that the essence of visual programming is the use of visual expressions (such as drawings or icons) in the process of programming.
Essentially different from visual programming is program visualization where the program is specified in a conventional, textual manner and the visual representation is used to illustrate some aspect of the program e.g. the algorithm, the data structures or the dynamic behavior of the program [4--9]. These approaches are not considered here as they require the program to be specified in an textual language and thus would not help the end-user in mastering the machine.
Visual programming languages have many advantages over textual programming languages [1,2,10--12]. Their two-dimensional layout and use of icons seem to be closer to the human way of thinking . This then simplifies the translation of the representation used in the mind while thinking about a problem to the representation used in programming a problem. The shorter translation distance makes visual languages easier to comprehend, learn, use, and remember. The use of pictorial elements is important because frequently pictures convey more meaning than text: a single picture is often worth more than a thousand words (the converse may also be true). Furthermore, the combination of a two-dimensional layout and the use of animation visualizes the execution of a program to help in debugging and program optimalization. Finally, the two-dimensional layout facilitates the detection of potential concurrency in a program for parallel computation.
A disadvantage of visual programming is the large space it requires on the screen to create a program. This can be solved only partially through the use of scrolling and/or various abstraction mechanisms such as a hierarchical structure in the program. This problem is most obvious in the general purpose visual programming languages [14--22], the visual languages used as an interface to a textual programming language [23--25] and the concurrent visual programming languages [26--28]. They all use low level basic elements, functions and data objects, to develop programs. Although these languages can be used in different application domains, the low level basic elements often make it be too cumbersome to write a non-trivial program, especially for laymen. Combining the visual language with a textual language [29--32] reduces the space problem and allows for the use of textual programming in those part of a problem that are hard or impossible to solve using the visual language.
However, textual languages require more programming skills and do not have the advantages of the visual languages so they can not assist the laymen. They are only of interest to an expert because experts like to have an escape possibility from the particular language they are using.
Other visual programming environments use high level basic elements to allow for the development of small, yet powerful, programs. These environments are used in database processing [33--37], in image processing [38-- 40], in educational software [41--44], as a command shell [45, 46], in user interface design , in expert systems , in security systems , in matrix computation , etc. The disadvantage of these environments is that they can only be used in the small application domain they were developed for. The visual programming interface is hard coded and thus the environment is not easily modified and not extensible to other application domains.
It is felt that visual programming is not generally accepted because the approaches mentioned above all have serious drawbacks: writing a program in a general purpose visual programming language is too cumbersome and using specialized visual programming environments limits the use to a small application domain. Combining the approaches could be a solution. The visual programming environment presented here adheres to the concept of high level basic elements in the construction of programs since they are essential for end-users. To avoid being trapped in a small application domain the environment was made easily extensible for new basic elements. To give the expert his escape possibility the combination with a textual language is also provided for. The KHOROS system [51, 52] uses a similar approach but requires the basic elements to be developed especially for the environment. This makes it more difficult to add existing software libraries to the environment. Section 2 gives an overview of the SCIL environment upon which the presented visual programming environment was build. The concept of SCIL-VP is described in section 3. Some implementational aspects are described in section 4. Section 5 shows the development of a sample program. Section 6 concludes with a discussion of the presented environment. Extract: Intent
The intent of SCIL-VP is to create small, yet powerful programs by combining high level functions from a user specified library from one or more application domains. This intent implies that the visual language must be able to express an operation on data clearly. The language is not to be an algorithmic language because these kinds of languages require the inexperienced user to focus too much on the process of programming. This can lead to what is termed ''analysis paralysis'': the means become the ends as you forget what you wanted to get out of the computer and become wrapped up in the process of getting it out . These observations lead to the choice of a data flow language.
The data flow language used in SCIL-VP does not support the use of control structures. Although control structures have been added to data flow languages [14, 15, 17, 29], it is hard, if not impossible, to make them flexible enough and still easy to use. The data flow language is combined with the textual language C to give a more experienced programmer the possibility to address problems that cannot be solved using the controlless data flow language only. It also gives him the possibility to escape from the visual language in those parts of a problem that can be expressed more clearly in a textual language.
The functionality of the system is provided by the functions from the user'specified library (or libraries). The functions are the building blocks from which the user starts to construct a visual program. To keep the environment application independent, the addition of a new library of functions should be simple, where only a compact description of each function has to be supplied.
This description includes the name of the function and a list of parameters, if present. The only restriction imposed upon the functions by SCIL-VP is that they must be C-callable functions. For most systems this does not necessarily imply that the functions are written in C. There should be no restrictions to possibilities of a function for user interaction: it should have normal access to the standard input/output of a terminal and to the window system.
The use of arbitrary functions requires the support of arbitrary data objects. Therefor, the environment is designed such that it is extensible in its data objects. To accomplish this the environment makes use of only a limited number of functions in the communication with the data objects. A data object should be able to represent anything as long as it can be accessed through (a reference to) an object. There should be no restriction to the complexity of an object.
A visual and hierarchical overview of the functions is to be provided by the library handler. This overview should reflect the ordering of the functions in groups and subgroups. As always the (sub) groups and the functions are represented by icons.
The user'should be able to use multiple worksheets in the development of a visual program. These worksheets should also be able to reflect the hierarchical structure of a program. Upon completion of the development of a visual program it should be possible to execute the program without the visual programming environment.
in Proceedings of the 1992 ACM/SIGAPP symposium on Applied computing: technological challenges of the 1990's, March 1992, Kansas City, Missouri, United States view details