Djang et al. [1998] introduced a new model of types for declarative visual programming languages (VPLs). Implicit static typing is used in their type model, in order to eliminate the programming mechanisms associated with type declarations, provide immediate visual feedback with respect to type errors and guarantee type safe programs. Their type model also evaluates types on a level of granularity that is finer than in previous approaches to types. Instead of evaluating types on the basis of abstract names, their model determines a set of operations that an object guarantees and compares this set to the set of operations this object is required to support. If the set of required operations is a subset of the set of guaranteed operations, then the object is considered type safe. This granularity provides their model with the ability to support inheritance without introducing explicit type declarations and to communicate type errors to users without requiring the user to understand a large set of terminology. These features of their model attempt to provide VPL users with more powerful programming capabilities without the introduction of a high learning curve. In this thesis, an implementation of the Djang et al.'s model of types is presented. Data structures and algorithms are developed that conform to the axioms prescribed by Djang et al. The space and time complexity analyses for our data structures and algorithms are examined. Our implementation provides new insights into the cost and performance of the Djang et al.'s type model. / Graduation date: 2000

We believe concreteness, direct manipulation and responsiveness in a visual programming language increase its usefulness. However, these characteristics present a challenge in generalizing programs for reuse, especially when concrete examples are used as one way of achieving concreteness. In this thesis, we present a technique to solve this problem by deriving generality automatically through the analysis of logical relationships among concrete program entities from the perspective of a particular computational goal. Use of this technique allows a fully general form-based program with reusable abstractions to be derived from one that was specified in terms of concrete examples and direct manipulation. Also addressed in this thesis is how to statically represent the generalized programs. In general, we address how to design better static representations. A weakness of many interactive visual programming languages is their static representations. Lack of an adequate static representation places a heavy cognitive burden on a VPL's programmers, because they must remember potentially long dynamic sequences of screen displays in order to understand a previously-written program. However, although this problem is widely acknowledged, research on how to design better static representations for interactive VPLs is still in its infancy. Building upon the cognitive dimensions developed for programming languages by cognitive psychologists Green and others, we have developed a set of concrete benchmarks for VPL designers to use when designing new static representations. These benchmarks provide design-time information that can be used to improve a VPL's static representation. / Graduation date: 1997

Most current DFVPLs support flow control to facilitate experiments and complex problems. However, current approaches in DFVPLs still remain inefficient. We show that inadequacies in existing visual programming languages may be magnified in applications involving image analysis. These include a lack of efficient communication mechanisms and strong dependency on human involvement to customise properties. For instance, properties in one computational component can not be shared for other components. Moreover, conditional expressions used in control components hold data values that are unrelated with those computational components. Furthermore, since image processing libraries usua.lly only explicitly support pipeline processing, as exemplified by the widely used Insight Toolkit for Medical Image Segmentation and Registration (ITK), a looping algorithm would be difficult to implement without a feedback mechanism supported by the visual language itself. We propose a data-flow visual programming language that encompasses several novel control constructs and parameterised computational units. These components are facilitated by a novel hybrid data-flow model. We also present several conceptual models and design alternatives for control constructs. Several mechanisms and techniques are provided to enhance data propagation for these components. We demonstrate, in an environment that utilises ITK as the underlying processing engine, that the inadequacies in existing DFVPLs can be satisfactorily addressed through the visual components proposed in this thesis.

Specifying varying speeds and temporal relationships is necessary when programming graphical animations, but support for temporal programming has usually been done by adding new language features to a Visual Programming Language (VPL), and these features must be mastered over and above the other aspects of the VPL. However, some researchers have believed that time should be able to be treated like just another dimension. In this thesis, we explore whether temporal programming can indeed be done using exactly the same devices as in spatial programming in grid-oriented VPLs. Toward this end, we provide a continuum of models aimed at this goal and discuss their advantages and disadvantages. Also, we identify core issues that help illuminate the essence of the problem. / Graduation date: 2001

The temporal behavior in applications involving visual data can be critical for the correctness of some programs. Forms/3 allows the user to specify temporal behaviors in an independent way, without introducing extraneous code in the original spreadsheet, whereas some other languages define new language devices specific to time. In this thesis, we present the implementation of a new user interface for temporal programming in Forms/3 and the results of two empirical studies. The results of the first study show that one of the models for temporal programing in Forms/3 is more suitable for end users than a traditional stream-based approach representative of the approach used by many other languages. The results of our second experiment show that the explicit information provided by the approach can help the users to judge the correctness of their spreadsheets. / Graduation date: 2002

Exception handling is a programming language feature that can help increase the reliability of programs. However, not much work has been done on exception handling in visual programming languages. We present an approach for improving the exception handling mechanism in Forms/3, a declarative visual programming language based on the spreadsheet paradigm. We show how this approach can be added without sacrificing referential transparency and lazy evaluation in Forms/3. We then present a comparison of the Forms/3 exception handling mechanism with the mechanisms available in Java, C++, Prograph, Haskell and Microsoft Excel, based on their expressive powers. / Graduation date: 1998

