visual dataflow language

Dennis Koelma, Richard van Balen, Arnold Smeulders

University of Amsterdam

  • Koelma, D., R. van Balen, and A. Smeulders, "SCIL-VP: a multi-purpose visual programming environment" pp1188-1198 view details Abstract: This paper presents a multi purpose visual programming environment called SCIL-VP. In SCIL-VP programs are specified as data flow graphs consisting of arbitrary functions operating on arbitrary data objects.
    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 [13]. 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 [47], in expert systems  [48], in security systems [49], in matrix computation  [50], 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 [55]. 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