BASIC is not dead. Time to erase the myths about Basic.

Having been programming in the BASIC language since 1975, I think it is time to explain what Basic is really all about, as well as what Basic is not about. Basic has been maligned for decades because of myths about what Basic is. Who better to explain what Basic is really all about than a programmer who has used it for decades and professionally. Follow along with me as I tell my story of how I learned about Basic, the different Basic languages I tried and what I have been able to accomplish over the years with basic.

My first exposure to Basic

Back in the mid 1970’s I took an advanced math class in high school. There were no computers in our classes back then, but my math teacher made an arrangement with a nearby college to use a terminal (keyboard/printer only and no screen) to connect to a nearby college mainframe via a modem. He taught us BASIC and it was easy to learn, but allowed us to use what we learned in our calculus class via programming. It was an amazing experience at the time. There were no cell phones in those days. No tablets. No inexpensive computers. It was the mainframe era and BASIC was there.

In college I took a Fortran programming class. Typing programs onto punch cards (little holes in them) and then bringing a stack of cards to the computer department to run in hopes that sometime soon they will run your app and you get a printout was primitive at best. But something happened with an obscure little language called BASIC. Timesharing was used to allow hundreds of computer terminals (with green screens) to all communicate with a mainframe at the same time and you could type in your program and get an immediate result. This was amazing! BASIC put all other languages to shame because of the use of an interpreter and time sharing. The immediate results when coding allowed one to truly enjoy programming. BASIC was not a child’s programming language. It was a powerful tool put into the hands of college students. It did something few, if any, other languages were doing. It made programming productive, fast and immersive.

The age of the home computer

In the 1980’s, the so called home computer came into existence. Such computers as the Commodore 64, Atari 400/800/XL, Texas Instruments TI/994A, Sinclair, Timex and so on. They were not cheap. These computers were not children’s toys. There were for the hackers of old. The makers of old. Those excited about technology, when technology was in its youth.

They were too expensive for me to buy, but as time went on and new computers came to the for, these home computers came down in price. Once I found one on clearance at a local department store, I picked up my first home computer, a TI99/4A . I started programing again for fun. In time I eventually purchased an Atari 400 and a Commodore 64. My excitement about programming was reignited.

BASIC was not all about Interpreters

One myth today is that Basic has always been a slow interpreter geared towards use by children. Back in the 1980’s the Commodore 64 introduced the world to computing at home, but many a business and maker used the C64 to do all sorts of things. Real work was done with the C64. BASIC was only the beginning with the C64. A good number of Basic users realized the need for more performance and so they often learned 6502 machine language. Commodore Basic encouraged learning about the low level hardware, likely better than most programming languages of today. The C64 books on the low level of the computer hardware opened a new world for many. Basic had PEEK and POKE to allow one to directly access the hardware. The Basic interpreter in ROM could be extended by hacking into the system and adding new commands. One of the first things I learned was 6502 machine language so I could extend the Basic language. C64 BASIC has commands (SYS, USR) to call machine language routines from your BASIC program. Rather than hide the user from the hardware, BASIC embraced it.

Then I found the Abacus BASIC language compiler. Now I could write in BASIC and then compile the code directly to machine language for a speed improvement of more than 10 fold. Yes, BASIC programmers had compilers back in those days. Abacus BASIC offered improvements to the BASIC language as well.

I then used the Abacus compiler to write my own compiler for writing even faster programs. My compiler was a subset of basic. A very limited command set, but it taught me how to write a compiler, how to generate machine code and how to get the maximum performance out of 1 mhz (CPU) computer. I wrote my first family friendly video game and sold it to a computer magazine (the Compute Gazette) and it was published in the October 1987 issue. That little game, written in a subset Basic language using a compiler I wrote using the Abacus BASIC compiler, earned me a whopping $1500 back then.

BASIC and the business world (days of CPM and IBM Dos)

