Benton Harbor BASIC
Designed byGordon Letwin
DeveloperWintek, Heathkit
First appeared1978; 46 years ago (1978)
PlatformHeathkit H8
LicenseCommercial proprietary software
Influenced by
Dartmouth BASIC

Benton Harbor BASIC and Extended Benton Harbor BASIC were two versions of the BASIC programming language written by Heathkit for their H8 microcomputers. The BASICs were patterned on Dartmouth BASIC, and thus differ in some respects from the many Microsoft BASIC clones of the late-1970s era. The two differ from each other in that the former was able to run in machines with only 8 kB of main memory and only supported string constants, while Extended required 12 kB and added string variables and additional features. It is named after the town where Heathkit was located.[1]


Heathkit had been watching the emerging microcomputer field since 1974, but at the time, they could not figure out what any of the traditional Heath customers would use one for. Attitudes changed when MITS introduced the Altair 8800 kit in January 1975 and it was a runaway bestseller. Heathkit began a program to develop their own kit that would be much superior to the Altair,[2] which was known to have poor reliability due to a number of design decisions.[a] The concept of building a computer remained a heated issue in the company, but started moving forward after one engineer stated "All right, we'll build a computer. But we're not going to get involved in software!"[2]

The idea of not getting involved in software quickly revealed itself as a bad one. Although the new design was largely a cleaned up Altair, or S-100 bus design as they were known by this time, it differed enough that software for the Altair would not run without conversion. This would leave the prospective owner will little or nothing to do with their computer.[3] The decision was made to sell the systems with at least some fundamental programs, but no one in the company had any software experience.[3]

The company contacted Wintek of Lafayette, Indiana to write a suite of programs for the system. Wintek sent one of their programmers, Gordon Letwin, to the Heath headquarters in Benton Harbor, Michigan to meet with them. The project lead at Heath, Louis Frenzel, recounted that Letwin once arrived for a business meeting with long hair, high-top sneakers and a velvet coat. In spite of his surprise at Letwin's appearance, Frenzel quickly realized Letwin knew what he was doing and decided to hire him directly.[3]

Letwin's first project was HDOS, an operating system for the platform. With this completed, he began work on BASIC. The first versions were extremely simple, supporting only the most basic functionality, limited to 6 digits of precision, lacking string manipulation,[3] and only allowing a single statement per line.[4] This version shipped with all H8 systems. For $10, the user could also purchase Extended BASIC, which started at Version 10, which added string variables and various additional functions.[5]

The system was not particularly well reviewed. One review called it "medium quality" and expressed concern about how slow it was, some 10 times slower than North Star BASIC.[6] Additionally, in spite of Heath's claims that Extended offered improved performance, benchmarking by one user demonstrated that most operations were either identical in speed or slightly slower, with the exception of some math functions like square root.[7]


Program editing

Like most BASICs of the era, the system could be used in either interactive or program mode, or as it was known at the time, immediate mode and deferred mode. Heath refers to these as command mode and program mode. Statements entered without a line number, in command mode, were run immediately. Those with a number at the front were put into the appropriate place in the program storage, possibly replacing an existing line with the same number. In contrast to later home computer versions, the H8 did not assume any sort of cursor addressable display, so editing the code had to be done by re-entering the entire line at the * prompt.[8] Line numbers could be between 1 and 65,535,[9] and any single line could be up to 80 characters in the base version, and 100 in Extended.[8]

One advanced feature of the system was that it offered an autocomplete system. As the initial command is being typed in, as soon as it can be uniquely identified, the system will insert the entire word immediately.[10] Although some other dialects like Sinclair BASIC offered similar features, they did so using special keystrokes or characters that performed the replacement.

Statements and commands

Statements were split into groups: those that could only be used in command mode, and thus known as commands, and those that could be used in command or program mode. Among those that could only be used in command mode were: RUN, CONTINUE if it was paused, and SCRATCH rather than the more common NEW to erase a program— (SCRATCH was used in a number of contemporary BASICs). Programs were saved using DUMP instead of SAVE, but loaded using LOAD. Files had long filenames and could be VERIFY after DUMPing.[11]

Statements that could be used in command or program mode represented the majority of the language. Among these were the common IF...THEN and the equivalent IF...GOTO seen on a few other systems, FOR...NEXT...STEP, DIM for 1 or 2 dimensions, GOSUB...RETURN, GOTO with the ability to use variables as well as line number constants, the optional LET, LIST which could only list a single line or the entire program, ON...GOTO and ON...GOSUB computed branches, PEEK and POKE, PRINT, READ...DATA and RESTORE. A number of statements seen in most dialects of the era were missing, including STOP, END, DEF FN and REM. INPUT was supported with a single optional prompt, and if the prompt was there, the question mark that would normally appear was suppressed. This could also be triggered by entering no prompt string and just the semicolon separator.[12] An addition was the PAUSE command, seen in a few dialects, that stopped execution until a key was pressed.[13]

