Copyright © Philip M. Parker, INSEAD. Terms of Use.

Basic

Specialty Definition: Basic

Top     

Specialty Definition: Base

(From Wikipedia, the free Encyclopedia)

A base is:

• A number that is raised to a power, or base of an exponential function. This finds common use, for example, in the depiction of numbers, for instance, 10 is the base used in the decimal system, whereas 2 is the base in the binary system. See also numeral system and radix
• The base of a logarithmic function.
• One of the parallel sides of a trapezoid or the unequal side of an isosceles triangle.
• Another mathematical meaning is described in the topology glossary.
• Base of a transform in mathematics
• In biochemistry, see nitrogenous base.
• In baseball, a base is one of 4 bags placed at corners of the infield diamond that a player has to run to after hitting the ball.
• In a transistor the base is the controlling connection to the junction.
• BASE jumping is a popular variation on skydiving.
• The name of the terrorist group Al-Qaida translates as "the base."
• In 2001, the catchphrase "All your base are belong to us" swept across the Internet.
• In chemistry, a base is the reactive complement to an acid. (Sometimes the term alkali has been used historically where base is now preferred.) See Acid-base reaction theories. Technically, a substance capable of neutralizing acid, with a pH greater than 7.0. See Table of bases
• Base is also an isolated settlement in inhospitable conditions that must rely on outide help in order to survive, such as military base, Anctarctica base, Moon base.

  Source: adapted by the editor from Wikipedia, the free encyclopedia under a copyleft GNU Free Documentation License (GFDL) from the article "Base."

Top     

Base (chemistry)

(From Wikipedia, the free Encyclopedia)

In chemistry, a base is a compound that is the opposite of an acid in the sense that it will neutralize an acid. Common bases include compoundss such as some metal oxides and hydroxides, and ammonia.

An acid "donates" H+ ions to the solution, while a base "accepts" H+ ions _or_ donates OH- ions. Both of those actions will decrease the hydrogen ion (H+) concentration, and thus increase pH (-log[H+])

Soluble bases (alkalis) produce hydroxyl ion (OH^-) in aqueous solution and have a pH above 7.

Example:

The amino group (NH2) acts as a base by accepting a H+ ions from the solution. It does this by forming a coordiate covalent bond with the unshared pair of electrons belonging to the nitrogen atom. This decreases the hydrogen ion concentration.

Sodium hydroxide (NaOH) decomposes into Na+ and OH-, lowering the hydrogen ion concentration because the hydroxide ion will accept hydrogen ions to form water.

See also: acid-base reaction theories. alkaline foods

Source: adapted by the editor from Wikipedia, the free encyclopedia under a copyleft GNU Free Documentation License (GFDL) from the article "Base (chemistry)."

Top     

Basic

(From Wikipedia, the free Encyclopedia)

The word basic may refer to one of several articles in Wikipedia:

• Basic English
• BASIC programming language
• Basic (chemistry), the opposite to acidic, reacting with acids to form salts.
• Basic (geology), of rock: containing less than 52% of silica.
• Basic (movie), 2003 film starring John Travolta and Samuel L. Jackson

Source: adapted by the editor from Wikipedia, the free encyclopedia under a copyleft GNU Free Documentation License (GFDL) from the article "Basic."

Top     

Basic (dance move)

(From Wikipedia, the free Encyclopedia)

The site were u can find so good info. Come and get ur info here so see ya some time email me at footballman20015@aol.com The '''basicc f] j ''' dance move is the simplest of all Lindy hop moves. Essentially, the guy (lead) and girl (follow) remain in the same place for 2, 4, 6, or 8 counts. The basic dance move is common to all Swing dance forms.

There are many variations to the basic. This page also include freezes. The basic is closely related to the sugar push.

There are many stylizations and variations.

Open Position

In open position, partners stand facing each other at an arm's length apart. They may hold one or two hands. They may have parallel or crossed arms.

Basic:

Spins

Follow Spin: Girl spins. Overhead: Spin left or right. Push-down spin. (push shoulders down). Straight arm spin, multiple times. Rock-step-spin, with hip reverse and free-spin.

Spins with the girl's left hand, overhead, free, pull to cuddle.

Lead Spins: The lead can spin into the follow's arm, so it ends up on his shoulder.

Both Spin: She goes, he goes. Both do inner turns.

Barrel Roll: She does inner turn, he does outer turn. Or they both go the other way.

Both Free Spin:

Alternating Spins: This has crossed hands grip. They alternate spinning, often the girl goes first. Spins may end when the guy looks at the girl and turns back, or when the girl looks at the guy and turns back.

