Trends in Trends in Functional Programming 1999/2000 versus 2007/2008

The Trends in Functional Programming Symposia are an annual event dedicated to promoting new research directions in functional programming and to investigating the relationship between functional programming and other branches of Computer Science. The TFP series started in 1999 and the 2008 meeting marked the first decade of the symposium. In this paper we identify and discuss the trends presented at TFP using a macro-vision lens that looks at topics in the first two volumes of TFP and the two most recent volumes of TFP. The goal is to calibrate how trends have changed over a decade instead of analyzing trends with a micro-vision lens that focuses on changes from year to year. The major trends identified are work on parallel functional programming, types, formal verification, implementation of functional languages, and application development.

[1]  Huiqing Li,et al.  Formalisation of Haskell refactorings , 2005, Trends in Functional Programming.

[2]  João Paulo Fernandes,et al.  Shortcut fusion rules for the derivation of circular and higher-order programs , 2011, High. Order Symb. Comput..

[3]  Marko C. J. D. van Eekelen,et al.  Concurrent Clean , 1991, PARLE.

[4]  Cormac Flanagan,et al.  Unifying Hybrid Types and Contracts , 2007, Trends in Functional Programming.

[5]  Stefan Monnier,et al.  One Vote for Type Families in Haskell! , 2008, Trends in Functional Programming.

[6]  Matthias Felleisen,et al.  Functional programming and theorem proving for undergraduates: a progress report , 2008, FDPE '08.

[7]  Jun Yang.  Explaining Type Errors by Finding the Source of a Type Conflict , 1999, Scottish Functional Programming Workshop.

[8]  Marko C. J. D. van Eekelen,et al.  Proof Tool Support for Explicit Strictness , 2005, IFL.

[9]  Yolanda Ortega-Mallén,et al.  A distributed operational semantics for a parallel functional language , 2000, Scottish Functional Programming Workshop.

[10]  Karl-Filip Faxén.  The costs and benefits of cloning in a lazy functional language , 2000, Scottish Functional Programming Workshop.

[11]  Marco Pil.  Dynamic Types and Type Dependent Functions , 1998, IFL.

[12]  Nick Benton,et al.  Type inference for MLj , 2000, Scottish Functional Programming Workshop.

[13]  Douglas R. Troeger,et al.  The MT Architecture and Allocation Algorithm , 1999, Scottish Functional Programming Workshop.

[14]  Julien Signoles,et al.  Designing a Generic Graph Library Using ML Functors , 2007, Trends in Functional Programming.

[15]  Sharon Curtis,et al.  An application of functional programming: quilting , 2000, Scottish Functional Programming Workshop.

[16]  Simon L. Peyton Jones,et al.  Complete and decidable type inference for GADTs , 2009, ICFP.

[17]  Olha Shkaravska,et al.  Size Analysis of Algebraic Data Types , 2008, TFP 2008 2008.

[18]  Sanjay Ghemawat,et al.  MapReduce: Simplified Data Processing on Large Clusters , 2004, OSDI.

[19]  Martin Hofmann,et al.  Static prediction of heap space usage for first-order functional programs , 2003, POPL '03.

[20]  Frédéric Loulergue,et al.  Parallel Juxtaposition for Bulk Synchronous Parllel ML , 2003, Euro-Par.

[21]  László Lövei,et al.  Refactoring Erlang programs , 2007 .

[22]  Frédéric Loulergue,et al.  Parallel Superposition for Bulk Synchronous Parallel ML , 2003, International Conference on Computational Science.

[23]  Mitchell Wand.  Finding the source of type errors , 1986, POPL '86.

[24]  Peter Dybjer,et al.  Embedding a logical theory of constructions in Agda , 2009, PLPV '09.

[25]  Peter Thiemann,et al.  WASH/CGI: Server-Side Web Scripting with Sessions and Typed, Compositional Forms , 2002, PADL.

[26]  Alex Aiken.  Modern languages for modern parallel computing (invited lecture, abstract only) , 1999, ICFP '99.

[27]  Colin Runciman,et al.  Smallcheck and lazy smallcheck: automatic exhaustive testing for small values , 2008, Haskell '08.

[28]  Frédéric Loulergue,et al.  Parallel composition and bulk synchronous parallel functional programming , 2000, Scottish Functional Programming Workshop.

