While not strictly adhered to, this is somewhat of a generalization of computer listings found in the more popular magazines of the time - BYTE, Kilobaud, PC Computing, etc. This explains the exclusion of other versions of Basic, Pascal, C, Turtle etc.

What caused the demise of BASIC/BASICA as the primary front end development language in the late 1980's?

  • 5
    BASICA was only available in actual IBM PCs and not IBM PC clones. I'm not sure it actually gained the popularity of the other languages you listed because of it's limited scope.
    – user722
    Commented Jun 2, 2018 at 13:32
  • 5
    You mean beside the fact, that ADA wasn't even defined prior to1980, while PASCAL was already arround since 1970 - and a big player in the 1980, think UCSD, not to mention that the whole LISA and Mac system was developed in PASCAL? Or that PERL was the web language during the 90s with PHP taking hold in 2000? Serious, above list is maybe a personal experiance, but not tied in any common reality.
    – Raffzahn
    Commented Jun 2, 2018 at 13:36
  • 1
    You can distil a couple of trends out of this: efficiency oriented (e.g. FORTRAN) being replaced by simplicity oriented languages with otherwise similar characteristics (e.g. BASIC), and unstructured languages (e.g COBOL) being replaced by structured ones (e.g. Pascal) and finally by object oriented ones (e.g. Javascript). As Raffzahn points out, the details here aren't exactly right, but you can spot both of those trends in play, and I think that's the real point here.
    – Jules
    Commented Jun 2, 2018 at 13:43
  • 5
    I see the poster asked a pretty straightforward question. I see no reason to get tied into knots over the degree of accuracy in his "generalized" history of popular front-ends. When did being highly critical of the question become more important than just providing thoughtful answers?
    – Brian H
    Commented Jun 2, 2018 at 18:05
  • 1
    Idk how you define "front end" here, but my personal observation was that BASIC faded away quickly when DOS became a common thing. BASIC was not only the language for beginners, it was actually a shell on most pre- IBM PC-compatibles. I see it more as a graphical version of command.com, actually, than as a programming language. BLOADing a compiler or a translator (assembler) was an overkill when you had all commands right at hand. Commented Jun 3, 2018 at 18:37

10 Answers 10


In my view, the brief popularity of BASIC in the 1980s is directly related to the popularity of Javascript today - Simply, it's the Runtime that is Everywhere. That is what BASIC was back then.

During the home computer revolution of the 1980s, every new system had to at least have a viable claim to be useful for something in terms of software. By providing a BASIC run-time in the firmware, the early home computers were instantly programmable and had access to a large body of relatively portable software previously written in BASIC. This made the machines exceptionally useful for hobbyists and budding programmers, and marginally useful for everyone else. If the machine gained a decent market share, then more professional software would follow and the reliance on BASIC would slowly fade, but it was an essential ingredient for the early adopters of the new hardware. Likewise, imagine how little market share a new web browser could hope to attain without Javascript support.

As things progressed through the 1980s, the reliance on a built-in BASIC run-time for compatibility with existing software turned to reliance on IBM PC compatibility. The new question wasn't whether the new machine supports BASIC; rather, whether it was "PC Compatible" or not. Hobbyists became a much smaller segment of the market, and obtaining a run-time or development environment for a new machine became just another software choice.

  • 8
    Not only that but BASIC was the lingua franca of microcomputers. If a manufacturer released a new micro they pretty much had to ship BASIC with it (the Jupiter Ace being a notable exception). This is true even for machines meant solely for professional use such as the HP-85. Commented Jun 2, 2018 at 20:58
  • 2
    Sort of, yes. But you couldn't take a BASIC program written on one computer type and run it on another. There was BASICODE which tried to address that (en.wikipedia.org/wiki/BASICODE).
    – Hobbes
    Commented Jun 3, 2018 at 10:30
  • 1
    @Hobbes The different dialects weren't actually all that different. Take a browse though the book "Computer Spacegames for the ZX81, ZX Spectrum, BBC, TRS-80, Apple, Vic, and PET" and you'll see what I mean: drive.google.com/file/d/0Bxv0SsvibDMTNlMwTi1PTlVxc2M/view Commented Jun 4, 2018 at 2:42
  • 1
    Also take a look at the conversion chart of page 47 of "Practise your BASIC" drive.google.com/file/d/0Bxv0SsvibDMTVkhkWV9ZVllEalk/view (both of these are from usborne.com/browse-books/features/computer-and-coding-books - scroll down to the bottom) Commented Jun 4, 2018 at 3:00
  • 3
    @Hobbes It isn't that important that you couldn't take a program and run it on another because there was no universal data storage format at that time anyway. Users just typed printed out source code into their computers themselves. Commented Jun 4, 2018 at 6:23

