Full BASIC

Full BASIC,sometimes known asStandard BASICorANSI BASIC,is aninternational standarddefining a dialect of theBASIC programming language.It was developed by theAmerican National Standards Institute(ANSI) X3.60 group in partnership with the EuropeanECMA.It describes an advanced version of BASIC with many features includingstructured programming,matrix math,input/outputforfile handling,and many other options.

ANSI's BASIC standardization was a two-stage process. The first, carried out asMinimal BASICstarting in 1974, was an effort to clearly define and standardize the originalDartmouth BASIClanguage so it could be correctly implemented on different platforms. After its release in late 1977, attention turned to Full BASIC which would be based on the more powerful Structured BASIC being developed atDartmouth College.The complexity of the system and the many additions promoted by members of the standards committee led to the effort bogging down and the first draft standard was not ready until 1986, four years late.

The standard was ratified on 26 June 1986 asECMA-116and January 1987 asANSI X3.113-1987.It was completely ignored; themicrocomputerrevolution had occurred while the specification was being argued over, and by the early-1980sMicrosoft BASICrunning on tens of millions ofhome computershad already come and gone. Watching the process drag on, the Dartmouth participants left to produceTrue BASICbased on parts of the standard, but this saw little use.De factostandards like Microsoft's dominated the market and formed the basis for newer languages likeMicrosoft Visual Basicwhich incorporated similar concepts.

History

Minimal BASIC

Main article:Minimal BASIC

The introduction ofDartmouth BASICin 1964 combined a number of emerging concepts in the computer field, includingtimesharingand direct interaction with the user, known at the time as a "conversational interface".General Electric,who supplied theGE 235mainframecomputer it ran on, used a modified version of Dartmouth's system to start aservice bureauwhich would eventually evolve into theGEnieonline service.Many other companies,TymshareandCompuServenotable among them, quickly introduced hosted BASIC services of their own, following the Dartmouth model.

In 1968,Hewlett-Packard(HP) introduced theHP 2000seriesminicomputers,which offered the same features of the earlier mainframe systems in a rack-mount system that could be configured in a complete form for around $100,000 (equivalent to $876,172 in 2023).TheirHP Time-Shared BASIChad a number of differences from Dartmouth,and these were soon copied by other mini vendors likeData General.One holdout wasDigital Equipment Corporation(DEC), who did not introduce a BASIC of their own design until 1972. This version,BASIC-PLUSwas different from either the HP or Dartmouth dialects. By the early 1970s where were three major dialects and dozens of minor variations being used in the market.

In January 1974 a new group formed under the ANSI umbrella to define a single standard BASIC.The Dartmouth team formed a core part of the group. Dartmouth was working on a greatly expanded version of BASIC known as Structured BASIC (SBASIC) which became the basis for ANSI. At the time, few other dialects supported its many new features. The group decided that a complete standard based on SBASIC would take some time to agree on, so the ANSI BASIC effort was split into two milestones. The first,Minimal BASIC,would produce a standard that included only the most basic features that would be required of any implementation. Even long-supported features from Dartmouth likematrix mathwould be left out. The draft standard for Minimal BASIC was released in January 1976, the final draft in July 1977, and it was ratified that December.Arthur Luehrmann,a physicist fromDartmouth Collegewho was a proponent of BASIC and part of the ANSI group later stated:

"X3J2's first few years were spent (in hindsight, some might say 'wasted') on standardizing what amounts to the original 1964 Dartmouth Basic... Minimal Basic was more a toy than an actual language."

Full BASIC

The group then turned their attention to Full BASIC. By this time themicrocomputerrevolution was in full flight, and millions of machines runningMicrosoft BASICor a similar BASIC were entering the market.In spite of this, none of the participants were microcomputer vendors or suppliers. Instead, the participants remainedmainframevendors likeIBM,Control DataandGeneral Electric,minicomputervendors likeDigital Equipment Corporation(DEC),Data GeneralandWang Laboratories,and other very large companies like3M,American ExpressandKodak.

The effort immediately ran afoul of thesecond-system effectas every member began to add their own list of "must have" features. Some wanted the language to continue the tradition of being aimed at educational uses running on small machines and desired a simple language with only rudimentary file support and similar features. Others weremainframeusers that wanted to support loadable modular programs and other expansive programming features to compete with languages likeCOBOLorFORTRANwhile offering betterstring manipulation.A third group was primarily interested in business applications, especially European users where BASIC had become a primary business language, and they demanded the system include extensive file handling and decimal math that did not suffer from rounding problems.

