Re: An Observation

J Thomas wrote:
On Mar 6, 11:26 pm, step...@xxxxxxxxxxxxxxxxx (Stephen J. Bevan)
wrote:
John Doty <j...@xxxxxxxxxxxxxxxxxxxxxxx> writes:
Stephen J. Bevan wrote:
...
Forth 83 made the mistake of changing so many fundamental things that
Forth 79 code didn't work. It was the biggest setback Forth has ever
had. I don't have numbers but it would be quite plausible that Forth
lost half its user base then. Maybe more.

Forth 94 bent over backward going the opposite way, and now people
complain that it stifled innovation. It does though allow lots of
great innovative systems -- provided that those innovations are
invisible to users who write standard code.

One problem is that the sloppiness that permits this places a burden on the user.


I don't know how to solve this. But creating a new simpler and more
powerful Forth looks like fun, and continuing to argue about Forth 94
does not look like fun. I'd rather spend my hobbyist hours having fun.
On the other hand, I have to spend my professional hours working on
maintainable code.

Since users literate in Standard Forth are extremely rare, code in Standard Forth has a negligible maintainability advantage over other dialects. Better to go with simplicity.


So if we get a simpler more powerful Forth, it needs to be compatible
with standard Forth.

You'll never get a better Forth that way. Chuck figured that out.

It should be possible to make a system that does
both.

Given a Forth with a clean, well defined foundation you should be able to define a compatibility layer. The sloppiness of Forth 94 helps. But don't start by worrying about Forth 94: worry about what a user applying Forth is going to need.

...
By some measures Forth is maintaining its niche. By Anton's measure
we're advancing. By the TIOBE measure we're holding steady at 0.15%.
(We've recently climbed to 36th place without increasing our
percentage share.) http://www.tiobe.com/tpci.htm

But Python is in 7th place and Ruby has gone from 21st place to 10th
place in a year. By whatever TIOBE measures, Ruby's popularity has
gone up 7-fold in one year.

Note that neither of these have standards: they have *specifications* and portable *implementations*. This moves many of the compatibility and portability issues off of the language users' plates onto the language developers' plates, giving everybody better leverage.


Could a Forth do that? Yes, why not? If
there was some reason that lots of new users thought a Forth dialect
was very easy to learn and also very powerful, and easy to integrate
into multi-language apps, why not?

Because a sloppy standard puts a burden on users that users of languages with clean specifications don't have to bear?

Comp.lang.forth could be flooded
with newbies asking newbie questions.

We'd scare 'em away pretty quick ;-)



I'm confident that any reasonably unbiased sample of computer users
would judge C code more readable by humans than Standard Forth code.
The vast majority of computer users don't program at all and so I'm
not sure what they find readable. However, one thing I am confident
about is that those users would lump LSE and Standard Forth in the
same category since the difference between them is tiny compared with
the difference between them an C.

Sure, but John isn't considering LSE an end-point. He just considers
it farther along the way to where we need to be than Forth 94 is.

Yep. But I know one physicist who considers LSE the most readable programming language ever. I think part of this comes from the fact that when he had a bunch of students writing LSE code for him, they wrote very *straightforward* code: nothing clever. There was no stack manipulation more complex than SWAP, for example. Then the advantages of a language that gives you the flexibility to adapt the low level abstractions to the hardware and the high level abstractions to the application really shine through.

I think, though, that for more readable code, Mathematica offers an interesting hint of an approach. Mathematica's low-level FullForm is flexible and Lispy, but other forms look more like traditional algebraic programming or traditional mathematics. Single keystrokes convert a selection from one to another. Edit in whatever form you want. Display in whatever form you want.

Note that Mathematica is kind of an umbilical system, with a GUI front end in a separate process from the kernel, which can be on a different machine, possibly even with a different architecture.

> ...


--
John Doty, Noqsi Aerospace, Ltd.
--
Specialization is for robots.
.

Relevant Pages

  • Re: Is C99 the final C? (some suggestions)
    ... > that someone will try compile their stuff on an old compiler. ... > because the ANSI standard obsoleted them, and everyone picked up the ANSI ... fixed by using another language. ... >>are multiplying two expressions of the widest type supported by your ...
    (comp.lang.c)
  • Re: subroutine stack and C machine model
    ... They could have standardized that the language would be ... getting the facts wrong anyway. ... And the answer, for the Schildt books, is that they consistently produced ... to C start with the standard. ...
    (comp.lang.c)
  • Re: Two Questions about "strlen", "strcat" and "strcpy"
    ... >> No. zero terminated strings is the whole problem in the first place. ... > OR length prefixed strings the language would retain compatibility ... is not easily duplicated with the old standard then it will foster interest. ... The C standards committee is dead. ...
    (comp.lang.c)
  • Re: Forth Frustrations
    ... How would they even know what they are without being language lawyers? ... standard systems and a large number of nonstandard ones. ... interpreter, ... They set up four states -- HOST INTERPRETER COMPILER ...
    (comp.lang.forth)
  • Re: Is C99 the final C? (some suggestions)
    ... >> because the ANSI standard obsoleted them, and everyone picked up the ANSI ... > fixed by using another language. ... programmers managing the meaning of the symbols for more generic operators. ... According to a paper by Intel, widening multiply accounts for something like ...
    (comp.lang.c)