Browsing The Next Generation

This column appeared in the May 2000 edition of EXE. It explains why Visual Basic developers will soon need to start calling themselves Visual Studio developers.

---

Once again the theme this month is concerned with keeping those skills up to date, while also keeping an eye on what lies ahead. To start with I’d like to cover the main points from a keynote speech given by Steve Ballmer, Microsoft president and CEO, in which he outlined the next generation of Visual Studio. Most people I speak to who are in our trade are always interested to know what’s in the next release of Visual Studio, Windows, SQL Server, or whatever, so this month I thought it would be fun to indulge ourselves a little bit. Finally, having completed this, there is a book that I’d like to recommend to those developers who are lucky enough to be working on the newest platform, namely Windows 2000.

Visual Studio 7

Strictly speaking the next version of Visual Studio 7 was due out in the first half of this year and was chiefly intended to accommodate some of the newer technologies such as SQL Server 7, COM+ and, of course, Windows 2000. However, at the Visual Basic Insiders Technical Summit (VBITS) in San Francisco on February 15th, Steve Ballmer announced that this next version was being postponed until the “end of the year” (which will probably be 2001). The primary reason for the delay was declared to be the amount of work being done to build in support for Windows DNA 2000. Dave Mendlen, Visual Studio Product Planner at Microsoft, described the new version as “revolutionary”, for reasons that will become obvious as I describe the new features. Before I start covering the new features of Visual Studio 7 please do remember that this is a very early preview that was demonstrated so there is every possibility that the specification will change again before the product finally hits the streets; just treat it as an intention of things to come.

The most significant visual change will be that Visual Basic is finally hosted within the Visual Studio environment. This has frankly been long overdue; long–standing VB developers will recall that the first three versions consisted of a strange mix of different control windows that all sat independently on the Windows desktop. The current IDE concept wasn’t actually introduced until Visual Basic 5, and even then you had the option to revert to the old style if you preferred. Having Visual Basic share the same IDE as the other development languages finally means that we get direct access to the same utility tools that have been available to the Visual C++ and Visual InterDev crowd for so long. For example, Visual Studio has always provided integrated editors for bitmap, icon, and resource files, whereas the Visual Basic resource editor add–in always left me feeling like the poor relation. They’ve even got a To Do task list for crying out loud! For this integration alone I’m extremely pleased.

There’s more, however. One of the biggest criticisms of Visual Basic so far has been that it’s not truly object–oriented, but instead is merely object–based. Up to and including the current release Microsoft provided a partial implementation of inheritance – a key requirement of OO – by providing the Implements keyword. This is all set to change as Ballmer has promised that VS7 will provide a “first class object oriented programming language”. This means a full–implementation of the concepts that were previously missing and thus disqualified it from being described as an OO language, namely Inheritance, Encapsulation, Overloading, and Polymorphism. It will also be possible to pass parameters to the class constructor, the absence of which has thus far limited the usefulness of the Class_Initialize method.

From the day that a 32–bit version of Visual Basic existed the development community have been asking why some of the most fundamental features of 32–bit Windows aren’t available, namely thread support and structured exception handling. Again, both of these will be provided for the first time. Actually, although I say for the first time there has actually been a partial implementation of thread support in that an apartment–threaded model is provided for ActiveX components. The term apartment threading is used to indicate that objects created under a current thread are aware of other objects that are created under the same thread, but cannot see objects created by other threads even thought they might be part of the same component; as if these other objects lived in another apartment within the same building. But while the apartment–threaded model has its place the feature that developers have really been waiting for is free threading. This other model allows the programmer to create a new execution thread on the fly for the purpose of performing some other task, such as a background calculation or print set–up job. In order to implement this the AddressOf operator is used, together with a couple of new thread–related functions. The code fragment that Microsoft have provided for this is:

Dim b As BackGroundWork
Dim t As Thread
Set b = New BackGroundWork()
Set t = New Thread(New ThreadStart(AddressOf b.DoIt))
t.Start

The structured error handling (SEH) is something that will be totally familiar to Visual C++ developers who have had it since version 2.0. The idea of an SEH block is to identify a section of code for which you have a specific course of action that you’d like to follow in the event of a failure; it also provides a guarantee that a subsequent piece of tidy–up code will always be executed. The section that contains the code that might fail is called the guarded body, whereas the guaranteed–to–run finish–up code is called the termination handler. If an error occurs then execution will be shunted an exception handler. It is coded within a new control–of–flow sequence called a Try..End Try block, such as:

