This article was published in PC Plus issue 121 (Nov 96), and is reproduced here for information purposes only. This is the original copy which was sent to the magazine, not the subbed version which appeared on the page. |
Analysis/Technical Backgrounder - Microsoft Active Platform and Visual Studio, Nov 96.I did this two-pager for PC Plus after attending a Visual Studio reviewer's workshop in Seattle. Its aim is to give the reader an overview of the Active Platform architecture, and of the contents of Visual Studio.
|
|
|
|
[BEGINS]
<Head> Microsoft's
designs for Net application dominance <Strap> Microsoft is
bidding to control application development standards on the Internet, and
gain the corporate acceptance it's always wanted for Windows. Paul
Stephens examines the masterplan. <Body> This spring
Microsoft will reveal the final elements of its 'Active Platform', the
systems architecture it hopes will set the standards for client-server
business applications running across the Internet and closed-circuit
corporate Intranets. On the face of it, this is yet another example of the
company's sudden and total conversion to all things Net. The truth,
however, is slightly different.
Microsoft is a recent Net convert, but for much longer has been
trying to get its Windows operating systems and COM/ActiveX (formerly OLE)
programming standards accepted in the serious world of corporate
computing. The Active Platform, largely a reworking of those standards, is
a combination of Windows-hosted programming languages, developer tools and
server products which make heavy use of COM technology.
It allows developers to create server-based applications which
simultaneously support client machines connected via the Internet,
Intranets and old-style 'enterprise' networks - a factor which may be
enough to swing things Microsoft's way in many Net-anxious I.T.
departments. If it can grab a big share of the new Net-based applications
market too, then Microsoft's cup will well and truly run over. Back to the
future. This being Microsoft, the server is Windows NT, and the application code
is mostly configured as 'components' in the shape of COM objects and
ActiveX controls. The relative thickness of the client and server
application layers isn't fixed; instead developers are offered a sliding
scale of compromise between what Microsoft calls reach (number of suitable
client platforms) and richness (how much clever processing happens in the
client machine). This is the key to its multi-client strategy. At one extreme lie basic graphical web browsers, running on any platform
(e.g. Macintosh, UNIX) and required only to handle HTML-standard forms and
tables. These receive pure HTML, generated dynamically by Microsoft's Web
server with the help of software components containing the 'business
rules' of the application. Components also deal with back-end databases,
so one might receive the results of a database query and format it as an
HTML table, which the Web server would merge with an HTML document
template and send to the browser.
The next step up the richness scale is termed the 'Active Client',
which means browsers (such as Internet Explorer 3.0) capable of handling
applets and ActiveX controls downloaded with HTML pages. Once this line is
crossed, the degree of client sophistication is unlimited; an ActiveX
control can do virtually anything a regular application can do, whether
it's powerful data validation or the flashy visual effects so evident in
the reborn MSN online service. This result is a client-server model with
fully programmable application logic at both ends, allowing the developer
to decide how thick each end's application layer should be. This document-driven, Web-model approach has the big advantage of easy
accessibility, whatever type of network you're working across. A user
simply specifies the URL of the relevant 'Active Server Page' (Microsoft's
term for server-tweaked HTML documents) as if they were browsing the
regular Web, the document is opened and the application code kicks in.
This in turn brings (relatively) easy scaleability. Make your Web server
visible only within your own workgroup, and you've got a tiny Intranet;
make it accessible via the Internet, and you've got worldwide coverage. These aren't advantages that have traditionally been associated with the
richest type of client, conventional programs running as stand-alone
Windows applications. However Microsoft has designs on this area too.
Besides HTML pages, its Internet Explorer 3.0 can handle 'Active
Documents', a new variation on the old theme of OLE 2.0 in-situ editing
which allows the browser to host fully-functional applications. Point IE
3.0 at an 'active' document (such as a .doc file produced by Word 97) and
it will hand over its menus and toolbars to the file's originating
('server') application. If the active document is a Visual Basic form,
then IE 3.0 effectively becomes the Visual Basic application that lies
behind it. It's goodbye to program launching, and goodbye to the old
desktop metaphor too, as browsing the company intra-web becomes the main
way to get information to your fingertips. (Active)
Xhead According to Microsoft, MTS allows developers to design components as
single-user (able to serve just one client at a time), then use them,
unchanged, in multi-user mode. It also identifies the start and end of
each transaction automatically, rolling back failed transactions' database
updates as required. If true, these are quite historical achievements,
although the company’s comment that MTS would rely on 'a well-designed
back-end database' to handle issues such as clashing record locks
indicates that things may not be quite that perfect.
Visual Studio looks set to cause the same upheaval in the
programming world as Microsoft's Office bundle did in desktop
applications. Due in mid-97, it will contain new versions of all
Microsoft's Visual programming languages - Visual Basic 5.0 (complete with
native mode compiler and ActiveX control creation), Visual C++ 5.0 and
Visual J++ 1.1 - working through a common (C++-derived) IDE based
on Microsoft's trademark multi-pane 'explorer' design. Also included will
be the Visual FoxPro 5.0 database, and Visual InterDev, the product
formerly (and confusingly) known as Internet Studio.
Apart from striking fear into the hearts of competing language
vendors, the idea of packaging the languages together is to allow
developers to pick the most suitable one for each component in their
systems. Visual FoxPro, a feature-rich database in its own right, gets a
reduced (and slightly humiliating) role here as an Active Server scripting
language, producing database-derived content for dynamically-generated
HTML. In compensation it gets to share the new IDE, and to keep it for
stand-alone use too.
Visual InterDev is itself a multi-product bundle. Its main jobs are
to create Active Server web pages, define database server connections and
queries for use by application components, and assemble pages and
components together ready for delivery to IIS. It uses the Visual Studio
IDE, this time working as a 'Website Explorer', much like the one in
FrontPage (to which InterDev is more closely related than Microsoft likes
to admit). It can act as the design centre for an entire application
system - you can pick a Web page from the site diagram and edit it using
the embedded version of FrontPage's HTML editor, or drill down to a
VB-written control, and have Visual Basic take over the IDE to modify and
test the code.
InterDev also acts as a design interface for ODBC-compliant
databases and servers, with a range of tools for creating and testing
queries, complete with live results. It works best with Microsoft's own
SQL Server, however, for which it provides complete table creation and
modification facilties, even stretching to a graphical relationship
diagram taken straight from the Access desktop. Microsoft is at pains to emphasise that the Active Platform is open (it's
even handed control of the COM standard to the Open Group), and that
anyone can plug their development tools into it, for example producing
compilers capable of creating ActiveX controls, which work together
irrespective of the languages they're written in. However, with such an
all-encompassing (and, it must be said, consistently engineered) suite of
design, server and client products on offer from day one, it'll be very
hard for anyone else to grab a major share of the Active Platform
development or systems markets. Whether the Active Platform will catch on is another matter. Against it
is the ghost of OLE, with its bad, and not yet totally exorcised,
reputation for performance, complexity and reliability. In its favour is
the fact that nobody else has concocted anything remotely as comprehensive
a plan for linking today's back office databases with tomorrow's
superhighway-born clients - and that even when they do, it won't be based
on what is already the de facto platform of the commercial Net,
Windows. On balance, it looks like pole position to Microsoft in the most
important computing race of the decade. <Caption
for big diagram> Microsoft's Active Platform aims to put client-server applications onto the Inter and Intranets, using software components built to its COM (formerly OLE) standards. Its NT-based Internet Information Server actgs as a translation layer between 'business rule' application components and HTML-based Web clients (browsers), while the Microsoft Transaction Server shares components between multiple client transactions. Non-Web client applications can also use the component/MTS application server, and legacy applications can still talk directly to database servers as before [ENDS] (C) Paul Stephens 1996. All rights reserved.
|
|||
