Programming Windows: Visual Basic to the Future (Premium)

Looking back at Microsoft’s history from a software development perspective, I’m struck by how dedicated the firm remained over time to BASIC, the language that co-founder Bill Gates sold as its first commercial product. Microsoft championed BASIC far past the point that its competitors did, and it even proved some wrong about this dated language with the blockbuster release of Visual Basic in 1991.

But as the 90s unfolded, Microsoft’s obsession with BASIC may have given it a bit of tunnel-vision with regards to the language innovations and new platforms that were happening outside the company. By the time the decade ended, the Internet had arrived as a major disruptor that was driven by companies other than Microsoft, platforms other than Windows, and languages other than BASIC.

That story factors very heavily into the future of this series, as you can imagine. But before we get to that, I will for now conclude the BASIC portion of the series with a look at the other BASIC and BASIC-like products that Microsoft released between the late 1980s and the early 2000s. Not all of these were strictly derivates of Visual Basic, but it’s fair to say that the success of Visual Basic at least inspired most of them.

Because of the timeframes involved here, this article doesn’t slot neatly into our timeline either. That’s going to happen from time-to-time, and I suspect that I will jump around a bit more as we move forward and not tell the story as chronologically as I’ve done so far. (Actually, I had expected to run into this issue before now.) As I think I noted early on, however, I’m keeping track of what I’ve written in a table of contents that will eventually let readers access the content chronologically, for the most part, and topic-by-topic.

But first, a quick and sometimes personal tour of what I think of as Visual Basic’s family tree.

WordBASIC

In 1992, my wife and I were planning a move to the Phoenix area so that so I could go back to school to study software development. As an Amiga user at the time, I knew that I was going to have to switch to the PC, and to MS-DOS and Windows. And that meant that I was going to have to learn more about Microsoft’s software and development platforms. So, my wife’s parents bought me a book about WordBASIC by Woody Leonhard that year. It was transformational.

And I wish I could tell you with certainty which book it was. Researching this article, I found two titles that might be the right book, but the dates seem wrong: Hacker’s Guide to Word for Windows (1993, second edition in 1994) or The Underground Guide to Word for Windows: Slightly Askew Advice from a Winword Wizard (1994). Regardless, Leonhard, like Jerry Pournelle, wrote in a conversational and humorous style that I immediately became quite enamored of. And it’s fair to say that both writers profoundly impacted my own future career: Technical writing, I discovered, needn’t be dry or boring.

The other neat thing about the book was that it came with a floppy disk that included a runtime version of Windows with Word for Windows so that you could just boot it up and explore WordBASIC. Really cool.

As for WordBASIC itself, it first arrived in 1989 with the original version of Word for Windows. It was basically a subset of QuickBasic, and as I mentioned in Programming Windows: Visual Basic Beginnings (Premium), it was the result of an effort by Microsoft to make its Office productivity applications extensible using BASIC macros. As such, the language itself was very similar to that of Visual Basic, and so moving from WordBASIC (or QuickBasic) to Visual Basic, from a syntax perspective, was fairly straightforward.

Visual Basic for Applications

In 1993, Microsoft replaced WordBASIC with the more sophisticated and powerful Visual Basic for Applications (VBA). VBA was literally based on Visual Basic and could be compiled to the same Microsoft p-code (pseudocode) intermediate language as VB. And it was also updated alongside VB throughout the 1990s, and then independently of VB into the 2000s.

Indeed, VBA’s evolution followed that of VB. When VB 4 was released in 1995, Microsoft followed it up with VBA 4.0 (the second release, but versioned to match VB 4), a complete rewrite that added true object-oriented programming (OOP) capabilities to the product. This was made possible by an architectural change in Visual Basic, in which the VB language was separated from the GUI library so that it could be embedded in other applications, like those in Office. (The switch to VB 4 also signaled the move from VBX controls to OLE controls.)

Future VBA releases mapped to Office milestones like Office 97, Office 2000, Office XP, Office 2003, Office 2007, and Office 2010, and Office 2013. But the time Office 2016 was released, VBA was no longer being updated, so that release included the same VBA version as its predecessor.

There are two interesting points to this history.

First, Visual Basic itself was no longer updated after the release of VB 6 in 1998. But because the VB language had been separated from Visual Basic, it was, in theory, updated multiple times between 2000 and 2013. That said, I’m not personally aware of any language improvements that occurred over that time, and I suspect that most of the improvements in VBA were related more to changes in the Office applications themselves. Still, it’s rather impressive to consider that Microsoft’s first BASIC was created in 1975 and that the firm, in some way, was still plugging away at a straight-shot evolution of that language almost 40 years later. (Yes, it still makes a Basic today, but it’s not really the same. See below.)