Double-handed Spins: Double-handed spins, each goes as far as possible (shoulder lock).

Arm

Kick: Kick over arm, release arm, grab arm

Duck Under Arm: The follow's right arm (or left arm) rests on the lead's shoulder. The lead ducks under her arm to move it to the other shoulder.

Pushing and Pulling (Retitle)

Leans: The follow leans away from lead who counterbalances (4 counts), follow leans toward lead who counterbalances (4 counts).

Arm Arcs: The arm leads up an over left (4 counts), then up and over right (4 counts).

Arm Loops: Arm loops may move toward lead or follow. Arm loops bring the follow from open position to closed position. When lead puts his left arm over head, his right arm can go to back.

Arm Stuff: Spin with arm stuff. These are complex are, like Todd and Emily or Steve and Rebecca.

Girl Push: Girl push guy's chest.

Girl Pull: Girl pull guy's shirt or tie.

Freeze

This means simply hold a pose. (Rethink)

Basic Pose: Hold shape in whatever position you are in.

Body Rolls: Body rolls. See hip hop for more details.

Shimmy: Shake shoulders.

Hips: Shake hips.

Run: Run in place.

Closed Position

in closed position, the lead and follow stand together, with the lead's right arm on the follow's back.

Basic: Hold in closed position, and do footwork.

Messing Around: Move hips in a big circle, which usually takes 4 to 8 counts.

Wiggle Down: Rock hips left and right, while sinking lower and lower, legs between each other, then stand up.

Spin: Girl spin in arms. (Left, right, apache (to open), overhead, push down, free, single, double, many). Lead with follow's right or left hand.

Kicks:

Side Lean with Kicks: Step on left and lean left, kick with right foot, step on right foot and lean right, kick with left foot.

Body Rolls:

Break: To open

Cuddle to Arm Lock: Double arm grip, with a tuck turn, but don't let go.

Cuddle and Promenade Positions

The cuddle position is double hand hold with the follower next to the lead in closed. The promenade position is the lead with his right arm on follow's right shoulder, standing side by side. Often the lead holds the follow's hand, but not always. Both are side-by-side positions. The follow's hands are crossed in cuddle position and straight in promenade position. (Right hand to left hand, on shoulder or hip)

Peek-a-Boos:

Spin: Cuddle to arm lock.

Spin: Overhead, let go lead's right. Free spin.

Tuck Turn:

Side-to-Side: (footwork?)

Skip Ups: Walk forward, backward, kicks, skips.

Alternate Step in Front:

Messing Around:

Armlock Position

In armlock position, the follow's left arm is behind her back and her right arm is in front of her. The partners face each other and the lead has a crossed arm lead.

Duck Out: From hammerlock, guy ducks out.

Swivels:

Arm lock to Cuddle: Pull to cuddle with a single 1/2 turn, but don't let go.

Tandem Position

In tandem position, one partner stands right behind the other, with one or two hand hold. Often the guy is in front and leads with visual cues. The lead may hold her hand or put her hand on his shoulder.

Something: Pull forward from open tandem to closed tandem, when the follow is behind. He may put up his hand to stop her from running into him.

Imitation: They often do Shorty George, but any footwork will do or alternate the imitation. Also see Charleston for more about tandem position.

Back-to-Back Position

In back-to-back, the dance partners face away from each other, usually not holding hands.

Butt Fight: Stand facing in opposite directions, with butts touching. Shake them.

Butt Bump: When the partners are back to back, the guy sticks his butt back, pushing both apart.

Back-to-Back Charleston: This is not lead.

Style

Point to audience.

Arm blocks and reverses (in spins) (arm, shoulder, hip)

Other Variations

Position: Move forward or back.

Direction: Rotate 1/4 turn in either direction.

Mirror Image: Flip the move left-to-right.

Speed: Move at a different speed, for example, half speed or double speed.

Start Count: Start on any count.

Roles: The girl may lead and the guy may follow.

Combinations

Spin: Armlock to promenade or cuddle and back.

Cuddles: Move follow back and forth from one side to the other. Exit by ducking under the arm (either side).

Pretzel: Duck under arm, around back, duck under arm.

See Also

Dance move - Basic - Sugar push - Side pass - Swing out - Circle - Groucho - Skip up - Aerial - Charleston - Jazz

Dance - Swing - Lindy hop - East coast swing - West coast swing

Lead and follow - Connection - Musicality

To Do

Source: adapted by the editor from Wikipedia, the free encyclopedia under a copyleft GNU Free Documentation License (GFDL) from the article "Basic (dance move)."

Top     

Basic Pokémon

