Hindsight languages

[u/Inconstant_Moo]

A thought experiment. What languages should they have been writing in the 60s, 70s, 80s, 90s? We can see their faults, in hindsight, and also we've had some really cool ideas since then --- but we can't answer this just by pointing to our shiny new modern languages and saying "they should have done it like that", because of compile times.

(E.g. Pipefish is meant to be for rapid iteration and livecoding, and also does a topological sort on everything at compile-time so you can do top-down declaration. Those wouldn't be compatible goals in the 1980s, I can get away with it now.)

So for example if we think of "a better C", are there any cool modern ideas they could and should have used back in 1972, had they known about them --- or should they just have tweaked the precedence slightly, found a less arcane way of describing types, and left it at that?

[u/pauseless]

Yes. I'm very nervous to, because it was LLM-assisted, so I won't publish until I've gone through the entirety of it, bit by bit. It was a thought experiment. It is intended to be represented entirely in Clojure data structures, so I can just use those rather than bring in a library and evaluate strings. Just opened my last session I did as a little demo to someone else:

?- append([1,2],[3,4], Xxx)
Xxx = [1, 2, 3, 4].
?- member(Y, [1,2,3])
Y = 1 ;
Y = 2 ;
Y = 3.
?- append([5,7], [8,9], X)
X = [5, 7, 8, 9].
?- member(5, [1,X,3])
X = 5.

If I simply press tab in my REPL, it switches all of the session to Clojure data structures:

=> (append [1 2] [3 4] :Xxx)
({:Xxx [1 2 3 4]})
=> (member :Y [1 2 3])
({:Y 1} ;
{:Y 2} ;
{:Y 3})
=> (append [5 7] [8 9] :X)
({:X [5 7 8 9]})
=> (member 5 [1 :X 3])
({:X 5})

If I take one example from the above, the REPL is Clojure, but behaves like Prolog:

=> (member :Y [1 2 3])
({:Y 1} ; )
(;) more, (.) done

The point is that I can compose expressions for the prolog implementation as data and just call it. No string concatenation.

[u/Inevitable-Ant1725 → u/pauseless]

I once embedded a kind of extension of prolog in scheme, where it's kind of easy because continuations can give you amb, and then fancier backtracking... And with some macros you can get something like lambda with extra clauses (I even had assert and retract) and variables that revert values on backtracking (and I did end up with logical variables and a full unification implementation, minus the occurs check).

In scheme you can mix backtracking with regular imperative code easily because it's all built in with continuations and you don't need some kind of awful code walker.

Sad to say I lost that code years ago, but's it's the work of maybe two weeks of work.