[29]  Frédéric Loulergue,et al.  High level BSP programming: BSML and BS , 2007 .

[30]  Ali E. Abdallah,et al.  Interfacing Java with Haskell , 1999, Scottish Functional Programming Workshop.

[31]  Philip Wadler,et al.  Links: Web Programming Without Tiers , 2006, FMCO.

[32]  Michael Hanus.  Curry: A Multi-Paradigm Declarative Language (system description) , 1997, WLP.

[33]  Frédéric Loulergue,et al.  A calculus of functional BSP programs , 2000, Sci. Comput. Program..

[34]  Wouter Swierstra,et al.  The power of Pi , 2008, ICFP 2008.

[35]  Clara Segura,et al.  Bypassing of Channels in Eden , 1999, Scottish Functional Programming Workshop.

[36]  Takayasu ITO,et al.  A Parallel Lisp Language PaiLisp and Its Kernel Specification , 1989, Workshop on Parallel Lisp.

[37]  Henrik Nilsson,et al.  Optimisation of Dynamic, Hybrid Signal Function Networks , 2008, Trends in Functional Programming.

[38]  Robert S. Boyer,et al.  Proving Theorems about LISP Functions , 1973, JACM.

[39]  Michael Hanus.  Multi-paradigm declarative programming (tutorial) , 1997, ICLP 1997.

[40]  Cormac Flanagan,et al.  Space-efficient gradual typing , 2010, High. Order Symb. Comput..

[41]  Marinus J. Plasmeijer,et al.  Gast: Generic Automated Software Testing , 2002, IFL.

[42]  Robert H. Halstead,et al.  New Ideas in Parallel Lisp: Language Design, Implementation, and Programming Tools , 1989, Workshop on Parallel Lisp.

[43]  Marinus J. Plasmeijer,et al.  Lazy Dynamic Input/Output in the Lazy Functional Language Clean , 2002, IFL.

[44]  Yves Bertot,et al.  Interactive Theorem Proving and Program Development: Coq'Art The Calculus of Inductive Constructions , 2010 .

[45]  Sebastian Fischer,et al.  EasyCheck - Test Data for Free , 2008, FLOPS.

[46]  Mark Harman,et al.  Dependence clusters in source code , 2009, TOPL.

[47]  Peter J. Stuckey,et al.  Interactive type debugging in Haskell , 2003, Haskell '03.

[48]  Donatella Castelli,et al.  Research and Advanced Technology for Digital Libraries, 12th European Conference, ECDL 2008, Aarhus, Denmark, September 14-19, 2008. Proceedings , 2008, ECDL.

[49]  Jocelyn Sérot,et al.  CAMLFLOW: a CAML to data-flow graph translator , 2000, Scottish Functional Programming Workshop.

[50]  Bart Jacobs,et al.  AHA: Amortized Heap Space Usage Analysis , 2007, Trends in Functional Programming.

[51]  Simon L. Peyton Jones,et al.  Parallel Implementations of Functional Programming Languages , 1989, Comput. J..

[52]  Boleslaw K. Szymanski,et al.  Parallel functional languages and compilers , 1991 .

[53]  Robin Milner,et al.  Principal type-schemes for functional programs , 1982, POPL '82.

[54]  Frédéric Loulergue,et al.  Semantics of a Functional BSP Language with Imperative Features , 2003, PARCO.

[55]  Koen Claessen,et al.  QuickCheck: a lightweight tool for random testing of Haskell programs , 2011, SIGP.

[56]  Colin Runciman,et al.  The space usage problem: An evaluation kit for graph reduction semantics , 2000, Scottish Functional Programming Workshop.

[57]  Brian Campbell,et al.  Amortised Memory Analysis Using the Depth of Data Structures , 2009, ESOP.

[58]  Juan-Carlos Cano,et al.  HOP: achieving efficient anonymity in MANETs by combining HIP, OLSR, and pseudonyms , 2006, OOPSLA 2006.

[59]  Patricia Johann,et al.  Short Cut Fusion for Effects , 2008, Trends in Functional Programming.

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

[61]  U. Norell,et al.  Towards a practical programming language based on dependent type theory , 2007 .

[62]  David J. King,et al.  An Industrial use of FP: A Tool for Generating Test Scripts from System Specifications , 1999, Scottish Functional Programming Workshop.

