Display the name of the nearest definition before addr, and the offset of addr from the beginning of that definition. “dot-tick”

1.5 INTERACTIVE PROGRAMMING—AN EXAMPLE

The Forth language was designed from first principles to support an interactive development style. By developing a very simple application in this section, we will show how this style translates into practice.

The general process of developing a program in Forth is consistent with the recommended development practices of top-down design and bottom-up coding and testing. However, Forth adds another element: extreme modularity. You don’t write page after page of code and then try to figure out why it doesn’t work; instead, you write a few very brief definitions and then exercise them, one by one.

Suppose we are designing a washing machine. The overall, highest-level definition might be:

The colon indicates that a new word is being defined; following it is the name of that new word, WASHER. The remainder are the previously defined words that comprise this definition. Finally, the definition is terminated by a semi-colon.

Typically, we design the highest-level routines first. This approach leads to conceptually correct solutions with a minimum of effort. In Forth, words must be compiled before they can be referenced. Thus, a listing begins with the most primitive definitions and ends with the highest-level words. If the higher-level words are entered first, lower-level routines are added above them in the listing.

Introduction 27

Forth Programmer’s Handbook

Figure 6 shows a complete listing of the washing machine example. This is a typical Forth block of source code. Comments are in parentheses. In this example, lines 1–3 define named constants, with hex values representing hardware port addresses. Lines 5–15 define, in sequence, the application words that perform the work.

Figure 6. Example of a control program that runs a washing machine

The code in this example is nearly self-documenting; the few comments show the parameters being passed to certain words. Forth allows as many comments as desired, with no penalty in object code size or performance.

When reading,

: WASHER WASH SPIN RINSE SPIN ;

it is obvious what RINSE does. To determine how it does it, you read:

: RINSE FILL AGITATE DRAIN ;

When you wonder how FILL works, you find:

Reading further, one finds that FAUCETS is simply a constant which returns

28 Introduction

Forth Programmer’s Handbook

the address of the port that controls the faucet, while ON is a simple word that turns on the bits at that address.

Even from this simple example, it may be clear that Forth is not so much a language, as a tool for building application-oriented command sets. The definition of WASHER is based not on low-level Forth words, but on washing-machine words like SPIN and RINSE.

Because Forth is extensible, Forth programmers write collections of words that apply to the problem at hand. The power of Forth, which is simple and universal to begin with, grows rapidly as words are defined in terms of previously defined words. Each successive, newer word becomes more powerful and more specific. The final program becomes as readable as you wish to make it.

When developing this program, you would follow your top-down logic, as described above. But when the time comes to test it, you see the real convenience of Forth’s interactivity.

If your hardware is available, your first step would be to see if it works. Even without the code in Figure 6, you could read and write the hardware registers by typing phrases such as:

HEX 7010 INPUT .

This would read the water-level register at 7010H and display its value. And you could type:

to see if the valve opens and closes.

If the hardware is unavailable, you might temporarily re-define the words MOTOR, etc., as variables you can read and write, and so test the rest of the logic.

You can load your block of source (as described in Section 3.4.3), whereupon all its definitions are available for testing. You can further exercise your I/O by typing phrases such as:

MOTOR ON or MOTOR OFF

to see what happens. Then you can exercise your low-level words, such as:

Introduction 29

Forth Programmer’s Handbook

DETERGENT ADD

and so on, until your highest-level words are tested.

As you work, you can use any of the additional programmer aids described in Section 2.1.5. You can also easily change your code and re-load it. But your main ally is the intrinsically interactive nature of Forth itself.

References Disk and block layout and design, Sections 3.4, 6.1

Stack notation conventions, Section 2.1, Table 11, and Section B.3 Number base, Sections 1.1.6, 2.4

Numeric output (the word .), Section 2.4.1 Programmer conveniences, Section 2.1.5

30 Introduction