HN Theater @HNTheaterMonth

Using a Lisp with Parinfer makes the parens automagic without taking away the benefits they provide.

https://shaunlebron.github.io/parinfer/ https://www.youtube.com/watch?v=K0Tsa3smr1w

That's a great suggestion. Which attempts are you familiar with? The ones I'm familiar with are summarized in this talk: https://www.youtube.com/watch?v=K0Tsa3smr1w

⬐ mattnewport

Some explorations of similar ideas that I'm aware of:

- Intentional Programming: https://en.m.wikipedia.org/wiki/Intentional_programming

- Light Table: http://lighttable.com/ (inspired by some ideas from Bret Victor: http://worrydream.com/)

- Visual Programming (lots of examples)

- Literate Programming

You can view sophisticated IDEs and refactoring tools as an attempt to improve the interface to plain text representations of code. These have actually had quite a bit of success.

Some approaches that move away from editing code as plain text have had success in particular domains. Visual Programming has shader graphs, Houdini, Unreal Blueprints, Substance Designer and other niches where it is relatively successful. Literate Programming has Jupiter notebooks and Mathematica that are popular in certain domains. Most of the success seems to come in particular niches, it's hard to think of widely adopted examples for "general" programming.

And Excel of course is a very successful non text based programming model within many domains.

This is called 'projectional editing', an idea that to my knowledge goes back to the 60s.

A projectional editor shows you both the original source code, and alternate representations (or, 'projections') of it. Given the right plugins and config, these alternate projections could happen to be more intuitive to grasp/edit than the original source code. One plugin could, for example, remove all the unnecessary semicolons. Another, could remove all the unnecessary punctuations and project the code in an indentation-significant way or vice-versa. Your idea to replace all the `'bar' + foo`s with ``bar{foo}``s would also be possible.

It's easy to imagine much more advanced use-cases. A sufficiently advanced editor could detect calls to FRP libraries, and project the data flow as a visual graph (picture all the `flatMaps()` and `scanLatest()s` as nodes on that graph). Or, given access to compile-time type info (via a typescript-style language-server), it could overlay the type of a value with the missing fields being shown as slots to be filled.

I can imagine such an editor to mostly "obsolete" the idea of a single syntax for each language in the first place. Like the language but not the syntax? Roll your own syntax! Just configure your own editor plugins. No one would have to know. No one would have to agree with your "taste." Not even your git repo [0]. (See /r/nosyntax/ for more ideas)

A projectional editor can also be implemented in the runtime, ala Smalltalk. In that case, the language itself is designed from the bottom up to accommodate such DX and opens many more possibilities.

A Clojure Conj talk called "... forgotten Lisp UX" explores the history of this idea in the context of lisp [1]. The author is also on Patreon doing exciting things in this field (https://www.patreon.com/shaunlebron).

---

[0] the editor may store some metadata next to the code that'd be committed to the repo, but the code itself would still be saved in the original syntax. [1] Inspiring a future Clojure editor with forgotten Lisp UX - Shaun Lebron https://www.youtube.com/watch?v=K0Tsa3smr1w

⬐ chrisweekly

Thanks for such an insightful and educational comment, AriaMinaei! Really interesting stuff.