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?
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.
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:
The editor was far superior in every way (at least I thought so!)
The requirement for line numbers was removed: you didn't have to RENUM your program every time you made changes.
Functions and subroutines became first-class citizens, with formal parameters and less of an ad hoc feel to them.
Variables didn't require type characters for non-integers, and structures were introduced and arrays could change their starting index.
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.
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.
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.
SYSCP,32768,7168,512 instead of FOR I=0 TO 511:POKE I,PEEK(I+25600):NEXT.
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.
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.
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.
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”