John G. KemenyandThomas E. Kurtz,the original designers of BASIC and members of the ANSI group, were critical of the process. In a 1982 article, Kurtz wrote about how even seemingly small issues had turned into major controversies. He used the example of theOPTION BASEstatement. When arrays were first added to BASIC, they started at index 1, such thatDIM A(3)made an array with three slots, 1, 2 and 3. In some cases, an index 0 is more natural, soOPTION BASE 0was added in later versions of the Dartmouth code so the same definition would have four slots, 0 to 3. During Minimal, there was continual debate about what the default base should be, and 0 was finally selected. Five years later, during the Full efforts, it was decided that arrays could define any lower bound using new syntax,DIM YEAR(1970 TO 1990).This eliminated the demand forOPTION BASE 0and the decision was made to change the default to 1 again.

Initially, the X3.60 group was targeting a summer 1982 date for the first technical review copy, which would be sent to the ANSI X3 committee in the fall. During this period the proposed standard would be sent out, and comments from the public would be accepted. The final draft would be sent back to X3 in 1983 for ratification that year.This proved rather optimistic. The first draft was not released until January 1985and the final draft in 1986 for ratification in January 1987.During this time, the standard grew so large that it was ultimately split into a core module and five optional add-ons, which included complex file handling, real-time computing support, fixed decimal math, optional editing commands and even a platform-independent graphics module.

The result was criticized during the public comment period. One reviewer noted it had grown so large that "the resulting language rivals any current programming language in complexity" and that "conforming to the entire standard would compare with the most substantial compiler projects ever attempted".It goes on to describe, for instance, how there are no less than five different ways to describe a subroutine, three to define a string's maximum length and two ways to define an array.Referring to the issue of array bounds, it is noted that the committee agreed the adopted solution was "intolerable" and made plans to fix it "later".

There is no evidence that any of the participants actually built a conforming version after the release of the standard and any mention of ongoing effort promptly disappears. From 1987, the only mentions of the standard are that it exists and that True BASIC encompassed some of its features. Additionally, with millions of micros running some variation of MS'sde facto standardby this point, the new ANSI standard was seen as the non-standard solution.Much of the original success of BASIC on the micro platforms was that it allowed programs to be typed in from printedsource code,but by the mid-1980s this had been replaced byshrinkwrapapplications and the need for BASIC as a distribution system had faded.On the large-systems side, the original use as a teaching language was being increasingly replaced byPascal,as the external problems BASIC aimed to address, like interactivity and online editing, were now available in most systems.

True BASIC

The standards process was so slow that even the author of Structured BASIC eventually gave up on it. Stephen Garland was asked to prepare a series ofCollege Boardtests for high school students, and wrote them inPascalinstead. This was somewhat controversial given that many computers in wide use, like theCommodore 64andTRS-80did not have a full implementation of Pascal. Luehrmann, was critical of the effort, suggesting a more general course that would be applicable to more students.

It became clear to the Dartmouth participants in the ANSI group that the effort had no hope of being completed in any reasonable time period. They left the effort and started a new company to bring their version of the language to market asTrue BASIC.True BASIC combined many of the features of the core standard but also made a number of changes of its own. Among the most notable was that line numbering was now optional. The language was not well received, with many reviews expressing the same concerns about feature bloat that had been raised about the Full BASIC standard.Jerry Pournellederided it as "madness"andJohn Dvorakdismissed it as "sad" and "doomed to failure."

Description

Program editing

Like previous versions of BASIC, Full BASIC was designed to work in aline editorenvironment and thus usesline numbersto indicate individual or ranges of lines to be edited or removed. Line numbers could range from 1 to 50,000, in contrast to Minimal which was 0 through 9999. This meant that valid Minimal programs using line 0 were invalid in Full. Logical lines were at least 132 characters long. Logical lines could be extended across several physical lines using the "continuation character", the ampersand. Unfortunately, the ampersand was also selected as the string concatenation operator, which complicated the parser.

Additional editing commands includedRENUMBERandDELETE,which by this time were common on newer microcomputer dialects. A new concept wasEXTRACT,which copied a range of lines into a new file and deleted them from the original program, allowing them to be extracted to a subprogram.These could then be invoked using theCHAINcommand.CHAINcould also include an optionalWITHfollowed by a list of parameters, in which case it was expected to return a value in a variable with the same name as the program (see "Structure", below).

Basic functionality

