Programming Windows: Visual Studio (Premium)

Heading into the late 1990s, Microsoft sought to consolidate its developer languages and tools into a single, cohesive environment. The project, originally codenamed “Boston,” resulted in a new integrated suite called Visual Studio that persists to this day.

But long before that would ever happen, Microsoft’s developer tools and environments started humbly with the MS-DOS-based command-line utilities and basic text editors of the 1980s. But thanks to Borland and other competitors that innovated with integrated developer environments (IDEs), Microsoft’s developer offerings matured quickly to match these increasingly sophisticated offerings. And by the end of the decade, the firm offered a variety of DOS-based IDEs for assembly language (MASM, the Microsoft Macro Assembler), C and C++ (Microsoft C and Microsoft C/C++), BASIC (GW-BASIC, QBasic/QuickBASIC, Visual Basic), and other languages (like Pascal and Fortran).

IDEs were important then for the same reason they are today: They allowed developers to write, build, and test their applications from a single place rather than requiring them to drop out of an editor to the DOS command line to compile, build, and test. IDEs offered simple integrated commands for these tasks, and over time, they offered ever-more-sophisticated aids to make software developer easier and less error-prone.

In the early days of Windows, application developers who targeted this graphical operating environment were forced to work in DOS-based IDEs. But as Windows evolved, so too did Microsoft and third-party developer environments, and by the early 1990s, developers could write, build, and test Windows applications entirely from within Windows. By that point, Microsoft’s primary developer environments were Microsoft C/C++, which became Visual C++, and Visual Basic.

They couldn’t have been more different, and not just from a language perspective. Visual C++ targeted professional developers who wrote directly to the Windows API in the C programming language or used C++ frameworks like the Microsoft Foundation Classes (MFC) or the Active Template Library (ATL). Visual Basic, meanwhile, targeted beginners and those who wished to prototype application designs before committing to code.

Visual C++ wasn’t a superset of Visual Basic, or a more sophisticated version of the latter product. Instead, each had evolved separately, were made by different teams, and each included useful functionality that the other lacked. Where Visual Basic living up to its name and was indeed quite visual, Visual C++ did not and was not, and it only included basic visual tools for application resources like menus, toolbars, and dialog boxes. For the main application design, Visual C++ relied instead on wizards that created often obtuse code to construct different types of applications.

Consolidating the two wasn’t a priority at first, and it was hard to imagine a typical Visual Basic developer evolving into a Visual C++ professional. But events conspired to require such a consolidation.

The first was internal: Microsoft began pushing a component-based software development approach with its COM technologies in the early- to mid-1990s, and it evolved both products to support this work. Thanks to its sophisticated nature, Visual C++ was a natural fit for creating COM servers and controls (typically via ATL). And Visual Basic, with its more visual style, was a natural fit for consuming those servers and controls in applications. But developers could use either tool to leverage any part of the COM stack, and COM created an interesting new form of interface-based interoperability that made the differences in the products’ underlying languages less problematic.

The second factor was external: With the rise of the Internet in the late 1990s, Microsoft engaged in a two-year effort to not just catch up with what Netscape, Sun, and others had pioneered, but to surpass them. And it expanded its developer-related tools and technologies dramatically during this time frame. Among the advances were new development environments for Java and the web.

Microsoft did have the time to create an entirely new development environment for each, and of course by that point, it wouldn’t have made sense to do so anyway. Instead, it began an effort to consolidate its developer environments with the goal of perhaps arriving at a single IDE for all of the languages it supported. This wouldn’t happen immediately, as Visual C++ and Visual Basic were so different. But the plan was for this integration to happen over time.

For the first version of Visual Studio, Microsoft standardized on the Visual C++ Developer Studio IDE since it had the most sophisticated code editor, and editing code would be key to both Java and HTML/CSS/JavaScript. (A subsequent effort to move Visual Basic into this environment was codenamed Vegas.) As a result, the Java environment was named Visual J++ and the web development environment was eventually named Visual InterDev. (Earlier efforts were codenamed Blackbird and Internet Studio.) Even Microsoft’s developer documentation, called MSDN Library, was moved into Developer Studio and was now HTML-based.

Indeed, it is Visual Studio that triggered my first visit to Microsoft’s Redmond campus, in December 1996. There, I learned about the integration plans, and about Microsoft’s web server, called Internet Information Server (IIS). I also learned about the bizarre Seattle pseudo-culture around Starbucks specifically and coffee generally. And I witnessed what still is, to this day, the heaviest rainfall I’ve ever seen; it was like standing behind a waterfall. Which is odd, since the Seattle area is mostly just wet, and not actually known for heavy rain.

In any event, the first version of Visual Studio shipped in February 1997 and was called Visual Studio 97, in keeping with Microsoft’s branding tradition of the day. It included Visual Basic 5.0, Visual C++ 5.0, Visual J++ 1.1, and Visual InterDev 1.0, plus MSDN Library, SQL Server 6.5 Developer Edition and Visual FoxPro 5.0 (databases), Microsoft Transaction Server 1.0 (component management), and Visual SourceSafe 5.0 (source control).

Even the first Visual Studio version was, in effect, what Microsoft Office was to the individual office productivity apps, a reasonably integrated suite of solutions that together delivered a tremendous amount of power and flexibility. That you needed to install each tool separately was, of course, an indication of its newness, and something that would be fixed in subsequent versions. That Microsoft was bundling separate products together but not really integrating them during a time in which it was precluded from doing so was, of course, ironic and hypocritical.

But as Michael Otey—later a friend and coworker of mine—noted in Windows NT Magazine, Visual Studio 97 provided everything developers needed to build “distributed web applications, including client and server scripting using VBScript and JavaScript; server components using VC++, VB, VJ++, and VFP; client components, including Java applets, ActiveX controls, and Active document applications; HTML pages using VI; and back-end database queries … VS97 is also an enterprise-level application development toolkit.” It was a fairly complete package for the day.

But it wouldn’t last long: Microsoft announced its successor, called Visual Studio 6.0, in mid-1998, with a focus on component-based development and deeper integration (though Visual Basic remained outside of Developer Studio). Even the installer was finally integrated.

“In order for organizations to achieve a competitive advantage from their technology infrastructure, they need the ability to build solutions that can easily integrate disparate systems,” Microsoft group vice president Paul Maritz said at the product’s announcement. “Developers can use Microsoft’s comprehensive development suite, Visual Studio 6.0, with the enabling foundation of Windows DNA to make this a reality.”

Visual Studio 6.0 shipped in September 1998 with updated versions of Visual Basic, Visual C++, Visual InterDev, and Visual FoxPro, with a new version of Visual J++ arriving a bit later; each was updated to version 6.0 to make the products appear more consistent, but Visual InterDev and J++, as newer products, were both substantially updated and were quite a bit more sophisticated than their predecessors.

Microsoft’s developer tools integration a good idea, even though getting Visual Basic onboard would require yet another generation of upgrades. But the software giant would delay the release of a new Visual Studio version for three years, thanks to a major shift in its product strategy that would require it to sever ties with Java and create its own platform replacement called .NET. This, in turn, would lead to an even deeper integration of its developer products in a future version of Visual Studio. It was called Visual Studio.NET.