Can someone explain for me?

A different way to say the same: in forth, words get pushed on the stack, and popped from the stack by words that take arguments:

    code           stack
    I Forth love

    Forth love     I

    love           I
                   Forth

    ; love presumably pops
    ; subject, object args
    ; from stack - and does something 
    ; perhaps prints as side effect

Here is some inexplicably but meticulously formatted FORTH code that uses right justified indentation! Including reverse polish notation assembley.

https://donhopkins.com/home/code/tomt-cam-forth-scr.txt

https://donhopkins.com/home/code/tomt-users-forth-scr.txt

  ( FMOVE -- functional intersegment move                   ) HEX

  88 CONSTANT *MOV*  ( fn = 0 )   20 CONSTANT *AND*  ( fn = 1 )
  08 CONSTANT  *OR*  ( fn = 2 )   30 CONSTANT *XOR*  ( fn = 3 )

  CODE FMOVE ( fn s.seg s.off d.seg d.off length --)  AX, SI MOV
      CX POP  DI POP  ES POP  SI POP  DS POP  DX POP  AX PUSH
                        AL, # *XOR* MOV  DX, # 3 CMP  1$ JE
                        AL, #  *OR* MOV  DX, # 2 CMP  1$ JE
                        AL, # *AND* MOV  DX, # 1 CMP  1$ JE
                        AL, # *MOV* MOV               1$:
     CS: HERE 5 + , AL MOV  ( modify "[DI], AL MOV" ) 2$:
                      LODS  ES: [DI], AL MOV  DI INC  2$ LOOP
      AX, CS MOV  ES, AX MOV  DS, AX MOV  SI POP  NEXT,  END-CODE

                                                            -->

Is that loss?

No.

well played

Forth I assume uses reverse polish notation: arguments before the operator.

3 4 +

for example, would return 7.

> would return 7

more pedantically, it would push 7 onto the stack

even more pedantically, would remove 3 and 4 from the stack before pushing 7

Even oddly more pedantically, that's the operand stack, not to be confused with the separate return stack. >R and R> move values between the two stacks.

On the other hand, PostScript also has a dictionary stack, which you can use to implement a Smalltalk-like object oriented programming system. And its data types and executable code are basically polymorphic homoiconic JSON (like Lisp), not raw untyped bytes like FORTH.

https://news.ycombinator.com/item?id=22456471

https://news.ycombinator.com/item?id=47812317

The stack is really a convenience that makes pipeline-driven programming possible in the language.

somewhat relatedly, shell pipelining is very amenable to being massaged into (non stack-based) concatenative programming

Forth uses RPN so the "verb" is last.

That is, you provide the data first (I and Forth) and the command (heart) last.

AKA FJN (Forward Japanese Notation)

I found https://www.explainxkcd.com/wiki/index.php/Main_Page quite useful for that.

I have a daily puzzle game called https://lettered.io and I’ve been playing around with shareable replay gifs via gifenc. It’s been fun trying to get good looking replays without sacrificing size for quality

The age of AI has been incredible for the daily game space because you can play around with ideas so much faster and riff to find something that works. On the flip side, there’s a lot more games that just rip off another idea and change some mechanic slightly to make it “new”