
Lambda Cube - Cieplak
https://en.wikipedia.org/wiki/Lambda_cube
======
kvb
See also pure type systems

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

------
adamnemecek
Reminds me a bit of the "Commutative diagram of harmonic wave" from wikipedia

[https://commons.wikimedia.org/wiki/File:Commutative_diagram_...](https://commons.wikimedia.org/wiki/File:Commutative_diagram_of_harmonic_wave_properties.svg)

------
batoure
Why is it that when I look at equations it’s all just nonsense but send me a
gist example and all the sudden it’s the music of the universe.

~~~
dan-robertson
Because the definitions (eg as seen in OP) describe how things may be
synthesised but not what one might want to synthesise whereas a gist example
just gives you something to stare at and decide if you can understand how it
fits together. If all one has is the definitions one must build everything
from scratch but with a preexisting example one can start at the top level and
build an understanding down without needing to plan ahead through all the gory
details.

At first I wanted to finish this up dismissively by suggesting that maybe it’s
just that only the easier things would end up in a gist but having thought
about a tiny bit I think there’s a lot to gain from larger examples that won’t
fit in half a column in a paper.

------
DoofusOfDeath
Can anyone recommend an _online course_ for learning about the lambda calculus
and the introductory type theory?

I've tried learning about them on my own using books, but I have trouble
staying focused and motivated enough to get very far.

------
mFixman
Language theory and lambda calculus classes were some of my favourite in
college. I wonder how many serious bugs would be averted if programming
languages came with more complete type systems.

~~~
wespiser_2018
You might think this: but there is a major time and complexity cost to using
more advanced type systems that sometimes doesn't pay off in simpler
applications that must ship fast!

~~~
chriswarbo
This is a common meme, but I'd like to see some robust empirical evidence
either way (the only studies I've seen so far are with e.g. a handful of
undergraduates, implementing a toy problem, well-specified up-front, with no
maintenance/feature-drift/etc.)

As a trivial counterargument, there's nothing preventing programmers from
ignoring even the most advanced type system (see "stringly typed programming",
for example). In fact, my experience with "advanced type systems" (e.g. Agda,
Idris and Coq), the types have never been a hindrance; it's their totality
checking that can be painful (that's why Idris makes it easy to turn that off,
either completely or for certain pieces of code).

~~~
hota_mazi
> This is a common meme, but I'd like to see some robust empirical evidence
> either way

I wouldn't call that datapoint robust nor empirical, but Scala developers have
been complaining about the slowness of their builds for more than ten years
now, and it's pretty much accepted that the Scala compiler will never get
marginally faster than it is today. The Scala 3 compiler is not looking much
better either.

~~~
Drup
What does that has to do with type systems? OCaml is one of the fastest
compiler around, and yet it has a very rich type system. Julia also has a very
rich type system, but is interpreted/JITed. Many compilers are very slow, even
thought their typecheckers barely does anything.

The speed of the compiler is related to the design of both the language and
the compiler as a whole, not the presence or absence of a decent type system.
I would even argue that one of the point to recognize a well designed type
system is that it's conceived in a way that admit fast typechecking.

------
kuwze
"Each dimension of the cube corresponds to a new way of making objects depend
on other objects"

Is it normal to refer to data structures as objects? Just to my knowledge most
typed languages abhor the awesome potential of object-oriented programming,
like the CLOS.

~~~
betterunix2
In this context I think it refers to mathematical objects, since the
dependencies can be between either values or types in either direction (values
to values, types to types, types to values, values to types).

Also, lexical closures in a functional language are "classes" from the OO
setting, so it is natural to implement classes if you want them; see e.g.
OCaml. What you rarely see in the functional setting are common OO design
patterns, because many of those patterns are unnecessary or awkward in
functional languages.

~~~
Jim_Heckler
Could you explain what you mean by closures being classes? My only familiarity
is from Emacs/Common Lisp and Clojure.

~~~
cstrahan
Define a set of functions that close over their lexical environment, then
treat the closed-over variables as internal/private state, and treat those
functions as you would methods in OOP (reading/mutating the aforementioned
variables).

~~~
lispm
That's basically the same level of OOP compared to how one can implement
numbers and numeric operations as functions.

------
kyberias
What would be a good text book about language theory, type systems etc.?

~~~
sideeffffect
I personally hope that I will eventually find the time to read Practical
Foundations for Programming Languages by Robert Harper

[https://www.cs.cmu.edu/~rwh/pfpl/index.html](https://www.cs.cmu.edu/~rwh/pfpl/index.html)

direct link to a preview of the 2nd edition:

[https://www.cs.cmu.edu/~rwh/pfpl/2nded.pdf](https://www.cs.cmu.edu/~rwh/pfpl/2nded.pdf)

direct link to an unabridged version of the 1st edition:

[http://profs.sci.univr.it/~merro/files/harper.pdf](http://profs.sci.univr.it/~merro/files/harper.pdf)

------
Hackbraten
Slightly disappointing. I wanted to learn about four simultaneous 24-hour days
within a single rotation of the Earth.

~~~
wolfgke
For those who do not understand:

>
> [https://en.wikipedia.org/w/index.php?title=Time_Cube&oldid=8...](https://en.wikipedia.org/w/index.php?title=Time_Cube&oldid=885383984)

> [https://ti.mecu.be/](https://ti.mecu.be/)

~~~
HNLurker2
[https://www.youtube.com/watch?v=H7lWCqbgQnU](https://www.youtube.com/watch?v=H7lWCqbgQnU)

