Microsoft Professional Developers Conference Orlando July 2000
My thoughts and musings on the Microsoft PDC. This document does not
necessarily represent Microsoft's view in so far as a corporation of disparate
individuals can have a view. It is written soon after the PDC, before I have had
a chance to actually play with the preview code.
The general feeling, to some extent confirmed by talking to some of the MS
developer and attendees, is that the tools group have gone away for a couple of
year and rethought the whole approach to developing component based software.
Depending on when a particular group picked up, and bought into, the new stuff
depends on how integrated their products are with the new framework. Some of
these groups seem only to have become aware of the new stuff a few months before
The key to the conference, for me, are the new framework and development tools.
I believe the tools profoundly affect the approach and productivity of the
development cycle and from what I have seen the new stuff looks very good.
The initial general
session were pretty tedious except for a good piece by Anders Hejlsberg (Turbo
Pascal, Delphi) on the framework and C#. The breakout sessions got into the real
The .net framework
I have always hated COM. The basic idea is pretty good but the hoops you had
to jump through to make it work and the shear amount of code you had to generate
which is nothing but glue always made me avoid using it if at all possible. Well
the good news is that COM is dead - long live .net. Well, no one actual said this
and I am sure COM will be around for ages but the framework gives you a
seriously easier way to develop reusable components and thoroughly embraces the
web (HTTP, XML, SOAP). I think it is fair to say that in the majority of cases
COM can be considered a deprecated technology.
method for component development is the new common run time. The common runtime
is the framework of classes, JIT compiler and so forth which is the target for the new suite of compilers and development tools which collectively form Visual
Studio dot net. It is possible to
import existing COM components, as wrapped up second class citizens, into the framework.
It is also possible to expose new components as COM components but it is not
something you would want to do unless you absolutely had to work with
So what does the .net object model fix:
- Objects are first class citizens. A framework object is the actual object.
You can make a call to a method on an object over the net simply by adding
an attribute to the class method.
- Everything about an object (the code, the type library, the registry
settings) are stored in a single file. Installing consists of copy and run,
uninstall consists of deleting the file containing the object - wonderful!
- Language neutral. You can create a class in VB and derive from it in C#.
This comes at some price to the language, in the form of non standard
extensions, but is flexible enough to allow COBOL to be a supported framework
language. C++ is also supported with a few extensions.
- Sweet RPC using XML packets over HTTP protocol. Firewall friendly with
rich data typing of XML and the framework transparently generating all the
data definitions - no more IDL. Drag and drop object use in the form of web services.
Other framework features:
- Attributes available in all first class languages (C#, C++, VB). These
seem to be a very good idea. Essentially they provide a way of associating
additional data in the form of one or more class instances with an existing
item such as class or method. They are used to implement such powerful
features as exposing a method as a web interface.
- Single run time class library used across all languages - all features
available to all first class languages.
- Single debugger used across all language - the stack trace has a language
- A concept called reflection which allows the framework to contain a set of
classes which can manipulate the meta data associated with all types in the
framework. This allows cool applications to be written which inspect
the class library and generate automatic documentation about all
classes/methods available and the types they take. Visual Studio uses this
stuff to do its auto completion - which of courses works on user defined
classes as well.
The new compilers
Visual studio .net supports three main compilers out of the box:
- C# pronounced C sharp not C hash :-)
- Visual Basic
- C++ with managed extensions
There are a bunch of third party compilers, which plug into the framework. We saw a demonstration of a COBOL compiler!
This seems to be the new preferred language for pretty much anything. Sort of
a cross between C++ and Java without the law suit. I must admit it looks pretty
good and I would like to start using it. Some interesting features are:
- Automatic garbage collection. Supposedly incredibly fast. Figures of
40 CPU cycles were banded about as the average for deletes. Tricks such as
locking the garbage collector into L2 cache were also mentioned.
- Compilation to IL code. The IL code is Just In Time Compiled at load / run time. Caching of compiled code negates the cost of this on subsequent
- Everything is derived from a base object including ints longs etc. Some
cleaver tricks mean that there are few performance penalties for this. The
crux of this seem to be the division of types into structures which are
value types and classes which are reference types. Structures are allocated
on the stack, classes on the heap.
- No pointers. All classes are implicitly by reference and all structures
are implicitly by value.
- Very C++ like syntax. Exception handling - try, catch, finally - and a new
key word to iterate collections called foreach.
- Single inheritance from classes but multiple inheritance from interfaces (essentially
- Properties are first class entities and are accessed via get set methods.
- Events are first class entities - way way better than COM's connection
- Performance is expected to be similar to C++ code - maybe 10% slower.
- Can get dirty and drop into an 'unmanaged' code mode that allows the use
of pointers and the ability to pin garbage collected items down to non movable
- Some inheritance features I haven't got my head round yet but there seems
to be a way to change a base class in a derived class - you know fixing the
problem when you are using somebody else's class and they haven't made a key
method virtual so you can't override it.
I am not a VB dude but they seem to have added everything needed to compete
with a real programming language such as C++. This included inheritance,
exception handling, data structuring etc etc etc. The difference between
languages seems to be getting narrower and narrower (bit like the parties in the
British political system) now that they all have to conform to a minimum set of
features to leverage the common class library.
It is still possible to compile code with the C++ compiler which generates
native Intel code, however the interesting bit is the ability to instruct the
compiler to generate managed code. Thru a set of new keywords it is then
possible to mark individual objects as garbage collected. Most importantly the
full power of the runtime class library can then be used by C++ code. The main
reasons for using C++ over C# then become:
- Migrating existing C++ code to utilize features in the managed
- Ability to get that last 10% of performance.
- Ability to write code for environments where the new run time isn't available
The new IDE nice features:
- There is no separate Interdev part anymore. The HTML editor is part of the
standard language editing and includes all the good stuff like tag
completion for HTML and XML, to the point that a color picker dialog is an
option when completing an HTML tag with a color property.
- Ultra configurable, can make it look like C++ or VB development environment.
Easier to write code based wizards and deep extensions to the environment.
- Context sensitive help (all the help topics have been tagged with
attributes indicating their context).
- Winform based editor for dialogs replacing the old dialog editor.
- Start page - downloads latest news from web based on your language
Active Server Pages+
The active server team seems to have got on board early with the tools team,
and bought in heavily, consequently integration is very tight. So what have they
- You can use all the compiled languages that support the framework in
active server plus pages. No more yucky script languages :) The compiled
stuff runs a couple of times faster than the old interpreted scripts.
- There is now a proper document object model for server side programming.
This allows clean splitting of HTML from code. You can even stick the HTML
and code into different files.
- The range of server side controls is way better than the junk provided
with Visual Studio 6. Server side controls provide a nice way of abstracting
reusable functionality and they are build (or at least should be built) to
be browser aware.
- The server side controls are dragable from a pallet to allow the
creation of a webforms in the same way as a winfom (a sort of super dialog
box) for the windows environment.
- The HTML editor and form editor are integrated.
- Pagelets allow a chunk of a page to become a single reusable unit. The
pagelet can contain everything a page contains and is reusable through the
DOM it exposes. Great for things like page headers.
XML and ADO+
XML is deeply integrated into all the tools and a lot of the technologies.
Some points that come to mind:
- ADO+ introduces the concept of a dataset. A dataset is basically a mini
database consisting of record sets and the relationships between them. There
is a one to one relationship between XML and the dataset. The dataset is
transported over the net as its XML representation. You can work on the data
in its XML form or its relational form.
Bill seems to think the next stage for the web is the creation of lots of web
services. Web services are components served over the internet for consumption
not only by web clients but increasingly, as time goes on, other web service.
Applications will be constructed by calling upon these services to perform all
the back end work.
Microsoft intend to provide some of the infrastructure web services such as
passport, to confirm identity, scheduling for diary maintenance and preference
services to store user preferences.
Biztalk is the framework tool that is to the web service word what
transaction server is to the distributed database word. It seems to be a bit
'out on its own' however, it doesn't integrate with Visual Studio (it uses
and has the feel of the old (in my opinion useless) 4GL tools. It does have a
good XML data description generation tool however.
The Win Forms framework seem to be the merged replacement for:
- MFC dialog applications
- VB applications
- Active X controls
Not much seems to have been done to MFC. All the new control in IE are being
wrapped for MFC. MFC still seems to be the way to generate a rich standalone
client ala Word or Photoshop, however the message from the PDC is that this
approach is dated. The idea seems to be to go for a more component based
approach to applications in general and run your ad hock combination of
components on a universal canvas. IE seems to be the prime candidate for the
Internet explorer 5.5
We received the release version of IE 5.5 at the conference. This release has
seen few changes to the UI but has apparently had major changes under the hood.
Lots of work has been done to the printing engine although it still seems to
chop the right hand edge of documents that contain fixed positioning
information.... You can dive deep inside the rendering engine to do advanced
custom rendering stuff, but these interfaces seems to be old style COM. We will
have to wait for the new version before we see integration into the .net
- The live band which played at the start of the first couple of days was
- The room full of 400 workstation allowing you to check email, browse the
web etc. was cool to see in one room.
- The sea world party was well executed. The Kraken ride is intense. The
Shamu show was better than expected and there was free food and beer - say
Nick's initial Agenda
Nick's first C# program
More C# program (ettes)
Nick's notes about C#
Andrew's comments on the PDC
Microsoft PDC site