<!-- Article Starts -->
Microsoft PDC 2000 in brief
Microsoft PDC 2000 is over and I'd have to say it was a lot of fun. I got to
meet some very cool guys including Don Box, Jeff Prosise, George Sheppard, Matt
Pietrek, and many, many other amazing people. I also met a bunch of the
Microsoft team in and out of the conference and they are a bunch of really fun
people. Seeing the enthusiasm these guys have for their 3 years of work is
great. There is a real sense of relief that they can now talk about the stuff
that has previously been under NDA. Watching these guys and girls present the
new technology and seeing the smiles of delight as the crowd breaks out into
spontaneous appluase in the middle of talks was just wonderful.
poignant comment I got from one of the attendees during one of these talks was
"I just wish the DOJ could be here to see this". I really don't want to sound
like a Microsoft zealot, but these guys really love what they do, and are
immensely proud of what they have achieved - and so they should be.
Here's a brief rundown of each day's events.
Microsoft announced further details of Visual Studio 7.0 and
their .NET strategy. .NET will encompass a whole variety of new technologies
including the much talked about Visual Studio.NET, SOAP, ADO+, ASP+ etc. The
entire focus of the new technologies is to make development quicker, simpler,
more scalable, and less error prone. Languages such as C++, C#, VB, COBOL etc
will all have equal footing in this new paradigm, in that you can develop a
in one language, and inherit this functionality in another. Imagine
debugging your code and as you step through the call stack you change from ASP+
to VB to C# - all within the same context.
There will be only one IDE for
all languages, sharing common tools and objects and allowing mixed language
projects like never before. The common language runtime (CLR) will provide an
environment in which all languages are treated equally, and by concentrating
their best compiler guys into developing this framework, they have achieved
extremely high performance levels. Expect a slight dip in performance of, say,
C++ running in CLR, but expect major gains in other languages such as ASP.
Basically you just use whatever language you want - the performance will be the
same. There wil be an extremely fine level of control in security (down to which
methods an application can run!) and the application and the runtime environment
are able to discuss and negotiate an appropriate level of access.
IDE itself will be fully extensible and customisable like never before. There
will be huge increase in the interfaces exposed that will allow not only
customisation of the IDE's command bars, editor and dialogs, but also of the
Help system, debugger and About Box.
Visual Studio 7.0 will be beta
tested in a similar way to Windows 2000. Microsoft will not say when it will be
ready - they want us to tell them when it will be ripe. By working with partners
developing real-world apps MS will be able to get feedback and see exactly where
and how to improve the product. Though there was a fair amount of dodging of the
question, MS estimates that it will be ready sometime early next year.
More on .NET and Visual Studio.
Essentially .NET will
mean that websites are no longer isolated islands of information used only by
clients to pull information down via a browser. Using Web Services, sites will
be able to communicate with one another to provide the user with a range of
services and information limited only by web developers' ingenuity. This
server-to-server, server-to-client communication can be extended to encompass
client-to-client communication as is seen in apps such as Napster.
example, a website may offer online shopping. By having the website communicate
with, say, a courier's website, you would be able to use a single site to order
your items and check delivery schedules and track your order through a single
point of call.
Building Block Web Services such as an Authentication
Service ("Passport") or a Calender management Service would also be available
online for websites to use. Clients would not use these building blocks
directly, instead they would be used by websites to carry out common
Extending our example above we could envision the online
store using the Passport service to authentic your payment details, and the
courier site checking your calendar details to ensure that it delivers your
goods at a time that is convenient to you.
- .NET encompasses 4 main points:
- Tools such as Visual Studio .NET
- .NET enterprise servers that support SOAP and XML
- .NET Building Block services (eg Passport)
- .NET device software for items such as PocketPCs and WAP phones
.NET relies on the
Common Language Runtime (CLR) that allows any .NET language to run. This
includes common base libraries so all .NET languages have access to the same
functionality, inbuilt SOAP and COM support, are object oriented and allow
seamless integration and extension down to the code level.
.NET will make
COM development extremely simple by removing the need for components to register
themselves. GUIDs will be a thing of the past, replaced by a human readable
hierarchical naming system. IDL will no longer be needed because CLR implicitly
understands .NET languages. HRESULTS and function return values will also no
longer be needed because all languages will use structured exception handling.
Yes - try and catch in VB! AddRef/Release will no longer be needed, and the
CoCreate... functions will be replaced by a simple new. DLL Hell will be gone.
No more registering, no more version conflicts. You can install and delete your
components at will, with no lingering registry entries or problems. You can run
multiple versions of a DLL on the same machine - or even have the same app run
different versions at the same time.
Garbage collection is a necessity,
and one that has been given a lot of attention. While it may be hard to give up
your homegrown memory management routines, the garbage collection system in
place is extremely efficient.
Compilation modes: While there is a lot of
uncertainty about having to run C# and C++ through the CLR, there are also
compilation modes that allow you to compile to native code immediately. You can
still write code that runs as fast as ever! Also, CLR is not an interpreter.
Your code will be compiled to byte code and then either compiled to native code
at installation time, or compiled dynamically as its functions are needed.
That's right - everything runs as native code.
Each language is on an equal footing with every other
language. Each language shares the common base classes in the CLR and can
perform the same tasks, with the same security, with the same performance. C# is
what C++ must evolve to in order for the language to fit into this model. You
sacrifice the luxury of handling your own memory management in exchange for a
watertight simplified development environment. Microsoft is keenly aware of the
performance issues and has done the comparisons. You really shouldn't see much
of a change. The byte code their VC++ compiler spits out is damn fast - I am
entirely confident that they have been as diligent - if not more - in ensuring
that C# is as much of a speed demon.
While it all looks very cool there
were a number of glitches with the demos that were presented, which was a
There is no longer a VBRUN DLL. VB is run directly by the CLR
or compiled to native code. VB gets classes, inheritance, polymorphism,
Structured exception handling, overloading, and optional strong typing. VBScript
becomes full VB, and there will only be one form of assignment (no
VC++.NET introduces managed extensions that enable your
apps to run in the .NET framework. There are a few minimal extensions to the
ANSI standard that (prefixed by __ as required by ANSI) that facilitate a move
into the .NET world. Even so, by simply recompiling your current code in the new
compiler your app will work without touching a single line of code. By
recompiling you get the benefits of zero-impact installs (ie install/delete at
will, no registration, run concurrent versions etc). You can also mix and match
your standard C++ code with code that relies on garbage collection.
ASP+ is something you have to see to appreciate. Write your
pages using an object model in any language you like with a minimum of code and
using drag and drop development. HTML Controls such as buttons, lists etc are no
longer simply client side constructs. These controls are actually run on the
server as objects and have their own methods and events. When they run on the
server, their output is HTML that can be displayed on the client. For simple
controls like buttons there will be a simple HTML output such as
. For more complicated controls such as calendars etc it
will be more complicated HTML depending on the client
. These controls
will automatically adjust their output to suit the client, so you can write a
single ASP+ page that will work on IE5.5, Netscape4, or even a WAP enable mobile
phone. As a web developer I felt like giving the guys at Microsoft a big sloppy
kiss for this. Oh yeah! Seeing a website that had just been developed and tested
on a W2K box be viewed via a WAP phone without a single change to the ASP+ code
These controls have their own events, and store state.
So instead of writing convoluted script to ensure that a dropdown list always
has the current selection actually selected, it just automatically happens.
Instead of writing mixed HTML and script to generate your pages, you tag your
RUNAT=SERVER and write event handlers for the controls
that can be pre compiled.
ASP will no longer be interpreted - it
will be run as native code!
Microsoft ported Microsoft's search site to
ASP+, and did it in 1/3 of the time, with significantly less lines of code, and
it now runs twice as fast. I'm extremely excited about ASP+.
Will someone please explain why every second reference to a
language includes a reference to COBOL? It's kind of weird seeing MS parade not
only next generation languages, but next generation concepts, yet also spend so
much time talking up COBOL.
The highlight of today was the keynote speach by Bill Gates.
Crowds were big with a bit of a rush to get decent seats.
The talk was
more visionary than technical. This was good in that it bought the entire .NET
stategy into focus and showed that Microsofts ideas are not something that will
happen overnight, but will evolve over the coming years to create a more
cooperative network of data sharing and processing.
The Austin Powers
impersonation by Bill - complete with crushed velvet suit and teeth was a
Details on Whistler were announced: it will be the first
operating system to take advantange of web services. For example, with a simple
click of an icon you will be able to store files on a web based storage center.
Expect this in the second half of 2001.
Blackcomb was also mentioned and
it here that the major update to W2K will happen. The UI will be extensively
upgraded with the advent of sentence recognition, an information agent to help
organise and deal with your data requirements, plus a few other tittilating
comments that were very sparse on detail. Even with this change, there will be
no changes to the programming model. .NET is here for at least the next few
Windows 2000 64bit preview addition is now available today, and
Internet Explorer 5.5 was released on the net, and handed out on CD. As well as
this, we all received a bunch of CD's with Visual Studio 7.0 tech preview. Can't
wait to find a spare hard drive to install this baby!
on the .NET technologies consumed the rest of the day. Visual Studio was
showcased and looks great - but there was still a disturbing number of problems
while speakers were giving walk-through demos. It's a tech preview I guess, but
C++ managed extensions:
These extensions allow you to mix and match
managed code and data with unmanaged code and data. "Managed" means that the
runtime envoronment manages issues such as garbage collection. You can mix and
max code that uses garbage collection and code that doesn't. It's very cool. The
extensions also make COM development ultra simple. Microsoft have realised that
writing and consuming COM servers sometimes has too much messing around and not
enough focus on business logic. This will end.
There is a new "using"
keyword that is a combination of #include and #import. Just "use" a DLL and
everything is there ready for you to use. Too easy!
The big this is the
concept of "It Just Works". Compile your old apps into the .NET framework using
a simple compiler switch and it all just works.
Performance figures were
quoted using the latest pre-beta. Using managed code and data resulted in
roughly a 10% loss in performance overall (in some cases an improvement) - but
they still haven't finished optimising the compiler code so expect far better
figures than this.
ASP+ rules. It will seriously make web development fun and
easy. I'll have to write this all up in an article since there is just too much
to talk about here.
Basically an extension of the GDI. It has a whole bunch of new
image manipulation functions in built, as well as shading, gradient and texture
fills etc. Evolutionary, not revolutionary. Still cool though.
Will have to write up this separately too. This is a
seriously fun language.
Heaps of new functionality, and as mentioned before
there is now only one IDE across all languages. Still a little flaky in pre beta
but productivity improvements are definitely there.