Comment by nativeit | Hacker News Reader

Comment by nativeit | Hacker News Reader

If anyone else is as lost as I was, here’s a primer[1]:

Cognate is a project aiming to create a human readable programming language with as little syntax as possible. Where natural language programming usually uses many complex syntax rules, instead Cognate takes them away. What it adds is simple, a way to embed comments into statements.

…Cognate ignores words starting with lowercase letters, allowing them to be used to describe functionality and enhance readability. This makes Cognate codebases intuitive and maintainable.

Cognate is a stack-oriented programming language similar to Forth or Factor, except expressions are evaluated right to left. This gives the expressiveness of concatenative programming as well as the readability of prefix notation. Expressions can be delimited at arbitrary points, allowing them to read as sentences would in English.

Cognate borrows from other concatenative languages, but also adds unique features of its own.

—- 1. https://cognate-lang.github.io/

I’m still baffled by the assertion that right-to-left evaluation of novel arithmetic syntax “enhance[s] readability”.

Beware the difference between familiarity and simplicity!

To compare readability, you must first get used to the thing.

I would disagree with this. The prefix notation isn’t hard to understand, but even if I am familiar with how it works, it still requires the reader to do conversion, whereas when I write “a + b” in most other languages, it is quite clear to anyone what it means without mental conversion.

That's the opposite of the truth. With infix, you not only have to do conversions in your head, you need to keep track of which operator has precedence over another.

You say you make no conversion when doing `a + b`, but that's exactly equivalent to `+ a b` or `a b +`, you're simply used to a particular order. In English, adjectives normally come in front of the subject, but in many other languages, it comes after. Same thing: the order is not really very relevant and either order "works".

But where concatenative languages (and s-expression languages, e.g. Lisp) are superior is with complex expressions.

In "usual" languages, you need to convert this:

    2 * 3 + 4 - 6

to

    ((2 * 3) + 4) - 6

To clearly determine the order of operations.

In concatenative languages, you simply don't have to do anything, just apply the operators.

    * 2 3; + 4; - 6

No conversion required, just do `* 2 3`, then `+ 4 <result>`, then `- 6 <result>`.

Hence, if you really don't want to do conversions in your head, this is the way to go, not the conventional math notation!

Notice how if the expression was instead:

    2 + 3 * 4 - 6

Math notation would dictate you need to convert it to:

    (2 + (3 * 4)) - 6

That is , the order of the operations is not even the one you read it (it's not just left to right, like normal English prose, and not right-to-left either, like Arabic prose would be).

But in Cognate you MUST represent it pretty much the way you read:

    * 3 4; + 2; - 6

In your argument you fell right into the trap of confounding simplicity and familiarity.

Familiarity is when you say “look, this is like that other thing that I already do, neat”.

In a prefix language, I first learn what I'm going to be doing, then I learn what values I will be doing it to. This has the advantage that I understand the context in which things are going to be used. It helps in working from the top down.

In a postfix language, I first learn about how the values are constructed, then afterward I learn what I am going to do with them. This has the advantage that I am reading through things in the same order in which they happen. It helps me to think from bottom up.

Reply on news.ycombinator.com