SCELBAL

Last updated

SCELBAL, short for SCientific ELementary BAsic Language, is a version of the BASIC programming language released in 1976 for the SCELBI and other early Intel 8008 and 8080-based microcomputers like the Mark-8. Later add-ons to the language included an extended math package and string handling. The original version required 8 kB of RAM, while the additions demanded at least 12 kB.

Contents

The language was published in book form, with introductory sections followed by flowcharts and then the 8008 assembler code. The book described ways to save more memory, turning off arrays for instance, and how the user could add their own new features to the language.

History

The primary author of SCELBAL is Mark Arnold, who was a high-school student in 1974 when the SCELBI was announced. Arnold was friends with professors at the University of Wyoming (UW), and through them had arranged to have an account on their Sigma 7 mainframe computer. The first version of what became SCELBAL was written for this machine. Later that year, he wrote an 8008 cross compiler on that platform.

Arnold entered UW in 1975 and contacted Nat Wadsworth, one of the founders of SCELBI, pitching the idea of a compiled version of BASIC for their new platform. This would be a multi-pass system that would save the intermediate versions on cassette tape. This would be very tedious to use but would produce programs that would run on the 4 kB 8H models of the system. Wadsworth favored an interpreter, which would require 8 kB, which would be available on the new 8B models of the system. The language used floating point routines published by Wadsworth in 1975 in Machine Language Programming for the 8008 .

It took Wadsworth several months to finally arrange a contract, which included sending Arnold an 8B development system. This significantly delayed the release of the language into 1976. Arnold speculated that, lacking these delays, SCELBAL could have been released at about the same time as Altair BASIC in late 1975. It was first presented in a lengthy article in the second issue of Dr. Dobb's Journal in February 1976. [1]

The release of SCLEBAL was announced in an advertisement in Byte's June 1976 issue. The ad did not specifically link the language to the SCELBI platform, instead, it simply offered itself in book form as a complete source listing to create a version of BASIC on any 8008 or 8080 system with the requisite 8 kB of RAM. The book's price was $49, about $223 in 2020. [2]

Description

SCELBAL used a 32-bit (four byte) floating point format for numeric calculations, with a 23-bit mantissa, 1-bit sign for the mantissa, a 7-bit exponent, and 1-bit sign for the exponent. These were organized in reverse order, with the least significant byte of the mantissa in the first byte, followed by the middle and then most significant byte with the sign in the high bit. The exponent came last, again with the sign in the high bit. [3] The manual provides well-documented assembly code for the entire math package, including entry points and usage notes. [4] 32-bit formats were common in this era, while later versions of BASIC, starting with Microsoft BASIC for the MOS 6502, generally adopted a 40-bit (five byte) format for added precision. [5]

SCELBAL was otherwise similar to other BASIC dialects, including early MS versions like Altair BASIC, lacking string variables and operators and a number of mathematic functions. Other differences were less pronounced. The IF statement had an optional form IF...GOTO that removed the need for THEN, IFX<YGOTO100. [6] It also retained the MS-style short form for the same concept, IFX<YTHEN100. It also allowed conditional execution of other statements, such as IFX<YTHENPRINTX. [7]

The base language did not support string handling, although literal (constant) strings could be used in PRINT, and had the supporting functions of CHR to print non-printable characters, and TAB to provide layout. Oddly, the system required ASCII codes to have the high-bit set, so to convert from normal ASCII to SCELBI character codes, one had to add or subtract 128. For instance, 

PRINT"HELLO";CHR(172);CHR(160);"WORLD"

to produce the string "HELLO, WORLD" in the output. [8]

INPUT would normally read the user-entered text as a number, but allowed the dollar sign to indicate the value should be read as the SCELBI code instead. For instance, INPUT A would read the user input "1" into A as the floating-point value 1, while INPUT A$ would result in A being set to 177, 49 (ASCII for "1") + 128. Additionally, when the dollar sign is used, the traditional "?" prompt is not printed, and command returned to the language as soon as a single character is entered, instead of waiting for the carriage return as in the normal case. [8]