(From Wikipedia, the free Encyclopedia)

The following is an alphabetical list of Basic Pokémon:

• Bulbasaur
• Caterpie
• Charmander
• Pidgey
• Rattata
• Squirtle
• Weedle

Also see

• Stage 1 Pokémon
• Stage 2 Pokémon

This list will be expanded as more Pokémon entries are created on Wikipedia.

Source: adapted by the editor from Wikipedia, the free encyclopedia under a copyleft GNU Free Documentation License (GFDL) from the article "Basic Pok�mon."

Top     

BASIC programming language

(From Wikipedia, the free Encyclopedia)

BASIC is a family of high-level programming languages. Originally devised as a teaching tool, it became widespread on home microcomputers in the 1980s, and remains popular to this day in a handful of heavily altered dialects.

BASIC's name, coined in classic computer science tradition to result in a nice acronym, 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 (the name thus having no relation to C. K. Ogden's series "Basic English"). Some critics have humorously called the language Bill's Attempt to Seize Industry Control in response to Microsoft's policies with respect to BASIC interpreterss included with early IBM PC compatibles.

History

Background

Prior to the mid-1960s, computers were terribly expensive tools that were used only for special-purpose task, running a single "job" at a time. During the 1960s, however, computers started to drop in price to the point where even small companies could afford them, and the speed increased to the point where they often sat idle because there weren't enough jobs for them.

Programming languages of the era tended to be designed, like the machines they ran on, for specific purposes such as scientific formula processing. Since single-job machines were expensive, they also tended to consider execution speed to be the most important feature of all. In general they were hard to use, and tended to be somewhat "ugly".

It was at this time that the concept of time-sharing systems started to become popular. In such a system the processing time of the main computer was "sliced up" and each user was given a small amount in sequence. The machines were fast enough that most users would be fooled into thinking that they had a single fast machine to themselves. In theory timesharing reduced the cost of computing tremendously, as a single machine could be shared among, in theory at least, hundreds of users.

Birth and early years

The original BASIC language was invented in 1964 by John George Kemeny (1926-93) and Thomas Eugene Kurtz (1928-) at Dartmouth College. 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 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 designers of the language also wanted it to remain in the public domain, which helped it to spread.

The eight design principles of BASIC were:

1. Be easy for beginners to use
2. Be a general-purpose language
3. Allow advanced features to be added for experts (while keeping the language simple for beginners)
4. Be interactive
5. Provide clear and friendly error messages
6. Respond fast for small programs
7. Not require an understanding of computer hardware
8. Shield the user from the operating system

The language was based partly on FORTRAN II and partly on Algol 60, with additions to make it suitable for timesharing and matrix arithmetic, BASIC was first implemented on the GE-265¹ mainframe which supported multiple terminals. Contrary to popular belief, it was a compiled language at the time of its introduction. Almost immediately after its release, computer professionals started to deride BASIC as being too slow and too simple.² Such elitism is a recurring theme in the computer industry.

BASIC nevertheless spread to a number of machines, and became fairly popular on newer minicomputers like the DEC PDP series and the Data General Nova. In these instances the language tended to be implemented as an interpreter instead of a compiler, or alternately, both were supplied.

Explosive growth

However it was the introduction of the Altair 8800 microcomputer in 1975 that truly spread BASIC. Most programming languages were too large to fit in the small memory most users could afford on these machines, and with the slow paper tape (or later audio cassette tape) storage (disks of any kind were not available at any price for some years) and the lack of suitable text editors, a small language like BASIC was a good fit. One of the first to appear for this machine was Tiny BASIC, a simple BASIC implementation originally written by Dr. Li-Chen Wang, and then ported onto the Altair by Dennis Allison at the request of Bob Albrecht (who later founded Dr Dobbs Journal). The Tiny BASIC design and the full source code was published 1976 in DDJ.

In 1977 Microsoft (then only two people -- Gates and Allen) released Altair BASIC. Versions then started appearing on other platforms under licence, and millions of copies and variants were soon in use; it became one of the standard languages on the Apple II. By 1979 Microsoft was in talks with several microcomputer vendors, including IBM, to license a BASIC interpreter for their computers. A version was included in the IBM PC's ROM chips and, for PCs without disks, was booted automatically on power up.

As newer companies attempted to follow the success of Altair, IMSAI, North Star, and Apple, and thus created the home computer revolution, BASIC became a standard feature of all but a very few home computers; most came with a BASIC interpreter in ROM (a feature pioneered by the Commodore PET in 1977). Soon there were many millions of machines running BASIC around the world, likely a far greater number than all of the users of all other languages put together. Many programs, especially those on the Apple II and IBM PC, depended on the presence of Microsoft's BASIC interpreter and would not run without it; thus, Microsoft used the copyright license on the BASIC interpreters to gain leverage in negotiations with the computer vendors.

