Revision as of 00:16, 30 December 2022

In a future world with gem-gum technology where all the manipulation of matter in the large scale industry (like building of housings streets and means of transport) is done by software. The quality of programming languages is of paramount importance.

Programming languages must become so easy to learn and use that they are learned by accident.
Obviously there are many problems with high inherent complexity where great knowledge is needed to solve them. But current mainstream programming languages (state 2016) make problems with very little inherent complexity so hard that they become practically impossible for the majority of (by now computer using) humanity.

The gap between users and developers is not a fundamental law. It is there because of the weakness of our current programming systems. This is hard to believe for todays users since there are no mainstream systems yet that show otherwise. This is even harder to believe for todays programmers who where always walking just one step back to look at some other mainstream programming languages and came to the conclusion that misery is conserved by some hidden law. What we all fight is side effects. We want predictability but what we increasingly often get is some seemingly random behavior. Few programmers get the luxury to walk out of the forest of mainstream programming languages (metaphorically speaking) to check out the wide planes of purely functional languages (like e.g. Haskell). Those languages build upon some very different elegant and powerful stuff in their very cores. Those programmers who look carefully from there on out through all the weaknesses in this still very young world should see tremendous potential.

Bridging the gap between users and developers would make everyone a "deveuser". In lack of an existing world I'll continue to use this freshly invented neologism here. With better tools everyone gets much more power to bring their inner ideas to reality for others to see.

Someone named Bret Victor is trying to get that message out with impressive demonstrations:
See: http://worrydream.com/

Promising innovative new programming languages

There are several things future modern programming languages must have.

• They must feature guaranteed isolation against side effects.
• They must be representation agnostic. That means that the program code data can be displayed in multiple ways. E.g. what best fits the problem at hand. Or what best suits the "deveusers" taste.

unison

A representation agnostic language. It's focus is on tearing down historically grown barriers in computer systems by extending the principle of immutability beyond the core of the programming language. Very similar to the principle the Nix package mangerger uses The language tackles the problem of "code plumbing" (serialisation and deserialisation).

The language is function name agnostic that is it uses hashes of the actual implementations for function identification.

• http://unisonweb.org/

enso (formerly luna)

A representation agnostic language. The developers call it:

• a category oriented programming language -- a pure programing language -- it features immutable objects
  (TODO: find out in what relation they stand to typeclasses)
• a hybrid visual textual programming language
• https://github.com/enso-org/enso

Links to old sites:
Associated are the tools "Nodelab" a general graphical editor for luna and "Flowbox FX" a specialized editor for media processing. While the core language is open sourced both of the editors are unfortunately not planned to be made open source.

• https://enso.org/ (formerly http://www.luna-lang.org/)
• http://flowbox.io/ - Video: Demonstration of Flowbox FX - Broken :(
• (http://nodelab.io/ - archive)

Interesting programming language experiments

lamdu

A representation agnostic language. It uses named arguments making it argument order agnostic. It features row and column polymorphism.

• http://www.lamdu.org/
• Demo video: source 1 source 2

eve

A novel relational language (near logic programming) on top of a functional core language (as it seems) (wiki-TODO: read up some details).
The language is going for a Wiki like interface (for the moment).
The language is a result of the culmination of many experiments involving a lot of bootstrapping.

subtext

Semantic tables. This language factors out branching, pattern matching operations and automates boolean refactoring

• http://www.subtext-lang.org/

Especially interesting videos:

• 2016 "No ifs, ands, or buts" — https://vimeo.com/140738254
• 2017 "Reifying Programming (LIVE’17 submission)" — https://vimeo.com/228372549
• 2018 "Direct Programming" — https://vimeo.com/274771188

other

• isomorf: https://isomorf.io/

Related

• General software issues
• Visually augmented purely functional programming
• Problems with classical graphical programming
• Annotated lambda diagrams – Annotated lambda diagram mockups – Lambda diagrams
• Software

• Structural editors
• Projectional editors
• Typed holes

• Problems with classical graphical programming
• Problems with classical spreadsheets

External links

• Collected list of relevant videos

Programming language experiments / research prototypes (also see: Projectional editors):

• List of "Projectional programming" experiments (on reddit) https://www.reddit.com/r/nosyntax/wiki/projects

Missing in above's list:

• PANE - a live, functional programming environment built around data-visibility. (site) (video)

Bridging the gap between programming languages and graphics modeling (2D&3D):

• 2D: Sketch-n-Sketch web-page & associated youtube-channel
• 2D: Apparatus http://aprt.us/ – a reimplementation of what Bret Victor presented in his Talk: "Drawing dynamic visualizations" (youtube) (vimeo)
• ...