HOME
The Info List - BBC BASIC


--- Advertisement ---



BASIC
BASIC
(an acronym for Beginner's All-purpose Symbolic Instruction Code)[2] is a family of general-purpose, high-level programming languages whose design philosophy emphasizes ease of use. In 1964, John G. Kemeny, Thomas E. Kurtz
Thomas E. Kurtz
and Mary Kenneth Keller designed the original BASIC
BASIC
language at Dartmouth College
Dartmouth College
in New Hampshire, United States. They wanted to enable students in fields other than science and mathematics to use computers. At the time, nearly all use of computers required writing custom software, which was something only scientists and mathematicians tended to learn. Versions of BASIC
BASIC
became widespread on microcomputers in the mid-1970s and 1980s. Microcomputers usually shipped with BASIC, often in the machine's firmware. Having an easy-to-learn language on these early personal computers allowed small business owners, professionals, hobbyists, and consultants to develop custom software on computers they could afford.[original research?] In the 2010s, BASIC
BASIC
was popular in many computing dialects and in new languages influenced by BASIC, such as Microsoft's Visual Basic.

Contents

1 Origin 2 Spread on minicomputers 3 Explosive growth: the home computer era 4 IBM PC
IBM PC
and compatibles 5 Visual Basic 6 Post-1990 versions and dialects 7 Calculators 8 Windows command line 9 Other 10 Nostalgia 11 Syntax

11.1 Typical BASIC
BASIC
keywords 11.2 Data types and variables 11.3 Examples

11.3.1 Unstructured BASIC 11.3.2 Structured BASIC 11.3.3 Object-oriented BASIC

12 Standards 13 See also 14 Notes 15 References

15.1 General references

16 External links

Origin[edit] The original BASIC
BASIC
language was released on May 1, 1964 by John G. Kemeny and Thomas E. Kurtz[3] and implemented under their direction by a team of Dartmouth College
Dartmouth College
students.[4][5][verification needed] One of the graduate students on the implementation team was Mary Kenneth Keller, one of the first people in the U.S. to earn a PhD in computer science.[6] The acronym BASIC
BASIC
comes from the name of an unpublished paper by Thomas Kurtz.[7] BASIC
BASIC
was designed to allow students to write mainframe computer programs for the Dartmouth Time-Sharing System. It was intended specifically for less technical users who did not have or want the mathematical background previously expected. Being able to use a computer to support teaching and research was quite novel at the time. The language was based on FORTRAN II, with some influences from ALGOL 60 and with additions to make it suitable for timesharing. Initially, BASIC
BASIC
concentrated on supporting straightforward mathematical work, with matrix arithmetic support from its initial implementation as a batch language, and character string functionality being added by 1965. Wanting use of the language to become widespread, its designers made the compiler available free of charge. (In the 1960s, software became a chargeable commodity; until then, it was provided without charge as a service with the very expensive computers, usually available only to lease.) They also made it available to high schools in the Hanover, New Hampshire
New Hampshire
area and put considerable effort into promoting the language. In the following years, as other dialects of BASIC
BASIC
appeared, Kemeny and Kurtz's original BASIC
BASIC
dialect became known as Dartmouth BASIC. Spread on minicomputers[edit]

"Train Basic every day!" — reads a poster (bottom center) in a Russian school. (ca. 1985–1986)

Knowledge of the relatively simple BASIC
BASIC
became widespread for a computer language, and it was implemented by a number of manufacturers, becoming fairly popular on newer minicomputers such as the DEC PDP series, where BASIC-PLUS was an extended dialect for use on the RSTS/E
RSTS/E
time-sharing operating system. The BASIC
BASIC
language was available for the Data General Nova, and also central to the HP Time-Shared BASIC
BASIC
system in the late 1960s and early 1970s, where the language was implemented as an interpreter. A version was a core part of the Pick operating system from 1973 onward, where a compiler renders it into bytecode, able to be interpreted by a virtual machine. During this period a number of simple computer games were written in BASIC, most notably Mike Mayfield's Star Trek. A number of these were collected by DEC employee David H. Ahl and published in a newsletter he compiled. He later collected a number of these into book form, 101 BASIC
BASIC
Computer Games, published in 1973.[8] During the same period, Ahl was involved in the creation of a small computer for education use, an early personal computer. When management refused to support the concept, Ahl left DEC in 1974 to found the seminal computer magazine, Creative Computing. The book remained popular, and was re-published on several occasions.[9] Explosive growth: the home computer era[edit]

Commodore BASIC
Commodore BASIC
v2.0 on the Commodore 64

MSX BASIC version 3.0

The introduction of the first microcomputers in the mid-1970s was the start of explosive growth for BASIC. It had the advantage that it was fairly well known to the young designers and computer hobbyists who took an interest in microcomputers. Despite Dijkstra's famous judgement in 1975, "It is practically impossible to teach good programming to students that have had a prior exposure to BASIC: as potential programmers they are mentally mutilated beyond hope of regeneration",[10] BASIC
BASIC
was one of the few languages that was both high-level enough to be usable by those without training and small enough to fit into the microcomputers of the day, making it the de facto standard programming language on early microcomputers. One of the first BASICs to appear was Tiny BASIC, a simple BASIC variant designed by Dennis Allison at the urging of Bob Albrecht of the Homebrew Computer Club. He had seen BASIC
BASIC
on minicomputers and felt it would be the perfect match for new machines like the MITS Altair 8800. How to design and implement a stripped-down version of an interpreter for the BASIC
BASIC
language was covered in articles by Allison in the first three quarterly issues of the People's Computer Company newsletter published in 1975 and implementations with source code published in Dr. Dobb's Journal of Tiny BASIC
Tiny BASIC
Calisthenics & Orthodontia: Running Light Without Overbyte. Versions were written by Li-Chen Wang
Li-Chen Wang
and Tom Pittman.[11] In 1975 MITS released Altair BASIC, developed by Bill Gates
Bill Gates
and Paul Allen
Paul Allen
as the company Micro-Soft,[12] which eventually grew into corporate giant Microsoft. The first Altair version was co-written by Gates, Allen, and Monte Davidoff. Almost universally, home computers of the 1980s had a ROM-resident BASIC
BASIC
interpreter, which the machines booted directly into.[notes 1] When the Apple II, PET 2001, and TRS-80
TRS-80
were all released in 1977, all three had BASIC
BASIC
as their primary programming language and operating environment. Upon boot, a BASIC
BASIC
interpreter in immediate mode was presented, not the command-line interface used on systems running CP/M or MS-DOS. Commodore Business Machines included a version of Microsoft BASIC. The Apple II
Apple II
and TRS-80
TRS-80
each had two versions of BASIC, a smaller introductory version introduced with the initial releases of the machines and a more advanced version developed as interest in the platforms increased. As new companies entered the field, additional versions were added that subtly changed the BASIC
BASIC
family. The Atari 8-bit family had its own Atari BASIC
Atari BASIC
that was modified in order to fit on an 8 kB ROM cartridge. The BBC
BBC
published BBC
BBC
BASIC, developed by Acorn Computers Ltd, incorporating many extra structured programming keywords and advanced floating-point operation features. As the popularity of BASIC
BASIC
grew in this period, computer magazines published complete source code in BASIC
BASIC
for video games, utilities, and other programs. Given BASIC's straightforward nature, it was a simple matter to type in the code from the magazine and execute the program. Different magazines were published featuring programs for specific computers, though some BASIC
BASIC
programs were considered universal and could be used in machines running any variant of BASIC (sometimes with minor adaptations). Many books of type-in programs were also available, and in particular, Ahl published versions of the original 101 BASIC
BASIC
games converted into the Microsoft
Microsoft
dialect and published it from Creative Computing
Creative Computing
as BASIC
BASIC
Computer Games. This book, and its sequels, provided hundreds of ready-to-go programs that could be easily converted to practically any BASIC-running platform.[8][13][14] The book reached the stores in 1978, just as the home computer market was starting off, and it became the first million-selling computer book. Later packages, such as Learn to Program BASIC
BASIC
would also have gaming as an introductory focus. On the business-focused CP/M
CP/M
computers which soon became widespread in small business environments, Microsoft BASIC (MBASIC) was one of the leading applications.[15] IBM PC
IBM PC
and compatibles[edit]

IBM Cassette BASIC 1.10

When IBM was designing the IBM PC
IBM PC
they followed the paradigm of existing home computers in wanting to have a built-in BASIC. They sourced this from Microsoft
Microsoft
IBM Cassette BASIC – but Microsoft also produced several other versions of BASIC
BASIC
for MS-DOS/PC DOS including IBM Disk BASIC
IBM Disk BASIC
( BASIC
BASIC
D), IBM BASICA
IBM BASICA
( BASIC
BASIC
A), GW-BASIC
GW-BASIC
(a BASICA-compatible version that did not need IBM's ROM) and QBasic, all typically bundled with the machine. In addition they produced the Microsoft BASIC Compiler aimed at professional programmers. Turbo Pascal-publisher Borland
Borland
published Turbo Basic
Turbo Basic
1.0 in 1985 (successor versions are still being marketed by the original author under the name PowerBASIC). Microsoft
Microsoft
wrote the windowed AmigaBASIC
AmigaBASIC
that was supplied with version 1.1 of the pre-emptive multitasking GUI Amiga computers (late 1985 / early 1986), although the product unusually did not bear any Microsoft
Microsoft
marks. These languages introduced many extensions to the original home-computer BASIC, such as improved string manipulation and graphics support, access to the file system and additional data types. More important were the facilities for structured programming, including additional control structures and proper subroutines supporting local variables. However, by the latter half of the 1980s, users were increasingly using pre-made applications written by others, rather than learning programming themselves, while professional programmers now had a wide range of more advanced languages available on small computers. C and later C++
C++
became the languages of choice for professional "shrink wrap" application development.[16][17] Visual Basic[edit] In 1991 Microsoft
Microsoft
introduced Visual Basic, an evolutionary development of QuickBasic. It included constructs from that language such as block-structured control statements, parameterized subroutines, and optional static typing, as well as object-oriented constructs from other languages such as "With" and "For Each". The language retained some compatibility with its predecessors, such as the Dim keyword for declarations, "Gosub"/Return statements, and optional line numbers which could be used to locate errors. An important driver for the development of Visual Basic
Visual Basic
was as the new macro language for Microsoft
Microsoft
Excel, a spreadsheet program. To the surprise of many at Microsoft
Microsoft
who still initially marketed it as a language for hobbyists, the language came into widespread use for small custom business applications shortly after the release of VB version 3.0, which is widely considered the first relatively stable version. While many advanced programmers still scoffed at its use, VB met the needs of small businesses efficiently wherever ease of development was more of a concern than processing speed.[original research?] By that time, computers running Windows 3.1 had become fast enough that many business-related processes could be completed "in the blink of an eye" even using a "slow" language, as long as large amounts of data were not involved. Many small business owners found they could create their own small, yet useful applications in a few evenings to meet their own specialized needs. Eventually, during the lengthy lifetime of VB3, knowledge of Visual Basic
Visual Basic
had become a marketable job skill. Microsoft
Microsoft
also produced VBScript in 1996 and Visual Basic
Visual Basic
.NET in 2001. The latter has essentially the same power as C# and Java but with syntax that reflects the original Basic language.

Three modern Basic variants: Mono Basic, OpenOffice.org Basic and Gambas

Post-1990 versions and dialects[edit] Many other BASIC
BASIC
dialects have also sprung up since 1990, including the open source QB64 and FreeBASIC, inspired by QBasic, and the Visual Basic-styled RapidQ, Basic For Qt and Gambas. Modern commercial incarnations include PureBasic, PowerBASIC, Xojo, Monkey X
Monkey X
and True BASIC
BASIC
(the direct successor to Dartmouth BASIC from a company controlled by Kurtz). Several web-based simple BASIC
BASIC
interpreters also now exist, including Quite BASIC
BASIC
and Microsoft's Small Basic (educational software). Versions of BASIC
BASIC
have been showing up for use on smartphones and tablets. Apple App Store contains such implementations of B ASIC programming language
ASIC programming language
as smart BASIC, Basic!, HotPaw Basic, BASIC-II, tech BASIC
BASIC
and others. Android devices feature such implementations of BASIC
BASIC
as RFO BASIC
BASIC
and Mintoris Basic. Applications for some mobile computers with proprietary OS (CipherLab) can be built with programming environment based on BASIC. An application for the Nintendo 3DS
Nintendo 3DS
and Nintendo DSi
Nintendo DSi
called Petit Computer allows for programming in a slightly modified version of BASIC
BASIC
with DS button support. A 3DS sequel was released in Japan November 2014, in North America October 2015, and in Europe August 2017. Calculators[edit] Variants of BASIC
BASIC
are available on graphing and otherwise programmable calculators made by Texas Instruments, HP, Casio, and others. Windows command line[edit] QBasic, a version of Microsoft
Microsoft
QuickBASIC
QuickBASIC
without the linker to make EXE files, is present in the Windows NT
Windows NT
and DOS- Windows 95
Windows 95
streams of operating systems and can be obtained for more recent releases like Windows 7
Windows 7
which do not have them. Prior to DOS 5, the Basic interpreter was GW-Basic. QuickBasic is part of a series of three languages issued by Microsoft
Microsoft
for the home and office power user and small scale professional development; QuickC and QuickPascal are the other two. For Windows 95
Windows 95
and 98, which do not have QBasic
QBasic
installed by default, they can be copied from the installation disc, which will have a set of directories for old and optional software; other missing commands like Exe2Bin and others are in these same directories. Other[edit]

BASIC
BASIC
came to some video game systems, such as the Nintendo Famicom.

The various Microsoft, Lotus, and Corel office suites and related products are programmable with Visual Basic
Visual Basic
in one form or another, including LotusScript, which is very similar to VBA 6. The Host Explorer terminal emulator uses WWB as a macro language; or more recently the programme and the suite in which it is contained is programmable in an in-house Basic variant known as Hummingbird Basic. The VBScript variant is used for programming web content, Outlook 97, Internet Explorer, and the Windows Script Host. WSH also has a Visual Basic for Applications (VBA) engine installed as the third of the default engines along with VBScript, JScript, and the numerous proprietary or open source engines which can be installed like PerlScript, a couple of Rexx-based engines, Python, Ruby, Tcl, Delphi, XLNT, PHP, and others; meaning that the two versions of Basic can be used along with the other mentioned languages, as well as LotusScript, in a WSF file, through the component object model, and other WSH and VBA constructions. VBScript is one of the languages that can be accessed by the 4Dos, 4NT, and Take Command enhanced shells. SaxBasic and WWB are also very similar to the Visual Basic
Visual Basic
line of Basic implementations. The pre-Office 97 macro language for Microsoft
Microsoft
Word is known as WordBASIC. Excel 4 and 5 use Visual Basic
Visual Basic
itself as a macro language. Chipmunk Basic, an old school interpreter similar to BASICs of the 1970s, is available for GNU/Linux, Microsoft
Microsoft
Windows and macOS. Nostalgia[edit] The ubiquity of BASIC
BASIC
interpreters on personal computers was such that textbooks once included simple "Try It In BASIC" exercises that encouraged students to experiment with mathematical and computational concepts on classroom or home computers. Popular computer magazines of the day typically included type-in programs. Futurist and sci-fi writer David Brin
David Brin
mourned the loss of ubiquitous BASIC
BASIC
in a 2006 Salon article[18] as have others who first used computers during this era. In turn, the article prompted Microsoft
Microsoft
to develop and release Small Basic.[19] Dartmouth held a 50th anniversary celebration for BASIC
BASIC
on 1 May 2014,[20] as did other organisations; at least one organisation of VBA programmers organised a 35th anniversary observance in 1999.[21] Dartmouth College
Dartmouth College
celebrated the 50th anniversary of the BASIC language with a day of events[22] on April 30, 2014. A short documentary film was produced for the event.[23] Syntax[edit] Typical BASIC
BASIC
keywords[edit]

Data manipulation

LET—assigns a value (which may be the result of an expression) to a variable. DATA—holds a list of values which are assigned sequentially using the READ command.

Program flow control

IF ... THEN ... ELSE—used to perform comparisons or make decisions. FOR ... TO ... STEP ... NEXT—repeat a section of code a given number of times. A variable that acts as a counter is available within the loop. WHILE ... WEND and REPEAT ... UNTIL—repeat a section of code while the specified condition is true. The condition may be evaluated before each iteration of the loop, or after. DO ... LOOP WHILE or UNTIL —repeat a section of code Forever or While/Until the specified condition is true. The condition may be evaluated before each iteration of the loop, or after. GOTO—jumps to a numbered or labelled line in the program. GOSUB—jumps to a numbered or labelled line, executes the code it finds there until it reaches a RETURN Command, on which it jumps back to the operator following the GOSUB – either after a colon, or on the next line. This is used to implement subroutines. ON ... GOTO/GOSUB—chooses where to jump based on the specified conditions. See Switch statement for other forms. DEF FN—a pair of keywords introduced in the early 1960s to define functions. The original BASIC
BASIC
functions were modeled on FORTRAN single-line functions. BASIC
BASIC
functions were one expression with variable arguments, rather than subroutines, with a syntax on the model of DEF FND(x) = x*x at the beginning of a program. Function names were originally restricted to FN+one letter.

Input and output

LIST—displays all inputted code. PRINT—displays a message on the screen or other output device. INPUT—asks the user to enter the value of a variable. The statement may include a prompt message. TAB or AT: sets the position where the next character will be shown on the screen or printed on paper.

List of functions

ABS—Absolute value ATN—Arctangent value (result in radians) COS—Cosine value (argument in radians) EXP—Exponential value INT—Integer value LOG—Natural Logarithmic value RND—Random value SIN—Sine value (argument in radians) SQR—Square root value TAN—Tangent value (argument in radians)

Miscellaneous

REM—holds a programmer's comment or REMark; often used to give a title to the program and to help identify the purpose of a given section of code. USR—transfers program control to a machine language subroutine, usually entered as an alphanumeric string or in a list of DATA statements. TRON—turns on display of each line number as it is run ("TRace ON"). This was useful for debugging or correcting of problems in a program. TROFF—turns off the display line numbers. ASM—some compilers such as Freebasic,[24] Purebasic,[25] and Powerbasic[26] also support inline assembly language, allowing the programmer to intermix high-level and low-level code, typically prefixed with "ASM" or "!" statements.

Data types and variables[edit] Minimal versions of BASIC
BASIC
had only integer variables and one- or two-letter variable names, which minimized requirements of limited and expensive memory (RAM). More powerful versions had floating-point arithmetic, and variables could be labelled with names six or more characters long. There were some problems and restrictions in early implementations; for example, Applesoft allowed variable names to be several characters long, but only the first two were significant, thus it was possible to inadvertently write a program with variables "LOSS" and "LOAN", which would be treated as being the same; assigning a value to "LOAN" would silently overwrite the value intended as "LOSS". Keywords could not be used in variables in many early BASICs; "SCORE" would be interpreted as "SC" OR "E", where OR was a keyword. String variables are usually distinguished in many microcomputer dialects by having $ suffixed to their name, and values are often identified as strings by being delimited by "double quotation marks". Arrays in BASIC
BASIC
could contain integers, floating point or string variables. Some dialects of BASIC
BASIC
supported matrices and matrix operations, useful for the solution of sets of simultaneous linear algebraic equations. These dialects would directly support matrix operations such as assignment, addition, multiplication (of compatible matrix types), and evaluation of a determinant. Many microcomputer BASICs did not support this data type; matrix operations were still possible, but had to be programmed explicitly on array elements. Examples[edit] Unstructured BASIC[edit] The original Dartmouth Basic was unusual in having a matrix keyword, MAT.[notes 2] Although dropped by most later microprocessor derivatives it is used in this example from the 1968 manual[27] which averages the numbers that are input:

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

New BASIC
BASIC
programmers on a home computer might start with a simple program, perhaps using the language's PRINT statement to display a message on the screen; a well-known and often-replicated example is Kernighan and Ritchie's Hello world program:

10 PRINT "Hello, World!" 20 END

An infinite loop could be used to fill the display with the message. Most first-generation BASIC
BASIC
versions such as MSX BASIC and GW-BASIC supported simple data types, loop cycles, and arrays. The following example is written for GW-BASIC, but will work in most versions of BASIC
BASIC
with minimal changes:

10 INPUT "What is your name: "; U$ 20 PRINT "Hello "; U$ 30 INPUT "How many stars do you want: "; N 40 S$ = "" 50 FOR I = 1 TO N 60 S$ = S$ + "*" 70 NEXT I 80 PRINT S$ 90 INPUT "Do you want more stars? "; A$ 100 IF LEN(A$) = 0 THEN GOTO 90 110 A$ = LEFT$(A$, 1) 120 IF A$ = "Y" OR A$ = "y" THEN GOTO 30 130 PRINT "Goodbye "; U$ 140 END

The resulting dialog might resemble:

What is your name: Mike Hello Mike How many stars do you want: 7 ******* Do you want more stars? yes How many stars do you want: 3 *** Do you want more stars? no Goodbye Mike

Structured BASIC[edit] Second-generation BASICs (for example, VAX Basic, SuperBASIC, True BASIC, QuickBASIC, BBC
BBC
BASIC, Pick BASIC, PowerBASIC
PowerBASIC
and arguably COMAL) introduced a number of features into the language, primarily related to structured and procedure-oriented programming. Usually, line numbering is omitted from the language and replaced with labels (for GOTO) and procedures to encourage easier and more flexible design.[28] In addition keywords and structures to support repetition, selection and procedures with local variables were introduced. The following example is in QuickBASIC:

DECLARE SUB PrintSomeStars (StarCount!) REM QuickBASIC
QuickBASIC
example INPUT "What is your name: ", UserName$ PRINT "Hello "; UserName$ DO INPUT "How many stars do you want: ", NumStars CALL PrintSomeStars(NumStars) DO INPUT "Do you want more stars? ", Answer$ LOOP UNTIL Answer$ <> "" Answer$ = LEFT$(Answer$, 1) LOOP WHILE UCASE$(Answer$) = "Y" PRINT "Goodbye "; UserName$ END

SUB PrintSomeStars (StarCount) REM This procedure uses a local variable called Stars$ Stars$ = STRING$(StarCount, "*") PRINT Stars$ END SUB

Object-oriented BASIC[edit] Third-generation BASIC
BASIC
dialects such as Visual Basic, Xojo, StarOffice Basic and BlitzMax
BlitzMax
introduced features to support object-oriented and event-driven programming paradigm. Most built-in procedures and functions are now represented as methods of standard objects rather than operators. Also, the Operating System
Operating System
became more and more available to the BASIC
BASIC
language. The following example is in Visual Basic
Visual Basic
.NET:

Public Class StarsProgram Public Shared Sub Main() Dim UserName, Answer, stars As String, NumStars As Integer Console.Write("What is your name: ") UserName = Console.ReadLine() Console.WriteLine("Hello 0 ", UserName) Do Console.Write("How many stars do you want: ") NumStars = CInt(Console.ReadLine()) stars = New String("*", NumStars) Console.WriteLine(stars) Do Console.Write("Do you want more stars? ") Answer = Console.ReadLine() Loop Until Answer <> "" Answer = Answer.Substring(0, 1) Loop While Answer.ToUpper() = "Y" Console.WriteLine("Goodbye 0 ", UserName) End Sub End Class

Standards[edit]

ANSI/ISO/IEC Standard for Minimal BASIC:

ANSI X3.60-1978 "For minimal BASIC" ISO/IEC 6373:1984 "Data Processing — Programming Languages — Minimal BASIC"

ECMA-55 Minimal BASIC
BASIC
(withdrawn, similar to ANSI X3.60-1978) ANSI/ISO/IEC Standard for Full BASIC:

ANSI X3.113-1987 "Programming Languages Full BASIC" INCITS/ISO/IEC 10279-1991 (R2005) "Information Technology – Programming Languages – Full BASIC"

ANSI/ISO/IEC Addendum Defining Modules:

ANSI X3.113 Interpretations-1992 " BASIC
BASIC
Technical Information Bulletin # 1 Interpretations of ANSI 03.113-1987" ISO/IEC 10279:1991/ Amd 1:1994 "Modules and Single Character Input Enhancement"

ECMA-116 BASIC
BASIC
(withdrawn, similar to ANSI X3.113-1987)

See also[edit]

List of BASIC
BASIC
dialects List of Computers With On-Board BASIC

Notes[edit]

^ Probably the only exception was the Jupiter Ace, which instead used Forth. ^ From version 3 onwards.

References[edit]

^ Ring Team (5 December 2017). "Ring programming language and other languages". ring-lang.net. ring-lang.  ^ Kemeny, John G.; Kurtz, Thomas E. (1964). Basic: a manual for BASIC, the elementary algebraic language designed for use with the Dartmouth Time Sharing System (PDF) (1st ed.). Hanover, N.H.: Dartmouth College Computation Center.  ^ " Thomas E. Kurtz
Thomas E. Kurtz
– History of Computer Programming Languages". cis-alumni.org. Retrieved June 13, 2017.  ^ Alfred, Randy (January 5, 2008). "May 1, 1964: First Basic Program Runs". Wired. Retrieved June 13, 2017.  ^ " BASIC Programming
BASIC Programming
Language Nearing 50th Anniversary". The Spreadsheet. 16 (2): 3. February 27, 2014.  ^ Gurer, Denise (January 1995). "Pioneering women in computer science". Communications of the ACM. 38 (1): 45–54. doi:10.1145/204865.204875.  ^ "BASIC". Jargon File. Retrieved June 13, 2017.  ^ a b Ahl, David H. (1973). 101 Basic computer games. Morristown, N.J.: Creative Computing
Creative Computing
Press. OCLC 896774158.  ^ Ahl, David H. (May 11, 1981). "Computer Games". InfoWorld. Vol. 3 no. 9. p. 44. ISSN 0199-6649.  ^ Edsger, Dijkstra (June 18, 1975). "How do we tell truths that might hurt" (PDF). Selected Writings on Computing: A Personal Perspective. Springer-Verlag
Springer-Verlag
(published 1982). pp. 129–131. ISBN 0387906525. OCLC 693424350.  ^ Pittman, Tom. "you had to pay $5 up front to get it..." www.ittybittycomputers.com. Retrieved June 14, 2017.  ^ "We have a BASIC". New Mexico Museum of Natural History and Science. Archived from the original on November 30, 2012. Retrieved April 18, 2007.  ^ Ahl, David H. (1979). More basic computer games. Morristown: Creative Computing
Creative Computing
Press. ISBN 0894801376. OCLC 839377789.  ^ Ahl, David H. (1984). Big computer games. Morris Plains, N.J.: Creative Computing
Creative Computing
Press. ISBN 0916688402. OCLC 872675092.  ^ "Osborne 1". oldcomputers.net. Retrieved June 14, 2017.  ^ Pravin, Jain (2011). The Class Of Java. Pearson Education India. ISBN 9788131755440.  ^ "GNE: the C programming language". fysh.org. Retrieved June 14, 2017. During the 1980s, C compilers spread widely, and C became an extremely popular language.  ^ Brin, David (September 14, 2006). "Why Johnny Can't Code". Salon. Archived from the original on September 18, 2013. Retrieved 2017-06-19.  ^ "Small Basic". Microsoft
Microsoft
Developer Network. Archived from the original on March 17, 2014. Retrieved June 19, 2017.  ^ "Dartmouth plans celebration for 50th anniversary of BASIC
BASIC
computer language". New Hampshire
New Hampshire
Union Leader. April 28, 2014. Retrieved June 14, 2017.  ^ "50th anniversary of BASIC
BASIC
Google
Google
Search". Google.  ^ " BASIC
BASIC
at 50 – Event Schedule". Dartmouth College. Retrieved June 14, 2017.  ^ " BASIC
BASIC
at 50". Dartmouth College. Retrieved June 14, 2017.  ^ "KeyPgAsm". FreeBasic Wiki. Retrieved August 2, 2017.  ^ "Inline x86 ASM". Pure Basic. Retrieved August 2, 2017.  ^ "Using assembly-language in your code". Power Basic. Retrieved August 2, 2017.  ^ Kemeny, John G.; Kurtz, Thomas E. (January 1968). Basic: a manual for BASIC, the elementary algebraic language designed for use with the Dartmouth Time Sharing System (PDF) (4th ed.). Hanover, N.H.: Dartmouth College
Dartmouth College
Computation Center. p. 53.  ^ "Differences Between GW-BASIC
GW-BASIC
and QBasic". 2003-05-12. Archived from the original on 2013-10-19. Retrieved 2008-06-28. 

General references[edit]

Sammet, Jean E. (1969). Programming languages: history and fundamentals. Englewood Cliffs, N.J.: Prentice-Hall. OCLC 819683527.  Kurtz, Thomas E. (1981). "BASIC". In Wexelblat, Richard. History of Programming Languages I. New York: ACM. pp. 515–537. doi:10.1145/800025.1198404 (inactive June 19, 2017). ISBN 0127450408.  Kemeny, John G.; Kurtz, Thomas E. (1985). Back To BASIC: The History, Corruption, and Future of the Language. Addison-Wesley. p. 141. ISBN 9780201134339. OCLC 11399298.  Lien, David A. (1986). The Basic Handbook: Encyclopedia of the BASIC Computer Language (3rd ed.). Compusoft Publishing. ISBN 9780932760333. OCLC 12548310. 

External links[edit]

Wikibooks has a book on the topic of: Programming:BASIC

BASIC
BASIC
at Curlie (based on DMOZ) "BASIC — Beginners All-purpose Symbolic Instruction Code". The Encyclopedia of Computer Languages. Murdoch University.  The Birth of Basic on YouTube

v t e

Programming languages

Comparison Timeline History

APL Assembly BASIC C C++ C# COBOL Fortran Go Groovy Haskell Java JavaScript
JavaScript
(JS) Lisp Lua Objective-C Pascal Perl PHP Python Ruby Shell Smalltalk Swift Visual Basic
Visual Basic
.NET (VB.NET) more...

Category Lists

Alphabetical Categorical Generational Non-English-based

v t e

Dialects of the B ASIC programming language
ASIC programming language
(list)

Classic

Altair BASIC Applesoft BASIC Atari BASIC Atari Microsoft
Microsoft
BASIC Atari ST BASIC BASICA BASIC
BASIC
A+ BASIC
BASIC
Programming BASIC
BASIC
XE BASIC
BASIC
XL Casio BASIC Chipmunk Basic Color BASIC Commodore BASIC Extended Color BASIC Dartmouth BASIC Disk Extended Color BASIC Family BASIC GFA BASIC GW-BASIC HP BASIC
BASIC
for OpenVMS HP Time-Shared BASIC IBM BASIC Integer BASIC Locomotive BASIC Mallard BASIC Microsoft
Microsoft
BASIC MSX BASIC Pure Basic Rocky Mountain BASIC S'- BASIC
BASIC
(Tandy, Casio, Sharp Pocket Computers) ScriptBasic Sinclair BASIC Southampton BASIC
BASIC
System STOS BASIC TI BASIC
BASIC
(TI 99/4A) TI-BASIC (calculators) TI Extended BASIC
TI Extended BASIC
(aka XBasic) Tiny BASIC Turbo-Basic XL Tymshare SUPER BASIC UBASIC Vilnius BASIC XBasic

Procedure-oriented

AmigaBASIC AMOS BASIC ASIC BBC
BBC
BASIC Beta BASIC DarkBASIC FreeBASIC FutureBASIC GFA BASIC GLBasic Liberty BASIC Microsoft
Microsoft
Small Basic PowerBASIC PureBasic QBasic QB64 QuickBASIC SmallBASIC SuperBASIC ThinBasic True BASIC Turbo Basic XBasic Xblite Basic4ppc Visual Test B4J

With object extensions

AutoIt Basic For Qt (KBasic) BlitzMax Chipmunk Basic FreeBASIC Gambas GLBasic Monkey X OpenOffice Basic PowerBASIC ProvideX RapidQ REALbasic Run BASIC Visual Basic Visual Basic
Visual Basic
.NET Xojo

For mobile devices

B4X Basic4android (B4A) Basic4ppc GLBasic NS Basic Basic4ios (B4i)

Microsoft

Microsoft
Microsoft
BASIC

MBASIC IBM BASIC/BASICA GW-BASIC QuickBASIC QBasic

VBScript Visual Basic VBA Visual Basic
Visual Basic
.NET Embedded Visual Basic VB 5 for Microsoft
Microsoft
Excel 5.0

VSTO VSTA

WordBASIC TRS-80
TRS-80
Basics (Level I, Level II, Level III) Microsoft
Microsoft
Small Basic

Third-party VB-like

B4X Basic For Qt Gambas Hummingbird Basic LotusScript WinWrapBasic Xojo

Authority control

LCCN: sh85012076 GND: 4004624-2 SUDOC: 027330176 BNF:

.