Visual programming languages employ visual representation to make programming easier and make programs more reliable and more accessible. Visual program testing becomes increasingly important as more and more visual programming languages and visual programming environments come into real use. In this work, we focus on one important class of visual programming languages: form-based visual programming languages. This class of languages includes electronic spreadsheets and a variety of research systems that have had a substantial impact on end-user computing. Research shows that form-based visual programs often contain faults, but that their creators often have unwarranted confidence in the reliability of their programs. Despite this evidence, we find no discussion in the research literature of techniques for testing or assessing the reliability of form-based visual programs. This lack will hinder the real use of visual programming languages. Our work addresses the lack of testing methodologies for form-based visual programs. In this document, we first examine differences between the form-based and imperative programming paradigms, discuss effects these differences have on methodologies for testing form-based programs, and analyze challenges and opportunities for form-based program testing. We then present several criteria for measuring test adequacy for form-based programs, and illustrate their application. We show that an analogue to the traditional "all-uses" dataflow test adequacy criterion is well suited for testing form-based visual programs: it provides important error-detection ability, and can be applied more easily to form-based programs than to imperative programs. Finally, we present a testing methodology that we have developed for form-based visual programs. To accommodate the evaluation model used with these programs, and the interactive process by which they are created, our methodology is validation-driven and incremental. To accommodate the user base of these languages, we provide an interface to the methodology that does not require an understanding of testing theory. We discuss our implementation of this methodology, its time costs, the mapping from our approach to the user interface, and empirical results achieved in its use. / Graduation date: 1998

Declarative visual programming languages (VPLs), including spreadsheets, make up a large portion of both research and commercial VPLs. Spreadsheets in particular enjoy a wide audience, including end users. Unfortunately, spreadsheets and most other declarative VPLs still suffer from some of the problems that have been solved in other languages, such as ad-hoc (cut-and-paste) reuse of code which has been remedied in object-oriented languages, for example, through the code-reuse mechanism of inheritance. We believe spreadsheets and other declarative VPLs can benefit from the addition of an inheritance-like mechanism for fine-grained code reuse. This dissertation first examines the opportunities for supporting reuse inherent in declarative VPLs, and then introduces similarity inheritance and describes a prototype of this model in the research spreadsheet language Forms/3. Similarity inheritance is very flexible, allowing multiple granularities of code sharing and even mutual inheritance; it includes explicit representations of inherited code and all sharing relationships, and it subsumes the current spreadsheet mechanisms for formula propagation, providing a gradual migration from simple formula reuse to more sophisticated uses of inheritance among objects. Since the inheritance model separates inheritance from types, we investigate what notion of types is appropriate to support reuse of functions on different types (operation polymorphism). Because it is important to us that immediate feedback, which is characteristic of many VPLs, be preserved, including feedback with respect to type errors, we introduce a model of types suitable for static type inference in the presence of operation polymorphism with similarity inheritance. / Graduation date: 1999

Until now, attempts to extend the one-way constraint evaluation model of the spreadsheet paradigm to support complex objects, such as colored circles or user-defined types, have led to approaches featuring either a direct way of creating objects graphically or strong compatibility with the spreadsheet paradigm, but not both. This inability to conveniently go beyond numbers and strings without straying outside the spreadsheet paradigm has been a limiting factor in the applicability of spreadsheets. In this thesis we present a technique that removes this limitation, allowing complex objects to be programmed directly--and in a manner that fits seamlessly within the spreadsheet paradigm--using direct manipulation and gestures. We also present the results of an empirical study which suggests that programmers can use this technique to program complex objects faster and with fewer errors. The graphical definitions technique not only expands the applicability of spreadsheet languages, it also adds to their support for exploratory programming and to their scalability. / Graduation date: 1997

In a world where computers are a part of most people's everyday life, learning how to instruct one to perform time consumingand/or complex tasks is beneficial. Visual programming languages aim to make the experience for people programmingcomputers the best it can be by bypassing some of the issues of syntax and translation from mental plan to executable program. However, text-based languages come out on top when it comes to the programming languages most used. This paper aims at finding the strengths and weaknesses of teaching a visual programming language to novices in order to contribute to the otherwise lacking empirical evidence within the field of teaching computer programming. The methods used in order to collect data and answer the research question took inspiration from methods used in ethnomethodology. These methods were: observation through participation within a group of programming novices and semi-structured interviews with programming tutors. What can be seen from the study is that visual programming languages offer a quick introduction to the world of programming that in many ways plays down the difficulties within the area by making programming playful and creative. On the other hand, the boundaries of the language are quickly reached and require the students to switch to a text based language. Also, the visual programming language did not help the students learn how to plan and troubleshoot theirprograms. When progressing to a text-based programming language where planning and troubleshooting are required steps ofthe process this may become troublesome. / I en värld där datorer är en del av människors vardag är det fördelaktigt att lära sig att instruera datorer att utföra tidskrävandeoch/eller komplexa uppgifter. Visuella programmeringsspråk syftar till att göra upplevelsen för personer som programmerar så bra som möjligt genom att minska fokuset på syntax och översättning från mental plan till körbart program. Men de mest använda programmeringsspråken är idag de textbaserade språken och inte de visuella. Denna uppsats syftar till att hitta styrkor och svagheter i att lära ut ett visuellt programmeringsspråk för nybörjare för att bidra till bristen på empiriska bevis inom området datorprogrammeringsundervisning. De metoder som användes för att samla data och svara på forskningsfrågantog inspiration från metoder som används inom ethnomethodologi. Dessa metoder var: observation genom deltagande i engrupp av programmeringsnybörjare samt halvstrukturerade intervjuer med programmeringshandledare. Vad som kan konstaterats från resultatet samt diskussionen är att visuella programmeringsspråk erbjuder en snabb introduktion till programmeringsvärlden och på många sätt avdramatiserar området genom att göra programmeringen lekfull och kreativ. Negativa aspekter av att använda visuella programmeringsspråk är å andra sidan att gränserna för språket snabbt nås och kräver att studenterna byter till t.ex. ett textbaserat språk. Det visuella programmeringsspråket hjälpte inte heller eleverna att lära sig att planera och felsöka sina program. När man går vidare till ett textbaserat programmeringsspråk där planering och felsökning krävs steg i processen kan det bli besvärligt.