Unofficial FAQ 2.0 1/

 BBS: Inland Empire Archive
Date: 03-21-93 (12:53)             Number: 202
From: QUINN TYLER JACKSON          Refer#: NONE
  To: ALL                           Recvd: NO  
Subj: Unofficial FAQ 2.0    1/       Conf: (2) Quik_Bas
                                QUIK_BAS FAQ2.0

        *                                                              *
        *                   "Ask Doctor JackMack"                      *
        *     The JackMack List of Frequently Asked Questions with     *
        *           Some Simple Public Domain Solutions                *
        *                                                              *


        q1.0    The BASICS of BASIC
        q2.0    Commonly Requested Routines
                s1.0     FINPUT.BAS         -- restricted INPUT routine
                s2.0     COMLINE.BAS        -- parses command line

NOTE:   Neither Quinn Tyler Jackson nor his company, JackMack
        Consulting & Development accepts responsibility for the soundness
        of the following advice.  If your computer is not feeling well,
        or your programming skills seem pained, consult your
        manuals before attempting any of these exercises.....

Q1.0    The BASICS of BASIC:

Q1.1    What is the difference between GWBASIC, BASICA, QBASIC, QBI,
        and Power BASIC?

A.1.1   Over the years since those first days in 1964 at that now famous
        university, there have been many versions of BASIC.  (Beginner's
        All-purpose Symbolic Instruction Code)  Each version has
        expanded upon the abilities of the previous versions, while
        trying to overcome some of the limitations that earned earlier
        BASICs the then-deserved title of "Beginner's" programming
        language.  In the days of yesteryear, BASIC was mostly an
        interpreted language, as opposed to a compiled language, and
        was run on a large university mainframe computer, with each
        programmer being given only a noisy teletype like terminal that
        fought for its time with the mainframe.  Terminals were noisy and
        things were slow in this world.  That language was truly BASIC.

        As things progressed, however, certain parties made board room
        decisions that put BASIC into the ROM of every home enthusiast
        who could afford a personal computer with the then woppingly huge
        64k of RAM.  IBM's decision to make BASIC a part of the ROM of
        its early personal computers brought BASIC into the livingroom
        and out of the university labs.  Now that it was in the enthusiasts'
        living rooms, however, computer users began to demand more from
        their BASIC than the Dartmouth type BASIC was giving them.  And so,
        slightly more powerful features were added to each new release of
        BASIC dialects, until you could actually use variable names that
        made some kind of sense.  (Instead of a simple LET A=10, one could
        say Apples=10.  What improvement!)

        Time passed, and GW-BASIC and its look-alikes were born.  Such
        features as definable functions were added to the list of
        improvements, and many BASIC programmers were starting to feel
        as if the Beginner's language was starting to lose its beginners
        edge.  Sure, variables were still global to the whole program, but
        things were looking up!  After all, it wasn't just anyone who
        could turn out spaghetti code to solve the mortgage payment
        schedule!  Programming in BASIC was on its way with the introduction
        of GW-BASIC and BASICA.

        Then, in keeping with progress, other innovations were added to the
        BASIC family that seem so natural now, but without which modern
        BASIC programming would be a real drag.  The concept of local
        variable scope leapt out of the C labratories and into the BASIC
        interpreters and compilers.  Things were really looking up with
        local variables, since they made possible in BASIC somethere
        theretowith unheard of: recursion.  With recursion came some
        real innovation in BASIC programming, let me tell you!  Some
        algorithms are just better suited to recursive programming style
        than they are to the old linear method.

        Microsoft's BASIC series of compilers, in unison with the stepped
        down QuickBASIC versions that inevitably followed as a marketing
        plan, brought to BASIC something no serious programmer would
        ever give up.  Local variables are just too nice to overlook,
        as are definable FUNCTIONs, SUB programs, and a handfull of other
        features that QuickBASIC and compiled BASIC introduced.  And
        of course, through all this, there was competition!  Enter
        Turbo BASIC, now abandoned by Borland, and a few others in the
        shareware field that just didn't quite win the support that
        Microsoft's BASICs enjoyed.  ASIC, TSRBASIC, and company are
        oddities to most, and at best, exercises in imitation that
        didn't quite make it.

        Meanwhile, in the Window's world, everyone was programming either
        in C, or using some code engine that cost them a fortune.  Along
        came VBWIN, which introduced a whole new concept to BASIC, visual
        and event oriented programming.  This carried over eventually to
        DOS, and so were born VBDOS and VBDOS Professional, the replacements
        of QuickBASIC 4.5 and BASIC Professional Development System 7.1.
        Now, some confusion always existed about just what PDS meant.
        Actually, PDS means nothing by itself.  There are professional
        development systems in Microsoft's other programming languages, so
        just a simple PDS could mean anything from MASM 6.1 PDS or
        whatever.  PDS in BASIC circles, however, is always used to
        refer to the more full-featured BASIC compiler system for
        professional programmers.

        Therefore, when Microsoft decided to abandon its non-visually
        and event oriented lines of BASIC, it introduced two versions
        of VBDOS.  One to replace QuickBASIC 4.5, which they called
        VBDOS Standard.  The other to replace BASIC PDS 7.1, which they
        called VBDOS Professional.  It should be noted, however, that
        even VBDOS Standard adopted many features thereto unknown to
        QuickBASIC 4.5.  Such features as arrays in TYPE structures and
        REDIM PRESERVE had thereto been reserved for professionals, I
        suppose.  Now, amateur enthusiasts were allowed to, through
        the introduction of extended features, sometimes called PDS
        EXTENSIONS, do such things as redimension arrays without losing
        their previous contents.  True extensions were added to BASIC
        as well, such as OPTION EXPLICIT, which is used as a tool to
        speedier debugging, sinces it forces the programmer to declare
        all variables in a way only a C programmer would truly love to
        hate.  And of course, the VBDOS pair adopted the event oriented
        style of its first cousin 3.1 times removed: Visual BASIC for
        Microsoft Windows<tm>.

        Meanwhile, another contender reared its head: Power BASIC.  With
        its TSR capabilities and a few other nice features, some feel
        that it is real competition for the Microsoft line of BASICs.

        And all the while, DOS 5.0 users wonder what that QBASIC thingy
        is they got with their upgrade.  Well, that is a stepped down
        version of QuickBASIC, missing a few very important features,
        but it's a good place for someone learning BASIC for the first
        time to start, since it was free with DOS 5.0, and since, as
        a subset of VBDOS and QuickBASIC, one can always step up the
        ladder without changing one's programming habbits too much.
        QBI, a similar release, came with the book _Learn BASIC Now!_
        and probably is a waste of money for anyone with DOS 5.0, unless
        the book is worth the money to you.

Q1.2    So now I know that little bit of history, Quinn, thanks.  What is
        a FUNCTION and SUB, the things that you just mentioned?  I'm a
        GW-BASIC programmer, and haven't heard of these things before.
>>> Continued to next message

 * OLX 2.1 TD * QUIK_BAS FAQ 2.0

--- Maximus/2 2.01wb
 * Origin: The Nibble's Roost, Richmond BC Canada 604-244-8009 (1:153/918)
Outer Court
Echo Basic Postings

Books at Amazon:

Back to BASIC: The History, Corruption, and Future of the Language

Hackers: Heroes of the Computer Revolution (including Tiny BASIC)

Go to: The Story of the Math Majors, Bridge Players, Engineers, Chess Wizards, Scientists and Iconoclasts who were the Hero Programmers of the Software Revolution

The Advent of the Algorithm: The Idea that Rules the World

Moths in the Machine: The Power and Perils of Programming

Mastering Visual Basic .NET