View source for SCELBAL

{{Short description|1976 programming language}}
'''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 [[Intel 8080|8080]]-based [[microcomputer]]s like the [[Mark-8]]. Later add-ons to the language included an extended math package and [[String (computer science)|string handling]]. The original version required 8&nbsp;kB of [[random access memory|RAM]], while the additions demanded at least 12&nbsp;kB.

The language was published in book form, with introductory sections followed by [[flowchart]]s 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 [[SDS Sigma series|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 [[compiler|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&nbsp;kB 8H models of the system. Wadsworth favored an [[BASIC interpreter|interpreter]], which would require 8&nbsp;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 ''[http://www.scelbi.com/files/docs/books/Machine%20Language%20Programming%20For%20The%208008.pdf 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.<ref>{{cite magazine |magazine=Dr. Dobb's Journal |date=February 1976 |title=SCELBAL - A Higher Level Language for 8008/8080 Systems |first1=Mark |last1=Arnold |first2=Nat |last2=Wadsworth |url=https://archive.org/details/dr_dobbs_journal_vol_01/page/n31/mode/2up |pages=30–53|ref=none}}</ref>

The release of SCLEBAL was announced in an advertisement in [[Byte magazine|''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&nbsp;kB of RAM. The book's price was $49, about ${{inflation|US|49|1976}} in {{Inflation/year|US}}.<ref>{{cite magazine |magazine=Byte |date=June 1976 |title=Shocking! |page=47 |url=https://archive.org/details/byte-magazine-1976-06/page/n47}}</ref>

==Description==
SCELBAL used a 32-bit (four byte) [[floating point]] format for numeric calculations, with a 23-bit [[mantissa (logarithm)|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.{{sfn|Arnold|Wadsworth|1976|p=10.1}} The manual provides well-documented [[assembly code]] for the entire math package, including entry points and usage notes.{{sfn|Arnold|Wadsworth|1976|p=10}} 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.<ref>{{cite web |url=https://www.pagetable.com/?p=46 |title=Create your own Version of Microsoft BASIC for 6502 |date=20 October 2008 |first=Michael |last=Steil}}</ref>

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 {{code|IF}} statement had an optional form {{code|IF...GOTO}} that removed the need for {{code|THEN}}, {{nowrap|{{code|2=basic|IF X<Y GOTO 100}}.{{sfn|Arnold|Wadsworth|1976|p=14.10}}}} It also retained the MS-style short form for the same concept, {{nowrap|{{code|2=basic|IF X<Y THEN 100}}.}} It also allowed conditional execution of other statements, such as {{code|2=basic|IF X<Y THEN PRINT X}}. {{sfn|Arnold|Wadsworth|1976|p=2.3}}

The base language did not support string handling, although literal (constant) strings could be used in {{code|PRINT}}, and had the supporting functions of {{code|CHR}} to print non-printable characters, and {{code|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, {{sxhl|2=basic|PRINT "HELLO";CHR(172);CHR(160);"WORLD"}} to produce the string "HELLO, WORLD" in the output.{{sfn|Arnold|Wadsworth|1976|p=14.16}}

{{code|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, {{code|INPUT A}} would read the user input "1" into A as the floating-point value 1, while {{code|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.{{sfn|Arnold|Wadsworth|1976|p=14.16}}

Among the few other differences was that the {{code|NEW}} command found in MS, which clears out existing program code and data, is called {{code|SCR}} for "scratch",{{sfn|Arnold|Wadsworth|1976|p=14.1}} and the {{code|USR}} function, which called a [[machine language]] routine, was {{code|UDF}} for "user defined function".{{sfn|Arnold|Wadsworth|1976|p=14.17}} {{code|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.{{sfn|Arnold|Wadsworth|1976|p=14.3}}

Error codes were reduced to two letters, and code for {{code|LOAD}} and {{code|SAVE}} were provided in boilerplate form and expected to be implemented when ported to different platforms.{{sfn|Arnold|Wadsworth|1976|p=14.18}} Line numbers could be between 1 and 999999,{{sfn|Arnold|Wadsworth|1976|p=14.17}} 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.''{{sfn|Arnold|Wadsworth|1976}}

===Commands===
====Immediate-mode only====
Referred to as "executive" mode in the documentation.

; {{code|SCR}} : scratch, equivalent to MS {{code|NEW}}
; {{code|LIST}} : 
; {{code|RUN}} : 
; {{code|LOAD}} : 
; {{code|SAVE}} : 

====Immediate or program mode====
; {{code|PRINT}} : 
; {{code|INPUT}} : Like MS, could accept multiple variables, {{code|INPUT A,B,C|basic}}. Did not include a prompt string.
; {{code|LET}} : Like MS, the {{code|LET}} was optional, so {{code|15 LET X{{=}}10|basic}} and {{code|15 X{{=}}10|basic}} are equivalent.
; {{code|IF...THEN}} : 
; {{code|IF...GOTO}} : Alternate form of {{code|IF...THEN}}.
; {{code|GOTO}} : It appears the "spaced version", {{code|GO TO}}, was not supported.
; {{code|GOSUB...RETURN}} : 
; {{code|FOR...TO...STEP...NEXT}} : As in MS, {{code|STEP}} is optional and assumed to be 1. {{code|NEXT}} required a variable, unlike later MS versions.
; {{code|REM}} : 
; {{code|END}} : 
; {{code|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===
; {{code|INT}} : 
; {{code|SGN}} : 
; {{code|ABS}} : 
; {{code|SQR}} : 
; {{code|RND}} : As in MS, takes a dummy variable and returns a value between 0 and 1.
; {{code|CHR}} : Note the lack of the $ found in MS, which uses {{code|CHR$}}.
; {{code|TAB}} : 
; {{code|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 function]]s, {{code|SIN}}, {{code|COS}}, {{code|EXP}}, {{code|LOG}}, and {{code|ATN}}.{{sfn|Math|1977|p=1}}

===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 {{code|DIM}} statement.{{sfn|Strings|1977|p=1}}

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 {{code|LEFT$}}, {{code|RIGHT$}}, {{code|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:{{sfn|Strings|1977|p=1}}
{{sxhl|2=basic|1=
10 LET A$="HELLO"
20 PRINT A$(: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:{{sfn|Strings|1977|p=1}}
{{sxhl|2=basic|1=
100 LET A$(1)="HELLO"
150 LET A$(2)="WORLD"
200 PRINT A$(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:
{{sxhl|2=basic|1=
210 PRINT A$(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:<ref>{{cite encyclopedia |url=https://www.atariarchives.org/creativeatari/Atari_Strings_and_Text_Handling.php |title=Atari Strings and Text Handling |encyclopedia=The Creative Atari |publisher=Creative Computing |editor-first=David |editor-last=Small |date=1983}}</ref>
{{sxhl|2=basic|1=
20 PRINT A$(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:{{sfn|Strings|1977|p=3}}
{{sxhl|2=basic|1=
20 PRINT MID$(A$,2,3)
}}
and
{{sxhl|2=basic|1=
210 PRINT RIGHT$(A$(2),2)
}}

To add full support for strings, the Supplement replaced the original {{code|CHR}} with {{code|CHR$}}, which matched the syntax of its MS counterpart.{{sfn|Strings|1977|p=1}} Likewise, {{code|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.{{sfn|Strings|1977|p=2}} It also added the support functions {{code|LEN}} and {{code|ASC}},{{sfn|Strings|1977|p=1}} and {{code|VAL$}} to convert a string containing a numeric value to a string representation of that number. As in MS,  [[concatenation]] used the {{code|+}} operator.{{sfn|Strings|1977|p=2}}

==References==
===Citations===
{{reflist}}

===Bibliography===
*{{cite book |title=SCELBAL: A higher level language for 8008/8080 systems  |first1=Mark |last1=Arnold |first2=Nat |last2=Wadsworth |publisher=SCELBI Computer Consulting |date=1976 |url=http://www.scelbi.com/files/docs/scelbal/SCELBAL.pdf }}
*{{cite book |title=SCELBAL Mathematical Functions Supplement |first=Mark |last=Arnold |publisher=SCELBI Computer Consulting |date=1977 |ref=CITEREFMath1977}}
*{{cite book |title=SCELBAL Strings Supplement |first=Mark |last=Arnold |publisher=SCELBI Computer Consulting |date=1977 |ref=CITEREFStrings1977}}

===External links===
* [http://www.xlnsresearch.com/scelbal.htm<!-- https://web.archive.org/web/20200608063535/http://www.xlnsresearch.com/scelbal.htm --> A javascript simulator of 8008 preloaded with SCELBAL]
* [http://www.xlnsresearch.com/scelbalStrMath.htm<!-- https://web.archive.org/web/20200710214037/http://www.xlnsresearch.com/scelbalStrMath.htm --> A javascript simulator of 8008 preloaded with SCELBAL, Math and String Supplements]
* [https://scelbal.github.io An improved javascript simulator preloaded with SCELBAL]
* [http://www.scelbi.com/files/software/scelbal.hex Object code for Published SCELBAL in Intel Hex format ]
* [http://www.willegal.net/scelbi/scelbal.html Mike Willegal's SCELBAL page]
* [http://www.willegal.net/scelbi/scelbiapp.html Mike Willegal's SCELBI OS/X Emulator which can run SCELBAL]

{{BASIC}}

[[Category:BASIC interpreters]]
[[Category:BASIC programming language family]]