Among the few other differences was that the NEW command found in MS, which clears out existing program code and data, is called SCR for "scratch", [9] and the USR function, which called a machine language routine, was UDF for "user defined function". [10] UDF allowed a single floating-point parameter to be passed to the user-defined function, whose machine-language code must have been loaded into memory at a fixed location ahead of runtime. [11]

Error codes were reduced to two letters, and code for LOAD and SAVE were provided in boilerplate form and expected to be implemented when ported to different platforms. [12] Line numbers could be between 1 and 999999, [10] whereas most BASICs used a 16-bit integer and thus supported lines from 1 to 32767 or 1 to 65535.

Language features

Taken from the 1976 manual unless otherwise noted. [13]

Commands

Immediate-mode only

Referred to as "executive" mode in the documentation.

SCR
scratch, equivalent to MS NEW
LIST
RUN
LOAD
SAVE

Immediate or program mode

PRINT
INPUT
Like MS, could accept multiple variables, INPUTA,B,C. Did not include a prompt string.
LET
Like MS, the LET was optional, so 15LETX=10 and 15X=10 are equivalent.
IF...THEN
IF...GOTO
Alternate form of IF...THEN.
GOTO
It appears the "spaced version", GO TO, was not supported.
GOSUB...RETURN
FOR...TO...STEP...NEXT
As in MS, STEP is optional and assumed to be 1. NEXT required a variable, unlike later MS versions.
REM
END
DIM
Arrays worked as in MS, but were optional and could be turned off to save memory. Only single-dimension arrays were supported, and the total number of elements for all arrays combined was 64 numbers.

Functions

INT
SGN
ABS
SQR
RND
As in MS, takes a dummy variable and returns a value between 0 and 1.
CHR
Note the lack of the $ found in MS, which uses CHR$.
TAB
UDF

Extensions

SCELBI published two extensions to the system, the Mathematical Functions Supplement, and the Strings Supplement.

Math Functions Supplement

The Mathematical Functions Supplement added five new transcendental functions, SIN, COS, EXP, LOG, and ATN. [14]

String Supplement

The String Supplement was somewhat larger than the Math Functions, including a number of new features.

Strings could be up to 80 characters long, and the system could hold a total of 64 string variables. Any one of those 64, or all of them, could be one-dimensional arrays, but the total number still had to be 64 strings in total. Oddly, string arrays did not require a DIM statement. [15]

In contrast to MS BASIC, and the Dartmouth BASIC string handling that inspired it, SCELBI used the "slicing" style of string manipulation found in contemporary BASICs like SDS BASIC, HP Time-Shared BASIC and Northstar BASIC, or the later Atari BASIC. Instead of using functions like LEFT$, RIGHT$, MID$ to access substrings, the array-access syntax was used with a colon preceding the starting point and optionally a semicolon preceding the length. As SCELBAL also supported string arrays, the first number in the array accessors was the array index, and was optional if the variable was not an array. So, for instance, the code: [15] 

10LETA$="HELLO"20PRINTA$(:2;3)

would result in "ELL" being printed to the output. If an array was used the syntax required the array index in the first parameter: [15] 

100LETA$(1)="HELLO"150LETA$(2)="WORLD"200PRINTA$(2:2;3)

would result in "ORL" being printed to the output. SCELBAL also allowed omitting the semicolon, which specifies the characters from the starting point to the end of the string. So, for instance, the code:

210PRINTA$(2:2)

would result in "ORLD" being printed to the output.

Although similar to SDS BASIC, there is a major difference in the way this works in comparison to the other BASICs that used slicing syntax, in that the last parameter is the length, not a position. For instance, in Atari BASIC the similar-looking code: [16] 

20PRINTA$(2,3)

would instead output "EL", as the instruction translates to "print all characters between positions 2 and 3". In this fashion, SCELBAL works in a fashion more similar to MS BASIC, where the equivalents would be: [17] 

20PRINTMID$(A$,2,3)

and

210PRINTRIGHT$(A$(2),2)

