It appears that the BASIC programming language has been around a lot longer than most of us have realized. It had its beginnings back in 1964 at Dartmouth College. BASIC has a long and rich history as a programming language, but often today, it is viewed as a beginners' language or childs' language. What few may appreciate is how great an impact BASIC has had on programming and how it has grown over time. When programmers hear the name BASIC today, they often think about a slow interpreted language with little use for real world programming. This is the furthest thing from the truth though.
Why BASIC?
Having experienced writing a FORTRAN program using punch cards back in the 1970s, I can attest to how amazing it was to use BASIC on a video terminal in real time. You could get immediate results when writing code. Write a few lines of code and then RUN it and you had immediate results. Coding became something the average person could do. But what made BASIC so well received?
Aside from the immediate results one got from using an interpreted language, the real key to BASIC was its more natural syntax. If one had any experience with basic algebra in school, picking up the BASIC language was not very difficult. The idea of variables to store numbers, basic mathematical expressions along with a simple, easy to use command language for adding logic made BASIC just make sense. It was coding using language we are used to. Some have referred to it as a more “natural”programming language. Compared to languages of today, like C++, it is obvious why a language like BASIC would be appealing.
But Could You Get Real Work Done with BASIC?
Absolutely! As quickly as people started learning BASIC, they also started finding ways to get some real work done with it. The reason for programming languages is to be able to get real work done with a computer. As long as this is accomplished, a programming language is valuable. So, did a lot of programmers get some real work done with BASIC? More than many may imagine. Actually, BASIC created a different breed of programmer. Rather than simply leaving programming in the hands of a select few highly trained professionals, BASIC brought programming to the average person. A engineer could write programs to solve daily problems on his job. An accountant could write programs to make the daily drudgery of working with lots of numbers faster and more accurate. The first tasks these budding programmers solved likely were simple, but as one task was solved, they often would tackle something even more complex next. Before long, people were learning on their own how to write some very complex software, even turning what started as a hobby into a real business. They took their knowledge of their specific trade and used programming as a way to create new ways to solve all sorts of problems. They got real work done and did it well.
BASIC, the Language, Grew in Ways Few Would Have Expected
The interesting thing about BASIC is that the creators of the different BASIC flavors (brands) often did not expect the results they got. What may have been viewed as a training or hobby programming language, was often used to accomplish real work in the business world and was quite successfully. One of the best examples of this was Visual Basic. Visual Basic, for all practical purposes, was not intended to replace so called higher level languages like C. But something amazing happened with Visual Basic. People who were not professional programmers or even trained in college in computer science, were creating commercial software to solve all sorts of problems in business. The number of commercial applications written in Visual Basic by so called “hobby” programmers is likely astounding if one were to actually calculate the actual numbers. Some very good software was written by such “hobby” programmers too.
What some may not appreciate is that those who learned how to program in BASIC were (and are today) just as interested in finding ways to push the boundaries of software development as any college trained C (or C++) programmer is. This has been going on for a long time, whether the mainstream programming world has noticed. Let’s go back a few years and see.
BASIC On Every Computer!
Back in the 1980s, BASIC found its way onto nearly every desktop and home computer. GWBasic came with early MSDOS and later another version called QBasic shipped with Microsoft DOS. I was using BASIC back before DOS on CPM computers to write business applications. When the hobby home computer became popular, with the TI-99/4A computer by Texas Instruments, the Atari computers and the famous Commodore 64, they all came with a version of BASIC burned into ROM. While slow in execution speed, the languages made up for that in ease of use and accessability. BASIC was everywhere!
BASIC Programmers are More than Hobby Programmers!
But BASIC programmers quickly learned to want more. Did they all switch to C? No, they loved BASIC, so instead they found ways to expand the language, to improve it. Programmers using ROM based Basics learned machine language so they could extend the language. I once wrote such an extension to Commodore ROM basic which added sprite and graphic commands to the language. Now despite the misconception that all BASICs were (or are) interpretors, I started using a real BASIC language compiler on my Commodore 64 back in the 1980s. Abacus had a very nice compiler which produced programs nearly as fast as those hand coded in assembler and it was BASIC. I used the Abacus compiler to write my own subset BASIC compiler specifically for producing programs which were even closer to those written in assembler, in speed.
BASIC programmers have long appreciated the value of an optimized compiler. They stopped using line numbers and interpreted languages a long time ago. BASIC over the years picked up some of the best features from other languages, like Pascal and C. But BASIC though was about ease of coding. New features were not added to BASIC simply to make it the same as other languages, but simply to gain the best feature sets possible while maintaining the naturalness of BASIC. They wanted the best of both worlds, power and ease of use. What BASIC programmers didn’t want was added complexity to programming. Many different flavors of BASIC over the years came along and tried to maintain that goal of ease of programming. In the DOS days, BASIC programmers would use tools like screen layout designers, code generators and the like. In the Windows years, different versions of BASIC came along which provided drag and drop visual designers. If the BASIC language some used didn’t have a visual designer, its community of users often built their own. In the early Windows years, there were a number of commercial BASICs created, some by some very big companies. Aside from Visual Basic 1.0, there was GFA Basic, CA Realizer and a number of independent BASICs (indie developers who created shareware Basic languages or freeware). Early versions of Visual Basic were PCode compilers and in time users demanded more power and speed and Visual Basic 5.0 introduced a real compiler backend which was nearly as good as many a C compiler. In the DOS days some very powerful BASIC compilers were commercially sold, QuickBasic (and PDS 7.1) from Microsoft and TurboBasic from Borland (which still exists today as Powerbasic). Those BASIC compilers produced very high quality applications. Back when I was using Microsoft’s PDS 7.1 Basic compiler, I was writing some extension libraries in assembler to add even more power to the language. The way I compiled the applications was so complex, I couldn’t do it from the IDE and had to write batch files which would compile my applications just the right way so I could get the most out of the compiler.
Yes, BASIC programmers were (and still are) a unique breed. They want to be able to produce the best and the fastest software possible and were willing to push the limits of the compilers they used. As a long time BASIC programmer myself, I often found myself looking for something better. I wanted to program faster. I wanted to produce smaller and faster applications. I wanted more powerful features. But like many other BASIC programmers, it was not a matter of switching to a different language, like C++, but in finding ways to make BASIC better. There is something about BASIC which just makes it feel right for many programmers. Personally, I think it has a lot to do with the more natural syntax of the language. While many modern BASICs support object oriented syntax when wanted, many long time BASIC programmers find a more procedural style of coding preferable, since it can make coding simpler while producing smaller and faster applications. But whatever the reasons for sticking with BASIC and even the style of coding each BASIC programmer uses, BASIC is a language that just won’t go away.
