Central European Functional Programming School

In these lectures we will introduce an interactive system that supports writing simple functional programs. Using this system, students learning functional programming: – develop their programs incrementally, – receive feedback about whether or not they are on the right track, – can ask for a hint when they are stuck, – see how a complete program is stepwise constructed, – get suggestions about how to refactor their program. The system itself is implemented as a functional program, and uses fundamental concepts such as rewriting, parsing, strategies, program transformations and higher-order combinators such as the fold. We will introduce these concepts, and show how they are used in the implementation of the interactive functional programming tutor.

[1]  Simon L. Peyton Jones,et al.  State in Haskell , 1995, LISP Symb. Comput..

[2]  Sven-Bodo Scholz,et al.  Truly nested data-parallelism: compiling SaC for the Microgrid architecture , 2009 .

[3]  Manuel M. T. Chakravarty,et al.  An Approach to Fast Arrays in Haskell , 2002, Advanced Functional Programming.

[4]  Clemens Grelck,et al.  Improving Cache Effectiveness through Array Data Layout Manipulation in SAC , 2000, IFL.

[5]  Herbert Schildt,et al.  The annotated ANSI C Standard American National Standard for Programming Languages—C: ANSI/ISO 9899-1990 , 1990 .

[6]  Clemens Grelck,et al.  Asynchronous adaptive optimisation for generic data‐parallel array programming , 2012, Concurr. Comput. Pract. Exp..

[7]  David H. Bailey,et al.  The Nas Parallel Benchmarks , 1991, Int. J. High Perform. Comput. Appl..

[8]  Simon L. Peyton Jones,et al.  Parallel generational-copying garbage collection with a block-structured heap , 2008, ISMM '08.

[9]  Clemens Grelck,et al.  Dependently typed array programs don't go wrong , 2009, J. Log. Algebraic Methods Program..

[10]  Brian W. Kernighan,et al.  The C Programming Language , 1978 .

[11]  David A. Koufaty,et al.  Hyperthreading Technology in the Netburst Microarchitecture , 2003, IEEE Micro.

[12]  Clemens Grelck,et al.  Shared memory multiprocessor support for functional array processing in SAC , 2005, J. Funct. Program..

[13]  Herb Sutter,et al.  The Free Lunch Is Over A Fundamental Turn Toward Concurrency in Software , 2013 .

[14]  Sven-Bodo Scholz,et al.  Single Assignment C: efficient support for high-level array operations in a functional setting , 2003, Journal of Functional Programming.

[15]  G.E. Moore,et al.  Cramming More Components Onto Integrated Circuits , 1998, Proceedings of the IEEE.

[16]  Simon L. Peyton Jones.  Harnessing the Multicores: Nested Data Parallelism in Haskell , 2008, APLAS.

[17]  Clemens Grelck,et al.  SAC: off-the-shelf support for data-parallelism on multicores , 2007, DAMP '07.

[18]  Oracle's SPARC T4-1, SPARC T4-2, SPARC T4-4, and SPARC T4-1B Server Architecture , 2011 .

[19]  Alexander V. Shafarenko,et al.  Index Vector Elimination - Making Index Vectors Affordable , 2006, IFL.

[20]  Gaël Varoquaux,et al.  The NumPy Array: A Structure for Efficient Numerical Computation , 2011, Computing in Science & Engineering.

[21]  Kai Trojahner.  QUBE - Array programming with dependent types , 2012 .

[22]  Clemens Grelck,et al.  Controlling chaos: on safe side-effects in data-parallel operations , 2009, DAMP '09.

[23]  Lenore M. Restifo Mullin,et al.  Effective data parallel computation using the Psi calculus , 1996, Concurr. Pract. Exp..

[24]  Clemens Grelck,et al.  Classes and Objects as Basis for I/O in SAC , 1998 .

[25]  Zheng Zhangzheng.  Using OpenMP as an Alternative Parallelization Strategy in SAC , 2011 .

[26]  Dawei Huang,et al.  A 40 nm 16-Core 128-Thread SPARC SoC Processor , 2011, IEEE Journal of Solid-State Circuits.

[27]  Alexander V. Shafarenko,et al.  Numerical Simulations of Unsteady Shock Wave Interactions Using SaC and Fortran-90 , 2009, PaCT.

[28]  Clemens Grelck.  Implementing the NAS benchmark MG in SAC , 2002, Proceedings 16th International Parallel and Distributed Processing Symposium.

[29]  David C. Cann,et al.  Retire Fortran?: a debate rekindled , 1992, CACM.

[30]  Sven-Bodo Scholz,et al.  Breaking the GPU programming barrier with the auto-parallelising SAC compiler , 2011, DAMP '11.

[31]  Clemens Grelck,et al.  Towards an Efficient Functional Implementation of the NAS Benchmark FT , 2003, PaCT.