To add full support for strings, the Supplement replaced the original CHR with CHR$, which matched the syntax of its MS counterpart. [15] Likewise, INPUT was modified so string variables worked like numeric ones, waiting for the carriage return and then assigning the entire user input to the associated string variable. [18] It also added the support functions LEN and ASC, [15] and VAL$ to convert a string containing a numeric value to a string representation of that number. As in MS, concatenation used the + operator. [18]

Related Research Articles

Applesoft BASIC is a dialect of Microsoft BASIC, developed by Marc McDonald and Ric Weiland, supplied with the Apple II series of computers. It supersedes Integer BASIC and is the BASIC in ROM in all Apple II series computers after the original Apple II model. It is also referred to as FP BASIC because of the Apple DOS command used to invoke it, instead of INT for Integer BASIC.

BASIC Family of programming languages

BASIC is a family of general-purpose, high-level programming languages designed for ease of use. The original version was created by John G. Kemeny and Thomas E. Kurtz at Dartmouth College in 1964. They wanted to enable students in non-scientific fields to use computers. At the time, nearly all computers required writing custom software, which only scientists and mathematicians tended to learn.

PureBasic

PureBasic is a commercially distributed procedural computer programming language and integrated development environment based on BASIC and developed by Fantaisie Software for Windows, Linux, and macOS. An Amiga version is available, although it has been discontinued and some parts of it are released as open-source. The first public release of PureBasic for Windows was on 17 December 2000. It has been continually updated ever since.

Tiny BASIC is a family of dialects of the BASIC programming language that can fit into 4 or fewer KBs of memory. Tiny BASIC was designed in response to the open letter published by Bill Gates complaining about users pirating Altair BASIC, which sold for $150. Tiny BASIC was intended to be a completely free version of BASIC that would run on the same early microcomputers.

GRASS is a programming language created to script 2D vector graphics animations. GRASS was similar to BASIC in syntax, but added numerous instructions for specifying 2D object animation, including scaling, translation and rotation over time. These functions were directly supported by the Vector General 3D graphics terminal GRASS was written for. It quickly became a hit with the artistic community who were experimenting with the new medium of computer graphics, and is most famous for its use by Larry Cuba to create the original "attacking the Death Star will not be easy" animation in Star Wars (1977).

Atari BASIC

Atari BASIC is an interpreter for the BASIC programming language that shipped with the Atari 8-bit family of 6502-based home computers. Unlike most BASICs of the home computer era, Atari BASIC is not a derivative of Microsoft BASIC and differs in significant ways. It includes keywords for Atari-specific features and lacks support for string arrays, for example.

Microsoft BASIC is the foundation software product of the Microsoft company and evolved into a line of BASIC interpreters adapted for many different microcomputers. It first appeared in 1975 as Altair BASIC, which was the first version of BASIC published by Microsoft as well as the first high-level programming language available for the Altair 8800 microcomputer.

Integer BASIC is a BASIC interpreter written by Steve Wozniak for the Apple I and Apple II computers. Originally available on cassette for the Apple I in 1976, then included in ROM on the Apple II from its release in 1977, it was the first version of BASIC used by many early home computer owners.

Commodore BASIC, also known as PET BASIC or CBM-BASIC, is the dialect of the BASIC programming language used in Commodore International's 8-bit home computer line, stretching from the PET of 1977 to the C128 of 1985.

BASIC-PLUS is an extended dialect of the BASIC programming language that was developed by Digital Equipment Corporation (DEC) for use on its RSTS/E time-sharing operating system for the PDP-11 series of 16-bit minicomputers in the early 1970s through the 1980s.

HP Time-Shared BASIC is a BASIC programming language interpreter for Hewlett-Packard's HP 2000 line of minicomputer-based time-sharing computer systems. TSB is historically notable as the platform that released the first public versions of the game Star Trek.

Color BASIC is the implementation of Microsoft BASIC that is included in the ROM of the Tandy/Radio Shack TRS-80 Color Computers manufactured between 1980 and 1991. BASIC is a high level language with simple syntax that makes it easy to write simple programs. Color BASIC is interpreted, that is, decoded as it is run.

