Hacker News Reader

> These slides need a lot of work. I'll read the paper later, but the slides really lack context and motivation.

SPJ is an exceptional public speaker, but that involves a lot of talking, a lot of context, audience participation, and a lot of wild gesticulating at slides.

I'm not sure if this talk was recorded, but I am sure if it was the recording will be much better than the slides, the slides are not really designed for consumption outside of the talk context, but rather as a reminder rather than taking notes. At least that's my experience having seen a number of his talks over the years.

Looks like it just went online: https://youtu.be/832JF1o7Ck8

Thanks for the heads up. Just watched it, and the talk gives no additional details to the metaverse context or purpose of the language. Also, he uses a ton of filler words, and I find it pretty hard to listen to at times.

I see using the choice syntax as PROLOG-esque, rather than Python-esque.

When you are building simple structures to iterate upon, it makes sense to use the more readable comprehension syntax, where you define a list or set of items and their desired properties.

Yet this terse syntax makes more sense for logic programming, where a lot of the domain logic is built upon generate-and-test patterns; you define a combinatoric search space which is the enumeration of all base value in pairs (or tuples), and check which ones are kept for the next processing steps. When using this pattern, it's clearer to be able to express the space with the shortest syntax rather than the verbose one.

As for the adequacy and need for the language, I have my own ideas on what's needed for the stated use case, and I do agree with the authors that this kind of language will really be easier to learn for people without a programming background; it looks much more like mathematics than the traditional von-Neumann-architecture, continuation-based languages, and its declarative nature may make it easier to approach without having a full understanding of runtime behavior.

> I see using the choice syntax as PROLOG-esque, rather than Python-esque.

I didn’t think otherwise. Many functional languages have comprehension syntax, and I prefer declarative programming.

> When using this pattern, it's clearer to be able to express the space with the shortest syntax rather than the verbose one.

How is

    x <- [1,2,3]

or

    x <- {1,2,3}

more verbose than

    x := (1|2|3)

? Also, the first and especially second are basically identical to mathematical syntax, but the first implies order better.

True, those are not more verbose, but are merely list enumerations, not comprehension, which bundles multiple generators and tests within the same structure, e.g.:

[(x, y) for x in [1, 3, 5] for y in [2, 7, 8] if x < y]

It's a single monolithic expression that builds the list. The choice syntax however represents each generator and each test as separate expressions, which may even be part of different functions. This seems to offer more flexibility. For example (I don't know the exact syntax):

x:=(1|2); y:=(7|8); x<y; result = (x,y)

Here result is bound to the same values as in the comprehensive list; but these values are yield one at a time, instead of being part of a structure that you traverse.

> These are professors and language experts, so I'm a bit surprised by the presentation.

I am not surprised by this at all. If they really want to create something practical, I would rather employ the creator of Turbo Pascal, than one of the creators of Haskell. To me it seems as SPJ et al. are taking the money to do something fun and interesting, and scratching an itch they had for some time. Nothing wrong with that, but don't expect something that will be useful anytime soon.

Labeling someone who's had an immense impact on making strict static functional programming mainstream and relevant in the industry as unfit to developing such a language seems quite out of place.

SPJ has been implementing features that the industry and real world users wanted in Haskell for decades and yet you expect his cooperation with another great dev and business person like Sweeney to be fooling around and not produce "anything useful anytime soon"?

I recommend you reading the transcript of one of the latest SPJ's podcasts, he speaks both about the role of languages in the real world and about Sweeney's project:

https://haskell.foundation/podcast/11/

We can revisit your comment in 10 years, and I'll be happy to have been wrong. Undoubtedly there will be interesting research arising out of this. Let's see how many people will be programming in Verse by then.

If you rename `fst` to `first`, then `snd` becomes `second`, which is much much (much!) longer.

Why does that matter though?

No writer does this. Why are programmers obsessed with word length to such a degree?

Writers do something different from programmers. What programmers do is often more akin to mathematics, especially the type of stuff language creators do. And mathematical notation likes to be short.

I rather strongly disagree when it comes to programming. Programming is as much communication between humans and domain modeling as it is instructing a computer to do something. Shortening names seems to be a cultural holdover when name length had some real effect or constraint, and now there’s highly subjective and debatable constraints like being shorter, faster to type, length symmetry, etc.

Mathematics uses symbols because there is usually no specific context for an abstract concept, and on other cases it relies on convention to provide context. Shorter names are additionally a side due to the density of information and the ability to write complex symbols on a chalkboard and in LaTeX. The symbols are the meaning and not some shortened version of it.

`𝜋` is a mathematical symbol, but you could also write `CircumferenceOfCircleWithUnitDiameter`. The reason everyone prefers `𝜋` should be clear. The same is true for a less extreme case like `fst` and `first`: You don't need to think about what `fst` means, if you are fluent in the programming language it is clear, and more concise than `first`. `fst` becomes an atomic symbol in the programmer's mind, it is not something you need to interpret like `first`. This is not about communicating with other humans or even the computer, it is about efficient representation within your own mind.

so much so that I think "differently" in good old car/cdr lisp. even though car/cdr means nothing on any cpu architecture, are cryptic as can be .. they embody the structural inductive step perfectly in my mind. when in clojure or sml I write slower :)

How about they use 1st and 2nd as a compromise?

`fst` and `snd` possess a symmetry which `first` / `second` lack

Personally I've got used to them like in no time

Why is symmetry in word length needed?

Why is anything "needed"? It's all a continuum of convenience, readability, familiarity, prior art, and preference.

That you fall somewhere differently on any or all of those spectrums than the author is fine.

Alignment.

    x = fst(some complex expression)
    y = snd(some complex expression)

The need for such alignment denotes a further deficiency in the language if it lacks pattern matching.

    (x, y) = some complex expression

And I’m not for sure if this alignment overrides the readability aspect. Verify few languages have alignment in mind, and even less formatters do, so it isn’t clear why alignment is so strongly needed in this very particular case. And what about third and fourth?

some people click on this.

I still hate them after 5 years of professional PureScript.

I am not sure that fst and snd decreases readability. There was studies that showed that at least for alphabetic languages humans recognized words by the first and last characters initially ignoring the middle. So these abbreviations nicely play on that.

That’s probably a stretch because the study is probably more about the brain being able to fill in if needed rather than it being the same cognitive load. There’s no point in testing the brain in a programming language, and as far as I can tell, programmers are really the only ones that are obsessed with word length. It’s as if authors would just shorten “the” to “th” or “t” since it repeats a lot.

It's still mental overhead for a subset of users, thus an unnecessary shortening.

I read “snd” as “send”. I also read “fst“ as “fast”. Word length also matters.