article

A BRIEF HISTORY OF BASIC

Email
Submitted on: 6/28/2016 5:07:51 AM
By: Rde 
Level: Beginner
User Rating: By 2 Users
Compatibility: VB 3.0, VB 4.0 (16-bit), VB 4.0 (32-bit), VB 5.0, VB 6.0
Views: 3436
author picture
 
     A BRIEF HISTORY OF BASIC

This article has accompanying files
 
				

A BRIEF HISTORY OF BASIC

by Ethan Winer

Extract from Ethan Winer's "PC Magazine's BASIC Techniques and Utilities" as uploaded to CompuServe by him. Because Ziff Davis found it unprofitable to sell this book any longer, they gave all rights back to Ethan Winer. This is an excellent book for any QB/PDS/VBDOS programmers to read.

INTRODUCTION

BASIC has always been the most popular language for personal computers. It is easy to learn and use, extremely powerful, and some form of BASIC is included for free with nearly every PC. Although BASIC is often associated with beginners and students, it is in fact ideally suited for a wide range of programming projects. Because it offers the best features of a high- level language coupled with direct access to DOS and BIOS system services, BASIC is fast becoming the language of choice for beginners and professional developers alike.

A BRIEF HISTORY OF MICROSOFT COMPILED BASIC

In March of 1982, IBM released the first BASIC compiler for the IBM PC. This compiler, BASCOM 1.0, was written by Microsoft for IBM using code and methods developed by Bill Gates, Greg Whitten, and others. Although Microsoft had already written BASIC compilers for the Apple II and CP/M computers, BASCOM 1.0 was the most powerful they had produced so far.

Compared to the Microsoft BASIC interpreters available at that time, BASCOM 1.0 offered many additional capabilities, and also an enormous increase in program execution speed. Line numbers were no longer mandatory, program statements could exceed 255 characters, and a single string could be as long as 32,767 characters. Further, assembly language subroutines could be linked directly to a compiled BASIC application.

Over the next few years, Microsoft continued to enhance the compiler, and in 1985 it was released by IBM as BASCOM 2.0. This version offered many improvements over the older BASCOM 1.0. Among the most important were multi-line DEF FN functions, dynamic arrays, descriptive line labels (as opposed to numbers), network record locking, and an ISAM file handler. With named subroutines programmers were finally able to exceed the 64K code size limitation, by writing separate modules that could then be linked together. The inclusion of subroutine parameters--long overdue for BASIC- -was an equally important step toward fostering structured programming techniques in the language.

At the same time that IBM released BASCOM 2.0, Microsoft offered essentially the same product as QuickBASIC 1.0, but without the ISAM file handler. However, there was one other big difference between these compilers: QuickBASIC 1.0 carried a list price of only $99. This low price was perhaps the most important feature of all, because high-performance BASIC was finally available to everyone, and not just professional developers.

Encouraged by the tremendous acceptance of QuickBASIC 1.0, Microsoft quickly followed that with QuickBASIC version 2.0 in early 1986. This important new release added an integrated editing environment, as well as EGA graphics capabilities. The editor was especially welcome, because it allowed programs to be developed and tested very rapidly. The environment was further enhanced with the advent of Quick Libraries, which allowed assembly language subroutines to be easily added to a BASIC program. Quick Libraries also helped launch the start of a new class of BASIC product: third-party add-on libraries.

In early 1987 Microsoft released the next major enhancement to QuickBASIC, version 3.0. QuickBASIC 3.0 included a limited form of step and trace debugging, as well as the ability to monitor a variable's value continuously during program execution. Also added was support for the EGA's 43-line text mode, and several new language features. Perhaps most impressive of the new features was the control flow statements DO and LOOP, and SELECT CASE. Beyond merely providing a useful alternative to the IF statement, these constructs also let the compiler generate more efficient code.

Also added with version 3.0 was optional support for an 8087 numeric coprocessor. In order to support a coprocessor, however, Microsoft had to abandon their own proprietary numeric format. Both the Microsoft and IEEE methods for storing single- and double precision numbers use four bytes and eight bytes respectively, but the bits are organized differently. Although the IEEE format which the 8087 requires is substantially slower than Microsoft's own, it is the current standard. Therefore, a second version of the compiler was included solely to support IEEE math.

By the time QuickBASIC 4.0 was announced in late 1987, hundreds of thousands of copies of QuickBASIC were already in use world-wide. With QuickBASIC 4.0, Microsoft had created the most sophisticated programming environment ever seen in a main-stream language: the threaded p-code interpreter. This remarkable technology allowed programmers to enjoy the best features of an interpreted language, but with the execution speed of a compiler.

In addition to an Immediate mode whereby program statements could be executed one by one, QuickBASIC 4.0 also supported program break-points, monitoring the value of multiple variables and expressions, and even stepping *backwards* through a program. This greatly enhanced the debugging capabilities of the language, and increased programmer productivity enormously.

Also new in QuickBASIC 4.0 was support for inter-language calling. Although this meant that a program written in Microsoft BASIC could now call subroutines written in any of the other Microsoft languages, it also meant that IEEE math was no longer an option--it became mandatory. When a QuickBASIC 4.0 program was run on a PC equipped with a coprocessor, floating point math was performed very quickly indeed. However, it was very much slower on every other computer! This remained a sore point for many BASIC programmers, until Microsoft introduced BASIC 6.0 later that year. That version included an alternate math library that was similar to their original proprietary format.