[63]  Christoph Beierle,et al.  Detecting common elements of types , 2000, Scottish Functional Programming Workshop.

[64]  Peter Sestoft,et al.  Deriving a lazy abstract machine , 1997, Journal of Functional Programming.

[65]  Tom Schrijvers,et al.  Confluence for non-full functional dependencies , 2009 .

[66]  Cormac Flanagan,et al.  Hybrid type checking , 2006, POPL '06.

[67]  Rachid Benlamri,et al.  Performance Analysis of Semi-centralized Load Sharing , 2006, ISPA Workshops.

[68]  Peter Sestoft,et al.  Referential transparency, definiteness and unfoldability , 1990, Acta Informatica.

[69]  Christoph Beierle,et al.  How to Combine the Benefits of Strict and Soft Typing , 1999, Scottish Functional Programming Workshop.

[70]  Fredrik Lindblad.  Property Directed Generation of First-Order Test Data , 2007, Trends in Functional Programming.

[71]  Albert Y. Zomaya,et al.  A Functional Design Framework for Genetic Algorithms , 1999, Scottish Functional Programming Workshop.

[72]  Marinus J. Plasmeijer,et al.  Testing reactive systems with GAST , 2003, Trends in Functional Programming.

[73]  Mateo Valero,et al.  unreadTVar: Extending Haskell Software Transactional Memory for Performance , 2007, Trends in Functional Programming.

[74]  Marko C. J. D. van Eekelen,et al.  Collected Size Semantics for Functional Programs over Lists , 2008, IFL.

[75]  John A. W. McCall,et al.  A functional framework for the implementation of genetic algorithms: Comparing Haskell and Standard ML , 2000, Scottish Functional Programming Workshop.

[76]  Emanuele Covino,et al.  Complexity Certification of C++ Template Metaprogramming , 2008, Trends in Functional Programming.

[77]  Clement A. Baker-Finch.  An Abstract Machine for Parallel Lazy Evaluation , 1999, Scottish Functional Programming Workshop.

[78]  Graham Hutton,et al.  Compiling Concurrency Correctly: Cutting out the Middle Man , 2009, Trends in Functional Programming.

[79]  Fritz Henglein,et al.  Dynamic Typing: Syntax and Proof Theory , 1994, Sci. Comput. Program..

[80]  Edwin Brady,et al.  Lightweight Invariants with Full Dependent Types , 2008, Trends in Functional Programming.

[81]  Walter Dosch,et al.  List Homomorphisms with Accumulation and Indexing , 1999, Scottish Functional Programming Workshop.

[82]  Rita Loogen,et al.  Under Consideration for Publication in J. Functional Programming Parallel Functional Programming in Eden , 2022 .

[83]  Jean-Luc Gaudiot,et al.  Multiprocessor Systems Programming in a High-Level Data-Flow Language , 1987, PARLE.

[84]  Bastiaan Heeren,et al.  Top quality type error Messages , 2005 .

[85]  Paul Hudak,et al.  Alfalfa: Distributed graph reduction on a hypercube multiprocessor , 1986, Graph Reduction.

[86]  Rody Kersten,et al.  Test-based inference of polynomial loop-bound functions , 2010, PPPJ.

[87]  Ricardo Peña-Marí,et al.  From GranSim to Paradise , 1999, Scottish Functional Programming Workshop.

[88]  Rita Loogen,et al.  GpH and Eden: Comparing two parallel functional languages on a Beowulf cluster , 2000, Scottish Functional Programming Workshop.

[89]  Paul Hudak,et al.  Modeling user interfaces in a functional language , 2004 .

[90]  Robert H. Halstead,et al.  MULTILISP: a language for concurrent symbolic computation , 1985, TOPL.

[91]  Olaf Chitil,et al.  Compositional explanation of types and algorithmic debugging of type errors , 2001, ICFP '01.

[92]  Kenneth Knowles,et al.  Hybrid type checking , 2010, TOPL.

[93]  R. Hindley.  The Principal Type-Scheme of an Object in Combinatory Logic , 1969 .

[94]  Frédéric Loulergue.  DISTRIBUTED EVALUATION OF FUNCTIONAL BSP PROGRAMS , 2001 .

