That's true, but not only for languages. Network effects in particular are often dominant for the adoption of technology.

This reminds me of a discussion on Mastodon about Git being awful (from a UI perspective) but difficult to improve on because of network effects: mastodon.social/@gvwilson/110859585196043772

Meh, if you have a job to do and 90%+ of the work has been done "good enough" in some language you'll probably use it. Ecosystem and developer availability trump most things.

git was awesome from day one, and is why it won

hard <> hostile, FP is hard too and people don't say it hates devs

on langs, I like this reply

twitter.com/0xmmo/status/1689330851694391296

Network effects in particular are often dominant for the adoption of technology.

My language choice these days is almost 100% dictated by the community contributed library ecosystem.

That said, Carmack was talking specifically about languages themselves, so I think I agree with him

What precisely is meant by "compounding power"? Exponential as a function of what?

Anyway, it's important to remember the staggering levels of programming power that have become our baseline expectation. We take higher order functions for granted, forgetting that people used to program in assembly, to say nothing of plugboards. So, "compounding"? I don't know. And it's not impossible that we've picked all the order-of-magnitude fruits. But to say that there are no order of magnitude gains in language tech at all ignores history.

But to say that there are no order of magnitude gains in language tech at all ignores history.

I hadn't thought about it on a long time scale, but that's a good point. It also made me think even if "better" languages are developed and not widely used, they can still have a big impact since they can act as proof of concept and good ideas from them can make their way into more popular languages.

exactly, and every change to a better language requires more effort to be useful

A visual programming system ... with state charts ... and good control over execution ... will solve all your problems. 🪄 🎩 🐇

What about "visual programming system only of state charts" – (too hard to learn or start something new with?)

Something like xstate? Although it is javascript focused which might not suite everyone. In my own project I want to combine statecharts with more regular nodes and wires, hope to demo something "soonish" 😊

Maikel van de Lisdonk yeah for this thread I'm willing to try any tools or languages. I'm just curious to see examples of how others might organize the state machine in my doc to be easier to maintain.

it may be overkill but TLA+/PlusCal? 😄 learntla.com lamport.azurewebsites.net/tla/tla.html

I'd love to see what the TLA+ solution for this looks like. It wouldn't be directly executable, right? But it's one step more rigorous than the document, is that the right way to think about it?

executing it means proving it's a well formed specification

There's a big list of specifications here: github.com/tlaplus/Examples/tree/master/specifications

Lamport's TLA page has a video course that I found really useful

For me, executing it means when I click on the button I get a plot. And it doesn't hog disk reads too much, it's a good citizen of my computer.

If the state machine lives outside the program that executes, how can I get an automated alert when I add a state to the state machine but forget to change the code.

That's basically the problem statement. My sense is that formal methods aren't quite here yet. Which is fine, not a criticism. I just want to focus this thread on the best possible solution for a single example. We like programming by example here, right? For this example and these design goals, what is the best representation we can think of that's "hard scifi" (doesn't have to be working code yet, but also doesn't require solving hard unsolved research problems).

And I want to see the (pseudo)code 😛 Around the same level of detail as the 5 10-line versions I wrote in the doc.

I like programming by hand-waving at things that don't exist yet in the hope that someone else builds them.

Go away, Ivan 😛 <obi wan>This is not the thread you are looking for.</obi wan>

One idea I would love to have time for is a parser for TLA+ that draws it some way and allows to step through the execution of different "traces"

same for quickcheck style property based testing specifications

I have yet to see a trace visualizer for a logical language that was remotely legible, or a way of visualizing the execution of logical code using its source. I'm desperate to use them if they exist, so let me know. The closest I have seen is a system that maintains a set of successful search routes, then turns each into a tree-structured justification where each node of the tree and it's immediate children correspond to a rule clause. There might be things you could do to link those trees to the source code more explicitly in an interface. I've done something similar in Blawx where elements of the tree are linked to source legal text. But that's not execution tracing, it's answer justification.

I have been obsessed with making logical code easier to use for a few years, now, and I don't even know what I would WANT out of a trace visualizer. The only things I can imagine would work, like a zoomable, color coded, annotated search tree, seem like they would be of limited utility unless what you wanted to know was why your code ran so slowly. And you pretty much don't care about that when you are writing things like TLA+ specs.

For the record, I haven't actually used TLA+, but I have taken a lot of inspiration from Hillel Wayne's promotion of it, and of formal methods more generally.