Math operators were standard; +, -, *, / and ^. Logical operators were likewise standard; =, <, >, <=, >= and <>.[14] Boolean operators included NOT, AND and OR.[15]

Functions were largely standard as well, including ABS, ATN, ABS, COS, EXP, INT which was a truncate, not a floor as is the case in most versions, LOG, POS which returned the cursor position, RND, SGN, SIN, SQR, SPC that output a number of space characters and TAB to move to a particular column, FRE to print the amount of free memory and USR to call assembler language routines.[16] Random numbers were based on a series; RND(0) would return the last number without advancing the series, RND(-1) reseeded, and any positive value in the parameter returned the next value in the series.[17]

There were also a number of additional special purpose functions and commands, including PAD which returns the value of the key being held down on the front panel's keypad, and SEG which converted the key value from PAD into a digit that could then be POKEd to the 7-segment display.[18][19] Like Altair BASIC, Benton Harbor also included the OUT statement to write a value to a port number, as the Intel 8080 used numbered I/O ports.[19]

Variables could have a single character or a single character and one digit - two letter names were not allowed.[20]

Extended BASIC

Extended BASIC's primarily notable addition was string variables and a number of functions to operate on strings. String variables were indicated with the $ sign, as in most dialects, and could hold up to 256 characters.[20] String functions included the standard CHR$, STR$, LEFT$, RIGHT$, MID$, ASC and VAL.[21] Concatenation was performed with +.[15] Extended also supported LINE INPUT which read the entire line as a single string instead of interpreting spaces as separators between values.[22]

Another change was that the FRE function supplanted with the command FREE, which printed out a detailed table showing the memory use. PAUSE was modified to take an optional value that would exit the pause state after that amount of time. The internal clock was updated every other millisecond, so this value was in units of 2 ms. The new PORT statement allowed the output of PRINT to be directed to a different device, which made outputting text much easier than using OUT and looping over the string.[13]

Extended also added a number of features intended to make programming easier. Notable was the addition of a second comma-separated input to allow listing a range of lines, like LIST 10,500, also seen on some other dialects like Atari BASIC. Others included BUILD, which in most dialects would be called AUTO, which turned on automatic line numbering. For instance, BUILD 100,10 would result in a "100" being printed automatically after the line was entered, and then every line entered would increment the number by 10; 100, 110, 120 etc. This was turned off by pressing control-C.[23] DELETE allowed a range of lines to be deleted, using the same range format as LIST.[24]

Another addition was the CNTRL command, which had a variety of settings based on a list of numbered entries. CNTRL 0,500, for "setting zero", would set up the system to respond to control-B keypresses by performing a GOSUB to line, in this case, 500. Setting 1 set the number of digits before it would switch to exponent format, 2 controls the updates to the front-panel LED display, 3 sets the width of the "print zones" that are used when printing a list separated by commas (normally 14 characters), and 4 turns the hardware clock on or off.[25] Turning the clock off can speed up programs by as much as 15%.[26]

Finally, a small number of new math functions were added, including MAX and MIN which were provided with a comma-delimited list of number of values, and TAN.[27]


  1. ^ For a lengthy discussion by the original designers on some of these issues, see the S-100 Bus termination and legacy support page.



  1. ^ Surden 1977, p. 35.
  2. ^ a b Zimmerman 1982, p. 16.
  3. ^ a b c d Zimmerman 1982, p. 17.
  4. ^ Moore 1981, p. 122.
  5. ^ Poduska 1979, p. 134.
  6. ^ Moore 1981, p. 125.
  7. ^ Poduska 1979, pp. 134, 135.
  8. ^ a b Manual 1980, p. 5.74.
  9. ^ Manual 1980, p. 5.25.
  10. ^ Manual 1980, p. 5.72.
  11. ^ Manual 1980, pp. 5.27–5.32.
  12. ^ Manual 1980, p. 5.59.
  13. ^ a b Manual 1980, p. 5.89.
  14. ^ Manual 1980, p. 5.84.
  15. ^ a b Manual 1980, p. 5.85.
  16. ^ Manual 1980, p. 5.66.
  17. ^ Manual 1980, p. 5.91.
  18. ^ Manual 1980, pp. 5.64–5.65.
  19. ^ a b Poduska 1979, p. 135.
  20. ^ a b Manual 1980, p. 5.83.
  21. ^ Manual 1980, p. 5.70.
  22. ^ Manual 1980, p. 5.60.
  23. ^ Manual 1980, p. 5.27.
  24. ^ Manual 1980, p. 5.28.
  25. ^ Manual 1980, pp. 5.34–5.36.
  26. ^ Poduska 1979, p. 35.
  27. ^ Manual 1980, p. 5.92.


Further reading