Re: The Promise of Forth

On Mar 22, 7:56 pm, Jonah Thomas <jethom...@[EMAIL PROTECTED]
> wrote:
> People who don't like Forth say, why bother with a data stack at all?
> Declare variables, declare locals, let the compiler do the work of
> figuring out where everything is. Don't bother your little brain about
> it.

You are dishonest, or illogical, or both.
If you want your brain to do all of the work,
then don't use a computer.  Ever.  Understand?

>   And Forthers say that with a data stack we get a simpler compiler

Untrue.  Only those whose highest ambition is flushing a
toilet say that.

And why would the one using a compiler want it to be
as simple as possible?  That's what the lazy creator
of the compiler would want: "Let the users do most of
the work, not me."

> and we get simpler subroutine calling. We're encouraged to factor
> deeper, and that helps us write simpler code.

Untrue.

>    And they say it isn't
> simpler, programming in Forth is like solving a Rubik's cube, you're
> handling details the compiler could do better and it costs you in
> efficiency.
>
> The Forth promise is that the extra thinking will pay off. That the
> normal exponential crufty buildup will be slowed. That the simplicities
> will work together so that you'll wind up with less total work. Fewer
> places for bugs to hide means faster debugging and the possibility for
> actual correct code.

Untrue.

For example, you posted this stack spaghetti:

: BOX4 ( x1 y1 x2 y2 -- )
   2>R
   R'@[EMAIL PROTECTED]
 OVER 2R@[EMAIL PROTECTED]
 LINE
   OVER R@[EMAIL PROTECTED]
 2R@[EMAIL PROTECTED]
 LINE
   2DUP OVER R> LINE
   R> OVER LINE ;

Those of you who are honest and willing to think
will note the lack of factoring, the unreadability.
and the multitude of places for bugs to hide.
It is as though the programmer set out to generate
the worst possible gibberish.  Anyone who thinks
that this is acceptable code has a gigantic
mental blind spot.

I would never hire a programmer who produced
code like that.  I would never hire a "programmer"
who had a paranoid fear of local variables.


>    The less that extra complexity leaves you making
> work for yourself, the more time you have available to think and
> simplify and the more actual results you can produce.

The code you posted was hideously complex.

>
> It's true for some Forth programmers. When people try Forth and decide
> it wouldn't work for them, they may be right. The Forth Promise

You are capitalizing it as though it were your god.
I think that this is a religious belief that has no
connection with facts or reason.

>     can't
> pay off except for programmers who think of ways to keep it simple.

As simple as your BOX4?

Or as simple as one approach using locals:

: from_corner { x y  xx yy -- }
  x y  xx y line
  x y  x yy line ;

: box { x y  xx yy -- }
  x y  xx yy  from_corner
  xx yy  x y  from_corner ;