BASIC programming language |
BASIC is a family of high-level programming language. Originally devised as an easy-to-use programming language, it became widespread on home computer in the 1980s, and remains popular to this day in a handful of heavily evolved dialects. It was devised in 1963 by Profs. John G. Kemeny and Thomas E. Kurtz of Dartmouth College.
BASIC s name stands for Beginner s All-purpose Symbolic Instruction Code, tied to the name of an unpublished paper by the language s co-inventor, Thomas Kurtz.
= BASIC through the years =
=== Background === Prior to the mid-1960s, computers were highly expensive tools used only for special-purpose tasks, which ran a single job at a time (batch processing). During the 1960s, however, computer prices started to drop to where even small companies could afford them, and their speed increased to the point where they often sat idle, without jobs to run.
Programming languages of the era tended to be designed, like the machines on which they ran, for specific purposes such as scientific formula processing. Since single-job machines were expensive, the tendency was to consider execution speed the most important feature of all. In general, they were hard to use, and tended toward a certain ugliness.
It was at this time that the time-sharing system concept started to become popular. In such a system the processing time of the main computer is sliced up and each user is given a small amount in alternation. The machines were fast enough for most users to feel they had a single machine all to themselves. In theory, timesharing reduced the cost of computing tremendously, as a single machine could be shared among hundreds of users.
== Birth and early years ==
The original BASIC language was invented in 1963 by John George Kemeny (1926–1993) and Thomas Eugene Kurtz (1928–) at Dartmouth College and implemented by a team of Dartmouth students under their direction. In the following years, as other dialects of BASIC appeared, Kemeny and Kurtz original BASIC dialect became known as Dartmouth BASIC .
BASIC was designed to allow students to write programs using time-sharing computer terminals. BASIC was intended to address the complexity issues of older languages with a new language designed specifically for the new class of users the time-sharing systems allowed — that is, a simpler user who was not as interested in speed as in simply being able to use the machine.
The eight design principles of BASIC were: # Be easy for beginners to use # Be a general-purpose programming language # Allow advanced features to be added for experts (while keeping the language simple for beginners) # Be interactive # Provide clear and friendly error messages # Respond fast for small programs # Not require an understanding of computer hardware # Shield the user from the operating system
The language was based partly on FORTRAN programming language and partly on Algol programming language, with additions to make it suitable for timesharing and, later, text processing and matrix (math) arithmetic. BASIC was first implemented on the GE-200 series mainframe computer which supported multiple computer terminals. Contrary to popular belief, it was a compiled language at the time of its introduction. Several years after its release, highly-respected computer professionals, notably Edsger W. Dijkstra, expressed their opinions that the use of GOTO statements, which existed in many languages including BASIC, promoted poor programming practices.#Djikstra_footnote Some also derided BASIC as too slow and too simple.
The designers of the language decided that it should remain in the public domain in order to help it spread. They also made it available to high schools in the Dartmouth area and spent a considerable amount of effort in promoting the language. As a result, knowledge of BASIC became relatively widespread for a computer language and BASIC was implemented by a number of manufacturers, and became fairly popular on newer minicomputers like the Digital Equipment Corporation PDP series and the Data General Data General Nova. In these instances the language tended to be implemented as an interpreter instead of a compiler, or alternately, both were supplied.
In a 1975 tongue-in-cheek article, [http://www.cs.virginia.edu/~evans/cs655/readings/ewd498.html How do We Tell Truths that Might Hurt ], Sigplan Notices Volume 17 No. 5, Dijkstra gives a list of uncomfortable truths , including his opinion of several programming languages of the time, such as BASIC. It appears that many people confuse the two articles and conclude that he particularly hated BASIC as a result of its GOTO statement. However, BASIC receives no worse treatment than PL/I, COBOL or APL programming language in his articles.
== Explosive growth ==
Notwithstanding the language s use on several minicomputers, it was the introduction of the ). The Tiny BASIC design and the full source code were published in 1976 in DDJ.
In 1975, Microsoft (then only two people—Bill Gates and Paul Allen) released Altair BASIC programming language. The version written for the Altair was co-authored by Gates, Allen and Monte Davidoff. Versions then started appearing on other platforms under license, and millions of copies and variants were soon in use; it became one of the standard languages on the Apple II family. By 1979, Microsoft was talking with several microcomputer vendors, including International Business Machines, about licensing a BASIC interpreter for their computers. A version was included in the IBM PC Read-only memory chips and PCs without floppy disks automatically booted into BASIC.
Newer companies attempted to follow the successes of Micro_Instrumentation_and_Telemetry_Systems, IMSAI, North Star and Apple Computer, thus creating the home computer revolution; meanwhile, BASIC became a standard feature of all but a very few home computers. Most came with a BASIC interpreter in ROM. Soon there were many millions of machines running BASIC around the world, likely a far greater number than all the users of all other languages put together.
== Maturity ==
Many newer BASIC versions were created during this period. Microsoft sold several versions of BASIC for MS-DOS/PC-DOS including Microsoft BASICA interpreter, Microsoft GW-BASIC interpreter (a BASICA-compatible version that did not need IBM s ROM) and Quick BASIC programming language. Turbo Pascal-publisher Borland published Turbo BASIC programming language 1.0 in 1985 (successor versions are still being sold by another company under the name PowerBASIC programming language). Various extensions of home computer BASIC appeared, typically with graphics, sound and DOS commands, as well as facilities for structured programming. The BBC published BBC BASIC, developed for them by Acorn Computers Ltd, incorporating many extra structuring keywords, as well as comprehensive and versatile direct access to the operating system. It also featured a fully integrated assembler. Other languages used the widely-known BASIC syntax as the basis for otherwise completely different systems, GRASS programming language being one example.
However, by the latter half of the 1980s newer computers were far more complex. At the same time, computers had progressed from a hobbyist interest to tools used primarily for applications written by others, and programming as a whole became less important for the growing majority of users. BASIC started to fade, though numerous versions remained available.
BASIC s fortune reversed once again with the introduction of Visual Basic from Microsoft. Though it is somewhat difficult to consider this language to be BASIC (despite its many familiar BASIC keywords) by the time of writing it had become one of the most-used languages on the Microsoft Windows platform. It is said to represent some 70 to 80% of all commercial development. Microsoft created a variant called WordBasic and used it in versions of MS Word before Word 97. Microsoft added Visual Basic for Applications to Microsoft Excel in 1993, to Access 95 in 1995, and to the rest of its Microsoft Office in 1997. Internet Explorer 3.0 and later and Microsoft Outlook included a VBScript interpreter. The most recent version of Visual Basic is called Visual Basic .NET. The competing OpenOffice suite also includes a BASIC variant.
Many other BASIC variants and adaptations have also sprung up in the last few years, authored by hobbyists, equipment developers, and others. One variant, developed in 1996 out of market need, is the PIC BASIC compiler. A relative of the BASIC Stamp s PBASIC, PIC BASIC allows hobbyists to program microcontrollers using the BASIC language format.
= A look at the language =
== Syntax ==
Basic statements are terminated by line endings unless there is a line continuation character. A very minimal BASIC syntax only needs the LET, PRINT, IF and GOTO commands.
Line numbers were a very distinctive aspect of classic home computer BASIC. Some BASIC interpreters later appeared with a built-in RENUMBER command.
Some (but not all) modern BASIC dialects have abandoned line numbers, and support most (or all) of the structured control and data declaration constructs known in other languages like C programming language and Pascal programming language (note also that some advanced versions of line number-based home computer BASICs incorporated such constructs as these to good effect):
Recent variants such as Visual Basic have introduced object-oriented features, such as the For Each...Loop construct for looping through collections and arrays in VBA and Visual Basic 4 and later, and even inheritance (object-oriented programming) in the latest version. Memory management is easier than in many other procedural programming languages because of the commonly included garbage collection (computer science) (presumably for which, however, one pays a run-time performance penalty).
This wealth of variants shows that the language is an organic one and that it may be seen as a subculture dealing with computer programming rather than as a fixed set of syntactic rules. This applies as well to other old computer languages like COBOL and Fortran, although the BASIC movement is by far the largest; this may be explained by the large number of IT professionals who cut their teeth on BASIC programming during the home computer era in the 1980s.
== Procedures and flow control ==
BASIC does not have a standard external library like other languages such as C. Instead, the interpreter (or compiler) contains an extensive built-in library of intrinsic procedures. These procedures include most of the tools a programmer needs to learn programming and write simple applications, including functions for math, strings, console input/output, graphics and file manipulation.
Some BASIC dialects do not allow programmers to write their own procedures. Programmers must instead write their programs with large numbers of GOTO statements for branching. This can result in very confusing source, commonly referred to as spaghetti code . GOSUB statements branch to simple kinds of Subroutines without (sometimes with) parameters or local variables. Most modern versions of BASIC such as Quick BASIC programming language have added support for full subroutines and functions. This is another area where BASIC differs from many other programming languages. BASIC, like Pascal, makes a distinction between a procedure which does not return a value (called a subroutine) and a procedure which does (called a function). Many other languages (notably C) make no distinction and consider everything a function (with some returning a void value).
While functions in the larger sense of subroutines returning values were a latecomer to BASIC dialects, many early systems supported the definition of one-line mathematical functions by DEF FN ( DEFine FunctioN ). The original Dartmouth BASIC also supported Algol-like functions and subroutines from an early date.
== Data types ==
BASIC is well known for good literal string manipulation functions. Early dialects already had a set of fundamental functions (LEFT$, MID$, RIGHT$) to deal with strings easily. Because strings are often used in everyday applications this was a considerable advantage over other languages at the time of its introduction.
The original Dartmouth BASIC supported only numeric and string data types. There was no integer (computer science) type. All numeric variables were floating point. Strings were dynamic in length. Arrays of both numbers and strings were supported, as well as matrices (two dimensional arrays).
Every modern BASIC dialect at least has the integer and string data types. Data types are usually distinguished by a suffixed character; string identifiers end in $, whereas integers classically ended with a % . In some dialects, variables must be declared (with DIM) on their first usage; other dialects do not require it, but can optionally enforce it—typically using a directive such as Option Explicit (in Visual Basic .NET it is on by default but can be turned off using Option Explicit Off ). Many dialects also support such additional types as 16- and 32-bit integers and floating-point numbers. Some have polynomial , complex , list , and specialized types for the intended use of the implementation. Additionally, some allow user-defined types similar to Pascal record (computer science)s or C structs .
Most BASIC dialects beyond the most primitive also support arrays of integers or other types. In some, arrays must be pre-allocated (with the DIM statement) before they can be used. Support for two- and higher-dimensional arrays, as well as arrays of non-integer types, is common.
Visual Basic .NET DIM myIntArray (100) AS INTEGER DIM myStringArray (50) AS STRING
Depending on the dialect of BASIC, the resulting available elements in the array can vary. In some, commands similar to the first in the example will define a 101-element array of integers with elements from 0-100, others may define a 100-element array of integers with elements 1-100 or, rarely, 0-99. It may also be possible to set a default beginning element number other than 0 or 1 with an additional command such as Option Base . The Visual Basic .NET example will create an array from 0-100.
When working with strings, commands similar to the second may allocate a 50-element array of variable-length strings, or may allocate a single string of 50 characters. Note that they are also subject to the numerical differences mentioned above.
These non-standard and, to some, less than intuitive dimensioning can often trip up the novice (and even the advanced) programmer. Newer dialects offer specific dimensioning, such as DIM myIntArray (10 TO 20) AS INTEGER which would be a 10-element array from 10-20.
== Relational, logical operators ==
= equal = greater than or equal AND logical conjunction < less than OR logical disjunction > greater than
Note that there is no lexical distinction between the assignment operator and the equality operator in BASIC; a single equal sign is used for both. There is, however, a method available to the programmer if a visible difference between the two is wanted: the optional LET keyword allows for assignments to be clearly and unambiguously distinguished from the use of the equality operator. Example: IF X=7 THEN LET Y=3.
= Simple, concise examples =
==Hello world!==
The prototypical Hello world program: 10 PRINT Hello, world! 20 END
==Original vs. Modern style==
Sample 1: Original BASIC (Applesoft BASIC). Note that this example is actually well structured, demonstrating that use of the GOTO statement does not necessarily lead to an unstructured program.
10 INPUT What is your name: ; U$ 20 PRINT Hello ; U$ 25 REM 30 INPUT How many stars do you want: ; N 35 S$ = 40 FOR I = 1 TO N 50 S$ = S$ + * 55 NEXT I 60 PRINT S$ 65 REM 70 INPUT Do you want more stars ; A$ 80 IF LEN(A$) = 0 THEN GOTO 70 90 A$ = LEFT$(A$, 1) 100 IF (A$ = Y ) OR (A$ = y ) THEN GOTO 30 110 PRINT Goodbye ; 120 FOR I = 1 TO 200 130 PRINT U$; ; 140 NEXT I 150 PRINT
Sample 2: Modern Structured BASIC (e.g. QBasic) replacing GOTO statements by more modern keywords.
INPUT What is your name ; UserName$ PRINT Hello ; UserName$ DO INPUT How many stars do you want ; NumStars Stars$ = Stars$ = REPEAT$( * , NumStars)|
|