[32]  Clemens Grelck,et al.  SAC on a Niagara T3-4 Server: Lessons and Experiences , 2011, PARCO.

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

[34]  Alan Holt.  Programming in J , 2008 .

[35]  Clemens Grelck,et al.  On Code Generation for Multi-generator WITH-Loops in SAC , 1999, IFL.

[36]  Bruce A. Draper,et al.  High-Level Language Abstraction for Reconfigurable Computing , 2003, Computer.

[37]  Marko C. J. D. van Eekelen,et al.  Guaranteeing Safe Destructive Updates Through a Type System with Uniqueness Information for Graphs , 1993, Dagstuhl Seminar on Graph Transformations in Computer Science.

[38]  George E. Collins,et al.  A method for overlapping and erasure of lists , 1960, CACM.

[39]  Clemens Grelck,et al.  Axis Control in SAC , 2002, IFL.

[40]  Chris R. Jesshope,et al.  Implementation and evaluation of a microthread architecture , 2009, J. Syst. Archit..

[41]  Bruce A. Draper,et al.  Sassy: A Language and Optimizing Compiler for Image Processing on Reconfigurable Computing Systems , 1999, ICVS.

[42]  Kenneth E. Iverson,et al.  A programming language , 1899, AIEE-IRE '62 (Spring).

[43]  Clemens Grelck,et al.  Concurrent Non-deferred Reference Counting on the Microgrid: First Experiences , 2010, IFL.

[44]  M. A. Jenkins.  Q'Nial: A portable interpreter for the nested interactive array language, Nial , 1989, Softw. Pract. Exp..

[45]  Robert Bernecky,et al.  The role of APL and J in high-performance computation , 1993, APL '93.

[46]  Jie Cheng,et al.  Programming Massively Parallel Processors. A Hands-on Approach , 2010, Scalable Comput. Pract. Exp..

[47]  Sven-Bodo Scholz,et al.  WITH-Loop-Folding in SAC - Condensing Consecutive Array Operations , 1997, Implementation of Functional Languages.

[48]  Alexander V. Shafarenko,et al.  Implementing a Numerical Solution of the KPI Equation Using Single Assignment C: Lessons and Experiences , 2005, IFL.

[49]  Rafael Dueire Lins,et al.  Garbage collection: algorithms for automatic dynamic memory management , 1996 .

[50]  Clemens Grelck,et al.  With-Loop Scalarization - Merging Nested Array Operations , 2003, IFL.

[51]  Clemens Grelck,et al.  Merging Compositions of Array Skeletons in SAC , 2005, PARCO.

[52]  L. Dagum,et al.  OpenMP: an industry standard API for shared-memory programming , 1998 .

[53]  Barbara Chapman,et al.  Using OpenMP - portable shared memory parallel programming , 2007, Scientific and engineering computation.

[54]  Clemens Grelck,et al.  SAC—A Functional Array Language for Efficient Multi-threaded Execution , 2006, International Journal of Parallel Programming.

[55]  Clemens Grelck,et al.  With-Loop Fusion for Data Locality and Parallelism , 2005, IFL.

[56]  John H. G. van Groningen.  The Implementation and Efficiency of Arrays in Clean 1.1 , 1996, Implementation of Functional Languages.

[57]  Alexander V. Shafarenko,et al.  Asynchronous Stream Processing with S-Net , 2010, International Journal of Parallel Programming.

[58]  M. A. Jenkins,et al.  A Comparison of Array Theory and a Mathematics of Arrays , 1991 .

[59]  Paul Hudak,et al.  The aggregate update problem in functional programming systems , 1985, POPL.

[60]  John Glauert,et al.  SISAL: streams and iteration in a single assignment language. Language reference manual, Version 1. 2. Revision 1 , 1985 .

[61]  Clemens Grelck,et al.  Implicit Memory Management for SAC. , 2004 .

[62]  Philip Wadler,et al.  Comprehending monads , 1990, LISP and Functional Programming.

[63]  Paul R. Wilson,et al.  Uniprocessor Garbage Collection Techniques , 1992, IWMM.

[64]  Clemens Grelck,et al.  Efficient Heap Management for Declarative Data Parallel Programming on Multicores. , 2008 .

[65]  Chris R. Jesshope,et al.  On the Compilation of a Language for General Concurrent Target Architectures , 2010, Parallel Process. Lett..

[66]  Clemens Grelck.  A Multithreaded Compiler Backend for High-level Array Programming , 2003, Applied Informatics.

[67]  Guy E. Blelloch,et al.  Implementation of a portable nested data-parallel language , 1993, PPOPP '93.

[68]  Kenneth E. Iverson,et al.  The Design of APL , 1973, IBM J. Res. Dev..