Second, Microsoft’s Office applications are still extensible, of course, and that extensibility spans the Windows, Mac, web, Android, and iOS versions of the apps. But developers now use web technologies like HTML, CSS, and JavaScript to extend the capabilities of Word, Excel, PowerPoint, OneNote, Project, and Outlook.

VBScript

With the rise of web programmability via Java and JavaScript, Microsoft sought to embrace and extend these trends via Visual J++, its implementation of Java, and JScript (its first version of JavaScript) and VBScript—or, Visual Basic Scripting Edition—starting in 1996. VBScript didn’t make much sense for web page scripts, since only Microsoft’s web browser, Internet Explorer, supported it. But it made tons of sense for back-end scripting on Microsoft web servers.

As it turns out, I created some of the first “dynamic”—that, database-driven—websites on the Internet, and to do so, I created what we would now call a basic Content Management System (CMS), using Windows NT 4.0 and the NT 4.0 Option Pack, the Internet Information Services (IIS) web server, Active Server Pages (ASP), Microsoft Access (and then SQL Server) and VBScript. It was a powerful and flexible system for the day. And thanks to my experience with Visual Basic—I had written three VB books by that point—it was also a natural fit. The original WinInfo website—as well as other now-defunct sites like Hip Mama—were all published to the web using this system. (And we later improved performance by creating server-side software components in compiled VB.)

I went on to write several books about VBScript, both on the client and on the server, and about ASP and related Microsoft developer tools like Visual InterDev.

In any event, VBScript was very much based on the Visual Basic language and it was updated quickly and regularly over the subsequent four years. And this time, I know that these improvements were often specifically language improvements. It gained support for regular expressions, classes, and much more over this time period.

With the move to .NET in 2000/2001, ASP evolved into a far more sophisticated environment called ASP.NET that continues to this day (and is being supplanted by ASP.NET Core as I write this). As such, that marked that end of VBScript, which was a scripting language and not a compiled .NET language.

Visual Basic .NET

Two separate initiatives delayed and then canceled a follow-up to 1998’s release of Visual Basic 6: A desire by Microsoft to consolidate its separate integrated development environments (IDEs) into a single IDE that would work across all of its Visual Studio-based developer tools. And its unsuccessful attempt to wrest control of Java from Sun, resulting in a reset that led to .NET. As such, Visual Basic wasn’t updated again until Microsoft launched what it called Visual Basic .NET in 2002.

But it wasn’t the same language or environment. It wasn’t Visual Basic, not really.

Instead, Visual Basic .NET—Microsoft dropped the “.NET” part in 2005—was a full-fledged and professional .NET programming language, more closely aligned with the new C# programming language than “classic” versions of VB.

From a technical perspective, Visual Basic .NET was fully object-oriented where classic VB was just object-based. It supported advanced developer features like structured exception handling and could take advantage of the Java-like garbage collection functionality provided by the .NET Common Language Runtime (CLR). And instead of compiling to p-code (or, starting with VB 6, native code), VB .NET compiled to the same intermediate language (IL) as did C# and ran under the same .NET Framework runtime engine.

But it was also denser, harder to learn, and less visual than its predecessors. And while developers could still create forms-based applications using a .NET technology called Windows Forms that we’ll discuss in more detail later, it just wasn’t the same. Microsoft, inexplicably, had sucked the magic and fun out of Visual Basic.

Visual Basic .NET exists today, of course, and the most current version is called Visual Basic 15.8 to show you how far it’s come since 1991. Interestingly, it’s still one of the world’s most popular programming languages, though with the caveat that its audience is comprised solely of professional developers, not beginners or enthusiasts.

But in recent years, Microsoft has finally decoupled C# and VB development, with VB lagging functionally behind C# in many key areas and no promises that it will ever catch up. As we approach Microsoft’s 50th anniversary in 2025, there is a strong possibility that the software giant will finally have said goodbye to the language that created the company in the first place.

That will be sad in many ways, but it’s also unnecessary. When I look at today’s version of the first personal computers, which always shipped with BASIC and inspired a generation of youngsters to learn to code, I see a great opportunity today in the Raspberry Pi. In its current iteration, the Raspberry Pi 4, this tiny board-based PC has enough power to run a real operating system like Windows 10. And it deserves a truly simply software development language and environment. Like Visual Basic.

The Raspberry Pi 4 needs Visual Basic. We all do.