In my view, QuickBASIC caused the demise of GW-BASIC/BASIC(A). Microsoft had essentially ceased further development of GW-BASIC when they changed their focus to compiled BASIC in the mid-1980's: note that GW-BASIC never got VGA support, and Microsoft replaced it with QBASIC (a stripped-down version of QuickBASIC with just the interpreter) in MS-DOS 5+.

As to why QBASIC became more popular, I can think of several reasons:

  1. The editor was far superior in every way (at least I thought so!)

  2. The requirement for line numbers was removed: you didn't have to RENUM your program every time you made changes.

  3. Functions and subroutines became first-class citizens, with formal parameters and less of an ad hoc feel to them.

  4. Variables didn't require type characters for non-integers, and structures were introduced and arrays could change their starting index.

  5. Flow control was completely overhauled, allowing for more than GOTO, FOR..NEXT, and WHILE..WEND.

Has BASIC died out since? Not really. QuickBASIC became Visual Basic, VBA and VB.NET: the last two are still in common use today.

  • 3
    This is yet another very valid take on the theme that was in the back of my mind while writing my answer. (...) Most of us that got hooked on Borland utils/Pascal or later C, always thought QBASIC/QuickBasic was limited and came a little late to the party. Commented Jun 2, 2018 at 14:10
  • 8
    Of course, VB, VBA, and in particular, VB.NET, have very little in common with actual BASIC, apart from retaining a few keywords. It evolved from BASIC, but it ain't BASIC. :)
    – db2
    Commented Jun 2, 2018 at 18:09
  • 1
    This seems right to me. As per my comment to the question: QuickBASIC was a structured programming language, rather than the unstructured legacy of BASICA. As the complexity of typical programs grew rapidly throughout the 80s, it became very obvious to most programmers who had tried it that structured programming languages were absolutely essential for managing that complexity (and having made that leap, the leap to OO languages was the obvious next step, hence why we now have VB.NET as the last popular variant of BASIC).
    – Jules
    Commented Jun 3, 2018 at 2:54
  • @ErikF don't forget that QuickBASIC spun off QBasic, and now (2018) there is an actively maintained open-source cross-platform clone called qb64! qb64.net qb64.org
    – fabspro
    Commented Jun 3, 2018 at 5:19
  • Both QuickBASIC and QBasic where too late to the party to have much effect. Listings for these and other versions of Basic in national magazines was almost non existent (with the exception of the Commodore and TRS-80).
    – jwzumwalt
    Commented Jun 3, 2018 at 8:55

Performance and tooling.

Unless you go back and actually try to work on era appropriate hardware (or emulators at era appropriate speed), it's hard to appreciate just how good BASIC was for developing software.

Computers were just flat slow.

At the time, my friend and I were trying to write a game, similar to Rogue, on a PDP 11/70 running RSTS. We had already done a BASIC version, but ran out of memory, and so decided to try Pascal instead -- as it had a working memory much larger than BASIC.

We would go in on weekends, and take over 3 terminals in the college computer lab. One terminal was for the editor, as the size of the source code was large enough to where the editor started with the message "Loading file slowly...". It took several minutes to get the editor loaded. So, as a rule, once loaded, we never exited, we simply just repeated saved the file.

The second one was for running and testing the program. The third one was for compiling the program. We were constantly changing and compiling the program. When the compiler finished, we'd clean up our changes, and immediately start it up again, and then start testing the version we had just built. The compile took significant clock time -- several minutes, 10+, of turn around.

At this point, I'll mention how big the file was. The file was about 25K in size. 25,000 characters (50 "blocks") of code, simply took forever to compile and link.

Constrast that to some line changes in BASIC, and typing "RUN". The development cycle in BASIC, back then, was far, far, superior to pretty much anything else. The development environment, being able edit code in place, to STOP the code, PRINT variables, CONTinue execution. Very powerful. In contrast to 10-15 minute turn arounds for "simple" programs. It's well worth the lack of execution performance to be able to write the code at all.