In the late 1980’s small/medium sized businesses were beginning to see the benefit of using computers. It was not the same back then like it is today. There was little off the shelf software back then. To get a really useful software package one had to hire a programmer. Few small/medium sized businesses could afford to hire a programmer to write custom software for them. There was no internet like we have today where you could download opensource or free software. Before IBM brought the PC into the mainstream, there was the world of CPM. It was bad enough one had to hire a programmer to write software for you, but imagine trying to write such software in say C or Fortran, the cost would have been outrageous. But a growing language, called BASIC, came to the rescue! BASIC interpreters were found on a number of CPM systems. It allowed new buddying programmers to write and test software quickly. That is how I got my start professionally. As a self taught programmer, I found local custom programming jobs. I wrote a number of applications using BASIC. Also when PCDOS came to the fore with its own version of BASIC, I continued writing business applications. In those days between CPM and IBM compatibles I wrote a number of real world applications for businesses such as a video rental store (accounts), a furniture store (accounts) and even for a quality control department in a local factory and all using BASIC. Just as a little bit of information of interest, did you know that IBM’s flavor of BASIC was called Basica , which stood for IBM Advanced Basic. The idea of BASIC being advanced may be laughable to most today, but yes BASIC has a history of continuing to advance. It grew and changed over time. Yes, BASIC actually would borrow powerful constructs from other languages over time and put its own spin on them (meaning make them as easy to use as possible).

BASIC programmers yearn for Compilers

As the PC compatibles began to storm the world, Microsofts MSDOS became the operating system of fashion. It too had its own BASIC. Eventually Microsoft created the QuickBasic compiler. QuickBasic was unique in that you didn’t have to compile a program to run and test it. It used an interpreter of sorts to run your app immediately, but you could also compile it later so it benefited from the full performance of native compiled code. It was the best of both worlds. Because of its unique design, QuickBasic became a favorite programming language for buddying professional programmers who needed to develop apps quickly, but still produce high performance modern apps. The primary reason QuickBasic was so important is that the language was easy to use, but yet produced quality software which performed well and likely was developed in half the time of other languages. Microsoft’s pinnacle product back then was its Professional Basic. Yes, you read that right a Basic for professionals. That was PDS 7.1 or Microsofts Professional Development System. I used QuickBasic and then finally PDS 7.1 for developing software for local clients in a variety of businesses such as quality control for manufacturing, machine shop job tracking, lumberyard accounts receivable, sheriff department, transmission repair shop and a PBX tracking system. All realworld applications. BASIC being a compiler allowed me to write software as good as in any other programming language of the time. You may have noticed I spelled BASIC with all capitals up to this point. That is because the name was short for “Beginners’ All-purpose Symbolic Instruction Code“. From now the appropriate way to spell it is Basic (not all caps). Why ? Because Basic from this point on became a professional programming language. Microsofts PDS 7.1 even allowed you to link in modules written in other languages. I use to write some low level routine modules in assembler and then link them into my Basic app. Basic was now a professional programming language with many modern constructs such as Types, Subroutines, Functions, etc.

Basic and Windows

If it were not for Windows, Basic as a professional programming language would have likely continued to flourish and grow. Windows 1.0 threw a wrench into Basic and its future. Many a DOS Basic programmer would feel the pressure over time to convert their apps from DOS to Windows and the transition actually was too much for some. Even companies who manufactured programming languages would feel the pressure and some would fail at creating a Basic for Windows and some would succeed. There were two key reasons why moving from DOS to Windows was so challenging for Basic programmers. The first is that DOS usually was text based user interfaces (while some graphics did exist, each software program would have to define its own graphic engine so it was not easy). Windows was a change to a GUI environment which introduces event based programming. Windows was not object oriented back then and still procedural, but its code flow was significantly different because of Windows event (in API terms actually message based) style of coding. Windows simply put was confusing for programmers used to a strict linear procedural style of coding. There were attempts to create a Basic for Windows by a number of companies, but many just could not catch on because of the confusing nature of how Windows worked under the hood. DOS Basic programmers often would just get too confused by such tools and give up on them rather than spend the long time learning a totally new style of coding. You just could not port your DOS Basic app to a Windows Basic in short order. It would mean a total rewrite from scratch. Initially most apps for Windows were written in C (not C++). It was very challenging to write a Windows app. In time Basic came to Windows but a number of DOS Basic programmers could not make the jump successfully. The Basic programming language community took a big hit because of Windows initially. So how did I fare ?

Stumbling through the choices of Basic