Many of the commonly used keywords found in Minimal or other dialects remained;PRINT,INPUT,DATAandREADfor instance. There were numerous minor changes to these commands. For instance, at edit time keywords can be typed in upper or lower case, or any mixture. As was the case in the past, they were normally displayed in uppercase, while a new convention was to usesnake casefor multi-character variable names.

Dartmouth BASIC introduced theREMstatement for in-line comments and this was universally supported in other dialects. Many dialects also added a short-form, most commonly using the single-quote,',as seen in Microsoft BASIC. For Full, they selected the exclamation mark,!for this role,although there appears to be no reason not to use the single quote as it is not otherwise used - strings do not allow single-quote delimiters for instance.A more controversial change was that theLETkeyword was now required for all assignments in order to make the parsing simpler, whereas in every other dialectLETwas optional. This included Minimal, so any Minimal code using this short-cut was incompatible with Full.

On top of the relatively small set of 23 keywords and 11 functions from Minimal, Full added dozens of its own, for a total of 176 keywords (defining 161 separate concepts), 38 mathematical functions and 14 string functions if all extensions were included.A simple list of the keywords, laid out in three columns, fills two pages in the standards document.

Structure

The major difference between Full and Minimal was the addition of block-oriented structured programming constructs. In Minimal, and most BASIC interpreters, the program logically consisted of independent lines of code and one could start execution at any point byGOTOing any line number. The only exception to this rule was theFOR...NEXTloop, where all of the lines from the FOR to NEXT were logically considered to be a single block of code. Branching into or out of a FOR block would result in odd behaviour, typically implementation dependant but generally some form of error like "NEXT WITHOUT FOR".

In Full, branching into a FOR...NEXT block is not allowed, nor is branching out without using theEXITstatement. Implementations were supposed to check for such statements and disallow them, for instance, finding cases where to codeGOTOed into a loop. Checking for such code is difficult in an interpreter which normally examines the program line-by-line; checking for branches into a block from other code in the program would normally require whole-program parsing like a compiler.

In Full, several existing keywords were extended, and others added, to provide additional block structures. Notable was the multi-lineIF...THEN...ELSE...END IF,which allowed multiple lines of code to run if the condition was met or failed.SELECT...CASE...CASE ELSE...END SELECTwas added to make decision trees,which formerly would have been implemented using theON...GOTOor multipleIFs to select a line to run.FOR...NEXTloops remained as they were in Minimal, but a newDO...LOOPwas added with top testedDO WHILE...LOOPand bottom testedDO...LOOP UNTIL...varieties. All loops could now be safely exited using theEXIT FORandEXIT DOcommands.

On top of these changes to the block structures, Full also added keywords for defining procedures, functions and program blocks. Programs as a whole were now opened with the optionalPROGRAMkeyword followed by a program name, and ended, as before, withEND.Routines could be constructed withSUB...END SUBand called usingCALL name.Multi-line functions were created withFUNCTION...END FUNCTIONand did not declare a return type as that was part of the name - string function names ended with the dollar sign. The return value was provided by setting a variable to the same name as the function, for instance, a function named "DOIT" would contain a line likeLET DOIT=1.Functions could call other functions and themselves, meaning that the language was naturallyrecursive.Full also retained the earlier style of one-line function definitions using theDEFkeyword, but removed the requirement for the function name to start with "FN". For instance,DEF AVERAGE(X,Y)=(X+Y)/2.

In previous BASICs, there was no concept ofscopeand all variables wereglobal.This is not adequate for the construction of large modular programs, as one section of code may have been written using common variable names likeIand might change the value of that variable. As the variable is global, it retains the modified value when it returns to the original code. A key concept of structured programming is thelocal variable,which holds its value separate from other variables with the same name in other locations in the composite program. As BASIC did not have the concept of scope, many programs relied on the global behaviour and used variables to pass information in and out of subroutines. To allow both concepts in the new language, Full BASIC added theEXTERNALkeyword that could be added to a function or subroutine and made any variables within in local.As BASIC programs generally placed subroutines at the end of the program's source code, theDECLAREkeyword was added to provideforward declarations.

Data types and variables

Full BASIC introduced long variable names, finally breaking free of the single letter or letter-digit names of the past. It set the new limit at 31 characters. One minor downside to this change was that keywords had to have spaces between them, whereas most earlier versions allowed the spaces to be left out. This was because with single-letter names a line likeFORS=1TOAcan be parsed as "FORS", which can not possibly be a variable in a two-letter variety of BASIC. In Full, this would have to be typedFOR S=1 TO Abecause "FORS" is a valid variable name.As was the case in earlier BASICs, data types in Full were denoted by suffixes on the variable name. Minimal had avoided this issue by only having numeric variables, but Full included strings as well, denoted using the dollar-sign, for instanceA$.