Once, I tried to compile a C program on an Atari 800. The combination of the slow computer, glacial floppy drives, and C -> ASM -> Object -> Executable development cycle made it just simply unusable. 4MHz Z80s running CP/M weren't any better. The drives and CPUs were still slow.

Turbo Pascal was a breakthrough. It's ability to do much of its work in memory, plus the lack of the "link" phase, simply crushed the competing development systems. Now I get compiler runtime performance for almost BASIC development turn around, and a better language to boot.

The IBM PC offered faster CPUs, more memory, faster disk drives (or, even, GASP hard drives). From there, the machines were able to support much better development environments for better languages, and the advantages of BASIC started to no longer outweigh the costs of it. Make no mistake, BASIC's warts are famous for a reason.

But it should also be noted, that while that was happening on the personal computer market, there was a still a very large amount of BASIC development happening in the mini computer market. Alpha Micros, PICK System, BASIC Four. There were several BASICs for different operating systems. BASIC-PLUS on DEC systems was notable as being one of two languages that had first class support for DEC RMS, Record Management System, their database record and index system.

For writing business applications, BASIC was very popular.

And then, of course, there was Visual BASIC, phenomenally successful.

But, simply, as the computers got more capable, the development systems, not just compilers, but debuggers, link editors, etc. become more usable for more people. To the point that the features of interpreted BASIC were no longer as valuable as they once were.

  • 2
    Turbo Pascal was the death knell for Microsoft's interpreted BASIC on the PC, though the fact that DOS 5 came with QBasic put a nail in the coffin. The time between editing and running a BASIC program was essentially zero; even though interpreted BASIC was slower than compiled languages or assembly code, the time required to test a typical change to BASIC program was less than the time required to even finish building a program using any other kind of tools. Turbo Pascal changed all that. Building wasn't quite instantaneous, but even a thousand-line program...
    – supercat
    Commented Jun 4, 2018 at 15:59
  • 2
    ...(somewhat large at the time) could be built in under 30 seconds. In many cases, that would be less than the time savings afforded by Turbo Pascal's faster execution.
    – supercat
    Commented Jun 4, 2018 at 16:02
  • +1 for "Turbo Pascal was a breakthrough."
    – Tommylee2k
    Commented Sep 4, 2023 at 14:37
  • @Tommylee2k: One thing I've sometimes wondered is how well one could have made a compiled-language IDE work on a system with a ROM cartridge, two cassette drives or a reasonably fast paper tape reader and punch, and no disk drive. If one had a language which used separate "Interface" and "Implementation" files, and a combination loader and linker that could load data from multiple tapes, giving priority to whatever version of a module was loaded first, and then run the linked program directly in memory, I would think such a system could actually have been surprisingly workable.
    – supercat
    Commented Sep 4, 2023 at 18:19
  • @supercat I would have loved to see that. however, the market took a different approach and only delivered the bare minimum software. the most successful home computer was the one with the worst basic implementation: c64.
    – Tommylee2k
    Commented Sep 5, 2023 at 8:07

As BASICA only lived on ROM, to be pedantic, GW-BASIC superseded it firstly. a Básica binary implementation which was used in PC clones and eventually in all PC compatibles, IBM or not.

Besides BASIC falling somewhat out of fashion with the development in capabilities of home computers, in the PC environment, the Borland utilities with their compilation speed and integrated IDE and single-step debugger where a major reason for people to start migrating to Pascal and C.

The speed, and memory limits of the implementation itself, limiting itself to 64KB (can be wrong) also proved quite early a very damning shortcoming, and another reason to migrate to C or Pascal.

The GW-BASIC implementation, also not being that modular, and not encompassing new modules for integrating graphical and sound hardware support for new hardware, also provided yet another reason to not develop more modern software on it.

There were also serious shortcomings in the language itself, such as weak file manipulation operations, non-existent database handling directives, weak input and error handling.

I would also say that the strong Unix/Mainframes influence also tipped the scales on the adoption of other languages as C or Cobol.

Finally advancements in the computer science field also favoured other methods and techniques of programming such as code abstraction and code reuse. Besides, programming in BASIC was not considered cool anymore.

PS. I would say BASIC demise however started in the mids 1980s. I am however partially suspect, as I had my first introduction to Unix somewhere around '87 and started working as a professional C and assembly programmer with Microsoft C compiler in 1988.

