Forms/3: A first-order visual language to explore the boundaries of the spreadsheet paradigm

Although detractors of functional programming sometimes claim that functional programming is too difficult or counter-intuitive for most programmers to understand and use, evidence to the contrary can be found by looking at the popularity of spreadsheets. The spreadsheet paradigm, a first-order subset of the functional programming paradigm, has found wide acceptance among both programmers and end users. Still, there are many limitations with most spreadsheet systems. In this paper, we discuss language features that eliminate several of these limitations without deviating from the first-order, declarative evaluation model. The language used to illustrate these features is a research language called FormsF;3. Using FormsF;3, we show that procedural abstraction, data abstraction and graphics output can be supported in the spreadsheet paradigm. We show that, with the addition of a simple model of time, animated output and GUI IF;O also become viable. To demonstrate generality, we also present an animated Turing machine simulator programmed using these features. Throughout the paper, we combine our discussion of the programming language characteristics with how the language features prototyped in FormsF;3 relate to what is known about human effectiveness in programming.

[1]  M PaulHudakEt,et al.  Report on the programming language haskell: a non-strict , 1992 .

[2]  Henry Lieberman,et al.  ZStep 95: A Reversible, Animated Source Code Stepper , 1997 .

[3]  Abraham Silberschatz,et al.  Operating System Concepts, Sixth Edition , 2002 .

[4]  Abraham Silberschatz,et al.  Operating System Concepts , 1983 .

[5]  Ben Shneiderman,et al.  Direct Manipulation: A Step Beyond Programming Languages , 1983, Computer.

[6]  Marinus J. Plasmeijer,et al.  The Ins and Outs of Clean I/O , 1995, J. Funct. Program..

[7]  Alan Dix GIVING CONTROL BACK TO THE USER , 1987 .

[8]  Peter Linz,et al.  An Introduction to Formal Languages and Automata , 1997 .

[9]  Philip Wadler,et al.  Linear Types can Change the World! , 1990, Programming Concepts and Methods.

[10]  Thomas G. Moher,et al.  PROVIDE: A Process Visualization and Debugging Environment , 1988, IEEE Trans. Software Eng..

[11]  Margaret M. Burnett,et al.  Implementing level 4 liveness in declarative visual programming languages , 1998, Proceedings. 1998 IEEE Symposium on Visual Languages (Cat. No.98TB100254).

[12]  Marian Petre,et al.  Usability Analysis of Visual Programming Environments: A 'Cognitive Dimensions' Framework , 1996, J. Vis. Lang. Comput..

[13]  Mats Carlsson,et al.  FUDGETS: a graphical user interface in a lazy functional language , 1993, FPCA '93.

[14]  E.H. Chi,et al.  Principles for Information Visualization Spreadsheets , 1998, IEEE Computer Graphics and Applications.

[15]  Bradley T. Vander Zanden,et al.  An empirical study of constraint usage in graphical applications , 1996, UIST '96.

[16]  Margaret M. Burnett,et al.  Time in grid-oriented VPLs: just another dimension? , 2000, Proceeding 2000 IEEE International Symposium on Visual Languages.

[17]  Alexander Repenning,et al.  Tactile programming: a unified manipulation paradigm supporting program comprehension, composition and sharing , 1996, Proceedings 1996 IEEE Symposium on Visual Languages.

[18]  Andrew W. Appel,et al.  A Debugger for Standard ML , 1995, Journal of Functional Programming.

[19]  Jonathan J. Cadiz,et al.  Does continuous visual feedback aid debugging in direct-manipulation programming systems? , 1997, CHI.

[20]  Gary M. Olson,et al.  Comprehension differences in debugging by skilled and novice programmers , 1986 .

[21]  Brad A. Myers Graphical techniques in a spreadsheet for specifying user interfaces , 1991, CHI '91.

[22]  Jon Fairbairn,et al.  Non-Strict Languages - Programming and Implementation , 1989, Comput. J..

[23]  Bonnie A. Nardi,et al.  A Small Matter of Programming: Perspectives on End User Computing , 1993 .

[24]  Margaret M. Burnett,et al.  Visual forms of iteration that preserve single assignment , 1990, J. Vis. Lang. Comput..