Full BASIC required decimal math for the default implementation of thefloating pointsystem. As this was not universally supported in hardware, especially on minis and micros, it also added theOPTION ARITHMETIC NATIVEwhich indicates that math should be carried out using the system's default floating point implementation, whatever that may be. It can be returned to BCD mode withOPTION ARITHMETIC DECIMAL.This is in addition to the fixed-point math option, if installed. Numeric and string variables otherwise worked like those in other BASICs.

A new addition was the fixed-point math extension, which allowed variables to have specified accuracy. This was turned on using the commandOPTIONAL ARITHMETIC FIXEDfollowed by an asterisk and a format specifier, for instance,OPTION ARITHMETIC FIXED*8.2would set all numeric variables to have 8 digits of accuracy and two decimal places. Such a declaration must be placed before any mathematics code in the rest of the program.Furthermore, any single variable could be individually defined using something likeDECLARE NUMERIC*8.2 A, B.

Most BASICs supported the construction of array variables using theDIMkeyword, for instance,DIM A(5), B(2,2)defines two arrays, the single-dimension A and two-dimension (matrix) B. In Full BASIC, the lower bound of any array was normally 1, so in this case, the variable A has five "slots", numbered 1 though 5. UsingOPTION BASE 0above this declaration would add another slot at index 0.Full also added a new system to directly specify the lower and upper bounds using theTOkeyword, for instance,DIM A(100 TO 200)which makes a one-dimensional 101-slot array.To further confuse matters,DECLARE NUMERICcould also be used to create arrays; the same dimensions as the last example could be created withDECLARE NUMERIC A(100 TO 200).

Mathematics, logic and matrices

The list of supported math operators included all of those from Minimal,+,-,*,/and^.The newMODfunction returns the remainder of an integer division. The list of logical operators was expanded,AND,ORandNOThad been removed from Minimal and now re-added, and the alternative forms of comparison operators were added,=<,=>and><.

The list of primary built-in functions remained similar to previous versions of BASIC, including common examples likeSQRorABS.Trig functions were expanded to includeASIN,ACOS,ATN,COT,CSCandSEC.The newANGLEfunction returned the angle between the origin and a given X,Y point. BASIC normally calculated angles in radians, butOPTION ANGLE DEGREESwould convert all parameters and outputs to degrees, and the system exposed thePIfunction which was used in these conversions and elsewhere.

Dartmouth BASIC had introduced matrix operations relatively early in its evolution, and these were part of Full. Theseoverloadthe existing math functions, so one can multiply two arrays usingMAT A=A*Bor multiply the contents of an array by a scalar if the B parameter is not an array. The system also adds several array-only functions, which includesZERo,INVert andDETerminate, among others. The addition of matrix math also requires modification of existing keywords likePRINTandINPUT,which output or input multiple elements as needed to fill the array parameter.

Matrixes may be redimensioned as part of aMAT INPUTby specifying the new bounds, likeMAT INPUT A(3.3).The new dimensions must have a total number of elements equal or smaller than the originalDIM,so in this example if the original definition wasDIM A(2,2),the input would cause an error.

Strings

Early versions of Dartmouth BASIC did not include string variables or manipulation, the only strings in a program were constants likePRINT "HELLO, WORLD!".Version 4, of 1968, added string variables and a single method to manipulate them,CHANGE,which converted strings to and from an array containing theASCIIvalues of the characters. For instance,CHANGE "HELLO, WORLD!" TO Awould produce an array of values in A, where A(0) was 72, the decimal ASCII value for "H". This made string manipulation fairly difficult, for instance, to extract the "HELLO" from "HELLO, WORLD!", one would have to:

10A$="HELLO, WORLD!"
20DIMA(25),B(5)
30CHANGEA$TOA
40FORI=1TO5
50B(I)=A(I)
60NEXTI
70CHANGEBTOB$

