A minicomputer, or colloquially mini, is a type of smaller general-purpose computer developed in the mid-1960s and sold at a much lower price than mainframe and mid-size computers from IBM and its direct competitors. In a 1970 survey, The New York Times suggested a consensus definition of a minicomputer as a machine costing less than US$25,000 (equivalent to $188,000 in 2022),
with an input-output device such as a teleprinter and at least four
thousand words of memory, that is capable of running programs in a
higher level language, such as Fortran or BASIC.
The class formed a distinct group with its own software
architectures and operating systems. Minis were designed for control,
instrumentation, human interaction, and communication switching as
distinct from calculation and record keeping. Many were sold indirectly
to original equipment manufacturers
(OEMs) for final end-use application. During the two-decade lifetime of
the minicomputer class (1965–1985), almost 100 companies formed and
only a half dozen remained.
The term "minicomputer" developed in the 1960s to describe the smaller computers that became possible with the use of transistors and core memory technologies, minimal instructions sets and less expensive peripherals such as the ubiquitous Teletype Model 33 ASR. They usually took up one or a few 19-inch rack cabinets, compared with the large mainframes that could fill a room.
In terms of relative computing power compared to contemporary
mainframes, small systems that were similar to minicomputers had been
available from the 1950s. In particular, there was an entire class of drum machines, like the UNIVAC 1101 and LGP-30, that share some features of the minicomputer class. Similar models using magnetic delay-line memory
followed in the early 1960s. These machines however, were essentially
designed as small mainframes, using a custom chassis and often
supporting only peripherals from the same company. In contrast, the
machines that became known as minicomputers were often designed to fit
into a standard chassis and deliberately designed to use common devices
like the ASR 33.
Another common difference was that most earlier small machines
were not "general purpose", in that they were designed for a specific
role like process control or accounting. On these machines, programming was generally carried out in their custom machine language, or even hard-coded into a plugboard, although some used a form of BASIC. DEC wrote, regarding their PDP-5, that it was "the world’s first commercially produced minicomputer".
It meets most definitions of "mini" in terms of power and size, but was
designed and built to be used as an instrumentation system in labs, not
as a general-purpose computer. Many similar examples of small special-purpose machines exist from the early 1960s, including the UK Ferranti Argus and Soviet UM-1NKh.
The CDC 160,
circa 1960, is sometimes pointed to as an early example of a
minicomputer, as it was small, transistorized and (relatively)
inexpensive. However, its basic price of $100,000 (equivalent to
$989,201 in 2022) and custom desk-like chassis places it within the
"small system" or "midrange computer"
category as opposed to the more modern use of the term minicomputer.
Nevertheless, it retains a strong contender for the term "first
minicomputer".
1960s and 1970s success
Most computing histories point to the 1964 introduction of Digital Equipment Corporation's (DEC) 12-bitPDP-8 as the first minicomputer. Some of this is no doubt due to DEC's widespread use of the term starting in the mid-1960s. Smaller systems, including those from DEC like the PDP-5 and LINC,
had existed prior to this point, but it was the PDP-8 combination of
small size, general purpose orientation and low price that puts it
firmly within the modern definition. Its introductory price of $18,500 (equivalent to $171,794 in 2022) places it in an entirely different market segment than earlier examples like the CDC 160.
In contemporary terms, the PDP-8 was a runaway success, ultimately selling 50,000 examples. Follow-on versions using small scale integrated circuits
further lowered the cost and size of the system. Its success led to
widespread imitation, and the creation of an entire industry of
minicomputer companies along Massachusetts Route 128, including Data General, Wang Laboratories and Prime Computer. Other popular minis from the era were the HP 2100, Honeywell 316 and TI-990.
Raytheon RDS 500 seismic processing system in Benghazi in 1978Varian Data Machines system connected to analogue tape playback system in 1984
Early minis had a variety of word sizes, with DEC's 12 and 18-bit systems being typical examples. The introduction and standardization of the 7-bit ASCII character set led to the move to 16-bit systems, with the late-1969 Data General Nova being a notable entry in this space. By the early 1970s, most minis were 16-bit, including DEC's PDP-11.
For a time, "minicomputer" was almost synonymous with "16-bit", as the
larger mainframe machines almost always used 32-bit or larger word
sizes.
Raytheon RDS 704 onsite seismic processing system in Mogadishu in 1974
As integrated circuit design improved, especially with the introduction of the 7400-series integrated circuits,
minicomputers became smaller, easier to manufacture, and as a result,
less expensive. They were used in manufacturing process control,
telephone switching and to control laboratory equipment. In the 1970s,
they were the hardware that was used to launch the computer-aided design (CAD) industry and other similar industries where a small dedicated system was needed.
The boom in worldwide seismic exploration
for oil and gas in the early 1970s saw the widespread use of
minicomputers in dedicated processing centres close to the data
collection crews. Raytheon Data Systems RDS 704 and later RDS 500 were
predominantly the systems of choice for nearly all the geophysical
exploration as well as oil companies.
At the launch of the MITS Altair 8800 in 1975, Radio Electronics magazine referred to the system as a "minicomputer", although the term microcomputer soon became usual for personal computers based on single-chip microprocessors.
At the time, microcomputers were 8-bit single-user, relatively simple
machines running simple program-launcher operating systems like CP/M or MS-DOS, while minis were much more powerful systems that ran full multi-user, multitasking operating systems, such as VMS and Unix.
The Tandem Computers NonStop product line shipped its first fully fault-tolerant cluster computer in 1976.
Around the same time, minis began to move upward in size.
Although several 24 and 32-bit minis had entered the market earlier, it
was DEC's 1977 VAX, which they referred to as a superminicomputer, or supermini, that caused the mini market to move en-masse to 32-bit architectures. This provided ample headroom even as single-chip 16-bit microprocessors like the TMS 9900 and Zilog Z8000
appeared in the later 1970s. Most mini vendors introduced their own
single-chip processors based on their own architecture and used these
mostly in low-cost offerings while concentrating on their 32-bit
systems. Examples include the Intersil 6100 single-chip PDP-8, DEC T-11 PDP-11, microNOVA and Fairchild 9440 Nova, and TMS9900 TI-990.
Mid-1980s and 1990s decline
By
the early 1980s, the 16-bit market had all but disappeared as newer
32-bit microprocessors began to improve in performance. Those customers
who required more performance than these offered had generally already
moved to 32-bit systems by this time. But it was not long before this
market also began to come under threat; the Motorola 68000 offered a significant percentage of the performance of a typical mini in a desktop platform. True 32-bit processors like the National Semiconductor NS32016, Motorola 68020 and Intel 80386
soon followed. By the mid-1980s, high-end microcomputers offered
compute performance equal to low-end and mid-range minis, and the new RISC approach promised performance levels well beyond the fastest minis, and even high-end mainframes.
All that really separated micros from the mini market was storage
and memory capacity. Both of these began to be addressed through the
later 1980s; 1 MB of RAM became typical by around 1987, desktop hard drives rapidly pushed past the 100 MB range by 1990, and the introduction of inexpensive and easily deployable local area network (LAN) systems provide solutions for those looking for multi-user systems. The introduction of the workstation
machines opened new markets for graphics-based systems that the
terminal-oriented minis could not even address. Minis retained a force
for those using existing software products or those who required
high-performance multitasking, but the introduction of newer operating systems based on Unix began to become highly practical replacements for these roles as well.
Mini vendors began to rapidly disappear through this period. Data
General responded to the changing market by focussing entirely on the
high-performance file server market, embracing a role within large LANs that appeared resilient. This did not last; Novell NetWare rapidly pushed such solutions into niche roles, and later versions of Microsoft Windows did the same to Novell. DEC decided to move into the large-computer space instead, introducing the VAX 9000
mainframe in 1989, but it was a flop in the market and disappeared
after almost no sales. The company then attempted to enter the
workstation and server markets with the DEC Alpha, but was too late to save the company and they eventually sold their remains to Compaq in 1998. By the end of the decade all of the classic vendors were gone; Data General, Prime, Computervision, Honeywell, and Wang, failed, merged, or were bought out.
Today, only a few proprietary minicomputer architectures survive. The IBM System/38 operating system, which introduced many advanced concepts, lives on with IBM's AS/400. Great efforts were made by IBM to enable programs originally written for the IBM System/34 and System/36 to be moved to the AS/400. After being rebranded multiple times, the AS/400 platform was replaced by IBM Power Systems running IBM i. In contrast, competing proprietary computing architectures from the early 1980s, such as DEC's VAX, Wang VS, and Hewlett-Packard's HP 3000 have long been discontinued without a compatible upgrade path. OpenVMS runs on HP Alpha and Intel IA-64 (Itanium) CPU architectures.
Tandem Computers, which specialized in reliable large-scale computing, was acquired by Compaq in 1997, and in 2001 the combined entity merged with Hewlett-Packard. The NonStop Kernel-based NonStop product line was re-ported from MIPS processors to Itanium-based processors branded as 'HP Integrity
NonStop Servers'. As in the earlier migration from stack machines to
MIPS microprocessors, all customer software was carried forward without
source changes. Integrity NonStop continues to be HP's answer for the
extreme scaling needs of its very largest customers. The NSK operating
system, now termed NonStop OS, continues as the base software environment for the NonStop Servers, and has been extended to include support for Java and integration with popular development tools like Visual Studio and Eclipse.
Later, Hewlett-Packard would split into HP and Hewlett-Packard
Enterprise. The NonStop products and the DEC products would then be sold
by HPE.
Several pioneering computer companies first built minicomputers, such as DEC, Data General, and Hewlett-Packard (HP) (who now refers to its HP3000
minicomputers as "servers" rather than "minicomputers"). And although
today's PCs and servers are clearly microcomputers physically,
architecturally their CPUs and operating systems have developed largely
by integrating features from minicomputers.
In the software context, the relatively simple OSs for early microcomputers were usually inspired by minicomputer OSs (such as CP/M's similarity to Digital's single user OS/8 and RT-11 and multi-user RSTS
time-sharing system). Also, the multiuser OSs of today are often either
inspired by, or directly descended from, minicomputer OSs. UNIX was originally a minicomputer OS, while Windows NT kernel—the foundation for all current versions of Microsoft Windows-borrowed design ideas liberally from VMS. Many of the first generation of PC programmers were educated on minicomputer systems.
In addition to the programming language, Kemeny and Kurtz developed the Dartmouth Time Sharing System
(DTSS), which allowed multiple users to edit and run BASIC programs
simultaneously on remote terminals. This general model became popular on
minicomputer systems like the PDP-11 and Data General Nova in the late 1960s and early 1970s. Hewlett-Packard produced an entire computer line for this method of operation, introducing the HP2000
series in the late 1960s and continuing sales into the 1980s. Many
early video games trace their history to one of these versions of BASIC.
The emergence of microcomputers in the mid-1970s led to the development of multiple BASIC dialects, including Microsoft BASIC in 1975. Due to the tiny main memory available on these machines, often 4 KB, a variety of Tiny BASIC dialects were also created. BASIC was available for almost any system of the era, and became the de facto programming language for home computer systems that emerged in the late 1970s. These PCs almost always had a BASIC interpreter installed by default, often in the machine's firmware or sometimes on a ROM cartridge.
BASIC declined in popularity in the 1990s, as more powerful
microcomputers came to market and programming languages with advanced
features (such as Pascal and C) became tenable on such computers. In 1991, Microsoft released Visual Basic, combining an updated version of BASIC with a visual forms builder. This reignited use of the language and "VB" remains a major programming language in the form of VB.NET, while a hobbyist scene for BASIC more broadly continues to exist.
Origin
John G. Kemeny
was the chairman of the Dartmouth College Mathematics Department. Based
largely on his reputation as an innovator in math teaching, in 1959 the
College won an Alfred P. Sloan Foundation award for $500,000 to build a new department building. Thomas E. Kurtz
had joined the department in 1956, and from the 1960s Kemeny and Kurtz
agreed on the need for programming literacy among students outside the
traditional STEM fields. Kemeny later noted that "Our vision was that every student on campus should have access to a computer, and any faculty member should be able to use a computer in the classroom whenever appropriate. It was as simple as that."
Kemeny and Kurtz had made two previous experiments with simplified languages, DARSIMCO (Dartmouth Simplified Code) and DOPE (Dartmouth Oversimplified Programming Experiment). These did not progress past a single freshman class. New experiments using Fortran and ALGOL
followed, but Kurtz concluded these languages were too tricky for what
they desired. As Kurtz noted, Fortran had numerous oddly-formed
commands, notably an "almost impossible-to-memorize convention for
specifying a loop: DO 100,I=1,10,2. Is it '1, 10, 2' or '1, 2, 10', and is the comma after the line number required or not?"
Moreover, the lack of any sort of immediate feedback was a key problem; the machines of the era used batch processing and took a long time to complete a run of a program. While Kurtz was visiting MIT, John McCarthy suggested that time-sharing
offered a solution; a single machine could divide up its processing
time among many users, giving them the illusion of having a (slow)
computer to themselves.
Small programs would return results in a few seconds. This led to
increasing interest in a system using time-sharing and a new language
specifically for use by non-STEM students.
Kemeny wrote the first version of BASIC. The acronymBASIC comes from the name of an unpublished paper by Thomas Kurtz.
The new language was heavily patterned on FORTRAN II; statements were
one-to-a-line, numbers were used to indicate the target of loops and
branches, and many of the commands were similar or identical to Fortran.
However, the syntax was changed wherever it could be improved. For instance, the difficult to remember DO loop was replaced by the much easier to remember FORI=1TO10STEP2, and the line number used in the DO was instead indicated by the NEXT I. Likewise, the cryptic IF
statement of Fortran, whose syntax matched a particular instruction of
the machine on which it was originally written, became the simpler IFI=5THENGOTO100.
These changes made the language much less idiosyncratic while still
having an overall structure and feel similar to the original FORTRAN.
The project received a $300,000 grant from the National Science Foundation, which was used to purchase a GE-225 computer for processing, and a Datanet-30 realtime processor to handle the Teletype Model 33teleprinters
used for input and output. A team of a dozen undergraduates worked on
the project for about a year, writing both the DTSS system and the BASIC
compiler. The first version BASIC language was released on 1 May 1964.
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. Usage in the university rapidly expanded, requiring the main CPU to be replaced by a GE-235,
and still later by a GE-635. By the early 1970s there were hundreds of
terminals connected to the machines at Dartmouth, some of them remotely.
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 expensive computers, usually available only to
lease. They also made it available to high schools in the Hanover, New Hampshire,
area and regionally throughout New England on Teletype Model 33 and
Model 35 teleprinter terminals connected to Dartmouth via dial-up phone
lines, and they 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.
New Hampshire recognized the accomplishment in 2019 when it
erected a highway historical marker in Hanover describing the creation
of "the first user-friendly programming language".
Spread on time-sharing services
The
emergence of BASIC took place as part of a wider movement towards
time-sharing systems. First conceptualized during the late 1950s, the
idea became so dominant in the computer industry by the early 1960s that
its proponents were speaking of a future in which users would "buy time
on the computer much the same way that the average household buys power
and water from utility companies".
General Electric, having worked on the Dartmouth project, wrote
their own underlying operating system and launched an online
time-sharing system known as Mark I. It featured BASIC as one of its
primary selling points. Other companies in the emerging field quickly
followed suit; Tymshare introduced SUPER BASIC in 1968, CompuServe had a version on the DEC-10 at their launch in 1969, and by the early 1970s BASIC was largely universal on general-purpose mainframe computers. Even IBM eventually joined the club with the introduction of VS-BASIC in 1973.
Although time-sharing services with BASIC were successful for a
time, the widespread success predicted earlier was not to be. The
emergence of minicomputers during the same period, and especially
low-cost microcomputers in the mid-1970s, allowed anyone to purchase and
run their own systems rather than buy online time which was typically
billed at dollars per minute.
Spread on minicomputers
The HP 2000 system was designed to run time-shared BASIC as its primary task.
BASIC, by its very nature of being small, was naturally suited to porting to the minicomputer market, which was emerging at the same time as the time-sharing services. These machines had small main memory, perhaps as little as 4 KB in modern terminology, and lacked high-performance storage like hard drives
that make compilers practical. On these systems, BASIC was normally
implemented as an interpreter rather than a compiler due to its lower
requirement for working memory.
A particularly important example was HP Time-Shared BASIC,
which, like the original Dartmouth system, used two computers working
together to implement a time-sharing system. The first, a low-end
machine in the HP 2100
series, was used to control user input and save and load their programs
to tape or disk. The other, a high-end version of the same underlying
machine, ran the programs and generated output. For a cost of about
$100,000, one could own a machine capable of running between 16 and 32
users at the same time.
The system, bundled as the HP 2000, was the first mini platform to
offer time-sharing and was an immediate runaway success, catapulting HP
to become the third-largest vendor in the minicomputer space, behind DEC and Data General (DG).
DEC, the leader in the minicomputer space since the mid-1960s, had initially ignored BASIC. This was due to their work with RAND Corporation, who had purchased a PDP-6 to run their JOSS language, which was conceptually very similar to BASIC. This led DEC to introduce a smaller, cleaned up version of JOSS known as FOCAL,
which they heavily promoted in the late 1960s. However, with
timesharing systems widely offering BASIC, and all of their competition
in the minicomputer space doing the same, DEC's customers were clamoring
for BASIC. After management repeatedly ignored their pleas, David H. Ahl took it upon himself to buy a BASIC for the PDP-8,
which was a major success in the education market. By the early 1970s,
FOCAL and JOSS had been forgotten and BASIC had become almost universal
in the minicomputer market. DEC would go on to introduce their updated version, BASIC-PLUS, for use on the RSTS/E time-sharing operating system.
During this period a number of simple text-based games were written in BASIC, most notably Mike Mayfield's Star Trek.
David Ahl collected these, some ported from FOCAL, and published them
in an educational newsletter he compiled. He later collected a number of
these into book form, 101 BASIC Computer Games, published in 1973. 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.
Commodore BASIC v2.0 on the Commodore 64MSX BASIC version 3.0"Train Basic every day!"—reads a poster (bottom center) in a Russian school (c. 1985–1986)
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, many of whom
had seen BASIC on minis or mainframes. 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",
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.
Partially in response to Gates's letter, and partially to make an even smaller BASIC that would run usefully on 4 KB machines, Bob Albrecht urged Dennis Allison to write their own variation of the language. 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. This led to a wide variety of Tiny BASICs with added features or other improvements, with versions from Tom Pittman and Li-Chen Wang becoming particularly well known.
Micro-Soft, by this time Microsoft, ported their interpreter for the MOS 6502,
which quickly become one of the most popular microprocessors of the
8-bit era. When new microcomputers began to appear, notably the "1977
trinity" of the TRS-80, Commodore PET and Apple II, they either included a version of the MS code, or quickly introduced new models with it. Ohio Scientific's personal computers also joined this trend at that time. By 1978, MS BASIC was a de facto standard and practically every home computer of the 1980s included it in ROM. Upon boot, a BASIC interpreter in direct mode was presented.
Commodore Business Machines included Commodore BASIC,
based on 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 an MS-based version introduced 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. Sinclair BASIC was introduced in 1980 with the Sinclair ZX80, and was later extended for the Sinclair ZX81 and the Sinclair ZX Spectrum. 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. 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.
In 1978, David Lien published the first edition of The BASIC Handbook: An Encyclopedia of the BASIC Computer Language,
documenting keywords across over 78 different computers. By 1981, the
second edition documented keywords from over 250 different computers,
showcasing the explosive growth of the microcomputer era.
These later variations introduced many extensions, 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.
In 1991, 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 was as the new macro language for Microsoft Excel, a spreadsheet
program. To the surprise of many at 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. Microsoft also spun it off as Visual Basic for Applications and Embedded Visual Basic.
While many advanced programmers still scoffed at its use, VB met the needs of small businesses
efficiently as 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, and also
features some cross-platform capability through implementations such as Mono-Basic. The IDE, with its event-drivenGUI builder, was also influential on other tools, most notably Borland Software's Delphi for Object Pascal and its own descendants such as Lazarus.
Mainstream support for the final version 6.0 of the original
Visual Basic ended on March 31, 2005, followed by extended support in
March 2008. Owing to its persistent remaining popularity, third-party attempts to further support it, such as Rubberduck and ModernVB, exist. On February 2, 2017 Microsoft announced that development on VB.NET would no longer be in parallel with that of C#, and on March 11, 2020 it was announced that evolution of the VB.NET language had also concluded. Even so, the language was still supported and the third-party Mercury extension has since been produced. Meanwhile, competitors exist such as B4X, RAD Basic, twinBASIC, VisualFBEditor, InForm, Xojo, and Gambas.
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
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 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 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. Chipmunk Basic, an old-school interpreter similar to BASICs of the 1970s, is available for Linux, Microsoft Windows and macOS.
Legacy
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 as have others who first used computers during this era. In turn, the article prompted Microsoft to develop and release Small Basic; it also inspired similar projects like Basic-256. Dartmouth held a 50th anniversary celebration for BASIC on 1 May 2014, as did other organisations; at least one organisation of VBA programmers organised a 35th anniversary observance in 1999.
Dartmouth College celebrated the 50th anniversary of the BASIC language with a day of events on April 30, 2014. A short documentary film was produced for the event.
Syntax
Typical BASIC keywords
Data manipulation
LET
assigns a value (which may be the result of an expression) to a variable. In most dialects of BASIC, LET is optional, and a line with no other identifiable keyword will assume the keyword to be LET.
DATA
holds a list of values which are assigned sequentially using the READ command.
READ
reads a value from a DATA statement and assigns it to a variable. An internal pointer keeps track of the last DATA element that was read and moves it one position forward with each READ. Most dialects allow multiple variables as parameters, reading several values in a single operation.
RESTORE
resets the internal pointer to the first DATA statement, allowing the program to begin READing
from the first value. Many dialects allow an optional line number or
ordinal value to allow the pointer to be reset to a selected location.
DIM
Sets up an array.
Program flow control
IF ... THEN ... {ELSE}
used to perform comparisons or make decisions. Early dialects only allowed a line number after the THEN, but later versions allowed any valid statement to follow. ELSE was not widely supported, especially in earlier versions.
FOR ... TO ... {STEP} ... NEXT
repeat a section of code a given number of times. A variable that acts as a counter, the "index", 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.
Both of these commands are found mostly in later dialects.
DO ... LOOP {WHILE} or {UNTIL}
repeat a section of code indefinitely or while/until the specified
condition is true. The condition may be evaluated before each iteration
of the loop, or after. Similar to WHILE, these keywords are mostly found in later dialects.
jumps to a numbered or labelled line in the program. Most dialects also allowed the form GO TO.
GOSUB ... RETURN
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 statement 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, plus one letter, i.e., FNA, FNB ...
Input and output
LIST
displays the full source code of the current program.
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
used with PRINT to set the position where the next character will be shown on the screen or printed on paper. AT is an alternative form.
SPC
prints out a number of space characters. Similar in concept to TAB but moves by a number of additional spaces from the current column rather than moving to a specified column.
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 ("User Serviceable Routine")
transfers program control to a machine language subroutine, usually entered as an alphanumeric string or in a list of DATA statements.
CALL
alternative form of USR found in some dialects. Does not require an artificial parameter to complete the function-like syntax of USR, and has a clearly defined method of calling different routines in memory.
TRON / TROFF
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 it back off again.
ASM
some compilers such as Freebasic, Purebasic, and Powerbasic 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
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 BASIC 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 as a sigil,
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,
which can be used to solve 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
A simple game implemented in BASIC
Unstructured BASIC
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:
10PRINT"Hello, World!"20END
An infinite loop could be used to fill the display with the message:
10PRINT"Hello, World!"20GOTO10
Note that the END statement is optional and has no
action in most dialects of BASIC. It was not always included, as is the
case in this example. This same program can be modified to print a fixed
number of messages using the common FOR...NEXT statement:
10LETN=1020FORI=1TON30PRINT"Hello, World!"40NEXTI
Most home computers 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:
10INPUT"What is your name: ";U$20PRINT"Hello ";U$30INPUT"How many stars do you want: ";N40S$=""50FORI=1TON60S$=S$+"*"70NEXTI80PRINTS$90INPUT"Do you want more stars? ";A$100IFLEN(A$)=0THENGOTO90110A$=LEFT$(A$,1)120IFA$="Y"ORA$="y"THENGOTO30130PRINT"Goodbye ";U$140END
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
The original Dartmouth Basic was unusual in having a matrix keyword, MAT. Although not implemented by most later microprocessor derivatives, it is used in this example from the 1968 manual which averages the numbers that are input:
Second-generation BASICs (for example, VAX Basic, SuperBASIC, True BASIC, QuickBASIC, BBC BASIC, Pick BASIC, PowerBASIC, Liberty BASIC, QB64 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. In addition keywords and structures to support repetition, selection and procedures with local variables were introduced.
The following example is in Microsoft QuickBASIC:
REM QuickBASIC exampleREM Forward declaration - allows the main code to call aREM subroutine that is defined later in the source codeDECLARESUBPrintSomeStars(StarCount!)REM Main program followsINPUT"What is your name: ",UserName$PRINT"Hello ";UserName$DOINPUT"How many stars do you want: ",NumStarsCALLPrintSomeStars(NumStars)DOINPUT"Do you want more stars? ",Answer$LOOPUNTILAnswer$<>""Answer$=LEFT$(Answer$,1)LOOPWHILEUCASE$(Answer$)="Y"PRINT"Goodbye ";UserName$ENDREM subroutine definitionSUBPrintSomeStars(StarCount)REMThisprocedureusesalocalvariablecalledStars$Stars$=STRING$(StarCount,"*")PRINTStars$ENDSUB
Object-oriented BASIC
Third-generation BASIC dialects such as Visual Basic, Xojo, Gambas, StarOffice Basic, BlitzMax and PureBasic 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 increasingly accessible to the BASIC language.
PublicModuleStarsProgramPrivateFunctionAsk(promptAsString)AsStringConsole.Write(prompt)ReturnConsole.ReadLine()EndFunctionPublicSubMain()DimuserName=Ask("What is your name: ")Console.WriteLine("Hello {0}",userName)DimanswerAsStringDoDimnumStars=CInt(Ask("How many stars do you want: "))DimstarsAsNewString("*"c,numStars)Console.WriteLine(stars)Doanswer=Ask("Do you want more stars? ")LoopUntilanswer<>""LoopWhileanswer.StartsWith("Y",StringComparison.OrdinalIgnoreCase)Console.WriteLine("Goodbye {0}",userName)EndSubEndModule
_(3300726999).png)
