BASIC is a family of general-purpose, high-level programming languages whose design philosophy ...
BASIC
From Wikipedia, the free encyclopedia
BASIC
Screenshot of Atari BASIC, one of the BASIC implementations used by the small and simple home computers of the early 1980s. |
| Paradigm |
Unstructured, later procedural, later object-oriented |
| Designed by |
John George Kemeny and Thomas Eugene Kurtz. |
| First appeared |
May 1, 1964; 52 years ago |
| Major implementations |
| Dartmouth BASIC, Apple BASIC, Atari BASIC, Sinclair BASIC, Commodore BASIC, BBC BASIC, TI-BASIC, Casio BASIC, Microsoft BASIC, Just BASIC, Liberty BASIC, Visual Basic, FreeBASIC, PowerBASIC, PureBASIC |
| Influenced by |
| ALGOL 60, FORTRAN II, JOSS |
| Influenced |
| COMAL, Visual Basic, Visual Basic .NET, Realbasic, GRASS, AutoIt, AutoHotkey |
BASIC (an
acronym for
Beginner's All-purpose Symbolic Instruction Code)
[1] is a family of
general-purpose,
high-level programming languages whose design philosophy emphasizes ease of use. In 1964,
John G. Kemeny and
Thomas E. Kurtz designed the original BASIC language at
Dartmouth College
in the U.S. state of New Hampshire. 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 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.
In the 2010s, BASIC remains popular in many
computing dialects and in new languages influenced by BASIC, such as
Microsoft's
Visual Basic.
History
Before the mid-1960s, the only computers were huge
mainframe computers. Users submitted jobs (calculations or other requests) on
punched cards or similar media to specialist computer operators. The computer stored these, then used a
batch processing
system to run this queue of jobs one after another, allowing very high
levels of utilization of these expensive machines. As the performance of
computing hardware rose through the 1960s,
multi-processing was developed. This allowed a mix of batch jobs to be run together, but the real revolution was the development of
time-sharing. Time-sharing allowed multiple remote interactive users to share use of the computer, interacting with the computer from
computer terminals with keyboards and
teletype printers, and later
display screens, in much the same way as desktop computers or
personal computers would be used later.
Origin
The original BASIC language was released on May 1, 1964 by
John Kemeny and
Thomas Kurtz[2] and implemented under their direction by a team of
Dartmouth College students.
[3][4] The
acronym BASIC comes from the name of an unpublished paper by Thomas Kurtz.
[5] 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 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
area, and put considerable effort into promoting the language. In the
following years, as other dialects of BASIC appeared, Kemeny and Kurtz's
original BASIC dialect became known as
Dartmouth BASIC.
Spread on minicomputers
"Train Basic every day!" — reads a poster (bottom center) in a Russian school. (ca. 1985–1986)
Knowledge of the relatively simple 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 time-sharing operating system. The BASIC language was available for the
Data General Nova, and also central to the
HP Time-Shared 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 Computer Games, published in 1973.
[6][7] 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.
[8]
Explosive growth: the home computer era
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",
[9]
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 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 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 Calisthenics & Orthodontia: Running Light Without Overbyte. Versions were written by
Li-Chen Wang and Tom Pittman.
[10] In 1975 MITS released
Altair BASIC, developed by
Bill Gates and
Paul Allen as the company Micro-Soft,
[11] 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 interpreter, which the machines
booted directly into.
[notes 1] When the
Apple II,
PET 2001, and
TRS-80
were all released in 1977, all three had BASIC as their primary
programming language and operating environment. Upon boot, a 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 and 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 family. The
Atari 8-bit family had its own
Atari BASIC that was modified in order to fit on an 8 kB ROM cartridge. The
BBC published
BBC BASIC, developed by
Acorn Computers Ltd, incorporating many extra
structured programming keywords and advanced floating-point operation features.
As the popularity of BASIC grew in this period, computer magazines
published complete source code in 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
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 games converted into the Microsoft
dialect and published it from
Creative Computing as
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.
[12][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 would also have gaming as an introductory focus. On the business-focused
CP/M computers which soon became widespread in small business environments,
Microsoft BASIC (
MBASIC) was one of the leading applications.
[15]
IBM PC and compatibles
When IBM was designing the
IBM PC they followed the paradigm of existing home computers in wanting to have a built-in BASIC. They sourced this from Microsoft -
IBM Cassette BASIC - but Microsoft also produced several other versions of BASIC for
MS-DOS/
PC DOS including
IBM Disk BASIC (BASIC D),
IBM BASICA (BASIC A),
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 published
Turbo Basic 1.0 in 1985 (successor versions are still being marketed by the original author under the name
PowerBASIC). Microsoft wrote the windowing-based
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 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++ became the languages of choice for professional
"shrink wrap" application development.
[16][17]
Visual Basic
BASIC's fortunes reversed once again with the introduction in 1991 of
Visual Basic
("VB") by Microsoft. This was an evolutionary development of
QuickBasic, and included constructs from other languages such as block
structured control statements including "With" and "For Each",
parameterized subroutines, optional static typing, and a full
object oriented language.
But the language retained considerable links to its past, such as the
Dim statement for declarations, "Gosub"/Return statements, and even line
numbers which were still needed to report errors properly. An important
driver for the development of Visual Basic was as the new
macro language for
Microsoft Excel, a
spreadsheet
program. Ironically, given the origin of BASIC as a "beginner's"
language, and apparently even to the surprise of many at Microsoft who
still initially marketed it as a language for hobbyists, the language
had come 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 processing speed was less of a concern than ease of development.
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 had become a marketable job skill. Microsoft
also produced
VBScript in 1996 and
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.
Post-1990 versions and dialects
Many other 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 and
True BASIC
(the direct successor to Dartmouth BASIC from a company controlled by
Kurtz). Several web-based simple BASIC interpreters also now exist,
including
Quite BASIC and Microsoft's
Small Basic (educational software). Versions of BASIC have been showing up for use on
smartphones and tablets. Apple
App Store contains such implementations of BASIC programming language as
smart BASIC,
Basic!,
HotPaw Basic,
BASIC-II,
techBASIC and others. Android devices feature such implementations of BASIC as
RFO 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 and
Nintendo DSi called
Petit Computer
allows for programming in a slightly modified version of BASIC with DS
button support. A 3DS sequel was released in Japan in November 2014.
Calculators
Variants of BASIC are available on graphing and otherwise
programmable calculators made by
Texas Instruments, HP, Casio, and others.
[18]
Windows command line
QBasic, a version of Microsoft
QuickBasic without the linker to make EXE files, is present in the
Windows NT and DOS-
Windows 95 streams of operating systems and can be obtained for more recent releases like
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
for the home and office power user and small scale professional
development; QuickC and QuickPascal are the other two. For
Windows 95
and 98, which do not have 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
The various Microsoft, Lotus, and Corel office suites and related
products are programmable with 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.
[19]
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;
[20]
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
[21]
SaxBasic and WWB are also very similar to the Visual Basic line of
Basic implementations. The pre-Office 97 macro language for Microsoft
Word is known as
WordBasic. Excel 4 and 5 use Visual Basic itself as a macro language. Many
Linux distributions include
Chipmunk Basic, an old school interpreter similar to BASICs of the 1970s. Chipmunk Basic is also available for
Microsoft Windows and
OS X.
Nostalgia
The
ubiquity of 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 mourned the loss of ubiquitous BASIC in a 2006
Salon article
[22] as have others who first used computers during this era. In turn, the article prompted Microsoft to develop and release
Small Basic.
[23] Dartmouth held a 50th anniversary celebration for BASIC on 1 May 2014
[24] as did other organisations; at least one organisation of VBA programmers organised a 35th anniversary observance in 1999.
[25]
Syntax
Typical BASIC keywords
- 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 functions were modelled on FORTRAN
single-line functions. 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.
- 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 a visual, screen representation of the flow of BASIC
commands by displaying the number of each command line as it is run. The
TRON command,
largely obsolete now, stood for, TRace ON. This meant that command line
numbers were displayed as the program ran, so that the command lines
could be traced. This command allowed easier debugging
or correcting of command lines that caused problems in a program.
Problems included a program terminating without providing a desired
result, a program providing an obviously erroneous result, a program
running in a non-terminating loop, or a program otherwise having a
non-obvious error.
- TROFF: turns off the display of the number of each command line as command lines run after the command TRON has been used.
Data types and variables
Minimal
versions of 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
could contain integers, floating point or string variables.
Some dialects of 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
Unstructured BASIC
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
[26] 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 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 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
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
Second-generation BASICs (for example,
VAX Basic,
SuperBASIC,
True BASIC,
QuickBASIC,
BBC BASIC,
Pick BASIC and
PowerBASIC)
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.
[27] 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 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
BASIC with object-oriented features
Third-generation BASIC dialects such as
Visual Basic,
Xojo,
StarOffice Basic and
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 became more and more available to the BASIC language.
The following example is in
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
- 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 (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 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 (withdrawn, similar to ANSI X3.113-1987)
See also
References
Notes
Knowledge of the relatively simple 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 time-sharing operating system. The BASIC language was available for the Data General Nova, and also central to the HP Time-Shared 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."Train Basic every day!" — reads a poster (bottom center) in a Russian school. (ca. 1985–1986)
Commodore BASIC v2.0 on the Commodore 64
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",[9] 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.MSX BASIC version 3.0
When IBM was designing the IBM PC they followed the paradigm of existing home computers in wanting to have a built-in BASIC. They sourced this from Microsoft - IBM Cassette BASIC - but Microsoft also produced several other versions of BASIC for MS-DOS/PC DOS including IBM Disk BASIC (BASIC D), IBM BASICA (BASIC A), 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 published Turbo Basic 1.0 in 1985 (successor versions are still being marketed by the original author under the name PowerBASIC). Microsoft wrote the windowing-based 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 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++ became the languages of choice for professional "shrink wrap" application development.[16][17]IBM Cassette BASIC 1.10
The various Microsoft, Lotus, and Corel office suites and related products are programmable with 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.[19] 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;[20] 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[21] SaxBasic and WWB are also very similar to the Visual Basic line of Basic implementations. The pre-Office 97 macro language for Microsoft Word is known as WordBasic. Excel 4 and 5 use Visual Basic itself as a macro language. Many Linux distributions include Chipmunk Basic, an old school interpreter similar to BASICs of the 1970s. Chipmunk Basic is also available for Microsoft Windows and OS X.BASIC came to some video game systems, like the Nintendo Famicom.
No comments:
Post a Comment