[95]  Richard P. Gabriel,et al.  Qlisp: An Interim Report , 1989, Workshop on Parallel Lisp.

[96]  Hans-Wolfgang Loidl,et al.  Algorithm + strategy = parallelism , 1998, Journal of Functional Programming.

[97]  Manuel Serrano,et al.  Hop Client-Side Compilation , 2007, Trends in Functional Programming.

[98]  Nils Anders Danielsson,et al.  Fast and loose reasoning is morally correct , 2006, POPL '06.

[99]  Martín Abadi,et al.  Dynamic typing in polymorphic languages , 1995, Journal of Functional Programming.

[100]  Rance Cleaveland,et al.  Implementing mathematics with the Nuprl proof development system , 1986 .

[101]  Stephen Gilmore,et al.  Deep Type Inference for Mobile Functions , 1999, Scottish Functional Programming Workshop.

[102]  Robin Milner,et al.  A Theory of Type Polymorphism in Programming , 1978, J. Comput. Syst. Sci..

[103]  Bruce J. McAdam.  Generalising Techniques for Type Debugging , 1999, Scottish Functional Programming Workshop.

[104]  Andrew M. Pitts,et al.  A Metalanguage for Structural Operational Semantics , 2007, Trends in Functional Programming.

[105]  Murray Cole,et al.  BSP-based Cost Analysis of Skeletal Programs , 1999, Scottish Functional Programming Workshop.

[106]  Marinus J. Plasmeijer,et al.  An Introduction to iTasks: Defining Interactive Work Flows for the Web , 2007, CEFP.

[107]  Takayasu Ito,et al.  Parallel Lisp: Languages and Systems , 1990, Lecture Notes in Computer Science.

[108]  Ralf Lämmel.  Reuse by Program Transformation , 1999, Scottish Functional Programming Workshop.

[109]  Pierre Castéran,et al.  Interactive Theorem Proving and Program Development , 2004, Texts in Theoretical Computer Science An EATCS Series.

[110]  Murray Cole,et al.  Algorithmic Skeletons: Structured Management of Parallel Computation , 1989 .

[111]  Simon L. Peyton Jones,et al.  GUM: a portable parallel implementation of Haskell , 1996, PLDI '96.

[112]  Ricardo Peña-Marí,et al.  A Space Consumption Analysis by Abstract Interpretation , 2009, FOPARA.

[113]  João Saraiva,et al.  Shortcut fusion rules for the derivation of circular and higher-order monadic programs , 2009, PEPM '09.

[114]  Dana Petcu,et al.  SymGrid: A Framework for Symbolic Computation on the Grid , 2007, Euro-Par.

[115]  Edwin Brady,et al.  Ivor, a Proof Engine , 2006, IFL.

[116]  Marko C. J. D. van Eekelen,et al.  Functional Programming and Parallel Graph Rewriting , 1993 .

[117]  Edwin Brady,et al.  Constructing Correct Circuits: Verification of Functional Aspects of Hardware Specifications with Dependent Types , 2007, Trends in Functional Programming.

[118]  Graham Hutton,et al.  Towards a Verified STM , 2008, Trends in Functional Programming.

[119]  Rita Loogen,et al.  Controlling parallelism and data distribution in Eden , 2000, Scottish Functional Programming Workshop.

[120]  Clara Segura,et al.  Optimising Eden by transformation , 2000, Scottish Functional Programming Workshop.

[121]  S. Doaitse Swierstra,et al.  A Leaner Specification for GADTs , 2008, Trends in Functional Programming.

[122]  Takayasu Ito,et al.  Proceedings of the US/Japan Workshop on Parallel Lisp: Languages and Systems , 1989 .

[123]  Gudmund Grov,et al.  Towards a Box Calculus for Hierarchical Hume , 2007, Trends in Functional Programming.

[124]  Christian Haack,et al.  Type error slicing in implicitly typed higher-order languages , 2004, Sci. Comput. Program..

[125]  Shin-Cheng Mu,et al.  Algebra of programming in Agda: Dependent types for relational program derivation , 2009, J. Funct. Program..

[126]  Philip W. Trinder,et al.  An operational semantics for parallel lazy evaluation , 2000, ICFP '00.

[127]  Christopher D. Walton.  An Abstract Machine for Memory Management , 1999, Scottish Functional Programming Workshop.

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