Let’s first start with the Basics for Windows I tried but just could not be productive with. I did stretch the lifespan of the DOS Basic apps I wrote in PDS 7.1 . Actually one of my DOS apps written in the 1990’s was still in use by a company up until this last year. Yes some of my DOS Basic apps were in use for decades. Yet I did dabble with any programming language called Basic that I came across for Windows. One was called CA_Realizer by Computer Associates. Another was GFA_Basic. Both were excellent attempts at a Basic for Windows. Neither succeeded, so obviously there was something missing in them. I never became proficient in either one. The Basic which did catch my eye was Microsofts Visual Basic 1.0. It took some getting used to, but in time I did become productive with it. The only problem with Visual Basic 1.0 was it was a pcode compiler. While I always assumed Microsoft built Visual Basic from scratch, it was only in later years I learned they simply bought the rights to someone else’s software and turned it into Visual Basic. For more information about Allen Cooper who created what later became Visual Basic see: https://en.wikipedia.org/wiki/Alan_Cooper . Visual Basic quickly became popular, not simply because it was Basic, but because of its unique drag and drop environment. Basic just was the gravy on top, so to speak. The Basic language made coding in it easier than say C, but the drag and drop environment was truly amazing at the time. Combined it became one of the most popular programming languages ever for Windows. But Visual Basic 1.0 was a disappointment in some ways for the professional Basic programmers of the 1980’s and early 1990’s. Because it was a pcode compiler the performance was poor at best. Compared to so called “real programs” written in C, they rarely could compare. Microsoft was serious about making Basic a professional language in the DOS days, but Visual Basic became a “hobby” programming language in the early Windows days. We lost our ability to simply compile to native code and we noticed this. Visual Basic 1.0 was both a great leap forward and yet a few steps backwards. I really don’t think Microsoft expected Visual Basic to be the big hit it eventually became. One good decision was the support for ActiveX controls (and later OCX controls) which allowed all sorts of third party companies to build all sorts of addons for Visual Basic (likely most were written in C, not Visual Basic). I really believe this third party support is what really pushed Visual Basic out of the hobby world into the professional world. Real world software was being written in Visual Basic. Because so many software developers used Visual Basic to write commercial quality software with it, Microsoft had no choice to continue to improve it to make it more “professional”. Eventually it became a true native code compiler, but from what I have read about this it took using a C compiler backend to accomplish this. From my perspective and in hind sight I get the feeling Microsoft didn’t really take Visual Basic that seriously as a professional programming language. Yes it was popular. Yes Microsoft made it better. But the real question is why didn’t Basic ever be considered to be a language to properly build for professionals from the ground up ? Yes, despite its success, Visual Basic was a big hit to how programmers view the Basic language. Over time, no matter how good Visual Basic got, it never was viewed as a professional programming language. In the DOS days, Basic was a professional programming language, so why not in the Windows years ?

How did some other Basics fare ?

It should be pointed out that no matter how much the programming world tries to kill off Basic as obsolete, it still thrives in one form or another. There are a number of current “indie” versions of Basic around today which are of note and worth checking out. To name a few:

  • Purebasic (paid software, multi-platform) which is quite popular
  • Freebasic (free)
  • ThinBasic (free)
  • Oxygen (free, 32 bit and 64 bit)
  • Liberty Basic (paid)
  • AutoIt
  • Basic-256
  • Basic for QT
  • BBC Basic
  • Creative Basic
  • GLBasic
  • True Basic (created by original creator of Basic)
  • XBasic

This is not all of them, just the ones I am familiar with. The ones I would strongly recommend checking out are PureBasic, Freebasic, ThinBasic, Oxygen, Creative Basic and GLBasic, but only since I am more familiar with them and there benefits. I would like to now discuss two other current Basic languages which are more of a professional level. The first is XOJO. XOJO was actually called RealBasic and later on changed the name of the product. Sadly XOJO felt the need to deemphasize the Basic part. XOJO is still a Basic language though. I don’t know the real reason they did this, but one may wonder if all the negative views towards the word Basic in the programming world may have encouraged this change. XOJO is a very powerful, professional level Basic programming language much like classic Visual Basic. It has a powerful drag and drop environment and it is multi-platform. There is even a version that can generate an app for a Raspberry PI. The last Basic I would like to discuss the actual Basic programming language I have used for the last 20 years.

A Professional Basic which nearly died a couple times