Also added in QuickBASIC 4.0 were huge arrays, long (4-byte) integer variables, user-defined TYPE variables, fixed-length strings, true functions, and support for CodeView debugging. With the introduction of huge arrays, BASIC programmers could create arrays that exceeded 64K in size, with only a few restrictions. TYPE variables let the programmer define a composite data type comprised of any mix of BASIC's intrinsic data forms, thus adding structure to a program's data as well as to its code. The newly added FUNCTION procedures greatly improved on BASIC's earlier DEF FN-style functions by allowing recursion, the passing of TYPE variables and entire arrays as arguments, and the ability to modify an incoming parameter.

Although BASIC 6.0 provided essentially the same environment and compiler as QuickBASIC 4.0, it also included the ability to create programs that could be run under OS/2. Other features of this release were a utility program to create custom run-time libraries, and a copy of the Microsoft Programmer's Editor. The custom run-time utility was particularly valuable, since it allowed programmers to combine frequently- used subroutines with the BRUN.EXE language library, and then share those routines among any number of chained modules.

QuickBASIC 4.5 was introduced in 1988, although the only major enhancement over the earlier 4.0 version was a new help system and slightly improved pull-down menus. Unfortunately, the new menus required much more memory than QuickBASIC 4.0, and the "improved" environment reduced the memory available for programs and data by approximately 40K. To this day, many programmers continue to use QuickBASIC 4.0 precisely because of its increased program capacity.

In answer to programmer's demands for more string memory and smaller, more efficient programs, Microsoft released the BASIC Professional Development System version 7.0 in late 1989. This was an enormous project even for a company the size of Microsoft, and at one point more than fifty programmers were working on the new compiler and QBX environment. PDS version 7.0 finally let BASIC programmers exceed the usual 64K string memory limit, albeit with some limitations.

Other features introduced with that version were an ISAM file handler, improved library granularity, example tool box packages for creating simple graphics and pull-down menus, local error handling, arrays within TYPE variables, and greatly improved documentation. Because the QBX editor uses expanded memory to store subprograms and functions, much larger programs could be developed without resorting to editing and compiling outside of the environment.

Sixth months later PDS version 7.1 was released, with the long-overdue ability to redimension an array but without destroying its contents. Also added in that version were support for passing fixed-length string arrays to subprograms and functions, and an option to pass parameters by value to BASIC procedures. Although the BYVAL option had been available since QuickBASIC 4.0, it was useable only with subroutines written in non-BASIC languages. With this mechanism, BASIC can now create more efficient object code than ever before.

[Just as this book was being completed, Microsoft released Visual Basic for DOS. Although this book does not address VB/DOS specifically, most of the information about BASIC PDS applies to VB/DOS. One notable exception is that VB/DOS supports far strings only, where BASIC PDS lets you specify either near strings or far. Because far strings are stored in a separate "far" area of DOS memory, it takes slightly longer to access those strings. Therefore, a VB/DOS program that is string-intensive will not be as fast as an equivalent compiled with QuickBASIC or with PDS near strings. This book also does not cover the pseudo event-driven forms used by VB/DOS.]

ABOUT THE AUTHOR

Ethan Winer is the founder of Crescent Software, Inc. located Ridgefield Connecticut. He has programmed in BASIC and assembly language since 1980, and is the author of Crescent's QuickPak Professional and P.D.Q. products.

Ethan has also served as a contributing editor for both PC Magazine and BASICPro (now Visual Basic Programmer's Journal), and has written numerous feature articles for other popular computer publications. In 1992 Ethan retired from writing software professionally, and now spends his free time writing and performing music.

winzip iconDownload article

Note: Due to the size or complexity of this submission, the author has submitted it as a .zip file to shorten your download time. Afterdownloading it, you will need a program like Winzip to decompress it.Virus note:All files are scanned once-a-day by Planet Source Code for viruses, but new viruses come out every day, so no prevention program can catch 100% of them. For your own safety, please:
  1. Re-scan downloaded files using your personal virus checker before using it.
  2. NEVER, EVER run compiled files (.exe's, .ocx's, .dll's etc.)--only run source code.
  3. Scan the source code with Minnow's Project Scanner

If you don't have a virus scanner, you can get one at many places on the net including:McAfee.com


Other 15 submission(s) by this author

 


Report Bad Submission
Use this form to tell us if this entry should be deleted (i.e contains no code, is a virus, etc.).
This submission should be removed because:

Your Vote

What do you think of this article (in the Beginner category)?
(The article with your highest vote will win this month's coding contest!)
Excellent  Good  Average  Below Average  Poor (See voting log ...)
 

Other User Comments

6/28/2016 11:42:48 AMjonlegras

For many years, I used BasCom 2.0, QuickBasic 3.0 & 4.5 and PDS 7.1 and even used VB/DOS & VB/Win 1.0 when they first came out.

But the problem is, this is just a history of MS Basic, and even then it doesn't go back to the beginning, doesn't mention GWBasic or IBM BasicA.

VB/DOS was actually actually PDS v7.1 with a few changes and nothing like VB/Win.
VB didn't really become useful until VB3 was release, and it was so different from VB1.
And look at out much loved VB6, how different that is it VB3.

Shame there's not more info to tell the younger generation what it used to be like.
(If this comment was disrespectful, please report it.)

 
6/29/2016 9:58:38 AMdave Carter

Hi Rohan
Thanks for these documents, they are very useful, very well written and very welcome.
Dave
(If this comment was disrespectful, please report it.)

 
6/30/2016 9:00:32 AMRde

Thanks Dave

Yes I agree Jon,
I uploaded this for those who know very little about the history of Basic. (I remember GWBasic)

VB6 truly is the ultimate evolution of many years of development.

Happy coding,
Rd :)
(If this comment was disrespectful, please report it.)

 

Add Your Feedback
Your feedback will be posted below and an email sent to the author. Please remember that the author was kind enough to share this with you, so any criticisms must be stated politely, or they will be deleted. (For feedback not related to this particular article, please click here instead.)
 

To post feedback, first please login.