Spirit of Forth

[AndreasKlimas]

What do you think is the spirit of Forth (the system, the language and programming) ?

• For me this is the reduction, or better elimination, of complexity. If I try to reduce the complexity and have to write the application with Java, then this does not make any sense to me. To write an application in a language orders of magnitude more complex than my solution, is an oxymoron.

• Another important point is that in Forth we almost don't have grammatical or syntactical rules. Maybe this is a part of reduction of complexity.

• One person can hold the full control over the whole environment.

best wishes Andreas Klimas

[pete]

Per Chuck Moore, there are three main principles:

• Keep it simple
• Do not speculate
• Do it yourself

The original paper "Programming in a Problem-Oriented Language" is unfortunately gone, replaced for a while with some Earthlink placeholder. Ouch. The Wayback Machine has a copy: https://web.archive.org/web/20160327044521/http://colorforth.com/POL.htm

[rdrop-exit]

• Understanding an overall problem deeply enough that you can discriminate essential from arbitrary complexity.
• Producing systems that are simple, transparent, tractable, and can be fully comprehended in their entirety by a single person.
• Thorough exploitation of the simplifying and streamlining benefits of:
  • stacks and RPN
  • different binding times
  • factoring for composability (one-liners please!)
  • judiciously chosen scaling factors

[RogerLevy]

Doing more with less.

[monsonite]

Sometimes described as a list processor - as the sort of embedded tasks we do today are well suited to being defined as lists of actions.

For example 3D printing, CNC machining, milling/drilling pcbs - and other desktop machining processes that are now commonplace.

These processes are defined in simple text files as lists of repeated actions - and this is what Forth with its text interpreter is very good at doing.

The other example is sending lists of drawing items to a graphics processor or printer - and PostScript is probably the best known application of a Forth-like language designed to do this.

I agree with other respondents in the ethos of keeping everything as simple as possible - and that a single person should be capable of complete understanding and control of the system that they are working with.

This totally flies in the face of the last 40 years of computing trends - where wrapping up unnecessary complexity in a multi-gigabyte operating system - and only exposing the fewest of interfaces seems to have become the norm.

My reaction to this over-complexity is that I am currently working on tiny Forth-like languages for MSP430 and other mcus - which fit into 1Kbytes - and provide access to memory, peripherals and provide a rich set of primitives.

Ken

On 24 July 2017 at 06:23, RogerLevy notifications@github.com wrote:

Doing more with less.

— You are receiving this because you are subscribed to this thread. Reply to this email directly, view it on GitHub https://github.com/ForthHub/discussion/issues/50#issuecomment-317322334, or mute the thread https://github.com/notifications/unsubscribe-auth/AAuUP12q5Im-1HtzFwlOaqftb7ffgZkOks5sRCpPgaJpZM4OgiWf .

[larsbrinkhoff]

Got permission from Charles Moore to put a copy of POL here:
https://github.com/larsbrinkhoff/forth-documents/tree/master/POL

[RigTig]

To me, the spirit of Forth is about doing more with less. The main advantage is that there are almost no rules: I let the problem dictate the solution. If I need a multi-level menu and I have just three keys and three 7-segment LEDS on an 8-bit cpu, then I can create whatever structures and operations I can think of. And I can optimise them (or not) as circumstances allow (or dictate). Sometimes (or maybe often), I just hack something into place: just do it. Later, maybe, sort out the mess, or live with it. In a team of just one, standards and rules can just slow down getting the outcome. Besides, most times for me is an experiment, so the software is not meant to last, just work (at least well enough). And what language and environment gives me the flexibility: Forth, what else comes even close?

[RigTig]

To me, the spirit of Forth is about doing more with less. The main advantage is that there are almost no rules: I let the problem dictate the solution. If I need a multi-level menu and I have just three keys and three 7-segment LEDS on an 8-bit cpu, then I can create whatever structures and operations I can think of. And I can optimise them (or not) as circumstances allow (or dictate). Sometimes (or maybe often), I just hack something into place: just do it. Later, maybe, sort out the mess, or live with it. In a team of just one, standards and rules can just slow down getting the outcome. Besides, most times for me is an experiment, so the software is not meant to last, just work (at least well enough). And what language and environment gives me the flexibility: Forth, what else comes even close?