PS2 I remember vaguely that, ignoring code quality, there were some issues with licenses that prevented GW-BASIC from being updated. Unfortunately did not find anything in Google.


And I'll go in another direction...

I think the main reason BASIC was ever "popular" on micros was not that everyone wanted to program, but that there was no other way to cheaply distribute software. There were attempts, I've seen records with the Kansas City Format bound into magazines in the late 1970s, and in the later days of the 8-bit era you saw a variety of ways to type in assembler.

But for a good portion of the home computer era, the only way to get a program into your machine was either buy a tape/disk, or to type it in from a magazine. BASIC was a simple format for the later, as it was easily printed in existing magazine formats. So you had a synergy; BASIC was available on every machine of the era because BASIC was available on every machine of the era...

The question is why did that change? Well, the big reason is programming got too large. New programs for platforms like the PC went on for pages and pages, and was totally unrealistic to type in. At the same time, the price of disks was falling rapidly and sneakernet was simple enough (thus the many "user groups" who's major value was the disk collection) and, later, BBS systems.

  • Some programs for the Apple II were given as hex listings to be keyed into the monitor, but most computers lacked a convenient means of entering straight hex data. It would have been fairly cheap for BASIC interpreters to have included a statement equivalent to the Macintosh StuffHex function (so e.g. "SHEX 1234,"C0DE" would be equivalent to "poke 1234,192:poke 1235,222") but I don't think any did. That would have been vastly more efficient than oodles of data statements listing decimal constants. It seems obvious now, but if someone had sent Compute's Gazette...
    – supercat
    Commented Jun 8, 2018 at 15:15
  • ...a small machine language routine that could be loaded with a list of decimal constants but would then allow "SYSSH,1234,"C0DE" to behave as described above, such a thing would likely have become really popular really quickly since it would cut the space required for data statements by about half, and the time required to process them by probably 90%.
    – supercat
    Commented Jun 8, 2018 at 15:16
  • Indeed, and such things did start to appear, but surprisingly late in the whole 8-bit evolution. Commented Jun 8, 2018 at 18:14
  • Compute's Gazette published a couple programs called (IIRC) MLX for the purpose of bulk-entering large chunks of binary data, but they needed to be used as stand-alone programs. I don't remember anything being published that would allow a program to use bulk-hex-format data rather than comma-delimited numbers even though the latter would have allowed many programs to start up much more quickly. Another surprising omission, btw, would be a quick memory-copy function (e.g. in the VIC-20, SYSCP,32768,7168,512 instead of FOR I=0 TO 511:POKE I,PEEK(I+25600):NEXT.
    – supercat
    Commented Jun 8, 2018 at 18:24

Another, perhaps less obvious reason, was the advent of the mouse. In most, if not all, variants of Basic (until Visual Basic), mouse routines were very cumbersome to write, and while there were a few "libraries" proposed, they were far from perfect.

  • 1
    Plenty of languages were late to add mouse routines, and I would argue that most never included mouse support as a built-in function - most used some sort of extra library. I actually bypassed mouse use and skipped from text-based to browser-based, where Javascript is the language interacting with the mouse and the server-side languages (PHP, Python, Java (ugh), etc.) still don't know about the mouse. Commented Jun 4, 2018 at 15:27
  • AmigaBasic had full mouse support. Commented Sep 13, 2023 at 17:21

I'm surprised that nobody seems to have mentioned Microsoft's BASIC compilers other than QuickBASIC.

When I started coding professionally straight out of college in 1982, we use Microsoft's BASIC compiler which was an absolutely no-frills version of BASIC. The PC was out, but the company I worked for wrote a point-of-sale and inventory control system for a slew of computers, like the PC, but also other computers like Televideo, Zenith, NCR, etc.

I want to say that first version of the compiler was 5.35 (how odd) and it was bare-bones, in that there was no CLS, or LOCATE, etc. We wrote a separate set of includes or linked object files that would handle each computers specific commands to do things like clear screen, locate the cursor, etc., even if that meant resorting to ANSI.SYS sequences.

I think Microsoft first created a professional compiler (BASCOM) for the IBM PC around that time, but we could not use it because we needed to be able to work on multiple machines. I wound up using that version whenever I changed jobs (for the next 30 years that same new employer) that was using the IBM version of the compiler. I want to say it was version 1.0 but I can't be sure.

I do remember a few years later Microsoft releasing their 6.0 version and I believe that's when they changed the name to Professional Development System (PDS) Basic 6.0, then later 7.0, and finally 7.1 which believe it or not I still use today on my 64-bit Windows 10 machine for the same code, accounting software, which was originally written for interpretive BASIC on a TRS-80 and ported to the PC before I came on board to be the sole programmer.

I inherited the code in 2010 when the owner retired, and I had written a Windows version of our accounting system in 2005 (we were late to the game) but I still to this day have a handful of customers who continue to use the DOS BASIC version of my software, simply because it works and they're comfortable with it.

In my case, BASIC was the predominant language I used. I wrote lots of routines in assembler for speed (pop-up windows for browsing in DOS, etc.) and I had all the mostly dead languages I learned in college: COBOL, RPG, etc., and I learned PASCAL and wrote a commercial app in Turbo Pascal, and dabbled with C, but until 2015 I was pretty much exclusively BASIC. Not something one tends to brag about among his peers.

I've since taken on a full-time job in QA writing test automation and have learned (and love) Java, but I continue to support my DOS and Windows customers part-time with their accounting and other applications I've written through the years.

  • 1
    I don't think your answer really addressed the original question. But I +1'd it anyway because I like the story. I don't have any applications still running in any flavor of Basic, but I've got a few still running in Clipper Summer 87 - a 31-year old development platform that I started using back in 87 (or maybe 88, I can't remember), though that needs XP Mode to run in Windows 7. Commented Jun 4, 2018 at 13:55
  • 1
    A close friend who I graduated college with and shared the same first employer for the first couple of years wrote his own POS/Inventory system after he left and he wrote it using Clipper as well. It interfaced our accounting package. Thanks for the upvote, I did realize that my answer was not 100% addressing the issue, but I wanted to share on one of the few topics on which I feel somewhat of an expert. Commented Jun 4, 2018 at 14:00

BASIC is/was a good language for simple computational tasks, good for simple business problems and even science/math work. BASIC is also more accessible for novice programmers than more sophisticated languages like C or C++. Where BASIC ran up against its limits was user interface and doing interesting/engaging things with sound or graphics (too slow or cumbersome). The BASIC interpreters I recall were geared primarily to serial console mode I/O. Although they had memory PEEK and POKE which could be used to read/write memory (including mapped display memory or memory-mapped I/O), there is only so much you can do with these techniques. BASIC (with its requirement for programmer-specified line numbers) did not lend itself to writing large programs; beyond a few hundred lines, programming became a major challenge. In a structured language like C, or successors like C++ and C#, a few hundred lines of code is nothing.


The personal computing market for which BASIC was a lingua franca was a pioneering one, in which it was important for individual computer users to learn to program in order to be able to put their computers to some productive use. When the commercial software industry evolved to the point of being able to serve all of the needs of an increasing share of people from the latest waves of arrivals to the world of computing, those who would have been the target audience for BASIC in an earlier era started to leak out at both ends into adjacent groups: non-programmer computer users, and commercial programmers (who could afford to pay for tools and used the languages of their choice to suit quality and performance needs and their preferences, not just whatever came with the system.)

BASIC didn't go away overnight -- The factors that led to its demise got going in the early to mid 80s, and yet there were still enough people learning BASIC for Visual Basic, which launched in 1991, to have a huge "built-in" audience that contributed to its success as a product through the 90s.

  • 1
    A key feature of BASIC was that an interpreter could easily and cheaply include a text editor. Many earlier languages were designed on the assumption that programs wouldn't be edited interactively on a computer, but would instead be manually produced as a stack of cards which could be inserted as a batch. BASIC was practical for use on a system with a single cassette drive as its sole mass-storage device in a way that few other languages could be. Computers with decently-fast floppy drives really didn't need BASIC.
    – supercat
    Commented Apr 29, 2019 at 15:31

Interesting answers, no doubt better than mine, but still, I think at least one element is missing: the end of BASIC coincided with the end of the 8-bit revolution. When the 16-bit machines came, it was time for more professional computer use. In the homes the gameconsoles made their own revolution. BASIC simply wasn’t needed anymore. Maybe most people here have other memories for themselves but don’t forget that most young people used two commands in BASIC: LOAD and RUN, to play games.

The first computer that really did something to rekindle the 8-pit revolution (with much less success, but still) was the Raspberry Pi, with Python as its modern “BASIC”

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .