Show HN: I created a language called AntiLang – breaking all the conventions (siruscodes.github.io)

apl-family languages also often read easier right to left

Postfixes are easier to use, if you know how to use them. They're not only used in programming but also in spoken language:

    It is how, in this sentence, the verb works.
    
    It isn't how the verb works, in this sentence.

Sentences that simple are equally understandable using the verb as a postfix or infix. When sentences get longer that changes, though:

    It is how, in this sentence, which now has an extra clause, the verb works.
    
    It isn't how the verb works, in this sentence, which now has an extra clause.

In the first sentence, it's clear that the extra clause is something the sentence has, not the verb. The second example has what is called a dangling modifier, which is a clause at the end of the sentence that ambiguously could be describing more than one thing, in this case it could mean that either the sentence has an extra clause or the verb has an extra clause.

The lack of ambiguity also means it takes fewer commands to describe a single operation. For example, in an calculator with infix notation, which is what most people learn, calculating the multiple of four pairs of sums would require the following keypresses:

    ( 5 + 6 ) x ( 2 + 7 ) x ( 3 + 8 ) x ( 7 + 9 ) =

With an RPN calculator, which has a postfix notation, it would only require these keypresses:

    5 Enter 6 + 2 Enter 7 + 3 Enter 8 + 7 Enter 9 + x x x

That's 24 in the first example and 19 in the latter, a reduction of over 20%.

My grandma never really learned how to use a computer and was generally not very good at complex instructions. When she learned to use a calculator, RPN was just as common as postfix notation, and she was able to figure out how to use RPN, but had trouble figuring out postfix notation. Nowadays, schools usually only teach postfix notation, so most students aren't exposed to the easier method, and will have to do extra work, in the short term, to lean it, but it means calculations will require less work, once learned.

tl;dr: Postfix notation is the Dvorak keyboard to infix notation's Qwerty keyboard. The former is easier and faster, but everyone learns the latter. Putting in the extra work to learn the former will save you more time in the long run.

Not in the sense of flow of execution. But you'd explicitly fire off an event, no? COME FROM is registering invisible triggers at arbitrary locations.

You see it in some treatments of abstract algebra too. (Which are not unrelated to permutations in any case.) I think at least one book used in my undergrad used postfixes for function application, but I can't remember which.

I just had another thought about this.

Programmers are pretty accustomed to thinking of functions as verbs. In some programming styles, we're even explicitly encouraged to name our functions after verbs describing what they do.

Sometimes mathematicians think of functions more as expressing a complete (and sort of timeless) relationship between a domain and a range. That relationship, considered in its totality, can be thought of as a noun rather than a verb.

Earlier mathematicians might also have tended to think of functional notation as referring to individual specific instances of the result of the calculation that the function refers to, like "the sine of 1/2" being a specific number (the result of computing the sine of one half, or, alternatively, the output of the function given a specific input). So when writing something like sin(1/2) they might not be thinking "please [person or machine] perform this computation on the number 1/2 right now" so much as "[I am here indicating] the specific [timeless and inherent] number that is the sine of 1/2". That's a different way that a function could be seen as a noun, essentially seeing the function as merely a way of referring to its output.

Calculus and real analysis start to give stronger reasons for thinking of functions as abstract objects in their own right (e.g. because we can say something like "d/dx sin(x) = cos(x)" or even "the derivative of sin is cos" without thinking about specific values. Or questions like "can a function exist that is continuous but not differentiable?". Maybe computer science then starts to give reasons for thinking of functions as descriptions of how to perform them (like source code or even machine code punched on punch cards) as opposed to references to their specific results (like a printed book of function tables, which someone else calculated ahead of time so you wouldn't have to).

This is all to say basically that maybe it's more natural for us as programmers to think of functions as verbs, but maybe Euler didn't conceive of them that way at all!

Don't be disappointed. That's cool! You've independently discovered something.

Breaking conventions has been a thing for about as long as conventions themselves. No need to be hard on yourself. Next thing you should look at is Malbolge, very convention-breaking ;)

you may want to browse https://codegolf.stackexchange.com for a while as well. There are all kinds of weird task-specific languages that can give you lots of ideas.

You can also look at this polyglot thread with 65 languages https://codegolf.stackexchange.com/questions/102370/add-a-la...

The solution is not to stick strictly to prefix, postifx, or infix notation. Instead, all three should be valid.

All these should be equivalent:

  + a b + c d + 
  + + + a b c d
  a + b + c + d
  a b c d + + +

More insidiously, these should be equivalent:

  x = a + b
  = + x a b
  x a b = +
  + x = a b
  x = a b +
  x a + b =

Do you want to lie to your users, or do you just want to use unconventional operators? If the latter, you could consider using something like ruby's `unless`.

(the number of times I've noticed code that does `unless !some_condition`... which is of course just the same thing as `if some_condition`)

Polyglottism

This is some of the evilest idea I got on the post...

Raised issue for it - https://github.com/SirusCodes/AntiLang/issues/9

The hegemony of software only accepting . has de facto pushed the standard everywhere for computers, but here in France I still write with a comma, but type with a dot.

A few years ago Excel and some other softwares started to be locale dependent and I never wanted to burn my computer this much

No. Some languages use . for thousand (or even hundred) separators.

Very much so.

Dot is often used as thousands separator too.

I remember the first time I saw 10,000 as a price and thought: 10 bucks? So cheap. But also: who needs 3 decimal points for a price?

Looks like its more or less 50% of the world [0].

[0]: https://en.wikipedia.org/wiki/Decimal_separator#Conventions_...

For example, German speaking countries use a comma instead of a decimal point, whereas the latter is used as a group separator. The German word for decimal place is "Kommastelle" (= "comma place").

It’s “,” in Poland, and a dot(or apostrophe) as thousands separator.

That’s why in region settings on your computer you will find not only date/tome formatting, but also the number format.

Cyprus and Peru use , for decimal point for non-currency amounts and . for decimal point with currency amount. So it's not even consisent inside some languages.

See https://en.wikipedia.org/wiki/Decimal_separator#Hindu%E2%80%...

International standards say that either dot or comma is acceptable as decimal separator and thousand separators are optional spaces, typically a half space when properly typeset.

    ISO 31-0 (after Amendment 2) specifies that "the decimal sign is either the comma on the line or the point on the line". This follows resolution 10[1] of the 22nd CGPM, 2003.[2]

    For example, one divided by two (one half) may be written as 0.5 or 0,5.

Raised issue - https://github.com/SirusCodes/AntiLang/issues/6

No surprise to see that coming from microsoft.

yeah, to keep it in spirit also add localization of function/operator names and make sure only the locale version works not all at the same time.

It is reverse GOTO. After (or before - your choice) that line is executed, execution jumps to the comefrom.

The compiler inserts a goto to the statement following the comefrom statement into the line specified. :^)

If multiple comefroms to the same line are specified, the comefrom to jump to is selected randomly.

It is like a regular goto, but with the label and statement reversed.

So instead of

  label: 
  do_something
  goto label

You have

  comefrom label
  do_something
  label:

Really, that's just syntax. Declare your labels with "comefrom", and ":" means "jump". But it looks a lot more confusing this way.

  comefrom label
  goto label
  label: