View source for Dartmouth BASIC

{{Short description|Programming language}}
{{Infobox programming language
| name = Dartmouth BASIC
| logo =
| paradigm = [[imperative programming|imperative]], [[array programming|array]]
| year = {{start date and age|1964}}
| designer = [[John G. Kemeny]], [[Thomas E. Kurtz]]
| developer =
| latest release version =
| latest release date =
| typing =
| implementations =
| influenced_by = [[Fortran|FORTRAN]], [[ALGOL]]
| influenced = Cf. [[list of BASIC dialects]]
| operating_system = [[Dartmouth Time-Sharing System]]
}}

'''Dartmouth BASIC''' is the original version of the [[BASIC]] [[programming language]]. It was designed by two professors at [[Dartmouth College]], [[John G. Kemeny]] and [[Thomas E. Kurtz]]. With the underlying [[Dartmouth Time-Sharing System]] (DTSS), it offered an interactive programming environment to all undergraduates as well as the larger university community.

Several versions were produced at Dartmouth, implemented by undergraduate students and operating as a [[compile and go system]]. The first version ran on 1 May 1964, and it was opened to general users in June. Upgrades followed, culminating in the seventh and final release in 1979. Dartmouth also introduced a dramatically updated version known as '''Structured BASIC''' (or '''SBASIC''') in 1975, which added various [[structured programming]] concepts. SBASIC formed the basis of the [[American National Standards Institute]]-standard [[Full BASIC|Standard BASIC]] efforts in the early 1980s.

