Revision as of 23:23, 22 September 2021

Conversion of Cartesian coordinates to polar coordinates in the representation of annotated lambda diagrams.
For details see: ALDs – example Cartesian to polar.

Quicksort algorithm as a single function in the representation of annotated lambda diagrams.
For details see: ALDs – example quicksort.

Annotated lambda diagrams (ALDs) are a proposed "code projection" that aims at being a highly enjoyably usable interface for telling computers what to do (aka coding/programming/automating/...)

Annotated lambda diagrams where inspired by plain unannotated lambda diagrams (PLDs)
These are presented by John Tromp on his homepage here: https://tromp.github.io/cl/diagrams.html These plain lambda diagrams are are in turn based on lambda calculus. A formalism with only three types of terms that can represent any kind of computation in a very minimalistic way.

The annotated lambda diagrams presented here add annotations and some minimal "syngraphic sugar" to plain lambda diagrams.
The idea is to make lambda diagrams into a really enjoyable programming interface that minimizes discontinuous visual jumps and minimizes the necessity of expending mental resources on navigating codebases. A "bicycle for the mind".

For an introduction maybe first read:

• The problem with current day programming and its causes
• What lambda calculus is

Unfortunately as of yet (2021-07) this is all still "vaporware" and only static non-interactive mockups.
The author may never come around to actually implement this programming interface as envisioned.
This is a mammoth project, and this wiki already eats up a big chunk of time.
But at least with these mockups I hope to get the idea out there.

We really really need software that is not broken in a future world where matter essentially becomes software.

The basic idea in brief bullet points

• annotate plain lambda diagrams with: variable names, types, current values, kinds (aka types of types), ... (not all shown per default of course)
• Make them into a structured editor where you can type normally pretty much as you would in "plain textfile code editing"
  – (See: Fructure Specifically in this video with Andrew Blinn shortly after 6:03 [1] where he says "My preferred alternative is to simply type normally")
• Add progressive disclosure without compromises!!! This is not negotaible.
• Make program fragments drag and drop interactive (like puzzle pieces)
  Give reasonable visual cues for efficiency (rather than fancy): identicons, arity mismatch visualization, ...
• Give ALDs typed holes of input holes, output holes, and bridge holes. Don't forget the bridge holes!
  Such that program fragments are extendable: upstream, downstream, and ...
  can also be tied up in one or more still open concurrent paths (wiki-TODO: make a sketch)
• (Eventually make data flow around holes as far as this is possible. See: Hazel)
• Add type directed context sensitive suggestions for extending onto the present holes
• Give ALDs a zooming user interface (ZUI) capability – that allows for (arbitrarily deep) in place evaluation preview
• Add inverse tabs – allowing to navigate the codebase-graph upwards along different upstream paths that where formerly traced downstream along some dependency tree
  This is about answering the question "By which functions is this function that I currently look at used by?" Basic functions will have a huge list as answer. So this needs to be filterable.
  (Some dependency tree is only a subset of the codebase graph. This needs more awareness.)
• Use an ultra finegrainedly content addressed programming language as a base!!!
  That in order to mop up with fragility of references, dependency hell and fix quite a number of other things too.
  (ony such language in construction as of 2021 seems to be the unison language)

Eventually add higher level data visualization:

• that follow code structure (see: Tangible values – by Conal Elliott) – but with added progressive disclosure.
• that give an immediate connection by bidirectional data-flow (see: Drawing Dynamic Visualizations – by Bret Victor) (See: enso language)

Center between visual and textual

Hypothesis: Annotated lambda diagrams are as in the middle as it gets between:

• typical textual programming interface (for pure languages)
• typical box-and-wire visual programming interfaces and

The reader may judge.

Annotated lambda diagrams are very close in structure to textual code as seen in pure functional programming languages
(that is: languages with computer checked guatntees on code purity like e.g. haskell, purescript, elm, ...)
Morphing an annotated lambda diagram representation into the corrsponding textual representation requires only:

• a slight rearrangement of the value-name-annotations
• removal of the lines without making things ambiguous by addition of some textual syntactic sugar

This closeness of the annotated lambda diagrams to a purely textual code representation
necessarily makes the representation equally scalable than a textual code representation.
Well, at least up to a constant factor given by lower "on screen information density". But ...

• Annotated lambda diagrams likely have an on "screen information density" somewhere between purely textual and box-and-wire visual code representations.

• Like graphical box-and-wire programming annotated lambda diagrams give a visual circuit board like network that is easy to trace for human eyes.
  
• Unlike graphical box-and-wire programming abstractions and applications and applications are kept separated though.

Totally tearing down the GUI vs command-line rift!

The idea is as follows:
If all progressive disclosure is in the "hide-the-details-state" then the UI is completely indistinguishable from a conventional GUI.
Except one little "+" or something as the starting point for progressive disclosure.
A progressive disclosure step opens up the ALD that corresponds to the visual element.
From there the "end-user" (now elevated to "deveuser") can trace the codebase to non-displayed or even non-visual code elements.
Tracing the codebase entails tracing the nicely visually traceable lines in the ALD.

With disclosure of enough GUI elements and hiding of enough visualizations one eventually ends up with Just ALDs or
some other kind of code projection (like e.g. a conventional purely textual code projection).

Add to that: Bookmarking of "interface visualizations" and
organizing "code" documentation and data storage in a desktop wiki like system that
is implemented in that whole programming system in a bootstrapped way.

The basic benefits of ALDs

Combines the best of the two worlds of textual and graphical code:

• Almost as traceable as graphical code (since there are traceable "program circuit" lines)
  – these lines are quite different to "conventional" graphical programming though
• Almost as scaleable as textual code (since the structure closely follows textual code) – a little less dense

Does NOT combine the worst of the two worlds:

• unscalability of graphical wire-monster-krakens and
• hard traceability of excessively indirected textual codebases)

• Seeing the whole code multiverse at a glance and and the live running state as a literal "red thread" within.
• Browsing the codebase in all dimensions without detours and disruptive jumps
  Human mental RAM is limited, it shouldn't be used for pointless navigation hurdles.

Mockup Demos

Note: If actually implemented all this should be dynamic and interactive

See main page: Annotated lambda diagram mockups

Related

• Annotated lambda diagram mockups
• Lambda diagrams – Lambda calculus
• Higher level computer interfaces for deveusers
• Projectional editors
• Software

External links

A basic write-up of some ideas with links to twitter posts.
(wiki-TODO: this needs to be published more properly (that is: more resilliently))

• (Forum: HC => Channel: Technical Watercooler => Topic: Future of Coding)

Zooming user interface:
For many user interfaces this idea seems rather impractical.
It is likely extremely useful for the case of ALD's though.

Table of contents