Many dialects of BASIC had added their own methods of performing more useful string manipulation to avoid such complication. For Full BASIC, the committee selected a variation on the concept introduced by HP, "string slicing". This concept treats the string as an array of characters and can access them using an array-like specification known as a"slice".To extract "HELLO" from "HELLO, WORLD" in Full, one would useB$=A$(1:5).The concept is similar to that ofCHANGE,but this method produces results that are themselves strings, not numeric values, and thus one canPRINT B$to produce "HELLO". One significant difference between Full's approach and previous ones like HP is that it used a different syntax for the slicing, whereas the earlier systems used array syntax. For instance, in HP, the equivalent line isB$=A$(1,5).As this is the same syntax as array accesses, HP (and similar) generally did not allow string arrays,whereas this was allowed in Full.

This approach should be contrasted with the solution selected by DEC, the use of functions that return new strings,LEFT$,MID$andRIGHT$.This was the solution picked up by Microsoft when they wrote their BASIC on thePDP-10.Converting between the two can be error prone, to perform the equivalent ofRIGHT$(n),Full would useDEF Right$(A$, n) = A$(Len(A$)-n+l).

Input/Output

Another area of focus for Full BASIC wasinput/output(I/O). Minimal BASIC's only I/O was theINPUTandPRINTcommands and the ability to hard-code data using theDATAstatements andREADit. Almost all practical dialects addedOPENandCLOSEto create a "channel" that was then used to refer to that particular file or device.

INPUTnow included an optionalPROMPT,followed by a string, a colon and then the input variables, for instanceINPUT PROMPT "What is your age?": A.By this time almost all BASICs included a similar feature without the wordPROMPTand using the existing print separator semicolon instead of colon, for instance in MS BASIC the same line would beINPUT "What is your age?"; A.On top of this, Full also added the newTIMEOUTandELAPSEDkeywords:INPUT TIMEOUT 30, ELAPSED T, PROMPT "What is your age?": A,which will continue execution after 30 seconds even if the user enters nothing, and will put the time it took, possibly the 30 seconds, into the variable T. For systems lacking a clock (which was not uncommon at the time), T would always return -1.

PRINTing was similarly expanded with the optionalUSINGstatement, which had already appeared on a number of implementations. TheUSINGwas normally followed by aformat stringusing number signs, asterisks and percent signs to mark decimal places. The format string could be placed in a string variable and then referred to, or an optional separate line containing aIMAGE:could be referred to by line number.Full also added new commands to set the printing area,SET MARGINandSET ZONEWIDTH.The current values of these various settings (and others) could be returned usingASK.For instance,SET MARGIN 10followed byASK MARGIN Jwould set J to 30.

Full supported file operations withOPENandCLOSEand a channel number prefixed with a number sign, for instance,OPEN #3: NAME "afile".Data can then be written usingINPUTandPRINTorREADand the newWRITE.Additional file handling commands includedERASEandREWRITE,and all of these commands had numerous options and modes. Much of this stemmed from the different types of physical devices that were still common in the late 1970s,magnetic tape,for instance, could only be accessed sequentially so the new standard offered options forSEQUENTIALorSTREAM,etc. The list of options and their interactions and limitations covers many pages in the standard.For instance, it is possible toPRINTto a file ofDISPLAYtype, but notINTERNALtype, which requiredWRITE.

Exception handling and debugging

Like many BASICs of the era, Full added theTRACE ONcommand which would print out line numbers as the program executed. It could also redirect the printing of the line numbers to another device or file usingTRACE ON TO #3,where #3 was a previously opened channel. It also added theDEBUG ONand relatedBREAKstatement, the latter of which would cause an exception if debugging had previously turned on. Debugging status was limited to a particular program, so it could be turned on in one program and off in a subprogram, for instance.

Additionally, Full added true exception handlers, based on theWHEN EXCEPTION...END WHENblock. There were two ways to use this, if the code block started withWHEN EXCEPTION INthe following code was executed as a block and any exception within it would cause it to jump to theUSEsection, which operates similar to anELSE.It can also be used by defining a separate subroutine-like block usingHANDLER namewhich would then be called by name usingWHEN EXCEPTION USE name.The code could test which exception had occurred using the meta-variablesEXTYPEor theEXTEXT$,neither of which needed anASK.RETRYexited the error handler and returned to the line of the error, whileCONTINUEcould be used within the mainline code to ignore errors even withinWHENblocks.

Graphics

Around the same time that Full was being designed, a parallel effort was underway to define theGraphics Kernel System,or GKS. This was offered as one of the optional modules in Full. This added dozens of special keywords likeLINE STYLEandWINDOWwith syntax that did not match that of the other modules in the standard. For instance, theCLIPcommand turned on clipping to the current viewport such that items drawn outside its boundaries would not be visible; this took a string value instead of a boolean,CLIP "On".Several common image modification commands were added,SHIFT,SCALE,ROTATEandSHEAR.

