Integrating Dataflow Evaluation into a Practical Higher-Order Call-by-Value Language

Dataflow programming provides an elegant model for computing with values that change over time. While many domain-specific dataflow languages have been developed, this dissertations presents a novel strategy for extending existing general-purpose call-by-value languages with a notion of dataflow evaluation. This strategy has been realized in the language FrTime, an extension of PLT Scheme that runs in the DrScheme programming environment. The primary challenges in developing FrTime have been to resolve interactions between its notion of dataflow and various features of PLT Scheme. This dissertation discusses the design, semantics, and implementation of FrTime, along with several applications.

[1]  Matthias Felleisen,et al.  DrScheme: a programming environment for Scheme , 2002, J. Funct. Program..

[2]  Shriram Krishnamurthi,et al.  The design and implementation of a dataflow language for scriptable debugging , 2007, Automated Software Engineering.

[3]  Philip Wadler,et al.  The essence of functional programming , 1992, POPL '92.

[4]  Linda G. DeMichiel,et al.  The Common Lisp Object System: An Overview , 1987, ECOOP.

[5]  Rob Miller,et al.  The Amulet Environment: New Models for Effective User Interface Software Development , 1997, IEEE Trans. Software Eng..

[6]  Manfred Broy,et al.  Specification and Development of Interactive Systems , 2001, Monographs in Computer Science.

[7]  Albert Benveniste,et al.  programmi language and its , 2001 .

[8]  Brad A. Myers,et al.  Citrus: a language and toolkit for simplifying the creation of structured editors for code and data , 2005, UIST '05.

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

[10]  Wilson C. Hsieh,et al.  SuperGlue: Component Programming with Object-Oriented Signals , 2006, ECOOP.

[11]  Gérard Berry,et al.  The foundations of Esterel , 2000, Proof, Language, and Interaction.

[12]  Arie van Deursen,et al.  Origin Tracking , 1993, J. Symb. Comput..

[13]  Nicolas Halbwachs,et al.  LUSTRE: A declarative language for programming synchronous systems* , 1987 .

[14]  Ying Xing,et al.  Scalable Distributed Stream Processing , 2003, CIDR.

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

[16]  R. K. Shyamasundar,et al.  Introduction to algorithms , 1996 .

[17]  Robert Bruce Findler,et al.  Slideshow: functional presentations , 2004, ICFP '04.

[18]  Shriram Krishnamurthi,et al.  Lowering: a static optimization technique for transparent functional reactivity , 2007, PEPM '07.

[19]  Paul Hudak,et al.  Functional reactive programming from first principles , 2000, PLDI '00.

[20]  Matthias Felleisen,et al.  From Macros to Reusable Generative Programming , 1999, GCSE.

[21]  Alan Borning,et al.  The Programming Language Aspects of ThingLab, a Constraint-Oriented Simulation Laboratory , 1981, TOPL.

[22]  Paul Hudak,et al.  Event-Driven FRP , 2002, PADL.

[23]  Matthew Flatt.  Composable and compilable macros: : you want it when? , 2002, ICFP.

[24]  FlattMatthew.  Composable and compilable macros , 2002 .

[25]  Phil Winterbottom.  ACID: A Debugger Built From A Language , 1994, USENIX Winter.

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

[27]  Jan A. Bergstra,et al.  Algebraic specification , 1989 .

[28]  R. Kent Dybvig,et al.  Revised5 Report on the Algorithmic Language Scheme , 1986, SIGP.

[29]  P. Hudak,et al.  FVision : A De larative Language for Visual Tra , 2001 .

[30]  Henrik Nilsson,et al.  Functional reactive programming, continued , 2002, Haskell '02.

[31]  Gert Smolka.  The Oz Programming Model , 1996 .

[32]  Jonathan P. Bowen,et al.  A shallow embedding of Z in HOL , 1995, Inf. Softw. Technol..

[33]  Frédéric Boussinot.  FairThreads: mixing cooperative and preemptive threads in C: Research Articles , 2006 .

[34]  Yannis Smaragdakis,et al.  Functional programming in C++ , 2000, ICFP '00.

[35]  Conal Elliott,et al.  Functional Implementations of Continuos Modeled Animation , 1998, PLILP/ALP.

[36]  Paul Hudak,et al.  The Haskell School of Expression , 2000 .

[37]  Arie van Deursen,et al.  The ASF+SDF Meta-environment , 1993, AMAST.

[38]  Henrik Nilsson,et al.  Dynamic optimization for functional reactive programming using generalized algebraic data types , 2005, ICFP '05.

[39]  Matthias Felleisen,et al.  Programming languages as operating systems (or revenge of the son of the lisp machine) , 1999, ICFP '99.

[40]  Manfred Broy,et al.  Specification and development of interactive systems: focus on streams, interfaces, and refinement , 2001 .

[41]  Raimondas Lencevicius,et al.  On-the-fly query-based debugging with examples , 2000, AADEBUG.

[42]  Antony Courtney,et al.  Frappé: Functional Reactive Programming in Java , 2001, PADL.

[43]  Paul Hudak,et al.  FVision: A Declarative Language for Visual Tracking , 2001, PADL.

[44]  David R. Hanson,et al.  DUEL - A Very High-Level Debugging Language , 1993, USENIX Winter.

[45]  Clinton Jeffery,et al.  A framework for automatic debugging , 2002, Proceedings 17th IEEE International Conference on Automated Software Engineering,.

[46]  Meurig Sage.  FranTk - a declarative GUI language for Haskell , 2000, ICFP '00.

[47]  Matthias Felleisen,et al.  A tail-recursive machine with stack inspection , 2004, TOPL.

[48]  William R. Cook,et al.  Mixin-based inheritance , 1990, OOPSLA/ECOOP '90.