Maturity

Newer and more powerful BASIC versions were created in this time period. Microsoft sold several versions of BASIC for MSDOS / PCDOS including BASICA, GW-BASIC (a BASICA-compatible version that didn't need IBM's ROM), and Quick BASIC. Turbo Pascal-publisher Borland published Turbo BASIC 1.0 in 1985 (successor versions are still sold under the name of PowerBASIC by another company). Various extensions of home computer BASICs appeared, typically with graphics, sound, and DOS commands, as well as facilities for structured programming. Other languages used the widely-understood BASIC syntax as the basis for otherwise completely different systems, GRASS being one example.

However by the latter half of the 1980s newer computers were far more complex and included features (such as graphical user interfaces) that made BASIC less and less suitable for programming them. At the same time computers were progressing from hobbyist interest to tools used primarily for running applications written by others, and programming as a whole became less important for the growing majority of users. BASIC started to fade, although numerous versions remained available.

BASIC's fortunes reversed once again with the introduction of Visual Basic from Microsoft. Although it is somewhat difficult to consider this language to be BASIC (despite its using many familiar BASIC keywords) it has gone on to become one of the most used languages on the Windows platform, and is said to represent some 70 to 80% of all commercial development. Visual Basic for Applications (VBA) was added to Microsoft Excel 5.0 in 1993 and to the rest of the Microsoft Office product line in 1997. Windows 98 included a VBScript interpreter. The most recent Visual Basic version is called VB.NET. The OpenOffice suite includes a BASIC variant reportedly less powerful than its MS counterpart.

The language

Syntax

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. An interpreter which executes programs with this minimal syntax doesn't need a stack. Some early microcomputer implementations were this simple. If one adds a stack, nested FOR-loops and the GOSUB command can be added. A BASIC interpreter with these features requires the code to have line numbers.

Line numbers were a very distinctive aspect of classic home computer BASICs. Alas, use of line numbers has the disadvantage of requiring the programmer to guesstimate ahead of program entry how many lines a given program part will take. This need is most often met by habitually incrementing successive line numbers by a regular interval, say 10, but naturally leads to problems as soon as code added at a later time exceeds the place available between the original lines. To alleviate this problem with early BASIC interpreters, expert users soon wrote their own utility programs for renumbering their programs after initial entry. Some BASIC interpreters later appeared with a built-in RENUMBER command, thus eliminating the most pressing problem with line numbers.

Modern BASIC dialects have abandoned line numbers, and support most (or all) of the structured control and data declaration constructs as known in other languages like C and Pascal (note that there were also some advanced versions of line number based home computer BASICs incorporating such constructs to good effect):

• do - loop - while - until - exit
• on x goto / gosub (switch & case)

Recent variants such as Visual Basic have introduced object-oriented features, and even inheritance in the latest version. Memory management is easier than in many other procedural programming languages because of the commonly included garbage collector (for which one presumably has to pay a run-time performance penalty, however).

The 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. The same applies to other "old" computer languages like COBOL and FORTRAN as well, although the BASIC movement is by far the largest; this may be explained by the large numbers of IT professionals who cut their teeth at BASIC programming during the home computer era in the 1980s.

Procedures and flow control

BASIC doesn't 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 and 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 parameters or local variables. Most modern versions of BASIC such as Microsoft QuickBASIC have added support for full subroutines and functions. This is another area where BASIC varies 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 with 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 its good string manipulation functions. Already early dialects had a set of fundamental functions (LEFT$, MID$, RIGHT$) to deal with strings easily. As 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 type. All numeric variables were floating point. Strings were dynamic 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 with a following character; string identifiers end in $, whereas integers do not. In some dialects, variables must be declared (with DIM) on first usage; other dialects do not require this, but have the option to enforce it -- typically using a directive such as Option Explicit. Many dialects also support additional types, such as 16 and 32-bit integers and floating-point numbers. Additionally some allow the definition of user-defined types, similar to Pascal "records" or C "structs".

Most BASIC dialects beyond the most primitive also support arrays of integers or other types. In some, arrays must be preallocated before they can be used (with the DIM statement). Support for two and higher-dimensional arrays, as well as arrays of non-integer types, are common.

DIM myIntArray(100) AS INTEGER
DIM myNameList(50) AS STRING

