Visual Studio .NET: Hits and misses

Visual Studio .NET was released in February with much fanfare. Check out one developer's impressions of the new IDE based on his experience with it thus far.

Depending on your point of view, February 13 was a day you anticipated like Christmas or dreaded like a dentist appointment. Whichever side of the fence you were on, the release of the newest version of Microsoft's application development suite, Visual Studio .NET, was a big deal for the millions of Windows developers around the world.

We've all heard the marketing buzz surrounding the .NET platform in general and some of its big features in particular—like easy Web services development and new support for mobile applications with the Mobile Internet Toolkit. But what about the environment itself? Will you be more productive using the newest Visual Studio in your day-to-day life as a developer?

I've been using Visual Studio practically every day since beta 2, and I've gotten to know the IDE fairly well. In this article, I'll take a look at the new suite through the eyes of an everyday user and share my impressions with you.

The more things change…
The changes made to this Visual Studio lean more toward the evolutionary than the revolutionary, although it may not appear so at first glance. The environment still provides various project and component templates that can be used to provide a foundation for your application. There are still numerous "wizards" to be found, although most are no longer of the "Next…Next…Finish" variety and are actually rather seamless.

The IDE itself will feel familiar if you've ever used one of the Visual Studio applications in the past, although it's decidedly unlike any previous versions. It incorporates quite a few of the best features of Visual Basic and Visual C++ but feels somehow more like Visual Interdev than either of the former. Of course, the fact that there is one unified development environment for everything but Visual FoxPro constitutes a big change in and of itself.

Hits: A pleasant, flexible environment
Let's start with the good stuff. The unified IDE is a blessing, given that Microsoft seems to want developers to build applications using multiple .NET languages. Although developers certainly could, and did, build applications in multiple languages before Visual Studio .NET, each IDE presented a slightly different user interface, and having to switch between them could be confusing. I usually had trouble keeping straight which function key shortcut meant "compile and run."

Visual Studio .NET, on the other hand, gives you the same look and feel regardless of the language you're writing. If that default setup doesn't suit you, you can customize the environment's behavior through the use of developer profiles, which let you change things like menu and toolbar placement and keyboard shortcuts based on the language you expect to use most.

In fact, the new IDE is more programmer-friendly than previous incarnations, incorporating features like collapsible tool windows that will automatically expand when your mouse hovers over them. This allows you to maximize your screen real estate for the task at hand, as shown in Figure A. Another feature I find useful is the ability to collapse infrequently edited functions and keep them out of the way in the code editor and to define my own collapsible regions of code using the #Region keyword.

Figure A
New tool windows get out of your way when you don't want them.

You'll be happy to know that InteliSense is alive and well in all its addictive glory, with a spiffy new enhancement. As you can see in Figure B, it not only provides parameter information about a method or function call, but it also displays a brief description of the object, method, or function itself. The net result is that you'll find yourself spending less time referring to the documentation while acclimating yourself to the massive contents of the .NET class library. You can take advantage of this and other documentation features in your own code by making use of the XML documentation tags in your code.

Figure B
InteliSense now provides context information.

Not a Harry Potter reference in sight
As I mentioned, wizards are alive and well, and they are all over the place in Visual Studio .NET. There's the Add Web Reference Wizard, which incorporates a UDDI browser for locating a Web service and automatically generates the glue code needed to consume it. The new Editor Wizard for Windows Forms works well, coping easily with changes made by the programmer. For instance, it automatically deletes code associated with a deleted control. That may not sound like much, but I've seen first-outing GUI editors fail miserably when it comes to managing something like that.

Misses: You have to take the good with the bad
As I'm fond of saying, every silver lining has a cloud, and it's no different here. I've found more than my fair share of annoyances and things that don't work quite right with the newest Visual Studio. For one thing, it seems overly "Web-ified," especially the new single-click Start Page you see when starting up the environment and the integrated Web browser controls toolbar that's shown by default. Maybe I'm prematurely becoming an old stick-in-the-mud, but I have yet to get my head around why Microsoft insists on including a Web browser in every product it makes.

Microsoft also seems to have a habit of throwing in features that sound really great on paper but which, in practice, fall short of their intended usefulness. One example is the misbegotten Dynamic Help feature. It's meant to display context-sensitive help about the code you're editing, but it's too slow and unwieldy, actually slowing down the IDE when activated, to be of much real use. I wound up turning it off almost immediately and haven't used it again.

The actual code editor isn't going to please everyone. For some reason, the environment seems to be biased toward VB.NET developers, giving them a bit more functionality, like inline error detection (Figure C), that their C# or C++ slinging counterparts will have to do without.

Figure C
VB.NET developers get a little extra context-sensitive help.

Those same C# and C++ developers will quickly notice the editor's predilection for moving opening and closing curly braces onto their own lines, enforcing a coding style that they may not agree with. At the same time, old VB folks, while freed from curly brace tyranny, will likely be disconcerted by the inability to edit code in the middle of a debugging run and the disappearance of the friendly immediate window.

Finally, getting back to the wizards, I'm not sure that I (along with many other developers) are at all comfortable with the amount of code that Visual Studio .NET writes for us behind the scenes. Actually, I suppose it's not the amount of code so much as the quality of that code, as Microsoft has a bit of a reputation for substandard code generators.

However, despite the annoying quirks—and given time to get used to it—the bottom line is that Visual Studio .NET is a big improvement over what was a good product to begin with. That's fortunate since it's really the only game in town for .NET development.

Share your impressions
If you've been using Visual Studio .NET, share your impressions by posting your comments in the discussion below.


Editor's Picks