[49]  Shriram Krishnamurthi,et al.  A dataflow language for scriptable debugging , 2004, Proceedings. 19th International Conference on Automated Software Engineering, 2004..

[50]  Shriram Krishnamurthi,et al.  Crossing State Lines: Adapting Object-Oriented Frameworks to Functional Reactive Languages , 2006, FLOPS.

[51]  Antony Courtney,et al.  Genuinely Functional User Interfaces , 2001 .

[52]  Philip Wadler,et al.  Deforestation: Transforming Programs to Eliminate Trees , 1990, Theor. Comput. Sci..

[53]  Philip Wadler,et al.  Deforestation: Transforming Programs to Eliminate Trees , 1988, Theoretical Computer Science.

[54]  Richard H. Crawford,et al.  Semantic issues in the design of languages for debugging , 1992, Proceedings of the 1992 International Conference on Computer Languages.

[55]  Simon L. Peyton Jones,et al.  Compiling Haskell by Program Transformation: A Report from the Trenches , 1996, ESOP.

[56]  Robert Eckstein,et al.  Java Swing , 1998 .

[57]  Joe Marshall,et al.  Continuations from generalized stack inspection , 2005, ICFP '05.

[58]  Paul Hudak,et al.  Real-time FRP , 2001, ICFP '01.

[59]  Douglas R. Smith.  A Generative Approach to Aspect-Oriented Programming , 2004, GPCE.

[60]  Shriram Krishnamurthi,et al.  Embedding Dynamic Dataflow in a Call-by-Value Language , 2006, ESOP.

[61]  Michael Sperber,et al.  Developing a stage lighting system from scratch , 2001, ICFP '01.

[62]  Robert Hieb,et al.  Syntactic abstraction in scheme , 1992, LISP Symb. Comput..

[63]  John Hughes,et al.  Generalising monads to arrows , 2000, Sci. Comput. Program..

[64]  Daniel P. Friedman,et al.  Towards Leakage Containment , 1992 .

[65]  Paul Hudak,et al.  Modular domain specific languages and tools , 1998, Proceedings. Fifth International Conference on Software Reuse (Cat. No.98TB100203).

[66]  EDDIE KOHLER,et al.  The click modular router , 2000, TOCS.

[67]  Ricky Yeung,et al.  TBAG: a high level framework for interactive, animated 3D graphics applications , 1994, SIGGRAPH.

[68]  C. Petri.  Kommunikation mit Automaten , 1962 .

[69]  Matthias Felleisen,et al.  Modeling an Algebraic Stepper , 2001, ESOP.

[70]  Edward A. Lee,et al.  Ptolemy: A Framework for Simulating and Prototyping Heterogenous Systems , 2001, Int. J. Comput. Simul..

[71]  E E Kohlbecker,et al.  Syntactic extensions in the programming language LISP , 1986 .

[72]  Mireille Ducassé,et al.  Coca: an automated debugger for C , 1999, Proceedings of the 1999 International Conference on Software Engineering (IEEE Cat. No.99CB37002).

[73]  Frédéric Boussinot,et al.  FairThreads: mixing cooperative and preemptive threads in C , 2006, Concurr. Comput. Pract. Exp..

[74]  Wilson C. Hsieh,et al.  Component programming with object-oriented signals , 2005 .

[75]  Mark S. Miller,et al.  Robust composition: towards a unified approach to access control and concurrency control , 2006 .

[76]  Bryan Cantrill,et al.  Dynamic Instrumentation of Production Systems , 2004, USENIX Annual Technical Conference, General Track.

[77]  David R. Hanson,et al.  A simple and extensible graphical debugger , 1997 .

[78]  Gordon D. Plotkin,et al.  Call-by-Name, Call-by-Value and the lambda-Calculus , 1975, Theor. Comput. Sci..

[79]  Clinton L. Jeffery,et al.  A lightweight architecture for program execution monitoring , 1998, PASTE '98.

[80]  Robert Hieb,et al.  Revised 5 Report on the Algorithmic Language , 1999 .

[81]  T. B. Dinesh,et al.  Animators and error reporters for generated programming environments , 1992 .

[82]  Robert Hieb,et al.  The Revised Report on the Syntactic Theories of Sequential Control and State , 1992, Theor. Comput. Sci..

[83]  Ilya Gertner,et al.  High-level debugging in parasight , 1988, PADD '88.

[84]  Philip Wadler,et al.  Listlessness is better than laziness: Lazy evaluation and garbage collection at compile-time , 1984, LFP '84.

[85]  Gregory D. Hager,et al.  Monadic robotics , 1999, DSL '99.

[86]  Bernd Brügge,et al.  Generalized path expressions: A high level debugging mechanism (Preliminary Draft) , 1983, SIGSOFT '83.

[87]  Michael Stonebraker,et al.  Monitoring Streams - A New Class of Data Management Applications , 2002, VLDB.

[88]  Mark Scott Johnson.  DISPEL: A Run-Time Debugging Language , 1981, Comput. Lang..

[89]  Guy E. Blelloch,et al.  Adaptive functional programming , 2002, POPL '02.

[90]  John Peterson,et al.  Parallel Functional Reactive Programming , 2000, PADL.

[91]  Ambuj K. Singh,et al.  Dynamic Query-Based Debugging of Object-Oriented Programs , 2004, Automated Software Engineering.

[92]  Matthias Felleisen,et al.  Classes and mixins , 1998, POPL '98.

[93]  Richard H. Crawford,et al.  Dalek: A GNU, Improved Programmable Debugger , 1990, USENIX Summer.

[94]  Paul Hudak,et al.  Lambda in Motion: Controlling Robots with Haskell , 1999, PADL.

[95]  Bertrand Meyer,et al.  Eiffel: The Language , 1991 .