[25]  Jonathan J. Cadiz,et al.  A seamless integration of algorithm animation into a visual programming language , 1996, AVI '96.

[26]  Margaret M. Burnett,et al.  Similarity inheritance: a new model of inheritance for spreadsheet VPLs , 1998, Proceedings. 1998 IEEE Symposium on Visual Languages (Cat. No.98TB100254).

[27]  Margaret M. Burnett,et al.  Static Type Inference for a First-Order Declarative Visual Programming Language with Inheritance , 2000, J. Vis. Lang. Comput..

[28]  David G. Hendry,et al.  CogMap: a Visual Description Language for Spreadsheets , 1993, J. Vis. Lang. Comput..

[29]  David G. Hendry Display-based problems in spreadsheets: a critical incident and a design remedy , 1995, Proceedings of Symposium on Visual Languages.

[30]  Magnus Carlsson,et al.  Programming with Fudgets , 1995, Advanced Functional Programming.

[31]  Gregg Rothermel,et al.  What you see is what you test: a methodology for testing form-based visual programs , 1998, Proceedings of the 20th International Conference on Software Engineering.

[32]  Allen L. Ambler,et al.  Formulate Solution to the Visual Programming Challenge , 1998, J. Vis. Lang. Comput..

[33]  Brad A. Myers,et al.  Demonstrational and constraint-based techniques for pictorially specifying application objects and behaviors , 1995, TCHI.

[34]  Margaret M. Burnett,et al.  Representation Design Benchmarks: A Design-Time Aid for VPL Navigable Static Representations , 1997, J. Vis. Lang. Comput..

[35]  Roger B. Dannenberg,et al.  Garnet: comprehensive support for graphical, highly interactive user interfaces , 1990, Computer.

[36]  Margaret M. Burnett,et al.  Is it easier to write matrix manipulation programs visually or textually? An empirical study , 1993, Proceedings 1993 IEEE Symposium on Visual Languages.

[37]  Paul Hudak,et al.  Functional reactive animation , 1997, ICFP '97.

[38]  Guijun Wang,et al.  Solving display-based problems , 1996, Proceedings 1996 IEEE Symposium on Visual Languages.

[39]  David Canfield Smith,et al.  KidSim: end user programming of simulations , 1995, CHI '95.

[40]  James D. Hollan,et al.  Direct Manipulation Interfaces , 1985, Hum. Comput. Interact..

[41]  Margaret M. Burnett,et al.  Programming complex objects in spreadsheets: an empirical study comparing textual formula entry with direct manipulation and gestures , 1997, ESP '97.

[42]  Margaret Burnett,et al.  A bug's eye view of immediate visual feedback in direct-manipulation programming systems , 1997, ESP '97.

[43]  Kavi Arya Processes in a functional animation system , 1989, FPCA.

[44]  Margaret M. Burnett,et al.  Graphical definitions: expanding spreadsheet languages through direct manipulation and gestures , 1998, TCHI.

[45]  Simon L. Peyton Jones,et al.  Report on the programming language Haskell: a non-strict, purely functional language version 1.2 , 1992, SIGP.

[46]  John Hughes,et al.  Lazy Memo-functions , 1985, FPCA.

[47]  Krishna Bharat,et al.  Supporting distributed, concurrent, one-way constraints in user interface applications , 1995, UIST '95.

[48]  Uday S. Reddy,et al.  Imperative functional programming , 1996, CSUR.

[49]  Mehmet A. Orgun,et al.  Dealing with Multiple Granularity of Time in Temporal Logic Programming , 1996, J. Symb. Comput..

[50]  Marc Eisenstadt,et al.  A Practical Graphical Tracer for Prolog , 1991, Int. J. Man Mach. Stud..

[51]  Philip T. Cox,et al.  Expanding the utility of spreadsheets through the integration of visual programming and user interface objects , 1996, AVI '96.

[52]  William W. Wadge,et al.  Lucid, the dataflow programming language , 1985 .

[53]  Gregg Rothermel,et al.  Testing strategies for form-based visual programs , 1997, Proceedings The Eighth International Symposium on Software Reliability Engineering.

[54]  Ralph D. Hill The Rendezvous constraint maintenance system , 1993, UIST '93.