Depending on the dialect of BASIC and on use of the Option Base statement, values can range from myIntArray(0) to myIntArr(100), from myIntArr(1) to myIntArr(100) or from myIntArray(LowInteger) to myIntArray(HighInteger).

Relational and logical operators

 =  equal           <=  less than or equal        NOT  logical negation
<>  not equal       >=  greater than or equal     AND  logical conjunction
 <  less than                                     OR   logical disjunction
 >  greater than

(notice that there is no lexical distinction between the equality operator and the assignment operator in BASIC)

Availability and dialect variants

BASIC is available for nearly every microprocessor platform made. One free interpreted version that is compliant with standards and highly cross-platform is Bywater BASIC (bwBASIC). The interpreter is written in C and comes under a GNU license. It is meant for text console programs, and as such does not include a builder for creating graphical user interfaces (GUIs). A free BASIC which does include a GUI builder, is similar to Visual Basic and runs on Windows and Linux is Phoenix Object Basic.

The best known compiled versions are Microsoft's Quick BASIC product line and QBASIC (a version which does not generate standalone programs.) Some versions of Visual Basic are also compiled, although Microsoft has kept Visual Basic at least minimally compatible with even early versions of its own BASICs.

Other versions include PowerBASIC's PowerBASIC programming language, as well as True BASIC's True BASIC, which is compliant with the latest official standards for BASIC. (True BASIC Inc. was founded by the original creators of Dartmouth BASIC.)

REALbasic is a variant available for the Apple Macintosh which also generates executables for Microsoft Windows. A variant of a simple BASIC dialect for the parrot virtual machine shows how a BASIC interpreter is implemented in an assembly-like language. PureBasic is a variant with a simple syntax but which produces fast and tiny executable files for Windows and Linux. It can as well compile in-line assembly instructions. SmallBASIC is a dialect which runs on many platforms (Win32, DOS, Linux and PalmOS) and comes under a GNU license (GPL).

Examples

Sample 1: Unstructured original BASIC (Applesoft BASIC) ---------- Sample 2: Modern Structured BASIC

 10 INPUT "What is your name: "; U$               INPUT "What is your name"; UserName$
 20 PRINT "Hello "; U$                            PRINT "Hello "; UserName$
 25 REM                                           DO
 30 INPUT "How many stars do you want: "; N          INPUT "How many stars do you want"; NumStars
 35 S$ = ""                                          Stars$ = ""
 40 FOR I = 1 TO N                                   Stars$ = REPEAT$("*", NumStars) '<- ANSI BASIC
 50 S$ = S$ + "*"                                    --or--
 55 NEXT I                                           Stars$ = STRING$(NumStars, "*") '<- MS   BASIC
 60 PRINT S$                                         PRINT Stars$
 65 REM                                              DO
 70 INPUT "Do you want more stars? "; A$                INPUT "Do you want more stars"; Answer$
 80 IF LEN(A$) = 0 GOTO 70                           LOOP UNTIL Answer$ <> ""
 90 A$ = LEFT$(A$, 1)                             LOOP WHILE UCASE$(LEFT$(Answer$, 1)) = "Y"
100 IF (A$ = "Y") OR (A$ = "y") THEN GOTO 30
110 PRINT "Goodbye ";                             PRINT "Goodbye ";
120 FOR I = 1 TO 200                              FOR I = 1 TO 200
130 PRINT U$; " ";                                   PRINT UserName$; " ";
140 NEXT I                                        NEXT I
150 PRINT                                         PRINT

Dialects

