[ajhenrydev]

Can someone explain for me?

[e12e]

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

[forsalebypwner]

Is that loss?

[fwip]

No.

[joshu]

well played

[DonHopkins]

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

                                                            -->

[spott]

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

3 4 +

for example, would return 7.

[zabzonk]

> would return 7

more pedantically, it would push 7 onto the stack

[dbcurtis]

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

[DonHopkins]

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

[argimenes]

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

[nagaiaida]

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

[HFguy]

Forth uses RPN so the "verb" is last.

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

[ithkuil]

AKA FJN (Forward Japanese Notation)

[daureg]

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