When did functional programming begin? • 1952, "The Use of Sub-Routines in Programmes", D.J.Wheeler, https://dl.acm.org/doi/pdf/10.1145/609784.609816 Mentions higher order functions like "integrate", which is (somehow) parameterized by the function to be integrated. • 1956, Fortran, John Backus. FORTRAN=FORmula TRANslation. Fortran supports nested arithmetic expressions. "Programming on the right side of the assignment statement" is an early glimpse of expression-oriented functional programming, as mentioned later in [Landin 1966]. • 1960, LISP, John McCarthy, "_Recursive functions of symbolic expressions and their computation by machine, part I_". Lisp is the first programming language with conditional expressions, recursive functions, higher order functions (including "map" under the name "maplist"), plus garbage collection. This is the true birth of functional programming, even though LISP has a strong imperative core, and some key elements are missing: LISP is not lexically scoped; there are no closures, and no convenient syntax for curried function calls. http://www-formal.stanford.edu/jmc/recursive.pdf • 1962, APL, Kenneth Iverson, the book "A Programming Language" is published. Has an exceptionally powerful expression language, including the now standard "map" and "reduce" higher order functions (under different names). There is no APL interpreter yet. http://www.softwarepreservation.org/projects/apl/Books/APROGRAMMING%20LANGUAGE • 1964, P.J.Landin, "The Mechanical Evaluation of Expressions" describes a referentially transparent, lexically scoped, pure functional language with lexically scoped closures and curried functions. The syntax is a recognizable precursor to ML and Haskell. A virtual machine called the SECD machine is described for implementing functional languages (including lexical scoping and closures, which are missing from LISP). Earliest use of "referential transparency" to describe a programming language? https://www.cs.cmu.edu/~crary/819-f09/Landin64.pdf • 1966, P.J.Landin, "The Next 700 Programming Languages". This is the earliest published use of the term "functional programming" I can find, although it is by now reportedly in common use. This is the original manifesto for functional (ie, non-imperative) programming. It describes the research language ISWIM, spawning the ML/Haskell lineage of functional languages. http://www-formal.stanford.edu/jmc/recursive.pdf

Anyone know of any "toy" optimizing compilers for a functional programming language that are small enough to study and fit in head? Looking for learning resources. Tangentially, are there any nanopass compilers that are used outaide of education?

Anyone here implementing a functional language themselves? I'm interested in: how you do lazy evaluation and how you do any parallelisation (or is that concurrency?)

The author of the CT/math book I'm reading (Paolo Aluffi) suggested that if functions defs put output first (

f : B <- A

instead of

f : A -> B

) then function composition like

f . g

would make more sense. Then a couple chapters later he goes on to say that writing

(x)f

instead of

f(x)

would make

(f.g)(x)

be

((x)g)f

(or even maybe

xgf

) Both are nice suggestions, but the mix really does hurt my head

A friend on twitter asks for what are good minimal lisps that run on top of the JS ecosystem. Can you help me reply? https://twitter.com/seagreen__/status/1310250528358760448

I was curious to see if I could make a data structure using nothing but lambdas, and I came up with these JavaScript snippets: (H)=>((F)=>F(F)())((S,V,P)=>(X)=>X?S(S,X,S(S,V,P)):(H(V),P||S(S))) (H)=>((F)=>F(F)())((Q,V,N)=>(X)=>X?Q(Q,V,Q(Q,X,N)):(H(V),N||Q(Q))) Try this in your browser debugger: (...either snippet here...)(console.log)(1)(2)(3)()(4)()()(5)()()()()()()(8)()()

Cross-posting: https://futureofcoding.slack.com/archives/CE1R695T7/p1620381392005400

I was thinking about how “mathematical substitutions” make sense as a metaphor for abstraction. Would this sort of thing be helpful? In what contexts? Thinking about how when I use a function as an argument I should be able to “expand” and “collapse” the function to see more verbose versions of it. Is there anything that already does this?

Are there any Zactronics like games for functional programming?

If we were to take the flipbook analogy from The Joy of Clojure for State, Identity, and Time, how would it be represented differently in Unison? https://www.unisonweb.org/

Does anyone know any good animations that show how

apply

works in Clojure? Something like these? https://jstutorial.medium.com/map-filter-and-reduce-animated-7fe391a35a47

fp hot take https://twitter.com/dalt_nb/status/1487165041375956992

Hi y’all! There’s a virtual meetup for some projectional typed functional language projects this Wednesday at 12:00 US Eastern time, details here: https://docs.google.com/document/d/1-l1TPN5CsTI3oEoQGpCrW4rYUoENNNG2qqh4IpMNiJ4/edit?usp=sharing You’re welcome!

Does someone know if ICFP recordings are available?