Most dialects of BASIC trace their history to the Fourth Edition (which added, e.g., string variables, which most BASIC users take for granted, though the original could print strings), but generally leave out more esoteric features like matrix math. In contrast to the Dartmouth compilers, most other BASICs were written as [[BASIC interpreter|interpreters]]. This decision allowed them to run in the limited [[Computer data storage#Primary storage|main memory]] of early [[microcomputer]]s. [[Microsoft BASIC]] is one example, designed to run in only 4&nbsp;KB of memory. By the late 1980s, tens of millions of [[home computer]]s were running some variant of the MS interpreter. It became the ''de facto'' standard for BASIC, which led to the abandonment of the ANSI SBASIC efforts. Kemeny and Kurtz later formed a company to develop and promote a version of SBASIC known as [[True BASIC]].

Many [[early mainframe games]] trace their history to Dartmouth BASIC and the DTSS system. A selection of these were collected, in [[HP Time-Shared BASIC]] versions, in the [[People's Computer Company]] book ''What to Do After You Hit Return''.<ref>{{cite book |url=https://archive.org/details/Whattodoafteryouhitreturn |title= What to do after you hit Return |date=1975 |publisher= People's Computer Company}}</ref> Many of the original source listings in ''[[BASIC Computer Games]]'' and related works also trace their history to Dartmouth BASIC.

==Development history==

===Earlier work===
[[John G. Kemeny]] joined the mathematics department of Dartmouth College in 1953 and later became its department chairman. In 1956 he gained access to an [[IBM 704]] via [[Massachusetts Institute of Technology|MIT's]] [[NERCOMP|New England Regional Computer Center]] efforts. That year, he wrote the [[DARSIMCO]] language, a version of [[assembly language|assembler]] which simplified the programming of mathematical operations. He was aided by [[Thomas E. Kurtz]], who joined the department that year.{{sfn|Kurtz|1981|p=516}}

DARSIMCO was forgotten when the first [[Fortran|FORTRAN]] compiler was installed on the machine in 1957. The arrival of FORTRAN instilled an important lesson. Kurtz, having been indoctrinated that FORTRAN was slow, spent several months writing a program in 704 assembler which had taken up about an hour of CPU time to debug and still was not running. Giving up, he rewrote it in FORTRAN and had it running in five minutes. The lesson was that high-level languages could save time, regardless of their measured performance.{{sfn|Kurtz|1981|p=516}}

In 1959, the school received its first computer, the [[drum memory|drum-based]] [[LGP-30]]. One student wrote a FORTRAN-inspired language called DART for the machine. This led to an effort to produce an ALGOL 58 compiler, turning to [[ALGOL 60]] when that definition was finalized. Writing the compiler was difficult due to the very small memory size, 32&nbsp;KB in modern terms, and was extremely slow, based on the drum speed of 3600&nbsp;rpm. Nevertheless, they were able to produce a functional cut-down version known as [[Dartmouth ALGOL 30|ALGOL 30]].{{sfn|Kurtz|1981|pp=516-516}} Further development produced SCALP, the "Self-Contained Algol Processor", a one-pass compiler that was ready to run the compiled program as soon as the [[punched tape]] finished reading in the source. Output with the program results or any error messages would immediately appear. This [[compile-and-go]] style of operation would later be used by BASIC.{{sfn|Kurtz|1981|pp=516-516}}{{sfn|Kemeny|Kurtz|1985|p=7}}

In 1962, Kemeny and high-school student Sidney Marshall{{sfn|Kemeny|Kurtz|1985|p=8}} began experimenting with a new language, [[DOPE (Dartmouth Oversimplified Programming Experiment)]]. This used numbered lines to represent instructions, for instance, to add two numbers, DOPE used:

  5 + A B C

Which meant "on line 5, perform an addition of the values in variables A and B and put the result in C". Although somewhat cryptic in layout, the basis for the future BASIC language can be seen.{{sfn|Kurtz|1981|p=517}} In addition to basic mathematical operations, the language included SQR, EXP, LOG, SIN and a simple branching construct.{{sfn|Kurtz|1981|p=518}}

===Computing in liberal arts===
Kemeny and Kurtz agreed on the need for programming literacy among students outside the traditional [[Science, technology, engineering, and mathematics|STEM fields]]; only 25% of the students at Dartmouth took STEM-related courses, but some level of mathematics was used in almost every field. Moreover, as computers became more important in society, they wondered "How can sensible decisions about computing and its use be made by persons essentially ignorant of it?"{{sfn|Kurtz|1981|p=518}}

Kemeny later noted that "Our vision was that every student on campus should have access to a computer, and any faculty member should be able to use a computer in the classroom whenever appropriate. It was as simple as that."{{sfn|Time|2014}} But doing so would be largely impossible given what they had to work with; the turnaround on a typical SCALP run was about 15 minutes, and the languages were far too difficult for non-STEM users to use for basic tasks.{{sfn|Kurtz|1981|p=518}}

It was not simply the complexity that was a problem, it was the entire concept of the [[batch processing]]. Students would prepare their programs on punch cards or paper tape, submit them to the computer operators, and then at some future point receive their output. This would often reveal an error that required the entire process to be repeated. As they later put it, "If it takes on the order of 1 day for one try, the student will either lose interest or forget what the problems were. At best, he will waste time standing around waiting for the day's results to appear."{{sfn|Kemeny|Kurtz|1968|p=3}}{{efn|Note the use of the term "his", which in this case was the only possibility as Dartmouth did not admit women until some time later.}}

In 1959, due largely to Kemeny's reputation as an innovator in math teaching, the department won an [[Alfred P. Sloan Foundation]] award for $500,000 to build a new department building.<ref>{{cite magazine |url=https://content.time.com/time/subscriber/article/0,33009,825616,00.html |title= High Math at Hanover |date=23 February 1959 |magazine=Time}}</ref>

===Developing the concept===
During a 1961 visit to MIT, they were introduced to the [[PDP-1]] and its recently completed experimental time-sharing [[operating system]]. [[John McCarthy (computer scientist)|John McCarthy]] asked Kurtz why they did not use time sharing for their efforts to bring computing to the masses. Kurtz returned to Dartmouth and told Kemeny "we should do time sharing", to which Kemeny immediately replied "OK".{{sfn|Kemeny|Kurtz|1985|p=3}}

In an experiment to test whether the concept was workable, students were broken into groups of five and given turns on the LGP-30 using SCALP.{{sfn|Kemeny|Kurtz|1985|p=7}} Computer time was broken into 15-minute sessions and each group of five was given one session and then turned it over to the next group. It was found that students could generally complete their programs in two or three "turnarounds" during a single session. This clearly suggested that an interactive system would allow hundreds of users to successfully use a single machine.{{sfn|Kemeny|Kurtz|1985|p=4}}

The arrival of the [[Teletype Model 33]] [[teleprinter]] using the newly introduced [[ASCII]] over telephone lines solved the problem of access; no longer would the programmers have to submit the programs on cards or paper tape, they would now use the Model 33 to type directly into the computer. All that was needed was a new machine that was fast enough to host a time-sharing system, and a simple language for the programmers to use.{{sfn|Kurtz|1981|p=519}}

When the topic of a simple language began to be considered seriously, Kemeny immediately suggested writing a new one. Kurtz was more interested in a cut-down version of FORTRAN or ALGOL.{{sfn|Kemeny|Kurtz|1985|p=6}} But these languages had so many idiosyncrasies that Kurtz came to agree with Kemeny:

{{blockquote|If we had corrected FORTRAN's ugly features, we would not have FORTRAN anymore. I reluctantly had to agree with John that, yes, a new language was needed.{{sfn|Kemeny|Kurtz|1985|p=9}}}}

Over time, four key elements emerged; the system would use time-sharing, a new language would be needed, to get users onto the system new courses would introduce programming as an adjunct to other subjects, and finally, the terminals would be open to all users.{{sfn|Kurtz|1981|pp=519-520}}

===Initial version===
The project officially started in September 1963. The goal was to develop the language and operating system on an off-the-shelf computer.{{sfn|Kiewit|1971|p=9}} In early 1964, they approached the [[National Science Foundation]] (NSF) for funding. The NSF sent the proposals, one for the time sharing system and another for the language, out for peer review. The reviews invariably suggested they did not understand the difficulty of what they were attempting. In spite of these negative comments, the NSF went ahead with both grants. Educational discounts available from [[General Electric]] led to the purchase of a [[GE-225]] computer, in an era when not "going IBM" was still fraught with peril.{{sfn|Kemeny|Kurtz|1985|p=5}}

The GE-225 was paired with the much simpler [[DATANET-30]] (DN-30) machine and a [[hard drive]] connected to both machines in order to share programs.{{sfn|Kurtz|1981|p=520}} The DN-30 lacked any programming documentation at the time, as it was never intended to be shipped from the factory without a program already installed.{{sfn|Kemeny|Kurtz|1985|p=5}} It included one key feature, [[direct memory access]] (DMA) access to the larger GE machines. This meant small messages could be quickly passed back and forth between the machines, allowing commands typed by the user to be immediately performed by the 225.<ref name=DN30Ref>{{cite book |last=General Electric Computers |title=DATANET-30 Programming Reference Manual |year=1965 |url=http://dtss.dartmouth.edu/scans/D-30%20Manuals/D-30manual.pdf}}</ref>

The system would work by having the DN-30 run the terminals and save the user's work to the disk. When the user typed <code>RUN</code>, the DN-30 would use DMA to send that command to the GE-225. The 225 would read that file, compile it, run it, and pass back the results to the DN-30 which would print the output on the terminal.<ref>[https://web.archive.org/web/20070808230115/http://www.dtss.org/index.php Dartmouth Time Sharing System (DTSS). March 1995].  Retrieved 27 May 2016</ref>

In the summer of 1963, pending the purchase of the computer, GE provided access to one of their GE-225s. Kemeny began working on a prototype compiler. Students Michael Busch and John McGeachie began working on the operating system design that fall. Both the language and the OS were extensively modified during this period, although the basic goals remained the same and were published in a draft form that November.{{sfn|Kurtz|1981|p=520}}

The school's machine arrived in the last week of February 1964,{{sfn|Kemeny|Kurtz|1968|p=224}} was operational by mid-March,{{sfn|Kiewit|1971|p=10}} and officially handed over on 1 April. By that point, the operating system design was already well developed. Most of the student programmers working on the operating system did so for 50 hours a week, in addition to their normal course load.{{sfn|Kemeny|Kurtz|1968|p=224}} The language was developed in parallel on borrowed time on another 225 machine.{{sfn|Kemeny|Kurtz|1968|p=225}} The OS was completed in April, and the entire system running on three Model 33 terminals was ready by the end of the month. John Kemeny and John McGeachie ran the first BASIC program on 1 May 1964 at 4 a.m. [[Eastern Time Zone|ET]].{{sfn|Kiewit|1971|p=10}}

It is not completely clear what the first programs were. Many sources, including Dartmouth, claim it was this simple program:<ref>{{cite web |url=https://www.dartmouth.edu/its-tools/archive/history/timeline/1960s.html |title=The 1960s |website=Dartmouth ITS}}</ref>

 PRINT 2 + 2

A later history of the language states that two programs were typed in at the same time, one by Kemeny and one by another unnamed programmer. They typed in their programs, typed {{code|RUN}} at the same time, and received the correct results.{{sfn|Kemeny|Kurtz|1985|pp=16,22}} Kurtz was an early riser and had already gone home and "missed all the fun."{{sfn|Kemeny|Kurtz|1985|p=16}}

Over the next month the system was tested by having a numerical analysis class test programs on the system. During this period, the machine remained running properly for an average of five minutes.{{sfn|Kemeny|Kurtz|1968|p=226}} The problems were rapidly addressed, and in June it was decided to increase the number of terminals to eleven. It was around this time that a faster GE-235 replaced the 225. By the fall, 20 terminals were in use.{{sfn|Kurtz|1981|p=520}}

GE began to refer to the combination of GE-235 and DN-30 as the GE-265,{{sfn|Kemeny|Kurtz|1985|p=21}} adding their model numbers together. GE built about 75 additional examples of the GE-265,{{sfn|Kemeny|Kurtz|1985|p=22}} many for their [[service bureau]] business. GE referred to these as their Mark I time-sharing systems.{{sfn|Kurtz|1981|pp=532,534}}

===New system===
One of the original goals of the program was to work programming into other coursework. This was a success, but it put considerable strain on the system and it became clear that it had no room for future growth.{{sfn|Kiewit|1971|p=11}}

In 1965, the team approached GE for support with ongoing development. In September, Vice President Louis Rader offered the new [[GE-635]], which ran approximately 10 times as fast and included two CPUs. Additionally, a second DN-30 would be added to handle more lines, enough for 150 simultaneous users.{{sfn|Kiewit|1971|p=11}} To house it, a larger facility would be needed than the basement of College Hall where the 265 was running. Peter Kiewit, Class of '22, along with additional support from the NSF, led to the construction of the Kiewit Computation Center, which opened in December 1966.{{sfn|Kiewit|1971|p=11}}

While waiting for this machine to arrive, in the summer and fall of 1966 a GE-635 at the [[Rome Air Development Center]] was used to develop MOLDS, the "Multiple User On-Line Debugging System". The GE-635 was operational in early 1967, and using MOLDS the new operating system was fully functional in September, at which time the GE-265 was sold off.{{sfn|Kurtz|1981|p=533}}

GE provided the machine for free for three years as part of a wider agreement under which Dartmouth would develop new versions of BASIC while GE used it to develop a new release of their version of the operating system.{{sfn|Kurtz|1981|p=533}} This collaboration proved to be a success;  GE began deploying these machines as their Mark II time-sharing systems,{{sfn|Kurtz|1981|p=534}} and by the end of the decade they were one of the largest time-sharing vendors in the world.{{sfn|Kiewit|1971|p=11}}

When this "Phase I" system became operational, the Dartmouth team began development of "Phase II", the ideal operating system. This was installed in March 1969, and changed its name to the [[Dartmouth Time-Sharing System]] shortly thereafter. When the three-year period was up, GE gifted the machine to the university. Although the two teams remained in contact, and several good-faith attempts were made to continue the relationship, little further collaboration occurred and the partnership officially ended on 20 September 1972.{{sfn|Kurtz|1981|p=533}}

===Expanding user base===
A review in 1968 noted that 80% of the students and 70% of the faculty was making some use of the system. Hundreds of terminals were spread across the campus, from the hospital to the business school. 57% of the CPU time was used for coursework, 16% for research, and the remaining 27% for "recreational use"; Dartmouth actively encouraged users to play games as a way to get hands-on use and overcome fear of the computer.{{sfn|Kiewit|1971|p=17}}

Beginning with another NSF grant, in 1967 Dartmouth also began placing terminals in off-campus locations, including high schools in the area. In terms of user counts, these terminals hosted 69% of the total users, although they used a smaller amount of computer time.{{sfn|Kiewit|1971|p=17}} By 1971 there were 79 remote terminals, as far away as [[New Jersey]] and [[Bangor, Maine]]. These were supported by [[multiplexer]] systems that allowed up to 12 terminals to be supported over a single voice-grade telephone line. Additionally, a number of these lines were available for dial-up use with a [[modem]].{{sfn|Kiewit|1971|p=18}}

===Influence===
Time-sharing was a major area of research in the 1960s, with many in the computer industry predicting that computing power would become inexpensive and widespread. This was most famously stated by John McCarthy, who said "computing may someday be organized as a public utility just as the telephone system is a public utility."<ref>{{cite book|title=Architects of the Information Society, Thirty-Five Years of the Laboratory for Computer Science at MIT|editor1-first=Hal|editor1-last=Abelson|first1=Simson|last1=Garfinkel|isbn=978-0-262-07196-3|publisher=MIT Press|year=1999|page=1|url=https://books.google.com/books?id=Fc7dkLGLKrcC&pg=PA1|location=Cambridge}}</ref>

While other languages were available on DTSS, {{as of|1972|lc=y}} 98% of its programs were written in BASIC.<ref name="kemeny1972">{{Cite book |last=Kemeny |first=John G. |url=https://archive.org/details/mancomputer00keme/page/32/mode/2up?view=theater |title=Man and the Computer |publisher=Charles Scribner's Sons |year=1972 |location=New York |pages=32–37, 41–42 |isbn=9780684130095 |language=en-US |lccn=72-1176}}</ref> With BASIC, computer services became far more accessible to end-users whose tasks would take too long to code for them to be suitable for solving on a computer. This led to a number of manufacturers who introduced computers specifically designed for this market of users who wanted to solve small or medium-scale tasks and were not as worried about outright performance. In particular, two machines aimed directly at this market became the "most widely used small time-sharing systems ever developed".{{sfn|Kurtz|1981|p=534}}

The [[HP 2000]] ran [[HP Time-Shared BASIC]], a combination of a BASIC and a time-share operating system almost identical to the DTSS setup. The system supported up to 32 simultaneous users, using a low-end HP 2100 CPU to run the terminals in the same fashion as the Datanet-30 of the original GE-265 setup, while the programs ran on a higher-end model of the same machine, typically differing in that it had more [[core memory]]. HP's BASIC used a semi-compiled [[lexical analysis#Tokenization|tokenized]] format for storing programs, which improved loading times and meant "compiles" were zero-time.<ref>{{cite book |url=ftp://ftp.mrynet.com/pub/os/HP2000/pdf/02000-90002_2000A_UG_Aug69.pdf |title=A Guide to Time Shared BASIC |date=August 1969 |publisher=Hewlett Packard}}</ref>

[[Digital Equipment Corporation]] took a different approach, using a single-machine offering based on their existing [[PDP-11]] line with the new [[RSTS/E]] operating system and [[BASIC-PLUS]]. BASIC-PLUS more closely followed the Fifth Edition, including the <code>MAT</code> commands, but was implemented as a pure interpreter as opposed to the Dartmouth compiler or HP's tokenized format. It also included a number of control structures following the [[JOSS]] model, like {{code|2=basic|PRINT I IF I > 10}}.<ref name=plus>{{cite book |url=http://bitsavers.informatik.uni-stuttgart.de/pdf/dec/pdp11/rsts/V04/DEC-11-ORBPA-A-D_BASIC-PLUS_LangMan_Oct72.pdf |title=BASIC-PLUS Manual |date=1972 |publisher=DEC}}</ref> [[Tymshare SUPER BASIC]] also supported JOSS-style structures and matrix math, but retained the original compile-and-go operation.

Practically every vendor of the era offered some solution to this same problem, although they may not have been so closely similar to the original. When Kurtz began considering the formation of an [[ANSI]] standard for BASIC in 1973, he found that the number of time-sharing service bureaus with BASIC available was greater than any other language. Unfortunately, this success was also a problem; by that point, there were so many variations that a standard seemed impossible.{{sfn|Kurtz|1981|p=534}}

===Games in BASIC===
Kemeny actively encouraged games on the DTSS platform, and considered it to be one of the major reasons for the success of the DTSS system.{{r|kemeny1972}} He was likely the author of an [[early mainframe game]]. Although Kemeny did not take credit for it, he later referred to ''FTBALL'' by stating it "was written on Sunday after a certain [[1965 Dartmouth Indians football team|Dartmouth]]-[[1965 Princeton Tigers football team|Princeton]] game in 1965 when Dartmouth won the [[Lambert-Meadowlands Trophy|Lambert trophy]]. It's sort of a commemorative program". The game was an upset over heavily favored Princeton.<ref>{{cite web |title=John Kemeny and Tecmo's BASIC FTBALL Granddaddy |url=https://tecmobowl.org/forums/topic/69925-john-kemeny-and-tecmo%E2%80%99s-basic-ftball-granddaddy/ |date=17 October 2017 |access-date=25 July 2018 |archive-date=25 July 2018 |archive-url=https://web.archive.org/web/20180725214835/https://tecmobowl.org/forums/topic/69925-john-kemeny-and-tecmo%E2%80%99s-basic-ftball-granddaddy/ |url-status=dead }}</ref>{{efn|[[David Ahl]] stated Kemeny had written it when describing the game in BASIC Computer Games.{{sfn|Ahl|1978|p=64}}}}

As the system expanded, especially after the addition of string handling in BASIC, the DTSS system became a major platform for the development of many [[text-based game]]s. In the early 1970s, the [[People's Computer Company]] began publishing these in their magazine, typically converted to the more widely available HP BASIC. Many of these listings were collected in their 1975 book, ''What to do after you hit return''. Although these are published in HP BASIC form, the majority of them trace their history to either DTSS or the [[Lawrence Hall of Science]] in California where a similar machine was set up, known as DECISION.<ref>{{cite book |url=https://archive.org/details/Whattodoafteryouhitreturn |publisher=People's Computer Company |date=1975 |title= What to do after you hit return}}</ref>

A more famous collection is ''[[BASIC Computer Games]]'' of 1978, where about half of the programs in the book were either written at Dartmouth, including another by Kemeny, Batnum, or more commonly, one of the many high schools that were connected to it after 1968. A particularly prolific high school was [[Lexington High School (Massachusetts)|Lexington High School]] in [[Massachusetts]] but many other schools appear as well. A number of the programs do not list their original locations, but come from authors that were likely connected to the system through a school or public projects like Project SOLO.{{sfn|Ahl|1978}}

[[Multiplayer video game]]s became possible in BASIC when [[Stephen J. Garland|Stephen Garland]] and John McGeachie developed the MOTIF Multiple Online Terminal Interface for DTSS.  To start a game, a user typed LINK followed by a session name instead of RUN, thereby enabling other users to connect to the game by typing JOIN followed by the session name.  MOTIF then multiplexed input and output for the BASIC program, prepending a string identifier to the beginning of each line of input and output.  The first programs developed with this interface were a two-person  version of FTBALL and a five-person poker game.  More serious was a management game that allowed up to ten students at the Amos Tuck School of Business Administration to compete in the production and marketing of a single product.<ref>John S. McGeachie, "Multiple terminals under user program control in a time-sharing environment", ''Communications of the ACM'' 16:10, October 1973, pages 587&&ndash;590.</ref>

==Versions==
===First Edition===
The original version, retroactively known as version one, supported the commands <code>LET</code>, <code>PRINT</code>, <code>END</code>, <code>FOR...NEXT</code>, <code>GOTO</code>, <code>GOSUB...RETURN</code>, <code>IF...THEN</code>, <code>DEF</code>, <code>READ</code>, <code>DATA</code>, <code>DIM</code>, and <code>REM</code>. It included basic math instructions, {{key|+}}, {{key|-}}, {{key|*}} and {{key|/}}, as well as the up-arrow for exponents "...since on a teletype typewriter it is impossible to print superscripts."{{sfn|Kurtz|1981|p=523}} In modern varieties, the up-arrow is normally replaced by the "hat" character, {{key|^}}. Exponents took the absolute value of the number before calculation, so to calculate {{code|-X^3}}, one had to use {{code|X*X*X}}. There was a further problem in the exponent function that treated {{code|-X^2}} as {{code|(-X)^2}} as opposed to the correct [[order of operations]] {{code|-(X^2)}}, which was not corrected until the third release.{{sfn|Kurtz|1981|p=523}} The <code>INT()</code> function always truncated towards zero.{{sfn|Kurtz|1981|p=524}}

The language had a number of idiosyncrasies of its own. In contrast to later versions, the <code>LET</code> command was required on all statements lacking another command, so {{code|2=basic|1=10 A=5*5}} was not valid in this version.{{sfn|Kurtz|1981|p=524}} The <code>PRINT</code> statement used the comma when printing multiple variables, advancing to the next of five "zones". The comma was not needed in the case where one was printing a prompt and single value, so {{code|2=basic|PRINT "value of A is "A}} was valid. A somewhat hidden feature was that all variables were capable of representing arrays (vectors) of up to ten elements (subscripts 1 to 10, changed to 0 to 9 in the Second Edition) without being declared that way using <code>DIM</code>. <code>DIM</code> was only needed if a different vector size was required.{{sfn|Kurtz|1981|p=525}}{{efn|This feature was found on most BASICs based on Dartmouth, but was rare on those that were created independently.}}

Variable names were limited to a single letter or a letter followed by a digit (286 possible variable names). User functions could only have a single letter, thus {{code|FNA}} through {{code|FNZ}}. All operations were done in [[floating point]]. On the GE-225 and GE-235, this produced a precision of about 30 bits (roughly ten digits) with a base-2 exponent range of -256 to +255.<ref>{{cite web|last=Kurtz|first=Thomas|title=BASIC Commands: The Original-Original Version|url=https://www.dartmouth.edu/basicfifty/commands.html#:~:text=All%20arithmetic%20was%20done%20in,of%20%2D256%20to%20%2B255.&text=Ten%20numeric%20functions%20were%20provided.}}</ref>

Additionally, due to the GE-235's word size being 20-bits and using a [[six-bit character code]], the language enshrined the use of three-letter function names because that allowed the storage of three six-bit characters in a 20-bit word (using 18 bits). This is why BASIC functions are three letters, like <code>INT</code> or <code>SQR</code>, something that remained in the many varieties of the language long after they left the GE-235.{{sfn|Kurtz|1981|p=524}}

===Second Edition, CARDBASIC===
The Second Edition of BASIC (though not referred to as such at the time) only made minimal changes. Released in October 1964, it could start arrays at subscript 0 instead of 1 (useful for representing [[polynomial]]s) and added the semicolon, {{key|;}}, to the <code>PRINT</code> statement.{{sfn|Kurtz|1981|p=526}} Unlike later implementations where this left space between items, the semicolon advanced printing to the next multiple of three characters, which was useful for "packing" more numbers into a line of output than the existing comma separator.{{sfn|Man4}} The three-character size was a side-effect of the GE-235's 20-bit [[Word (computer architecture)|word size]], which stored three six-bit characters. Skipping to the next three-character column was accomplished simply by moving to the next word in memory.{{sfn|Kemeny|Kurtz|1985|p=24}}

The October version also included a separate definition for CARDBASIC, which was simply a version of BASIC for use on card-based workflows. CARDBASIC was almost identical to the interactive version, with the exception being that it did not include the zero-based arrays. More important to the language's future, CARDBASIC added the <code>MAT</code> commands that worked with numerical matrices. CARDBASIC was not developed further, as the entire idea of BASIC had been to be interactive.{{sfn|Kurtz|1981|p=526}}

===Third Edition===
The Third Edition, released in 1966 and the first to use the "edition" naming, was the first designed specifically with the intent of running on the new GE-635 computer which was due to arrive shortly. This version includes the <code>MAT</code> functions from CARDBASIC, and they can now use 0 as a subscript.{{sfn|Kurtz|1981|p=527}}

The new <code>SGN</code> function gave the sign of its argument (positive?0 and negative?1), while <code>RESTORE</code> was added to "rewind" the position of <code>READ/DATA</code>. The exponentiation problem was fixed, so {{code|-X^2}} would be interpreted as {{code|-(X^2)}}.{{sfn|Kurtz|1981|p=527}} Additionally, the <code>INT</code> function was changed to be a true floor, as opposed to trim-toward-zero, which allowed rounding to be implemented with <code>INT(X+0.5)</code>.{{sfn|Kurtz|1981|p=524}}

The major change in this version was the new <code>INPUT</code> statement, which parsed numeric values, making the language truly interactive during execution for the first time; previously the only control one had during execution was to type <code>STOP</code> in the monitor. Additionally, the system now allowed, and encouraged, loops to be indented, a feature that was not seen on most other versions of BASIC.{{sfn|Kurtz|1981|p=528}}

===Fourth Edition===
The Third Edition remained in use through the GE-235's lifetime into the fall of 1967. However, as plans were made to receive the GE-635, an experimental version was created on the 635 in the spring of 1967. This version was a partnership between GE and Dartmouth, with GE contributing a new operating system as well as a number of features of BASIC from their own Mark 1 BASIC efforts.{{sfn|Kurtz|1981|p=528}}

This version, initially published as a supplement to the Third Edition, added the <code>RANDOMIZE</code> command to "seed" the <code>RND</code> function, and the <code>ON...GOTO</code> "computed goto" that closely matched the similar feature in FORTRAN. This version also allowed <code>ON...THEN</code>, arguing that <code>IF...THEN</code> did not require the <code>GOTO</code> then it would not be required here. The new <code>TAB</code> function moved printing to a given column, from 0 to 74.{{sfn|Kurtz|1981|p=528}} Another internal change was to once again change the <code>MAT</code> to be 1-based; one could use the 0th index, but it would normally be ignored by the various commands.{{sfn|Kurtz|1981|p=529}}

The major addition for this version was string variables, along with changes to the <code>READ/DATA</code> statements which could store strings in them and the <code>INPUT</code> statement to read them interactively. One feature of the string system was that trailing spaces were deliberately ignored in comparisons, so that "YES" and "YES " were considered equal.{{sfn|Man4|p=66}} This was later realized to be a grave error.{{sfn|Kurtz|1981|p=529}} String variables were indicated by the dollar sign, e.g. {{code|A$}}, simply because they were running out of characters that could be found on most keyboards. Someone pointed out that the $ looked like the S in "String", and that was that.{{sfn|Kemeny|Kurtz|1985|p=28}}

String manipulation was handled through the new {{code|CHANGE}} command. This converted the string value in a variable to the equivalent set of ASCII values. The numeric array could then be manipulated and converted back to a string. For instance, this code produces "is" on the console:
{{sxhl|2=basic|1=
100 LET S$ ="Now is the time"
110 CHANGE S$ TO S
120 LET T(1) = S(5)
130 LET T(2) = S(6)
140 LET T(0) = 2
150 CHANGE T TO T$
160 PRINT T$
}}
Line 140 sets the string length to 2, which has to be managed by the user. The first character is in T(1). While this system is flexible, it was by no means convenient to use. Later versions would address this with new functionality.{{sfn|Kemeny|Kurtz|1985|p=29}}

Minor changes in this version changed the semicolon in <code>PRINT</code> statements to do "close packing" of output with no spaces,{{sfn|Kemeny|Kurtz|1985|p=24}}{{sfn|Man4|p=64}} and the use of the apostrophe as a short-form <code>REM</code>.{{sfn|Man4|p=52}}{{efn|It is not clear if the apostrophe was used in previous versions, the Revision 4 manual is the first to mention it explicitly.}}

The official Fourth Edition did not appear until 1968, which added several new features on top of the previous additions. This included the ability to define multi-line functions with the <code>DEF</code> command, and the powerful <code>CHANGE</code> statement that treated strings as arrays of [[ASCII]]-like codes so individual characters could be operated on without looping over the entire string.{{sfn|Kurtz|1981|p=529}} This was also the only string manipulation function; to extract a single character or substring, one had to use <code>CHANGE</code> to convert it into an array of numbers, manipulate that array, and then convert it back. This was the reason MAT was 1-based again; the length of the string was placed in location zero, and it needed to be ignored normally.{{sfn|Man4|p=67}}

===Fifth Edition===
The Fifth Edition, from late 1970, once again started as two supplements to the Fourth Edition, from February and April 1969.{{sfn|Kurtz|1981|p=529}}

The major change was the introduction of file handling. Previously, any pre-defined data that had to be used in the program had to be placed in the {{mono|DATA}} lines and then read in one-at-a-time using the {{mono|READ}} command. This feature could be used to read files in a similar fashion. The {{mono|INPUT}} command could now read a single item from a file and {{mono|PRINT}} could write one. {{sfn|Kemeny|Kurtz|1985|p=31}}

Files were opened through the new {{code|FILES}} keyword, which was followed by a list of string constants describing file names. As these were constants, changing the file name demanded the code be changed to match. The names were assigned numbers, the first name became file #1, and so on. Two file formats were supported, random-access and linear. A linear file was treated as a text file would be today, one could {{code|LINPUT #1: A$}} to read a line of text into a string variable, and then {{code|PRINT A$}} to output it to the terminal.{{sfn|Kemeny|Kurtz|1985|p=31}} Later versions added the {{code|FILE $1,name$}} to allow files to be specified by strings, although for a time this required a {{code|FILES *}} near the top of the program to indicate you were using this format.{{sfn|Kemeny|Kurtz|1985|p=32}}

For random access files, the name had to specify the type of data within; {{code|%}} indicated it contained binary data, while {{code|$num}} indicated it should be read as strings with a maximum length of {{code|num}}.{{sfn|Kemeny|Kurtz|1985|p=31}} The {{mono|READ}} and {{mono|WRITE}} could be positioned anywhere in a random-access file with the {{mono|RESET}} command, while the current location was returned by the {{mono|LOC}} function, and the file length by {{mono|LOF}}. During sequential reads, one could also test whether it was at the end of the file using <code>IF END THEN...</code>.{{sfn|Kurtz|1981|p=530}}

Another major change was the ability for one BASIC program to call another using the {{mono|CHAIN}} command, and pass variables to it using the {{mono|COMMON}} list. It was later realized that this basic concept had a number of problems, but it was nevertheless used to write some large programs.{{sfn|Kurtz|1981|p=530}}

String handling received a major update. The new {{code|SEG$}} command returned a new string clipped out of another. In the example above, the string "is" is extracted from a larger string. Using the new command, this can be reduced to {{code|LET T$ {{=}} SEG$(S$,5,6)|basic}}, which works similarly to the {{code|MID$}} function found in most dialects ({{code|MID$(S$,5,2)}}). SEG$ uses first and last indices; MID$ uses first index and length. {{code|LEN}} returned the length of a string, which was otherwise now handled internally and did not require calculation in most cases, and {{code|POS}} returned the position of one string within another, which in most dialects was handled by {{code|SUBSTR}}. The ampersand, {{code|&}}, was introduced for [[Concatenation|string concatenation]].{{sfn|Kemeny|Kurtz|1985|p=29}}

Numerous more minor changes were also added. Among these were two-dimensional string arrays, as opposed to one-dimensional in the previous version, as well as the ability to use the {{mono|DEF}} to define string-based functions as well as mathematical. New system-oriented functions included {{mono|CLK$}}, {{mono|DAT$}} to work with times and dates, {{mono|TIM}} which returned the elapsed time, and {{mono|USR$}} which returned the user number, what would today be the username. New string functions included {{mono|STR$}}, {{mono|VAL}}, {{mono|ASC}}, which are common in modern BASIC dialects. The {{key|'}} as a short form for {{mono|REM}} also appeared in this version.{{sfn|Kurtz|1981|p=530}}

===Sixth Edition===
Work on the Sixth Edition began in the fall of 1969 before the Fifth Edition was finalized. A complete specification was written beforehand for the new version. This contrasts with previous versions where the specification documents were based on the changes in the compiler. This version was worked on by Kemeny and Kurtz as well as several former students who returned as faculty: Stephen Garland, John McGeachie, and Robert Hargraves. It was given considerable time to mature, with a beta version running for three months during the summer of 1971, before it was finally released on 21 September 1971. As a result of this maturity, Kurtz described it as "probably the best-designed and most stable software system Dartmouth has ever written."{{sfn|Kurtz|1981|p=531}}

One of the biggest changes was the replacement of the earlier <code>CHAIN</code> concept with the much better-defined <code>CALL</code> which operated in a fashion similar to <code>GOSUB</code>, but it referred to a function name rather than a line number. The functions were defined using <code>SUB...SUBEND</code>, and took arbitrary [[Parameter (computer programming)|parameters]] in the call rather than using [[global variable]]s via <code>COMMON</code> declarations. Another major change was to use file handles (numbers) created with the <code>FILE</code> command which is similar to <code>OPEN</code> which is found in most modern BASICs.<code>PRINT USING</code> provided formatted output in a fashion somewhat similar to FORTRAN,{{sfn|Elliott|1988|p=134}} while {{code|LINPUT}} accepted input with no interpretation, allowing commas, semicolons, and even BASIC code to be typed in.{{sfn|Kemeny|Kurtz|1985|p=26}}

The Sixth Edition was essentially the last version of the original BASIC concept. It remained unchanged for many years. Later versions were significantly different languages.{{sfn|Kurtz|1981|p=531}}

===SBASIC===
In 1976, Stephen Garland collected a number of [[structured programming]] additions to create Dartmouth Structured BASIC, or SBASIC.{{sfn|Garland|1976}} The primary goal was to replace the control structures based on <code>IF...THEN</code> and <code>GOTO</code> with a variety of block-oriented structures. It did this using a precompiler that took SBASIC source code, converted that to 6th Edition BASIC, and then compiled and ran that as normal. SBASIC also added a number of graphics features, based on the <code>PLOT</code> command that had been added by other programmers.{{sfn|Garland|1976|p=1}}

Block structures were terminated by matching statements as was the case in [[ALGOL 68]], as opposed to the generic block structures found in languages like [[Pascal (programming language)|Pascal]] or [[C (programming language)|C]]. For instance, the <code>DO WHILE...</code> spanned multiple lines until it ended with a <code>LOOP</code>.{{sfn|Garland|1976|p=4}} The <code>DO</code> loop could also be bottom exited by removing the <code>WHILE</code> or <code>UNTIL</code> and placing the conditional at the bottom on the <code>LOOP</code>. Infinite loops were supported using <code>DO FOREVER</code> or <code>LOOP FOREVER</code>.{{sfn|Garland|1976|p=5}}

"Original" Dartmouth BASIC did not allow statements after a <code>THEN</code>, only a line number to branch to. SBASIC allowed any statement, so for instance {{code|2=basic|1=IF X < 5 THEN X=X+1}}.{{sfn|Garland|1976|p=6}} This basic expansion to the <code>IF...THEN</code>, pioneered in 1972 with [[BASIC-PLUS]],<ref>{{cite book|url=https://archive.org/details/bitsavers_decpdp11rsSICPLUSLangManOct72_10455777|title=BASIC-PLUS Language Manual|publisher=Digital Equipment Corporation|year=1972|location=Maynard, Massachusetts|type=PDF|pages=3–13|ref=CITEREFPLUS1972}}</ref> was already widely supported by most variety of BASICs by this point, including [[microcomputer]] versions that were being released at this time. On top of this, SBASIC added block-oriented <code>IF</code> by placing the <code>THEN</code> on a separate line and then ending the block with <code>CONTINUE</code>.{{sfn|Garland|1976|p=7}} On top of this, SBASIC added the <code>SELECT CASE</code> mechanism that survives to this day in [[Visual Basic .NET]].{{sfn|Garland|1976|p=10}}

SBASIC also added a number of graphics commands intended to be used with [[plotter]]s. This required the <code>PLOTTER "plottername"</code> to direct subsequent commands to a selected device, and the <code>WINDOW...</code> to set up its parameters. From then on, <code>PLOT X,Y</code> would produce dots on the selected plotter, while adding the semicolon at the end of the statement, as used in <code>PRINT</code>, would leave the pen on the paper and produce a line, for instance <code>PLOT 10,10;20,20</code>.{{sfn|Garland|1976|p=21}}<ref>Stephen J. Garland and Arthur W. Luehrmann, "Graphics in the BASIC language," ''Computer Graphics'' (quarterly report of SIGGRAPH-ACM) 8:3, pages 1–8, 1974.</ref>

SBASIC eventually formed the basis of the 1987 [[ANSI BASIC|ANSI X3.113-1987 Standard for Full Basic]], which extended the earlier 1978 ANSI ANSI X3.60-1978 Standard for Minimal Basic.  The long delay in producing that standard, along with the lack of regard among computer scientists for unstructured Basic, led the College Board committee developing the [[AP Computer Science|Advanced Placement Course in Computer Science]], which Garland chaired, to opt for requiring Pascal and not allowing Basic as the language for the course.<ref>{{cite magazine |magazine=InfoWorld |date=6 September 1982 |first=Scott |last=Mace |title=College Board developing Pascal-based AP course |page=29 |url=https://books.google.com/books?id=CDAEAAAAMBAJ&pg=PA29}}</ref><ref>Stephen J. Garland, "Advanced Placement Computer Science," ''Computers in Mathematics Education'', Viggo P. Hansen and Marilyn J. Zweng (editors), pages 194–201. Yearbook of the National Council of Teachers of Mathematics, 1984.</ref>

Garland used SBASIC to teach the introductory course in computer science at Dartmouth,<ref>Stephen J. Garland, ''Introduction to Computing and Basic Programming'', Program in Computer and Information Science, Dartmouth College, 1982.</ref><ref>Stephen J. Garland, "Languages for first courses in computer science: Basic," ''Abacus'' 1:4, pages 39–49, Summer 1984.</ref> but rewrote his textbook for the course in Pascal<ref>Stephen J. Garland, ''Introduction to Computer Science with Applications in Pascal'', Addison-Wesley, Reading, MA, 1986.</ref> so that it could be used to teach the AP course.

===Seventh Edition===
Garland's SBASIC was a pre-compiler written in SBASIC source code itself. The system would read SBASIC source, write the corresponding 6th Edition code, and then compile that output. The Seventh Edition, released in 1980, was a version of SBASIC that was a stand-alone compiler of its own. It added a number of additions of its own. Most of the changes were further elaborations on the system for calling external programs and "overlays" that could be used to break up a program into parts. In this version, <code>SUB</code>s sharing a single file effectively shared data between them. This provided a modicum of [[data hiding]] within the group of routines. This separation would today be known as a module.{{sfn|Elliott|1988|p=135}}

In addition, this edition added structured error handling and arbitrary matrix math in <code>LET</code> statements, so one could <code>LET A = M*4</code> where M was a matrix variable, and the statement would output another matrix into A with all the elements in M scaled by 4. Finally, another major update was the use of [[activation record]]s for subroutines which made [[recursion]] possible.{{sfn|Elliott|1988|p=135}}

==={{Anchor|ANSI BASIC}}ANSI BASIC, Eighth Edition=== <!-- Other articles link here. -->
By the early 1970s, the number of BASIC implementations had grown to dozens, all of which had their own changes to the basic concept introduced in the original version. Most of these were based on the Fifth Edition, although they often lacked the MAT instructions and the ability to indent code. GE was one of these companies; they released their Mark II systems with the 5th edition rather than waiting for the 6th to arrive a few months later.{{sfn|Marconi}} BASIC-PLUS on the DEC platform was perhaps the closest implementation, including the MAT commands for instance, but then added a number of changes that were not backward-compatible.<ref name=plus />

After the release of the 6th edition, Kurtz became involved in an effort to define a standard BASIC. An [[American National Standards Institute]] (ANSI) working group, X3J2, formed in January 1974, and a corresponding [[Ecma International|European Computer Manufacturers Association]] (ECMA) group, TC21, that September. The goal at that time was to produce two related standards. Minimal BASIC would be similar to the Second Edition, but adding strings, a standard to which practically every BASIC would already be able to conform. Standard BASIC would add more functionality to produce something more in keeping with the real BASIC varieties seen in the market.{{sfn|Marconi}}

The process was slow, and the first draft of Minimal BASIC was not published until January 1976, leading to it being officially adopted in December 1977 by ECMA, and 1979 by ANSI as X3.60-1978. Minimal BASIC was similar to the 3rd edition, including string variables, while lacking MAT and other advanced features.<ref>{{cite book |title=Minimal BASIC |date=January 1978 |publisher=ECMA |url=https://www.ecma-international.org/publications/files/ECMA-ST-WITHDRAWN/ECMA-55,%201st%20Edition,%20January%201978.pdf}}</ref> In contrast, Standard BASIC had many new features that did not exist in other BASICs, and many of these were poorly considered and the subject of some criticism. For instance, the standard included a line-continuation character, but chose the ampersand, {{key|&}}, which was also used for string concatenation. Using these in a single line could lead to very confusing code.<ref>{{cite journal |first=Kurt |last=Guntheroth |title=The New ANSI BASIC Standard |date= July 1983 |volume=18 |issue=7 |doi=10.1145/988216.988221 |journal=ACM SIGPLAN Notices |pages=50–59|s2cid=31236801 }}</ref>

By this time, the release of the first [[microcomputer]] systems in 1975 had quickly led to the introduction of [[Altair BASIC]], the first version of what would soon be known as [[Microsoft BASIC]]. MS BASIC was patterned on BASIC-PLUS, and thus ultimately the Fifth Edition, but lacked indenting, MAT, and other features. It also added the <code>LEFT$</code> and <code>RIGHT$</code> functions, breaking the three-letter convention. As the number of microcomputers grew, and turned into the [[home computer]] market in the late 1970s, MS BASIC became the ''de facto'' standard.{{sfn|Marconi}}

With this rapid change in the market, the Standard BASIC effort slowed further and was not formally ratified until 1987 as X3.113-1987. By this time, there was no real purpose to the standards; not only was MS BASIC everywhere, but by the mid-1980s the use of BASIC was declining as shrinkwrap software took over from type-in programs. Both standards were eventually withdrawn.{{sfn|Marconi}}

In spite of the eventual failure of the ANSI efforts, the draft of Standard BASIC was implemented at Dartmouth as the Eighth Edition in 1982.{{sfn|Elliott|1988|p=135}}

==DTSS interface==
DTSS implemented an early <!-- Joss was about the same time --> [[integrated development environment]] (IDE): an interactive [[command line interface]]. This provided a number of user and job control commands. For instance, an idle terminal could be connected to a user account by typing <code>HELLO</code>, and logged out again with <code>BYE</code>.{{efn|There was no need to log out, if users did not respond, they were logged out after a short delay.}}

Any line typed in by the user, and beginning with a line number, was added to the program, replacing any previously stored line with the same number; anything else was assumed to be a DTSS command and immediately executed. Lines which consisted solely of a line number were not stored but did remove any previously stored line with the same number. This method of editing was necessary due to the use of [[teleprinter]]s as the terminal units.

Each user account could have any number of BASIC programs stored offline, while administrator accounts could also leave programs in permanent storage. Any one of these was active at a given time for a given user account, and if no program had been loaded, a new program was assumed. Stored programs were accessed using commands that are today better known as parts of the BASIC language itself; for instance, the <code>LIST</code> command instructed DTSS to print out the currently active program.

===List of commands===
; <code>HELLO</code>   : log in to DTSS
; <code>BYE</code>     : log out of DTSS
; <code>BASIC</code>   : start BASIC mode
; <code>NEW</code>     : name and begin writing a program
; <code>OLD</code>     : retrieve a previously named program from permanent storage
; <code>LIST</code>    : display the current program
; <code>RUN</code>     : execute the current program
; <code>STOP</code>    : interrupt the currently running program
; <code>TEST</code>    : use an instructor-provided program to test the current program 
; <code>LINK</code>    : execute the current program in a multiple-terminal mode
; <code>JOIN</code>    : join a program being executed in multiple-terminal mode
; <code>SAVE</code>    : save the current program in permanent storage
; <code>UNSAVE</code>  : clear the current program from permanent storage
; <code>REPLACE</code> : save the current program using a name already in use for another file
; <code>CATALOG</code> : display the names of programs in permanent storage
; <code>SCRATCH</code> : erase the current program without clearing its name
; <code>RENAME</code>  : change the name of the current program without erasing it
; <code>FRI</code>     : enable [[Friden Flexowriter|Friden]] mode for teletypes with mechanical linefeeds
; <code>NFR</code>     : disable Friden mode
; <code>EXP</code>     : explain (help) EXP EXP for list of commands that can be explained by the system

The commands were often believed to be part of the BASIC language by users, but, in fact, were part of the time sharing system and were also used when preparing ALGOL or FORTRAN programs via the DTSS terminals.

===TEACH/Test System===

Some 80% of all Dartmouth students in the late 1960s took two mathematics courses and learned Basic in the second course, either in calculus or in finite mathematics.  They received two one-hour lectures on Basic near the beginning of these courses and then had to write four programs in Basic, ranging from programs for approximating π or finding a root of a quintic polynomial to programs for solving a differential equation or finding (by simulation) the limiting probability in a Markov chain.  The TEACH/Test system helped students complete these assignments.  When they thought they had a working program, they typed the command TEST, and an instructor-written program either approved what they had written or provided a hint about where they might have gone wrong.  Students were required to hand in a listing of each program, a sample RUN, and an approval from the TEACH/Test system.  The system did not grade assignments or keep a record of how many times a student typed TEST; it simply assisted students and their instructors.<ref>John G. Kemeny and Thomas E. Kurtz, "Dartmouth Time-Sharing", ''Science'' 162, October 11, 1968, pages 223&ndash;228.</ref><ref>John G. Kemeny and Thomas E. Kurtz, [https://eric.ed.gov/?id=ED024602 ''The Dartmouth Time-Sharing Computing System, Final Report''] for National Science Foundation Grant NSF-GE-3864, June 1967, pages 9&ndash;10 and Appendix III.</ref>

==BASIC language==
The first release implemented the following statement types, taking some of its operators and keywords from [[FORTRAN|FORTRAN II]] and some from [[ALGOL|ALGOL 60]]. Overall, the language more closely follows the FORTRAN model,{{sfn|Kurtz|1981|p=523}} in that it generally has one statement per line of code, lacks ALGOL's "blocks" to group code (these [[structured programming]] constructs were a primary reason for ALGOLs development) and the use of GOTO to control program flow.

From ALGOL it took the <code>FOR...TO...STEP</code> style loops that replaced FORTRAN's unwieldy <code>DO...CONTINUE</code> statements.{{sfn|Kurtz|1981|p=524}} BASIC also simplified the <code>IF...THEN</code> construct to allow simple comparisons like {{code|IF X>5 THEN GOTO 20|basic}}, as opposed to FORTRAN's <code>IF (X-5) 20,20,30</code>.{{sfn|Kurtz|1981|p=524}} FORTRAN's style "computed IF" was reintroduced with the <code>ON...GOTO</code> command in later versions.

Variable names were limited to A to Z, A0 to A9, B0 to B9,&nbsp;..., Z0 to Z9, giving a maximum of 286 possible distinct variables. FORTRAN's odd system for setting up the variables I through N as integers and the rest as floating point was removed, and all variables were assumed to be floating point and dimensioned with up to 10 elements. The <code>DIM</code> command was only required if the array held more than ten elements.{{sfn|Kurtz|1981|p=524}} Array names were restricted to A to Z only.

===List of BASIC statements===
; <code>DEF</code> : define single line functions
; <code>DIM</code> : (short for ''dimension'') define the size of arrays
; <code>END</code> : define the end of the program
; <code>STOP</code> : stop a program before the textual end
; <code>[[For loop|FOR]] / TO / STEP</code> : define loops
; <code>NEXT</code> : mark the end of loops
; <code>[[GOSUB]]</code> : transfer control to simple subroutines
; <code>[[Return statement|RETURN]]</code> : return control from simple subroutines
; <code>[[GOTO]]</code> : transfer control to another statement
; <code>IF / THEN</code> : decision making
; <code>LET / =</code> : assign formula results to a variable
; <code>PRINT</code> : output results
; <code>DATA</code> : store static data within the program
; <code>READ</code> : input data stored in DATA statements
; <code>REM</code> : comment ("REMark")

It also implemented floating-point numeric variables and arithmetic.

===List of operators===

{|class="wikitable"
|-
!colspan="2"|Arithmetic operators
!colspan="2"|Relational/logical operators
|-
|style="vertical-align: top"|<code>-</code>
|style="vertical-align: top"|Negation (unary op.)
|style="vertical-align: top"|<code>=</code>
|style="vertical-align: top"|Equal To
|-
|style="vertical-align: top"|<code>+</code>
|style="vertical-align: top"|Addition
|style="vertical-align: top"|<code>&lt;&gt;</code>
|style="vertical-align: top"|Not Equal To
|-
|style="vertical-align: top"|<code>-</code>
|style="vertical-align: top"|Subtraction (binary op.)
|style="vertical-align: top"|<code>&lt;</code>
|style="vertical-align: top"|Less Than
|-
|style="vertical-align: top"|<code>*</code>
|style="vertical-align: top"|Multiplication
|style="vertical-align: top"|<code>&lt;=</code>
|style="vertical-align: top"|Less Than or Equal To
|-
|style="vertical-align: top"|<code>/</code>
|style="vertical-align: top"|Division
|style="vertical-align: top"|<code>&gt;</code>
|style="vertical-align: top"|Greater Than
|-
|style="vertical-align: top"|<code>?</code>
|style="vertical-align: top"|Exponentiation
|style="vertical-align: top"|<code>=&gt;</code>
|style="vertical-align: top"|Greater Than or Equal To
|-
!colspan="4"|Grouping operator
|-
|style="vertical-align: top"|<code>(&nbsp;)</code>
|colspan="3" style="vertical-align: top"|Grouping
|}

===List of functions===
; <code>ABS</code> : Absolute value
; <code>ATN</code> : Arctangent value (result in [[radian]]s)
; <code>COS</code> : Cosine value (argument in [[radian]]s)
; <code>EXP</code> : Exponential value
; <code>INT</code> : Integer value
; <code>LOG</code> : Natural Logarithmic value
; <code>RND</code> : Random value
; <code>SIN</code> : Sine value (argument in [[radian]]s)
; <code>SQR</code> : Square root value
; <code>TAN</code> : Tangent value (argument in [[radian]]s)

==Examples==
Early versions of BASIC did not have the ability to read and write external files. To represent lists of data that would normally be read from a file, BASIC included the <code>DATA</code> keyword, which could be followed by an arbitrarily long list of elements, ending only at the limit of the line length. The <code>DATA</code> was non-executable and was skipped if encountered. <code>READ</code> commands would consume the data one by one, keeping track of its location within the complete collection of <code>DATA</code> elements in an internal pointer. In version 3, a <code>RESTORE</code> command was added to reset the pointer to the first <code>DATA</code> command in a program.

In this example, "the first three data values are read into X, Y, and Z respectively. The value -1 is read into N. The next 11 values, .1 through .3, are read into the 11 elements of array B."<ref>{{cite book|title=BASIC Language Reference Mandual|date=January 1975|publisher=Interdata|pages=3–24}}</ref>

<syntaxhighlight lang="basic">
15 READ X, Y, Z
20 READ N
24 FOR I=0 TO 10
25 READ B(I)
26 NEXT I
40 DATA 4.2, 7.5, 25.1, -1, .1, .01, .001, .0001
45 DATA .2, .02, .002, .0002, .015, .025, .3, .03, .003
</syntaxhighlight>

Unlike most subsequent BASICs, Dartmouth BASIC, from the Third Edition onwards, had a matrix keyword, <code>MAT</code>, which could prefix a number of other commands to operate on entire arrays of data with a single command. In this example, from the 1968 manual,<ref>[http://www.bitsavers.org/pdf/dartmouth/BASIC_4th_Edition_Jan68.pdf BASIC, 4th Edition, 1968], page 53</ref> <code>MAT INPUT V</code> is used to input a series of variables. When the user enters nothing on a line, this process ends and the total number of elements is accessed in the <code>NUM</code> pseudovariable.{{efn|Why <code>NUM</code> was not implemented as a function, like <code>LEN()</code>, is a mystery.}} The code then adds up all of the individual elements in the matrix and calculates the average. The Third Edition also added indentation, which is used here to clarify the loop structure.

<syntaxhighlight lang="basic">
5 LET S = 0 
10 MAT INPUT V 
20 LET N = NUM 
30 IF N = 0 THEN 99 
40 FOR I = 1 TO N 
45   LET S = S + V(I) 
50 NEXT I 
60 PRINT S/N 
70 GO TO 5 
99 END
</syntaxhighlight>

==Notes==
{{notelist}}

==References==
===Citations===
{{Reflist|2}}

===Bibliography===
* {{cite journal
 |journal=Science
 |date=11 October 1968
 |volume=162
 |issue=3850
 |first1=John |last1=Kemeny
 |first2=Thomas |last2=Kurtz
 |title=Dartmouth Time-Sharing
 |pages=223–228
 |url=http://dtss.dartmouth.edu/sciencearticle/pages/page01.html
|doi=10.1126/science.162.3850.223
 |pmid=5675464
 |bibcode=1968Sci...162..223K
 |url-access=subscription
 }}
* {{cite book
 |first1=John |last1=Kemeny
 |first2=Thomas |last2=Kurtz
 |title= Back to BASIC: The History, Corruption and Future of the Language
 |publisher=Addison-Wesley
 |date=1985
 |isbn=0-201-13433-0
}}
* {{cite encyclopedia
 |chapter=BASIC
 |encyclopedia=History of Programming Languages I
 |last=Kurtz
 |first=Thomas E.
 |date=1981
 |publisher=[[Association for Computing Machinery|ACM]]
 |isbn=0127450408
 |doi=10.1145/800025.1198404
 |editor-last=Wexelblat
 |editor-first=Richard
 |location=New York
 |pages=[https://archive.org/details/historyofprogram0000hist/page/515 515–537]
 |chapter-url=https://books.google.com/books?id=Hy-jBQAAQBAJ
 |title=History of programming languages
 |url=https://archive.org/details/historyofprogram0000hist/page/515
 }}
* {{cite book
 |title=The Kiewit Computation Center and the Dartmouth Time-Sharing System
 |publisher=Dartmouth College
 |date=1971
 |url=http://dtss.dartmouth.edu/brochure/
 |ref=CITEREFKiewit1971
}}
* {{cite book |title=BASIC version 2 manual |publisher=Dartmouth College |date=October 1964 |url=http://www.bitsavers.org/pdf/dartmouth/dtss/196410_BASIC.pdf |ref=none}}
* {{cite book |title=BASIC version 4 manual |publisher=Dartmouth College |date=January 1968 |url=http://www.bitsavers.org/pdf/dartmouth/dtss/196801_BASIC_4th_Edition.pdf |ref=CITEREFMan4}}
* {{cite book
 |first=Stephen |last=Garland
 |title=Structured Programming, Graphics, and BASIC
 |publisher=Dartrmouth College
 |date=December 1976
}}
* {{cite magazine
 |magazine=Time
 |date=29 April 2014
 |title= Fifty Years of BASIC, the Programming Language That Made Computers Personal
 |url=https://time.com/69316/basic/
 |ref=CITEREFTime2014
}}
* {{cite book
 |title=BASIC Computer Games
 |first=David |last=Ahl
 |date=1978
 |url=https://www.atariarchives.org/basicgames/index.php
 |publisher=Creative Computing
}}
* {{cite web
 |first=Andrea |last=Marconi
 |url=http://www.q7basic.org/History%20of%20BASIC.pdf
 |website=Q7basic
 |title=History of the BASIC Programming Language
 }}
* {{cite encyclopedia
 |title=BASIC
 |encyclopedia = Encyclopedia of Microcomputers: Volume 2 
 |last=Elliott|first=Brig
 |date=1988
 |publisher= CRC Press
 |isbn= 9780824727017
 |editor1-last=Kent|editor1-first= Allen
 |editor2-last= Williams |editor2-first= James
 |pages=133–153
 |url=https://books.google.com/books?id=g2GJG7NEHKUC
}}

==External links==
* [http://dtss.dartmouth.edu/scans/BASIC/BASIC%20Compiler.pdf Listing of the source code for version 2 of the Dartmouth BASIC compiler circa 1965]{{cbignore|bot=medic}} (archived 2007)
* [http://dtss.dartmouth.edu/scans/BASIC/ Scans of original documentation and software.]
* [https://web.archive.org/web/20120702192626/http://www.retrowiki.es/e107_plugins/content/content.php?content.186 Dartmouth BASIC Interpreter], RetroWiki.es

{{BASIC}}

{{DEFAULTSORT:BASIC, Dartmouth}}
[[Category:Dartmouth College history]]
[[Category:Programming languages created in 1964]]
[[Category:Discontinued BASICs|Dartmouth BASIC]]
[[Category:BASIC compilers|Dartmouth BASIC]]
[[Category:Time-sharing]]
[[Category:BASIC programming language family]]
[[Category:1964 software]]