This Basic language is called PowerBasic. One has to know the history of this language to better appreciate it. Before Microsoft QuickBasic and Borland International TurboBasic in the DOS days there was a programmer named Bob Zale. He created a compiler called Basic/Z. Microsoft had the most popular Basic compiler for professionals in the DOS days and Borland International was competing with Microsoft in the programming language market. Borland had their highly popular Turbo Pascal which Microsoft noticed. Borland wanted to add a Basic to the Turbo family of Turbo Pascal and Turbo C. They chose to buy out Bob Zales compiler and renamed it Turbo Basic. Turbo Basic really gave Microsoft a “run for their money” so to speak back then. It was a professional level compiler just like Microsoft had. Sadly Borland gave up on programming languages. They sold off most of their languages to Embarcadero, where they still exist today and are used professionally. Turbo Basic though they sold back to its creator, Bob Zale. He renamed it Powerbasic. So TurboBasic almost disappeared, but thanks to its creator it continued on. The problem with Powerbasic, was not the product, but was that it changed hands from a big company with deep pockets to a small company with much less resources. This transition was later hindered by the jump from DOS to Windows. Powerbasic was an amazing professional level Basic compiler. PowerBasic could do as well as any C compiler of the time. Windows created a problem which could have caused this programming language to just disappear once again, but Bob Zale found a way to make a small jump to Windows, but not completely. The problem in creating a programming language for Windows, is not the programming language itself, but how to support for all the GUI features in Windows. PowerBasic (the company) did not have the resources like Microsoft to create a drag and drop visual designer like Visual Basic at first. Trust me when I say, it is hard to write a drag and drop visual design environment(I know I have done it). So Powerbasic used it strengths to determine the market for the Windows version of the compiler. Powerbasic itself (the compiler part) was written in assembler. It generated native code as good as any C compiler could. They converted some of the Windows API headers to Powerbasic syntax so it could access the Windows API. PowerBasic could compile both to an EXE or DLL, so PowerBasic marketed itself as an addon to Visual Basic (early versions before VB became a native code compiler). Now you could write DLL’s in Basic for use with your Visual Basic apps (or any other language). The performance was on par with C. This is when I was first introduced to the PowerBasic programming language. The product was called PowerBasic DLL compiler. I was using Visual Basic 1.0 and 2.0 and found PowerBasic to be so exciting. I could write code like any C programmer could, but in Basic and it ran fast. At first I used it to write DLL’s for use with Visual Basic. Then I later used it to write a DLL addon to a multimedia tool called MediaForge. But I wanted to do more with it. This meant I had to learn how to work with the Windows API. It took me time, since coding to the Windows API was more in the realm of what C programmers do. But the raw power of a native code compiler and the Windows API is just amazing! In time though something again almost ended Powerbasic’s usefulness. Microsoft dropped classic Visual Basic in favor of VB dot.net. Classic VB slowly lost its favor with programmers and what happens to a product marketed as a DLL compiler for VB? It had to be reinvented. Fortunately for Powerbasic this came from its extensive community of users. From them came programmers who developed things like Visual Designers, GUI frameworks, custom controls and more. Now PowerBasic could stand on its own for developing a complete app. From all of this excitement, even the Powerbasic company took on the task of reinventing itself. They created their own visual designer (PB Forms) and renamed the product PowerBasic for Windows. Despite being a small company with little resources it continued to flourish in the Windows world. Sadly in 2012 Bob Zale, the creator of Turbo Basic and Powerbasic died. This time, this professional programming language nearly died with him. The community of users kept PowerBasic alive until it was eventually sold to its current owner Drake Software. Yes, professional level Basic still lives. XOJO’s version of Basic is continuing to grow. They seem like a strong company with a good user base. Powerbasic, despite challenge after challenge continues to live and it is likely one of the few professional level compilers today which is written in assembler. Basic became a professional level tool in the 1980’s. It is still a professional level tool today despite its challenges. New Basic languages keep popping up. In the embedded word of microcontrollers Basic is still popular too. Basic’s long life is one indication that it is a real programming language for professionals, not just for the hobby programmer. If there is one thing I would like to accomplish from this article is that Basic not only still lives, but it should be a serious language syntax to consider using in any next generation programming languages yet to come.

Note: I haven’t discussed much here about what software I have created with Powerbasic, but suffice it to say that I have learned how to push the limits of the WIN32 API using it. I designed full blow GUI framework as well a Visual Designers using it. Here is just a sample of what I could do with Powerbasic in some small simple test apps I wrote. It may not seem like much, but it may surprise you.

WIN32 test app using my GUI framework:

http://cwsof.com/download/testwin8.zip

http://cwsof.com/download/ezmodvw11.zip

My CodeProject Intel Contest app I submitted:

http://cwsof.com/download/sandbox3d.zip

tagged with