My History of Visual Studio (Part 5)

[All the other Parts: History of Visual Studio]

We’re still on the part of the story where I was off working in MSN which means all I can give you are the first- and second-hand stories that I’ve heard over the years. So I guess that makes them second- and third- hand to you.  This would be a great time to watch the Channel Nine Documentary for more authoritative information J

In the last part I wrote a little bit about what was happening in the VC++ IDE – “edit and continue” for C++ programmers – pretty amazing stuff. 

At about this time the Internet happened.  I mention that like it’s in passing but, even looking at the phenomenon super-narrowly, just from the perspective of how it affected our programming tools it had some pretty big effects.

Of course probably the most major one was the creation of Visual Interdev to help people create great web applications.  You know that shell is going to be central to the story in a way nobody expected at the time (ok, maybe the VID guys expected it, but nobody else J) but also script and dynamic languages made a huge resurgence.  Perl, Python – remember web sites in Perl?  And of course jscript, at first as a client-side language in the browser, but then more generally, and its twin in our world: vbscript.

But for the web server needs and the browser needs, we might not have driven these languages within Microsoft as hard as we did.  They helped our tools grow up in unexpected ways, like for instance, I think in VC5 you could finally call the editor “grown up” – it had been originally fairly underpowered as programmer’s editors go – but in VC5 full macro support was added (not just little recordings) using the vbscript engine.  It still needed polish but you could now no longer argue that it was lacking in raw potential/power.  Like other MS applications the macro language encompassed not just the editor but virtually all aspects of the product.  I remember making a command line debugger interface in an editor window with macros as a example for a friend. 

Speaking of BASIC, during all this time, our friends in VB weren’t exactly idle either. In the VB5 IDE, Intellisense makes its appearance.

Can you imagine programming without Intellisense?  Well I guess you probably all can because many of you did without it in the past, but certainly a good amount of cursing happens in my office when I find myself without it.  It isn’t just that it saves you typing – it fundamentally changes the way you work.  For many applications Intellisense makes API documentation obsolete because it used to be that the #1 use for that stuff was to get method signatures, it is easily the #1 way people get “help” – blowing away the F1 key for usage.  But it’s more important than that… it goes as far as freeing you to use better naming techniques, especially in frameworks.   Maybe Dennis Ritchie would not have left off the ‘e’ in ‘creat()’ if he’d had Intellisense.  And what about what it did for Office?  The Visual Basic for Applications (VBA) engine got Intellisense too and that meant Office programmers got much easier automation scripting.

At any rate, Intellisense was a total game-changer and was soon in the entire Visual Suite.  And by soon I mean what you might call Visual Studio 6.0 – by an amazing coincidence the language version numbers had synchronized or been forced to synchronize (VJ and VID).

Now VS6, and more importantly its parts, VB6 and VC6 are widely considered to be the best we ever made.  Not universally but certainly there are factions that think we should have stopped right there, or stayed on that track.  I think this is true because they represent the last of that evolutionary line, for both languages.  The IDE that would become Visual Studio became available in its first incarnation at that time, as I have alluded to in the past, and it was Visual Interdev.  In some ways, from a consolidation perspective it looked like we had taken a step backwards -- there were now four major shells rather than three.  The respective teams polished their products to a bright shine and Intellisense bloomed like daisies across the suite.

For those of you that just lost me on shell count, I went to four with the addition of the VID shell (used by VJ++), add VB and VC++ and that makes three.  What is this fourth shell you speak of Rico?

The problem is that in this entire history I’ve been completely silent on another suite member – Visual FoxPro which also had its own shell.  Now there’s a reason for this – and that is that I know painfully little about that product other than when I did a study of database technologies for Sidewalk in 1995 I was stunned by how many advanced features were already in the FoxPro product.  Who remembers “Rushmore” – I remember getting some pretty slick demos!  Little known fact: it was the FoxPro team that taught me the basics of database programming -- thank you, you know who you are 🙂

But, with apologies, I must go on, paying only very little homage to that shell.  It would be great if someone else posted a My History that included more FoxPro stuff.  Or any other My Histories for that matter…

I feel like I should mention Office a little bit more at this point.  I’ve hardly mentioned Office but it’s important to note that Office, and the needs of Office Programmability, were often key forces in language and tools design, to say nothing of the needs of the Office programmers themselves – which frequently pushed our tools to the breaking-point.  IMHO, probably more than any other single force, it was Office that was driving BASIC – from as early on as the Embedded Basic which then went on to power VB, and then later VBA, Office was a huge influence.  I think specifically it was Office that drove how application automation had to work and that in turn drove OLE Automation generally and that in turn drove BASIC.  Those of you who have ever had to program with VARIANTs a lot can probably thank or curse this dependency cycle.

One other big thing to mention and then I’ll wrap up for this installment.  Another notable change in this time period was the maturation of the data access layers.  I think this, too, was partially internet-needs driven but also I think the technologies were just ripe.  OLEDB was born during these years and with it the BASIC access mechanism – ADO.  These things seem pretty mundane on the surface but they offered much richer data access than ever before and inspired the first of increasingly popular and powerful datagrid mechanisms for both display and editing of data.  When compared to the clumsy DDX/DDV type things we had been doing it was a breath of fresh air for data programming and forms over data.  All of this would go on to influence many different types of designers and data management services, but I think the spark for that was here, in say 1997.

Visual Studio 6.0 – synchronized across the versions and starting to show some (distant) signs of consolidation between its various parts appeared in 1998.  It was a great release, as I wrote above, it’s still the favorite release of many.  After that, the developer division “went dark” for about 4 years, they were working on what would become “Visual Studio .NET”.

[See The Documentary on Channel 9!]

Comments (5)

  1. Tommy says:

    Could you PLEASE increase the spacing between lines in your CSS?

    I’m on a Mac and don’t have that Windows font that makes the page look ok on your screen.

  2. ricom says:

    Is that theme better?  I was getting kind of sick of the old one anyway.

    I think the only real solution is to paste cleaner HTML into the thing if that doesn’t do it.  I can remove the various font references with a little work.

  3. Doug says:

    It was easy to read on my iPod. The visual style looks good.

  4. There’s a pre-made history of FoxPro at

  5. Keith Patrick says:

    I do agree that VS6 was an excellent release. And Intellisense was a huge, huge addition (I like to think it helped hasten the demise of Hungarian notation). Can’t wait to read this history of VS.Net…so much of it is fresh in my mind, but I look forward to hearing how going to managed code changed MS itself.

Skip to main content