Galaksija BASIC was the BASIC interpreter of the Galaksija build-it-yourself home computer from Yugoslavia. While being partially based on code taken from TRS-80 Level 1 BASIC, which the creator believed to have been a Microsoft BASIC, the extensive modifications of Galaksija BASIC—such as to include rudimentary array support, video generation code and generally improvements to the programming language—is said to have left not much more than flow-control and floating point code remaining from the original.

FutureBASIC

FutureBasic is a free BASIC compiler for Apple Inc.'s Macintosh.

SCELBI

SCELBI was an early model of microcomputer based on the Intel 8008 processor. The company SCELBI Computer Consulting in 1973, by Nat Wadsworth. The SCELBI 8H was marketed in 1974 and was delivered either as an assembled unit or as a kit, with five basic circuit boards and provision for memory expansion to 16 kB. The company offered input/output devices including a keyboard, teleprinter interface, alphanumeric oscilloscope interface, and a cassette tape interface for data storage. The basic system only used a front panel with 11 switches and LEDs for input and output.

SUPER BASIC, sometimes SBASIC for short, is an advanced dialect of the BASIC programming language offered on Tymshare's SDS 940 systems starting in 1968 and available well into the 1970s.

Data General Extended BASIC, also widely known as Nova Extended BASIC, was a BASIC programming language interpreter for the Data General Nova series minicomputers. It was based on the seminal Dartmouth BASIC, including the Fifth Edition's string variables and powerful MAT commands for matrix manipulation. In contrast to the compile-and-go Dartmouth BASIC, Extended BASIC was an interpreter.

SDS BASIC, also known as CP-V BASIC, Batch BASIC or Sigma BASIC depending on the version, is a BASIC programming language compiler for Scientific Data Systems's (SDS) Sigma series mainframe computers, originally released in 1967. Xerox purchased SDS in 1969 and began rebranding it as Xerox Data Systems, and finally just Xerox, at which time the language became known as Xerox BASIC.

BASIC interpreter Interpreter that enables users to enter and run programs in the BASIC language

A BASIC interpreter is an interpreter that enables users to enter and run programs in the BASIC language and was, for the first part of the microcomputer era, the default application that computers would launch. Users were expected to use the BASIC interpreter to type in programs or to load programs from storage.

Wang BASIC is a series of BASIC programming languages for computers from Wang Laboratories. The term can be used to refer to the BASIC on any Wang machine, but is mostly associated with the versions on the Wang 2200 minicomputer series of the early 1970s. When these machines were updated to the VP series in 1976, BASIC-2 was introduced and remained the pattern for future machines in the 2200 series. A planned BASIC-3 was never released.

References

Citations

  1. ↑ Arnold, Mark; Wadsworth, Nat (February 1976). "SCELBAL - A Higher Level Language for 8008/8080 Systems". Dr. Dobb's Journal. pp. 30–53.
  2. ↑ "Shocking!". Byte. June 1976. p. 47.
  3. ↑ Arnold & Wadsworth 1976, p. 10.1.
  4. ↑ Arnold & Wadsworth 1976, p. 10.
  5. ↑ Steil, Michael (20 October 2008). "Create your own Version of Microsoft BASIC for 6502".
  6. ↑ Arnold & Wadsworth 1976, p. 14.10.
  7. ↑ Arnold & Wadsworth 1976, p. 2.3.
  8. 1 2 Arnold & Wadsworth 1976, p. 14.16.
  9. ↑ Arnold & Wadsworth 1976, p. 14.1.
  10. 1 2 Arnold & Wadsworth 1976, p. 14.17.
  11. ↑ Arnold & Wadsworth 1976, p. 14.3.
  12. ↑ Arnold & Wadsworth 1976, p. 14.18.
  13. ↑ Arnold & Wadsworth 1976.
  14. ↑ Math 1977, p. 1.
  15. 1 2 3 4 5 Strings 1977, p. 1.
  16. ↑ Small, David, ed. (1983). "Atari Strings and Text Handling". The Creative Atari. Creative Computing.
  17. ↑ Strings 1977, p. 3.
  18. 1 2 Strings 1977, p. 2.

Bibliography

This page is based on this Wikipedia article
Text is available under the CC BY-SA 4.0 license; additional terms may apply.
Images, videos and audio are available under their respective licenses.