[55]  Simon L. Peyton Jones,et al.  Lazy functional state threads , 1994, PLDI '94.

[56]  William Stoye Message-Based Functional Operating Systems , 1986, Sci. Comput. Program..

[57]  William W. Wadge,et al.  A 3D spreadsheet based on intensional logic , 1990, IEEE Software.

[58]  Joyce L. Vedral,et al.  Functional Programming Languages and Computer Architecture , 1989, Lecture Notes in Computer Science.

[59]  Satoshi Matsuoka,et al.  Declarative programming of graphical interfaces by visual examples , 1992, UIST '92.

[60]  Nicolas Halbwachs,et al.  Synchronous Programming of Reactive Systems , 1992, CAV.

[61]  DONALD MICHIE,et al.  “Memo” Functions and Machine Learning , 1968, Nature.

[62]  Eugene H. Spafford,et al.  Debugging with dynamic slicing and backtracking , 1993, Softw. Pract. Exp..

[63]  Gregg Rothermel,et al.  Scaling up a "What you see is what you test" methodology to spreadsheet grids , 1999, Proceedings 1999 IEEE Symposium on Visual Languages.

[64]  Henry Lieberman,et al.  Bridging the gulf between code and behavior in programming , 1995, CHI '95.

[65]  Clayton Lewis,et al.  Spreadsheet-based interactive graphics: from prototype to tool , 1990, CHI '90.

[66]  Margaret M. Burnett,et al.  Exception Handling in the Spreadsheet Paradigm , 2000, IEEE Trans. Software Eng..

[67]  Satoshi Matsuoka,et al.  Interactive generation of graphical user interfaces by multiple visual examples , 1994, UIST '94.

[68]  Philip Wadler,et al.  How to declare an imperative , 1997, CSUR.

[69]  Henry G. Baker,et al.  NREVERSAL of Fortune - The Thermodynamics of Garbage Collection , 1992, IWMM.

[70]  Marko C. J. D. van Eekelen,et al.  Implementing a Functional Spreadsheet in Clean , 1995, J. Funct. Program..

[71]  Robin Milner,et al.  Definition of standard ML , 1990 .

[72]  B. H. McCormick,et al.  Visualization in scientific computing , 1995 .

[73]  Rob Miller,et al.  Easily adding animations to interfaces using constraints , 1996, UIST '96.

[74]  Margaret M. Burnett,et al.  Scaling Up Visual Programming Languages , 1995, Computer.

[75]  Allen L. Ambler,et al.  Visual representation and manipulation of matrices , 1992, J. Vis. Lang. Comput..

[76]  Simon L. Peyton Jones,et al.  Concurrent Haskell , 1996, POPL '96.

[77]  Andrew W. Appel,et al.  Debuggable concurrency extensions for standard ML , 1991, PADD '91.

[78]  Scott E. Hudson,et al.  User interface specification using an enhanced spreadsheet model , 1994, TOGS.

[79]  Gregg Rothermel,et al.  Slicing spreadsheets: an integrated methodology for spreadsheet testing and debugging , 1999, DSL '99.

[80]  Simon L. Peyton Jones,et al.  Composing the User Interface with Haggis , 1996, Advanced Functional Programming.

[81]  M. W. Curtis,et al.  A Turing Machine Simulator , 1965, JACM.

[82]  Clayton Lewis NoPumpG: Creating Interactive Graphics With Spreadsheet Machinery , 1987 .

[83]  Steven L. Tanimoto,et al.  VIVA: A visual language for image processing , 1990, J. Vis. Lang. Comput..

[84]  Marc Levoy,et al.  Spreadsheets for images , 1994, SIGGRAPH.

[85]  Margaret M. Burnett,et al.  Interactive Visual Data Abstraction in a Declarative Visual Programming Language , 1994, J. Vis. Lang. Comput..

[86]  P. J. Landin,et al.  Correspondence between ALGOL 60 and Church's Lambda-notation , 1965, Commun. ACM.

[87]  Jennifer L. Leopold,et al.  Keyboardless visual programming using voice, handwriting, and gesture , 1997, Proceedings. 1997 IEEE Symposium on Visual Languages (Cat. No.97TB100180).

[88]  Henry Lieberman,et al.  Watch what I do: programming by demonstration , 1993 .