• Altair BASIC (MITS Altair, S-100; Microsoft's first product)
• AMOS (Commodore Amiga)
• Apple Business BASIC (Apple ///)
• Applesoft BASIC (Apple II)
• ASIC (MSDOS)
• Atari BASIC (Atari 8-bit family)
• BASIC09 (for Motorola 6809 8-bit and 680x0 16-/32-bit CPUs and the OS9 and OS9 68K operating systems)
• BASICA (Advanced BASIC, available in ROM on IBM PCs) (later disk based versions for PC-DOS)
• BASIC-E (aka 'submarine BASIC')
• BBC BASIC (Acorn/BBC Micro, RISC OS, Cambridge Z88, CP/M, MSDOS)
• Blitz Basic (Commodore Amiga, MSDOS)
• Bywater BASIC (bwBASIC) (MSDOS, POSIX)
• CBASIC (successor of BASIC-E) (CP/M, MSDOS)
• Color BASIC (Tandy/Radio Shack TRS-80 Color Computer)
• Commodore BASIC (PET/CBM, VIC-20, C64, ...)
• Dartmouth BASIC (see also True BASIC)
• Ethos Basic (Windows)
• Extended Color BASIC (TRS-80 Color Computer)
• FutureBASIC (Macintosh)
• Gambas (Linux) (similar approach as Visual Basic)
• GNOME Basic (Linux) (discontinued Visual Basic clone)
• GFA BASIC (Commodore Amiga)
• GW-BASIC (MS-DOS) (BASICA compatible independent of IBM ROM routines)
• Hbasic (Linux) (similar approach as Visual Basic)
• IBasic (Windows)
• Integer BASIC (Apple II)
• Liberty BASIC (Windows)
• Locomotive BASIC (Amstrad CPC)
• LotusScript (Lotus Notes)
• Mallard BASIC (Amstrad PCW, CP/M on ZX Spectrum +3)
• MBASIC (Microsoft BASIC for CP/M)
• MSX BASIC (MSX)
• Phoenix Object Basic (Linux)
• PowerBASIC (successor of Turbo BASIC) (MSDOS, Win32)
• PureBasic (Win32, Linux and Amiga)
• QBASIC (MSDOS)
• Quick Basic (MSDOS)
• REALbasic (Macintosh, Win32)
• Revelation Basic (MSDOS)
• SAM BASIC (Sam Coupé)
• ScriptBasic (Win32 and Linux, GPL)
• Sinclair BASIC (ZX80, ZX81/TS1000, ZX Spectrum)
• SmallBASIC (Linux, MSDOS, Win32, PalmOS; GPL)
• StarOffice Basic (aka StarBasic) (OpenOffice, StarOffice)
• STOS (Atari ST)
• SuperBasic (Sinclair QL)
• THEOS Multi-User Basic
• TI BASIC (Texas Instruments TI 99/4A)
• TI Extended BASIC (ditto)
• Tiny BASIC (any microcomputer, but mostly implemented on early 8080/S-100 based ones)
• True BASIC (DOS, Windows, Macintosh)
• TRS-80 Level  I BASIC (TRS-80)
• TRS-80 Level II BASIC (TRS-80)
• Turbo BASIC (successor of BASIC/Z) (see PowerBASIC)
• VBScript (MS ASP, Windows WSH)
• Visual Basic (Windows)
• Visual Basic for Applications (VBA) (MS Office on Windows and Macintosh)
• Visual Basic .NET (Windows)
• XBasic (Win32 and Linux, GPL)
• YaBasic (Win32 and Linux, GPL)
• Northstar BASIC (sold with a DOS for Processor Technology computers,later for Northstar's own computers...later adapted to the x86 as Bazic '86)

Standards

• ANSI Standard for Minimal BASIC (ANSI X3.60-1978 "FOR MINIMAL BASIC")
• ISO Standard for Minimal BASIC (ISO/IEC 6373:1984 "DATA PROCESSING - PROGRAMMING LANGUAGES - MINIMAL BASIC")
• ANSI Standard for Full BASIC (ANSI X3.113-1987 "PROGRAMMING LANGUAGES FULL BASIC") $79 USD
• ISO Standard for Full BASIC (ISO/IEC 10279:1991 "INFORMATION TECHNOLOGY - PROGRAMMING LANGUAGES - FULL BASIC") $53 USD
• ANSI Addendum Defining Modules (X3.113 INTERPRETATIONS-1992 "BASIC TECHNICAL INFORMATION BULLETIN # 1 INTERPRETATIONS OF ANSI 03.113-1987")
• ISO Addendum Defining Modules (ISO/IEC 10279:1991/ Amd 1:1994 "MODULES AND SINGLE CHARACTER INPUT ENHANCEMENT")

External links

• wxBASIC: Open Source BASIC interpreter with cross-platform GUI library
• Tiny BASIC (Dead link)
• GFA Basic
• Ethos Basic

References and notes

• Lien, David A. (1986). The Basic Handbook: Encyclopedia of the BASIC Computer Language (3rd ed.). Compusoft Publishing. ISBN 0932760333. Documents dialect variation for over 250 versions of BASIC.

• Kemeny, John G.; & Kurtz, Thomas E. (1985). Back To BASIC -- The History, Corruption, and Future of the Language. Addison Wesley Publishing. ISBN 0-201-13433-0.

¹Per correspondence with Thomas E. Kurtz.

Based on an article originally written for Nupedia by Peter Fedorow

²In a 1968 article Edsger Dijkstra considered programming languages using GOTO statements for program structuring purposes, harmful for the productivity of the programmer and the quality of the resulting code (Communications of the ACM Volume 11, 147-148. 1968, reprinted here). This article does not mention any particular programming language. It merely states that the overuse of GOTO is a Bad Thing and gives the technical reasons why this should be so.

In a 1975 tongue-in-cheek article, published in Sigplan Notices Volume 17 No. 5, How do We Tell Truths that Might Hurt (reprinted here), he 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 Dijkstra particularly hated BASIC as a result of its GOTO statement. However BASIC receives no worse treatment than PL/I, COBOL or APL in his articles.

Source: adapted by the editor from Wikipedia, the free encyclopedia under a copyleft GNU Free Documentation License (GFDL) from the article "BASIC programming language."

Top     

Commodore BASIC

(From Wikipedia, the free Encyclopedia)

Commodore BASIC is the dialect of BASIC used in Commodore International's 8-bit home computer line, stretching from the PET of 1977 to the C128 of 1985. The core part was based on 6502 Microsoft BASIC, licensed from the young Microsoft on a "pay once, no royalties" basis.

A very convenient feature of Commodore's ROM-resident BASIC interpreter and KERNAL was the brilliantly implemented full screen editor, which allowed users to input, edit, and enter direct commands as well as program lines anywhere on the screen – simply by pressing the RETURN key whenever the cursor happened to be on a line containing a valid BASIC statement. This marked a huge leap forward in program entry interfaces compared to other common home computer BASICs at the time, which typically used a separate EDIT command for line editing.

Versions (in chronological order, with successively added features)

• V1.0: PET 2001 with chiclet keyboard and built-in Datassette (original PET)
  • bug: arrays limited to 256 elements
  • bug: PEEK command won't work above memory location $C000

• V2.0: PET 2001 with full-size keyboard & upgrade ROMs; VIC-20; C64
  • most 1.0 bugs squashed
  • PET easter egg – enter WAIT 6502, and see what happens...

• V4.0: PET4000, 8000 series (and late version PET 2001's); CBM; CBM-II
  • disk operations: DLOAD,DSAVE,COPY,SCRATCH, etc (15 in all)
  • disk error-channel variables: DS,DS$

• V3.5: C16, Plus/4
  • sound and graphics commands
  • joystick input: JOY
  • hexadecimal conversion: DEC(),HEX$()
  • flexible data read: RESTORE [linenumber]
  • string search function: INSTR
  • formatted printing: PRINT USING,PUDEF
  • alternative branching: ELSE
  • structured looping: DO,LOOP,WHILE,UNTIL,EXIT
  • function key assignment: KEY
  • program entry/editing: AUTO,DELETE,RENUMBER
  • dynamic error handling: TRAP,RESUME,ERR$()
  • debugging: TRON,TROFF

• V7.0: C128
  • more sound and graphics commands, incl sprite handling
  • paddle, lightpen input: POT,PEN
  • exclusive or function: XOR
  • get variable address: POINTER
  • text mode windowing: WINDOW
  • controlled time delay: SLEEP
  • memory management: BANK,STASH,FETCH,SWAP
  • more disk operations: BOOT,BLOAD,BSAVE,DVERIFY,DCLEAR
  • undocumented, working: RREG (read CPU registers after a SYS)
  • undocumented, non-w.: OFF,QUIT

    Source: adapted by the editor from Wikipedia, the free encyclopedia under a copyleft GNU Free Documentation License (GFDL) from the article "Commodore BASIC."

Top     

Locomotive BASIC programming language

(From Wikipedia, the free Encyclopedia)

Locomotive Basic is a proprietary dialect of the BASIC programming language used only on the Amstrad CPC (where it was built-in on ROM) and the Amstrad PCW (on which it is loaded from disc).It was published in two versions: 1.0 which only came with the CPC model 464, and 1.1 which shipped with all other versions. A special update—or rather, a ROM extension—was avaiable on the Amstrad CPC Plus series machines, which added specialised BASIC commands for taking advantage of the extra capabilities of those machines.

It was a rather simple but powerful BASIC implementation by the standards of the day, featuring dedicated commands for handling graphics (such as DRAW, PLOT, INK, PAPER, and CIRCLE,and FILL in v1.1), even allowing the creation of multiple screens, windows, and the like, although the color system and palette handling was awkward.Intereseting enough,a table giving the numeric codes for the 27 system colors was printer over the built in 3" disk drive casing. Also,it granted an almost full control over the CPC sound chip, an AY-3-8912 with 3 melodic channels and 1 noise channel (which was also used on the Sinclair Spectrum,ATARI ST and MSX computers,with none of them having such a complete built-in SOUND command). Everything, from selecting a particular channel or a combination of channels, setting envelopes, volume, pitch, noise, and so on could be done with a single SOUND command, with up to 7 parameters. The only thing that could not be done with BASIC was perhaps playing back digital sampled sounds, like in the game Robocop.

Disk, tape, and file management were managed by BASIC itself,and were usually good enough for simple file management,with commands such as GET,PUT,ERASE,etc. In fact,during those years,the BASIC supplied with low-cost homecomputers also acted as a very simple and crude operating system. Also available were some special commands for memory allocation and handling,like MEMORY and a parametric LOAD command,allowing,for example,to load a file containing "raw" picture data into video memory,causing it to be displayed,with a couple of BASIC instructions.

Locomotive BASIC competed with the Commodore 64's BASIC, which had no dedicated commands for graphics or sound. In general, Locomotive Basic allowed doing pretty much anything that was within the standard capabilities of the machine. This was not unimportant, as on most other machines of the era using graphics or sound was limited to assembler programmers. The only things going clearly beyond BASIC capabilities were the overscan modes used in games and demos, weird 27-color graphics modes, digital sound playback, and smooth scrolling.

Unlike the Sinclair Spectrum or Commodore 64 BASIC, Locomotive BASIC didn't rely on the keyboard having command shortcuts or specialized keys for choosing symbols or colors, save for the "?" abbreviation for the PRINT command and a few scarce and undocumented shortcuts, none too practical anyway: it was a 100% type-in language. Programs could be saved on disk or tape and retrieved as binary or ASCII files.

Drawbacks of Locomotive basic included the lack of structured programming (like almost all other common languages of the era, it was line based), and its rather slow speed, especially when plotting graphics. However,there were several games (even commercial games) for the CPC written in Locomotive BASIC, as well as business applications or utilites written entirely in BASIC.

Source: adapted by the editor from Wikipedia, the free encyclopedia under a copyleft GNU Free Documentation License (GFDL) from the article "Locomotive BASIC programming language."

Top     

Abbreviations & Acronyms: Basic

Top     

Top     

Top     

Modern Usage: Basic

Top     

Commercial Usage: Basic

Top     

Photo Album: Basic

Thumbnail	Description & Credit	Thumbnail	Description & Credit
	Shown are the hands of a technician performing a test. Visible are the test tubes she is working on and a pair of scissors, which she uses in her work. She is performing some basic research concerning breast cancer. Credit: Linda Bartlett (photographer).		The image shows scientists at work in a basic research laboratory. Credit: Bill Branson (photographer).
	The Basic Bench Mark at Pensacola Level party of H. J. Oliver. Credit: Coast & Geodetic Survey Historical Image Collection.		Wiredrag diagram The basic principle is to drag a wire attached to two vessels If the wire encounters an obstruction it will come taut and form a "V". Credit: Coast & Geodetic Survey Historical Image Collection.
	Basic facts and figures about the World Prodigy oil spill incident. Credit: NOAA Restoration Center.		Figure 17. Model of the HIRONDELLE's winch. From the beginnings of Prince Albert I of Monaco's oceanographic explorations, he became occupied with equipping his vessels with basic indispensable deck equipment and tools includin g winches, reels of cable, etc. He gave the engineer Jules LeBlanc responsibili ty for this but became a principle collaborator in this area. Credit: Sailing for Science - the NOAA Fleet Then and Now.
	Airman Basic Wendell Rush stands in front of his fellow airmen prior to basic military training graduation here Oct. 6. Rush, of Centralia, Ill., signed the 34,000th enlistment contract of fiscal 2000 in July, signifying the Air Force's attainment of its.		A head-up display can be a lifesaving tool in difficult flying environments. Students at the U.S. Air Force Test Pilot School are evaluating raster-capable HUDs that show a television-like image underneath basic HUD symbology. (Courtesy photo).
	Plan of the Basic Sciences Building of State University of New York College of Medicine at New York City. Credit: National Library of Medicine.		The University of Texas Southwestern Medical School, Dallas - Basic Science Building. Credit: National Library of Medicine.
Source: pictures compiled by the editor from various references; see picture credits.

Top     

Digital Photo Gallery: Basic
 

"Freedom Teaching a horse" by Olivier Borgognon Commentary: "A horse learning the basic tricks."	"Block the Sun" by James Stephen Windsor Commentary: "The basic idea here was to capture the light of the sun, and make it look like it was radiating out from my hand. Well - that idea failed."
Source: photographs selected by the editor, with permission from the photographers.

Top     

Familiar Quotations: Basic

Top     

Historic Usage: Basic

Top     

Non-Fiction Usage: Basic

Top     

Spoken Usage: Basic

Top     

Speeches: Basic

Top     

Usage Frequency: Basic

Source: compiled by the