eWEEK content and product recommendations are editorially independent. We may make money when you click on links to our partners. Learn More.
The first time you see a dancing bear, youre likely to be impressed that it can dance at all; you probably wont cavil if it steps on its trainers toes once or twice. Microsoft Corp.s Visual Studio .Net, launched today in San Francisco after what has sometimes seemed an endless wait, dances fairly well–and our feet are merely bruised, thank you, with no broken bones that weve yet noticed.
Microsoft has taken on the challenge of making distributed Web services and nonvisual, server-side application elements as accessible to developers as it made the resources of a stand-alone Windows PC with the original Visual Basic. The resulting product is a good deal more than just the next generation of “edit, compile, debug, repeat, release.”
The product comes in several editions, with a feature matrix online at msdn.microsoft.com/vstudio/prodinfo/purchase/features.asp. The fully loaded Visual Studio .Net Enterprise Architect is priced at $2,499. Visual Studio .Net Enterprise Developer is $1,799. Visual Studio .Net Professional is $1,079. Standard editions of Visual Basic .Net, Visual C++ .Net and Visual C# .Net are also available for $109. This review addresses features common to the Professional edition and later but does not examine the application test and life-cycle management tools of the higher-priced Enterprise editions, or the Unified Modeling Language-based visual design tools found in Enterprise Architect only.
A feature matrix alone, however, doesnt adequately capture the new feel of this product. If the integrated environment of the 1990s was a compiler with tools wrapped around it, the integrated environment of the Web services era might be characterized as an Internet portal–with development tools among the resources it offers. Without the portal elements, the tools to build Web services would be almost as useless as owning the only telephone in the world: No matter how well it works, on its own, its value is in the conversations it enables.
When you go through the Visual Studio .Net portal, youre not in Kansas anymore. (Chorus from offstage: “No, youre in Redmond, Wash.!”) Developers examining this tool set will want answers to a yin and yang of complementary questions. First, can it do what they want? Second, will it force them to do things that they dont want? Answering those questions requires a reviewer to consider some novel issues.
Welcome to the new
world”>
Welcome to the new world
The Visual Studio .Net environment takes a cue from the browser-style environment of Borland Software Corp.s JBuilder or Oracle Corp.s JDeveloper, with a Start Page as the front door. Starting a new project in Visual Studio .Net will bring up options that range from bleeding-edge C# applications and Web services to the bang-the-rocks-together Console application thats still sometimes the best way to test an idea or solve a simple problem. Were glad to see the latter option included.
As in the other above-mentioned tools, the Start page is not just a menu of available local resources but is also a subtle indoctrination tool. OK, forget the “subtle.” Why think of yourself as merely a lonely application developer when you can be part an Online Community? With access to code libraries, newsgroups of like-minded developers, online seminars and (in the true spirit of Windows XP) one-click access to favored commercial providers of .Net components? All these resources are just a few clicks away from the Visual Studio .Net opening screen.
On a somewhat more dynamic plane are the Start page links labeled XML Web Services and Web Hosting, which enable (respectively) UDDI (Universal Description, Discovery and Integration) registration of new services and free, “experimental playground” accounts with favored Web hosting providers. Note that UDDI registration through this mechanism requires the use of Passport. We are (with apologies to Claude Rains in “Casablanca”) shocked, shocked to find this linkage.
With services published in a playground (where data is subject to removal without warning–production services play at their own risk), developers can then stress-test their services with the Application Center Test facility (which we did not evaluate) in the Enterprise editions of the product.
When the Visual Studio .Net developer finally starts to cut code, the language-level innovations in this release of Microsofts tool set will become key concerns. In its new .Net incarnation, Visual Basic becomes a strikingly Java-like language with the ability to overload function names (so that the same function name may be applied to different types of data) and with structured exception handling (Try … Catch … Finally) instead of the unlamented On Error GoTo construct.
At the risk of seeming gloomy, well note that anyone writing Web services had better be prepared to start using high-level language facilities for detecting and handling other-than-expected conditions. As an aspiring programming platform, the Internet makes even Windows look rock-solid by comparison.
Developers using Visual C++ with .Net will find new 64-bit date and time functions, meaning that dates and times can now be calculated beyond the infamous horizon of January, 2038, that has long been lurking as the next Y2K-style crisis. Were now safe, said Microsoft, until the end of the year 3000. Unfortunately, the new security and cryptographic wrapper classes in the updated template library in Visual C++ .Net are less successful abstractions–knowledge of Win32 APIs is still required to use them, Microsoft said.
And then theres C#. The most entertaining thing about reading Microsofts C# documentation is the degree to which it rebuts so many of the nice things that Microsoft has had to say about C++ for lo, these many years. Poor error handling, lack of type safety, complex and brittle object emulation, and nearly impossible debugging at anything above the level of machine language: All of these are problems with C++ that didnt matter, according to Microsoft, when Java was fixing them, but all of them are apparently worthy of concern now that C# is here.
Microsoft also hopes that its separately offered JLCA, for Java Language Conversion Assistant, will pave the way for a general migration from Java to C#–but the Java development environments that weve been seeing lately may have spoiled the developers using that language to a degree that Visual Studio .Net will not quickly overcome. When we evaluate Microsofts effort as an integrated development environment, rather than as a portal to the .Net way, we find it merely competitive with other current tools–not the leap beyond that it needs to be, if its to become the obvious path of least resistance that past generations of Microsoft tools have been.
Some old things still
matter”>
Some old things still matter
The Visual Studio .Net environment tried to analyze what we were doing and to offer the relevant resources that we were most likely to need next, but it made some odd choices. For example, when we dragged the icon for an existing graphical control from the Class View inspector into the adjacent source code window for the corresponding form, the source editor generated an identifier for that control that was not accepted by a simple Rebuild command. We had to strip off qualifying prefix elements from the beginning of the generated identifier to produce the intuitively reasonable object reference that one might expect in a drag-and-drop tool.
The variety of integrated tools in Visual Studio .Net comes close to the high standard set by competing tool vendors, who have gone through several product cycles in the time since Microsofts last significant update. But the source code editor in Visual Studio .Net cannot drive the visual form designer, as can the source editor in Oracles JDeveloper. If we changed the code that defines a push buttons size and shape in JDeveloper code, the visual form designer took note of that change, but in Visual Studio .Net, the link is one-way between the Form Designer and the code that it generates.
In fact, the code that describes a visual form control in Visual Studio .Net comes marked with a “no trespassing” sign in the form of a comment that reads, in part, “do not modify the contents of this method with the code editor”–an affront to any red-blooded developer.
Overall, we found the new Microsoft environment less dynamically self-aware, for example, than either JDeveloper or Borlands JBuilder, with the different tools in Visual Studio .Net sometimes not noticing each others changes to a project in progress until we took some action that forced them to pay attention.
For example, if we clicked on a graphical control in an active form designer to bring up its information in the Properties inspector and changed the name of the control in the latter tool, the corresponding entry in the Class View inspector did not immediately change. If we then double-clicked on the old (and now invalid) Class View entry, it demurely disappeared, and the controls new name appeared wherever alphabetical ordering would put it–but with none of the entries selected, so it was up to us to figure out what we now wanted to examine.
We dont think were being unfair in throwing such deliberately confusing maneuvers at a product of this complexity: If it cant keep up with us on a project thats small enough to fit on a single screen, and where we can actually see the cues that reveal the resulting inconsistencies, were reluctant to rely on the tool sets ability to keep things straight on projects of more than trivial size.
In fact, projects of more than trivial size quickly expose the weaknesses of tools that demo well in a training seminar, but that may not stand up to enterprise demands. Visual Studio .Net is supposed to be the workbench of the developer whose world is defined in XML, and its visual XML schema editor ought to be one of its highlights. We naturally applied that visual tool to one of the environments own XML schema files, the ie5_0.xsd file that contains editor autocompletion data, with rather disconcerting results.
Our 1GHz Pentium III development system needed almost three minutes to render a visual map of this schemas 4,900-plus lines of XML text; any sustained navigation through the resulting display quickly pegged the CPU utilization measurement at more than 80 percent, while bringing up the complaining whir of the processors temperature-sensitive cooling fan. Its not often that you can actually hear the sound of a machine being brought to its knees.
The XML editors Schema Overview window was completely ineffective in aiding our navigation through this file, since the visual layout was one long horizontal row of hierarchical trees that the overview map condensed to barely more than a single row of pixels. When we moved to the more responsive text view of this file, the environment seemed unwilling to let go: It would revert, spontaneously and unpredictably, to the visual navigation tool without changing the state of the visual control that ought to have been our toggle between the two states (while the fan played on).
Ordinary source code editing will look familiar to Visual Studio users, which is to say that the editor still has not caught up with convenience features that have long been present in other programmers editors such as Mansfield Software Group Inc.s KEdit or SlickEdit Inc.s Visual SlickEdit. We could find no way, for example, to collapse the view of the source file to show only lines containing an arbitrary pattern (or even just a particular string) of text. It was possible to “Mark All” lines that fit a search condition and to move among them with “Next Mark” and “Previous Mark” commands, but this is not nearly as fast as seeing all such lines in a single view.
Were also concerned as to whether Visual Studio .Net can meet the rock-solid reliability requirement of an enterprise development tool. We tried to install the product from a privileged but non-Administrator account on our Windows 2000 workstation and were told that we must grant Administrator privileges. When this was done, however, we still encountered a reproducible Blue Screen of Death during the component update phase of that installation. We were able to avoid this only by logging in as Administrator to complete the job.
On one occasion, an attempt to load a sample code project failed with an error message, only to succeed on our next attempt. We get nervous when these things happen with an application; we get downright jittery when something as vital as a development tool shows such rough edges.
And yet, this bear does dance. In earlier reviews, we discussed in greater detail some of the leading-edge features that Microsoft is offering–namely, mobile client development, visual server-side development, and the integrated modeling aids for applications and database design. (See eWEEK Labs June 25, 2001, review of the Mobile Internet Toolkit beta; and Sept. 10, 2001, Visual Studio .Net Enterprise Architect Beta 2 review.)
Many developers, and every competing maker of application development tools, will want to study Visual Studio .Net to understand the ambitious agenda of Web services development–with the added incentive that Microsoft has clearly left some room for improvement, creating a space that other toolmakers will do well to promptly fill.
eWEEK Technology Editor Peter Coffee can be reached at peter_coffee@ziffdavis.com.
Related stories:
- Microsoft Tunes Windows
- From the Labs: BizTalk Server 2002 Eases B2B Comm.
- From the Labs: Visual Studio .Net/BizTalk Combo May Tame Web
- Walk-Through: Go Inside Visual Studio .Net with eWEEK Labs
- Picking Up on Web Services Tools