GW-Basic

John Foust jfoust at threedee.com
Wed Apr 13 14:49:14 CDT 2005


Here's a definitive response from Dr. Greg Whitten on this 
early history of Microsoft's BASIC, as well as other interesting material
on the history of Microsoft's scripting languages, up to 
present-day .NET technologies.

- John

Subject: FW: GW-Basic
MIME-Version: 1.0
Content-Type: text/plain;
	charset="us-ascii"
Content-class: urn:content-classes:message
Date: Wed, 13 Apr 2005 10:59:35 -0700
X-MimeOLE: Produced By Microsoft Exchange V6.5.7226.0
Message-ID: <5D48D9BE244AF5438B62E7BC4FBBF21D0A044A at medina-mail.whitten.net>
X-MS-Has-Attach: 
X-MS-TNEF-Correlator: 
Thread-Topic: GW-Basic
Thread-Index: AcVAPieWGJjLtpsESryrJFxdQKZpmQAAH5pw
From: "Gregory Whitten" <gregw at whitten.net>
To: <jfoust at threedee.com>
Content-Transfer-Encoding: 8bit
X-MIME-Autoconverted: from quoted-printable to 8bit by pc.threedee.com id j3DHL4O23678
Status:   

John,

If GW-BASIC is named for anyone, it is probably me because I developed
the Microsoft BASIC language standards in the BASIC Compiler line.  The
BASIC interpreter was much harder to extend and usually followed
afterwards.  The other story is that it stands for Gee-Whiz BASIC and it
sounded good to the Japanese OEMs at the time because it had graphics
features added to the language.  Some of them were similar to BASIC
extensions that I had made to Microsoft BASIC when I worked previously
at Intelligent Systems Corporation which was a Microsoft OEM.  ISC was
probably the only Microsoft OEM that actually had the source code for
the products at that time because I had to extensively modify them to
run on our more restricted memory machines.  I left ISC in 1979 to join
Microsoft as Director of New Products (BASIC Compiler, APL, and graphics
- APL never shipped).  I don't know what my exact employee number was -
probably around 16.

The GW-BASIC name stands for Gee-Whiz BASIC.  The GW- name was picked by
Bill Gates.  He is the one who knows whether it was Gee-Whiz or after me
because it has been used both ways.  I did set the directions for the
BASIC language features after joining the company in 1979.  I also
introduced the first object-oriented device drive interfaces into BASIC
(essentially the first use of C++-style vtables in 1979 well before C++)
and created the operating system abstraction layer that was used to port
of the Microsoft's language products to many operating systems.  Before
I got there, each OS port was done by conditional compilation scattered
through out the source code.  After I did this work, it usually took
one-half a day to port all of our products to a new OS instead of weeks
except for the BASIC Interpreter which I did the abstraction layer for
later.

On the Joel Spolsky subject he was a basically ignorant junior employee
who left Microsoft after a short number of years.  His short sighted
decisions to take the VB macro language in Excel in its own directions
caused 6 other major applications that were doing BASIC macro languages
to diverge and not be able to share any macro programs between the
applications.  He made other similarly stupid decisions like creating a
custom programming interface for BASIC in Excel instead of sharing a
common interface as strongly recommended.  The applications group spent
30 man-years integrating custom interfaces for each application with the
Office 95 applications.  In Office 98 they tossed it all and went back
to my original suggestion which only took 1.5 man-years to develop and
provided better commonality and learning between the applications.

I was one of the three original Chief Software Architects at Microsoft.
I initially managed the Language development groups and graphics
products.  I was the major designer for the BASIC language and compiler,
the memory models (including near and far) used by Microsoft languages
and operating systems - (DOS, Windows, OS/2, and XENIX - this is the
reason plus my design to allow preemptive multitasking in real mode that
Windows was almost trivial to move to protect mode - all of the
segmented real-mode apps just ran by original design that the Windows
team itself did not fully comprehend), the runtime libraries that
allowed all of Microsoft's languages to interoperate (BASIC, Fortran,
Pascal, COBOL, and C).  I started the Microsoft's graphics efforts
including the Windows project.  Marline Eller and Rao Remula worked for
me.  I was responsible for the infamous assembly language WINDOWS.INC
macros and memory segmentation.  I did the design for the multi-layered
GDI which was implemented by Marlin Eller who worked for me (co-author
of the Barbarian at the Gates).  I was the architect and designed the
incremental compiler technology and multi-stage pseudo-code design for
QuickBASIC 4.0 which carried through VB 6.0.  That pcode is much faster
than .NET's CIL or the pcode used in Excel which I showed the Excel team
how to speed up so that it was faster than Lotus 1-2-3.

I did a few other "minor" things (when I was not having lunch with Bill)
like setting the object technology strategy for the entire company
including working on the design of OS/2 and an object oriented version
of OS/2 that never shipped because of the divorce with IBM.  I shifted
from being Chief Software Architect of Langauges to Applications in
1988.  I was the chief architect for OLE and COM and did all of the
original requirement analyses for the feature breadth of OLE to support
compound documents across 19 applications for release with Windows 95.
This is what let Office 95 distance itself from Lotus who was late
supporting good application interoperability.  The design for OLE and
COM had location transparency I also personally managed the training of
Microsoft's software architects and the advanced object oriented
training for component software design in the company's products.  It
was my insights into multi-vendor component oriented systems using
interfaces that changed the object oriented world.  I was Microsoft's
original representative for the OMG (Object Management Group).  I made
the decision not to educate the OMG on the true requirements for
component software systems and left them to go in their own failed
directions based on implementation inheritance software engineering
techniques which don't work for systems.  They eventually changed their
model in CORBA 3.0 to include interfaces by which time they were
irrelevant.

I also personally wrote the strategy roadmap (95 pages) that was used by
Paul Maritz to eventually pull together the .NET technology pieces.  As
you can see, I personally lead the efforts for every predecessor
technology that was used in .NET.  That is why I was the only Chief
Software Architect that did true architecture in a company-wide
strategic context.  Unfortunately, for Microsoft and .NET, I left the
company in 1998.  The .NET team made a number of significant mistakes in
implementing support for component oriented software because they were
new and unfamiliar with COM.  They are still not fixed today and to
build truly innovative scalable distributed systems one has to create a
layer over the .NET object model.

Pam Edstrom's daughter made so many mistakes in her book that it is not
a credible piece of work.  My brother Gordon did work in my languages
group initially and later worked for Marlin Eller on a post-Windows
project.

I was Microsoft's first Ph.D. employee.  I received my Ph.D. from
Harvard in Applied Mathematics in 1978.  I was a world class expert in
graph theory, analysis of algorithms, sparse matrix algorithms for
linear systems, numerical analysis, and non-linear multi-variate time
series analyis before arriving at Microsoft to write language compilers.
I wrote survey papers for and with Robert Tarjan and others on graph
theory while I was working on my degree.

While an undergraduate at University of Virginia from 1970-1973, I
rewrote about 30% of HP's 2000 series BASIC Timesharing System to
improve the BASIC language and OS features to make it more suitable for
computer aided instruction in the Engineering School.  

I have a long history with improving BASIC since 1970.  I added many new
statements, recursive subroutines and functions with parameters,
inter-language calling, data structures, include files and separate
compilation units, etc.
  
I am sorry about the long winded response, but I felt it was time to
straighten out some of the actual facts surrounding the early days of
Microsoft that are commonly misreported.

Gregory Whitten




More information about the cctalk mailing list