Try
  Open "Testfile.txt" For Output As #1
  Write #1, CustomerInformation
Catch
  Kill "Testfile.txt"
Finally
  Close #1
End Try

But of course the most fundamental changes to the product are concerned with Internet development issues. In fact if anything the emphasis of the product will be more squarely aimed at building server–side logic for the servicing of web pages than for the construction of conventional Windows applications. By the sound of things the Visual Basic professional won’t need to leave the Visual Studio environment to perform any of the web development tasks. A new concept known as ASP+ Web Forms builds upon the drag and drop model employed in the construction of traditional Visual Basic forms, but this won’t be limited to a particular language. As a standard feature of Visual Studio a new Web Form can be created and defined; the layout of the page is stored as HTML while the event handling code is written in either Visual C++ or Visual Basic as you prefer. This source code is then compiled and stored at the server for execution. When the code is executed HTML 3.2 text is produced allowing the result to be viewed on any decent browser.

This approach speeds up execution because it is running a compiled executable, rather than text–based scripts. In order to be ready for this technology Microsoft recommends that a tiered approach be adopted to any development which is taking place now, with as much functionality as possible being placed in middle–tier business objects rather than in script. Then, when you are able to move up to Visual Studio 7, you will be able to import, extend, and then recompile the objects to take advantage of the new features. It’s likely that you will need to tweak your code a bit when you port it over; Visual Studio 7 is a major rewrite and it looks like there will be less emphasis on backward–compatibility this time around in order to get the most out of the new architecture. Some people will criticise this, but personally I think that the Windows landscape is changing so much that the product needs this kind of big leap in order to stay in the game.

When a middle–tier component, or set of components, is made available over HTTP it is known as a Web Service. As part of the process of designing a Web Service the developer will need to describe the flow of data in an XML document. This sounds a little scary on the face of it but there will be visual designers and wizards to “automate the task of creating complex XML data structures”. Phew! The upshot is that data can be passed between all three tiers as XML, effectively opening up the architecture to include other platforms if required.

As you may have gathered from some of the other topics in this month’s issue of EXE, XML is getting to be big and it’s here to stay. I’ve already skimmed the utmost basics of XML in a previous column (at least, as much as I could in two pages), but Ballmer has indicated that XML support will be deeply integrated within the full Visual Studio product set. XML is currently being integrated into just about everything that Microsoft produce for the business market right now; for example we will see the release of SQL Server 2000 a bit later this year, to which one of the primary additions is this very technology. Something else you’ll start hearing more about from Microsoft is the Simple Object Access Protocol (SOAP) which is an XML–based mechanism for remote object invocation and manipulation over HTTP. A forthcoming Visual Studio add–on called the Web Services Toolkit is a forerunner to this SOAP technology.

Book review

Having looked at a product that is yet to come, we’ll now come back to a product that is currently shipping, albeit for only a short while. Windows 2000 takes the concepts of the COM model, adds Microsoft Transaction Server (MTS) and a few other features and COM+ is the result. MTS under Windows NT 4 is currently used by a large number of Visual Basic developers to provide distributed transaction support within an enterprise infrastructure, although it is also good for providing straightforward object pooling. Despite Microsoft’s fondest wishes it is likely to be a while yet before large companies seriously start looking at upgrading their corporate platform to Windows 2000, but that doesn’t mean that you shouldn’t be familiarising yourself with the architecture. To this end I would recommend Understanding COM+, written by David S. Platt. In this book Platt made the decision upfront not to litter the book with code samples, and I think the decision was correct in this particular case. If you only program in Visual Basic then it can be quite off–putting to see loads of C++/MFC; in fact it would probably put you off buying the book. Having said that, sample code by the author is downloadable from the Internet.

Despite a rather irritating over–emphasis on categorising software developers as geeks he presents the subject matter clearly and makes the topic suitable for both developers who are new to the concepts of the technology formerly known as MTS, and to those who have programmed for it but need to understand how the architecture has altered. The only real problem with the book is that it was written against beta 3 of Windows 2000 and doesn’t take into account the fact that a whole subsystem, namely In–Memory Databases (IMDB), was removed from the product at the eleventh hour due to adverse feedback from some of the corporate testers; in the book Platt devotes a whole chapter to the topic. However I still believe that it will still make interesting reading because I understand that Microsoft still intend to re–implement it at a later time when they have addressed the criticisms that were levelled against the implementation. The book is published by Microsoft Press and is priced at £22.99 (ISBN 0–7356–0666–8).