
The Impact of the Lambda Calculus (1997) [pdf] - espeed
http://www-users.mat.umk.pl/~adwid/materialy/doc/church.pdf
======
galaxyLogic
An interesting detail from the paper is why it is called "LAMBDA". That is
because in the original notation what current-day programmers would call
formal argument of a function were denoted by putting an upward arrow-head on
top of variable/name but since that could not be type-set easily the arrow-
head was moved in front of such variable which resembles the Greek letter
"lambda".

~~~
jacquesm
Lambdatheultimate should be renamed to Lambdathetypo.

~~~
AnimalMuppet
Ah, but it's lambda the _ultimate_ typo...

------
mulholio
Does anyone have any favourite resources on the Lambda Calculus (i.e.
expanding upon the preliminaries in the introduction here)?

~~~
dwenzek
Here are 3 resources ordered by read-time length:

The Lambda Calculus for Absolute Dummies (like myself) :
[http://palmstroem.blogspot.com/2012/05/lambda-calculus-
for-a...](http://palmstroem.blogspot.com/2012/05/lambda-calculus-for-absolute-
dummies.html)

A short introduction to the Lambda Calculus:
[http://www.cs.bham.ac.uk/~axj/pub/papers/lambda-
calculus.pdf](http://www.cs.bham.ac.uk/~axj/pub/papers/lambda-calculus.pdf)

Lambda Calculus - Step by Step:
[https://www.dropbox.com/s/i0qgfoye6artcp8/untyped_lambda.pdf...](https://www.dropbox.com/s/i0qgfoye6artcp8/untyped_lambda.pdf?dl=0)

------
galaxyLogic
My question would be, why is Lambda-calculus not a good programming language
in practice?

~~~
dreamcompiler
Same reason Turing machines are impractical; it's too low-level. _But_ IMHO
starting with "functional composition without side effects" (LC model) and
adding the practical stuff gets you a lot farther than adding practical stuff
to "everything is a side effect and functions don't exist" (the TM model).

Back in the days before parallel programming, large-scale software
engineering, networks, cloud computation, etc it wasn't always clear that
anything was wrong with the TM model. But given how computing works today it's
clear (to me at least) that LC is a much, much better substrate for designing
computation.

~~~
dreamcompiler
As an aside, 1958 was definitely back in those days. But that's when John
McCarthy decided the TM model was lacking and said "Hey let's build a
programming language on Lambda Calculus instead" and Lisp was born. And that's
how John McCarthy was smarter than the rest of us.

------
Reli_Salazar
This is very interesting, thank you very much for sharing it.

------
harryking
Well i don't get it can anybody simplify it ?

~~~
austincheney
I cannot simplify the actual paper presented as I am not a mathematician and
cannot read Euler expressions (academic calculus). I can speak to lambda
calculus from a programming perspective though.

Lambda calculus is the basis of functional programming where a function is a
portable black box containing instructions and returning a result. That said,
a function is an abstraction such that a container of many instructions may be
represented by a single reference. Lambda calculus also accounts for nested
functions as a means of expressing layers of abstractions. One such style of
layered functions is the notion of creating a new function inside a function
and returning that new function, which is called _currying_. Currying allows
for the creation of an abstraction where the computation is not ready at the
time of creation, such as awaiting additional input via arguments, but ready
once called.

In my own code I use nested functions to create a separation of concerns. This
allows me to write code where portions are isolated from other portions but
available by reference where needed. This separation provides a formal means
of internal architecture and organization by which complexity is reduced.

A major consideration available from lambda calculus is the concept of lexical
scope, which is a concept similar to abstraction layers but applies to
reference resolution.

* [https://en.wikipedia.org/wiki/Lambda_calculus](https://en.wikipedia.org/wiki/Lambda_calculus)

* [https://en.wikipedia.org/wiki/Scope_(computer_science)#Lexic...](https://en.wikipedia.org/wiki/Scope_\(computer_science\)#Lexical_scoping)

~~~
galaxyLogic
Right I would say and argue that lexical scope is the main thing that makes
Functional Programming languages Functional Programming languages.

Why? Because it allows a function to create and return a new different
instance of a function-skeleton coded in the inner scope, part of which
function-instance is the values of the variables in its outer scope which were
the values of those variables at the time the outer function returned.

That means it is easy to create new function-instances. Function instances are
"first class citizens" as much part of the machinery of such language as any
data-structure.

In this sense the "inner function" coded inside an outer is not a function at
all. It is just an encoding, a set of instructions for creating a new function
which instructions are executed to create a new function when you execute the
outer function.

Whereas the outermost function is a function by itself since there can be only
one instance of it ever.

~~~
dreamcompiler
In practice the inner function (the body of a lexical closure) is only
compiled once. When a "new function is made" at runtime, a data structure for
the new lexical environment is created together with a pointer to the already-
compiled closure body. So the executable portion (the actual instructions of
the closure) are only allocated once.