As images are often built up from common elements, Full added the newPICTUREblock structure, which is otherwise similar to aSUBand invoked withDRAWrather thanCALL.The difference is that the output of a picture block can be modified with the modification usingWITH.For instance, if one defined aPICTURE CIRCLEwhich produced a circle of radius one, a smaller circle could be drawn and moved to the side withDRAW CIRCLE WITH SHIFT(2) * SCALE(.4).

Real-time

Full's real-time module added the concept of "parallel sections", through thePARACTkeyword. These looked like subroutines (and pictures) but had a number of additional keywords that controlled their invocation. For instance, one could define code that would respond to anEVENTand then cause it to run by issuing aMESSAGEelsewhere in the code. The messages could invoke multiple handlers using theSHAREDports concept.

The system also allowed these blocks and objects to be connected to external code that would create these messages. One could, for instance, have code that waited on a device that periodically created text output, and then the appropriate handler would automatically be called when new text was available. Because the actual data from such devices tends to be multi-part, not something simple like a string or number, the real-time library also added the ability to defineSTRUCTUREs that could then be read or written as an atomic unit.These were then read and written using theIN FROMandOUT TOcommands,or if the data wasSHARED,the otherwise similarGET FROMandPUT TO.

Although many real-time programs can be modelled as a system simply responding to external events, it is also common for the program itself to periodically post these events. For this, Full added theSTARTcommand and the associatedWAITwhich would pause execution for a givenDELAY(a number of seconds) orTIME(an explicit time-of-day) or until anEVENTwas seen.

ECMA vs. ANSI

The ECMA and ANSI standards were not developed jointly but in parallel, though with overlapping committee membership. Conversely, the ISO working group for BASIC did not develop a standard of their own, instead planning to adopt either the ECMA or ANSI standard.

Independently of ANSI, the ECMA committee responsible for the BASIC standard split it in two: ECMA BASIC-1 and ECMA BASIC-2. BASIC-1 included some of the file manipulation system but lacked the exception handling, while BASIC-2 added the full suite of file commands, fixed decimal math and the exception handling system.Additionally, in BASIC-1 all fundamental keywords likePRINTwere reserved words which simplified the parser, while in BASIC-2 they followed the ANSI pattern and could be used within user-created subroutines and functions.

The ISO working group had initially planned to use ECMA's standard. Faced with the problem of two different candidate standards, in September 1987 it was directed to develop a single international standard unifying the two. This was accomplished by specifying that compliance to either standard could be claimed as comformance to the ISO standard.

References

Bibliography

• ANSI Programming Languages: Full BASIC.ANSI. January 1987.
• Standard ECMA-116: BASIC(PDF).ECMA. June 1986. Archived fromthe original(PDF)on 2011-10-14.
• Minimal BASIC(PDF).ECMA. January 1978.
• Dvorak, John (19 November 1984)."Sad But True Basic".InfoWorld.p. 88.
• Guntheroth, Kurt (July 1983)."The New ANSI BASIC Standard".SIGPLAN Notices.18(7): 50–59.doi:10.1145/988216.988221.S2CID31236801.
• Kemeny, John; Kurtz, Thomas (1984). "Bringing Up BASIC". In Ditlea, Steve (ed.).Digital Deli.Workman.ISBN9780894805912.
• Kurtz, Thomas (June 1982)."On the Way to Standard BASIC"(PDF).Byte.pp. 182–218.
• Luehrmann, Arthur (May 1984)."Structured Programming in BASIC; Part 1".Creative Computing.pp. 152–156.
• Mace, Scott (6 September 1982)."College Board developing Pascal-based AP course".InfoWorld.p. 29.
• Pournelle, Jerry (September 1985)."PCs, Peripherals, Programs, and People".Byte.pp. 366–373.Retrieved20 March2016.
• Todd, Mike (19 September 1988)."Potentially Powerful Language Comes Up Short".InfoWorld.pp. 78–80.
• Kurtz, Thomas E. (1994). "The programming language standards scene, ten years on Paper 8: Basic".Computer Standards & Interfaces.16(5–6). Elsevier: 477–480.doi:10.1016/0920-5489(94)90028-0.

Further reading

• Kemeny, John; Kurtz, Thomas (1987).Structured BASIC Programming.Wiley.ISBN9780471810872.

External links

• Decimal BASIC- a relatively complete implementation of Full BASIC and its graphics modules