There's some great stuff in this road map presented by Brad Abrams and Jeffrey Richter.  It's clear that Microsoft have been doing more work on the patterns, speed improvements (the team must love being able to tune a V1.1). The session was an overview of the trolley load of goodies that come with the Whidbey release of the CLR. Brad Abrams mentioned his goal of making sure that the framework uses consistent design patterns. An example of this is the WinFX poster that shows how all of the technologies relate.

How .NET is being adopted

• 60% of the fortune 100 have .NET
• 70M machines have .NET Framework
• NET has had about 100% growth a month this year, recently growing to 300% growth per month

Brad mentioned that blogs and .NET user groups are helping to contribute to the success of the .NET framework (along with over 400 books).

Trustworthy Computing
Trustworthy Commitment is big deal for Microsoft. A few years ago security was just a feature of the product, with a single feature team. Microsoft now understand that security is a horizontal foundation that is thought about in each spec and code review. It's all part of the Trustworthy computing model. Some visible impacts: 1000's of hours of review, external parties have come in to audit the security code. The goals is to help developers build secure apps on top of the platform. This is where the Prescriptive Architectural Guidance comes from.

Base Innovations
These are the most important parts of the system:

• It works seamlessly on 64-bit support. Writing managed code is an investment that will pay off in future.
• Performance. Making the runtime faster to start up. Also raw throughput on ASP.NET - fastest response time possible (optimising the environment and code paths)
• Edit and Continue is here.
• 70's innovation - coloured consoles. This could open up a whole new field for games developers.

Generics
Added new IL instructions and changed metadata tables to get support for Generics, so VB can share it as well. It's also in C++ (why this is better than templates I'll have to look up). Generics have also been added to the common language runtime, which means that all the 3rd party languages can adopt generics (e.g. Eiffel).

Data Access
ADO.NET has no model changes. This is so incredible that it's worth repeating: Microsoft have not invented a new way of doing architecture in the Whidby version of the Framework. (this is extrordinary given the changes that have happened in the past - where did they shift the ADO guys too - surely they would have been itching to do some improvements), the focus is advanced features and performance.
System.XML is core to the platform. There are some performance improvements (from 50 - 100+% for different areas especially XSLT). Also support for Xquery for better support.

ObjectSpaces
ObjectSpaces. Treat rows and columns as an object graph. Based on an xml file that defines the mapping between the relational and the object representation. It basically creates an domain/business object wrapper around the database.  Having to remember the ordinals for rows in a columns is annoying. However, with ObjectSpaces the first things is to set up a connection

ObjectSpace os = new ObjectSpace(myConnections, myMappings);
foreach((customer c in os.GetObjectSet<Customer>( "city = Seatle")){
Console.WriteLine(c.name);
}

Data Acces - System.Data.SqlServer
The integration with Yukon looks like it uses the attributes, such as :
[SqlTrigger("EmailReview"), "Reviews", "FOR INSERT")].

The example Jeff showed how easy it is to write a stored procedure that sends and email when a new review is posted to a database. This used to be a horror in previous version of SQL Server. Just knowing that extended stored procs wont bring the machine down in a bunch of flames is big deal. This could seriously impact consulting revenues!

ASP.NET 2.0
A major release for ASP.NET. The team went away and looked at common code and controls that teams did. The goal was to reduce the plumbing code by 70%. This has been achieved with page framework, 40 new controls

Casini - the old Personal Web Service is back. This times its 100% managed code. It picks a random port each time it's run to protect from someone trying to hack into it (don't they trust developers to lock down their machine )

Where did all the code go?

Building Blocks
They build a range of "Building Block" APIS
Membership control (username/password, resetting the password)
RoleManager (control access based on role)
Personalisation (customize the layout of the site. You can define a class (e.g profile containing name and zip code) that is associated with the logged in user).
SiteNavigation - tracking how the users move between pages
SiteCounters - useful for sites that are paid based on behaviour such as view
Management - IT department get a page or email if there's something going wrong on the site.

The provide an abstract Provide Model Design Pattern that controls the storage of the data behind these controls. Very, very nice.

Page Framework Features
MasterPages - eack. Sounds like some of the FrontPage guys escaped and let loose the nasty FrontPage themes into the ASP.NET page
Themes/Skins - separate the UI from the logic so that it's easy to skin without changing code (like the themes in DasBlog)
AdaptiveUI - all of the controls will render to small handheld devices

Control Buckets (over 40 new controls)
Leverage the previous features to do tings like Security, Data, Navigation, Web Parts. These controls know how to talk to the underlying controls. One example was the bread crumbs links at the top of page.

Innovations on the Web
ASMX performance is being improved through making sure the server side requests per seconds is much better. Secondly there's a smaller working set required on the client to call a web services. They've also notice that web service calls must be asynchronous (the button shouldn't stick down while the web service is working). You need to use a thread pool. This is a little complicated for some developers with the IAsyncResult pattern, so that now this is much easier - this should be the main stream way to call webservices. It ends up just looking like an event.

.NET Remoting - authenticated and encrypted channels. I wonder whether this is WS-Security compliant? It doesn't have to be since remoting is about two .NET machines rather than interops.

System.Net - this has better 'network awareness'. For example Outlook 11 detects the type of network and adjust the experience based on that. FTP protocol support has also been added.

Client Tier with Windows Forms - System.Windows.Forms
Lots of developers wanted to move to Windows Forms, however deployment of client applications is still too difficult. .NET started to make it easier (each assembly has it's own metadata). Whidbey is concluding this story : click-once. It should be as easy to deploy a forms project to clients as it is to deploy a web server. 

XP Theme support has been added. Finally you can look like Office (why is this always a couple of months after the Office release?).  Apparently the Office team will be here this week showing how to make the Outlook interface in 100% managed code.

Longhorn Related

Windows Forms app will work great on Longhorn.  There will be a two-way interop with Avalon.  You can use Avalon markup and mentions win form controls, or you can use win forms on Avalon.

Don and Chris demoed the API underneath Longhorn.  Don achieved his aim of getting a VP to use a text editor to build a demo live.  The demos were very DM/Box with many text editors shown to build the code.  Great coding, a little slow in some of the delivery.

Now onto Longhorn.  Basically APIs in longhorn are a simple set of managed API.

Aero User Interface
The demo started with a simple HelloWorld window, to which they added text boxes, click events, enlarged all of the controls (they're vector graphics), rotated them and set the transparency so that a video could play underneath the controls.

There's a new idea of separating the C# style code from the layout information.  It seems very similar to the code-behind pages in ASP.NET.  The layout information uses XAML (pronounced zamel) an XML syntax to set the properties of the controls (now that I think of it, this seems like an improved version of the form layout information from the old days of VB6)

They also demoed the MSBuild tool.  This is an XML-based build system.  It uses three types of things - properties, tasks and item.  As Scott Hanselman says, 'Holy crap it smells like NAnt.  Wow, writing these build files is xml and is 90% the same concept as Nant.  Learn and use Nant now (I say) and use MSBuild soon.'

The demo showed how to do this using new namespaces such as as MSAvalon.Windows, MSAvalon.Windows.Controls that seemed to be in assemblies such as PresentationCore.dll, PresentationFramework.dlll and WindowsBase.dll

Here's some of the XAML to get a feel for it:

<window xmlns="http://schemas.microsoft.com/2003/xaml"
xmlns:def="Definition"
Def:Class="PDC.MyWindo"
Text = "Hello,world"
Visible = "true"
>
<Visible source="c:\clouds.wmv" Stretch="Fill" RepeatCount="…." >
<TextPanel DockPanel.Dock="Fill" Transform="rotate 10 scale 2.3 2.3">I can embed <Bold>really</Bold> text
 <TextBox id="bob" width="2in" Height="20pt"/>
 <Button Click="Pushed">Push me I'm a cliean</Button>
</TextPanel>

WinFS Search Demo
Don got Jim Allchin to write the code to search the file system and return the items using the Longhorn controls.  Nothing really that amazing here at the API level - it's a nice simple Find method that returns a set of objects that can be iterated through.

Using Indigo to post to Don's Blog
A demo using Indigo to post to Don's weblog.  I'm puzzled as to the the API under the cover (I'm assuming it's using a web service).  Indigo looks like a nicer API on top of the web services.  As Scott mentions, the

Using Indigo to post to the sidebar
Seemed to be a way of using Indigo to post the the sidebar of the desktop.  Similar to using WSE with tcp channels, there was a bit of hassling around with the code to get it set up.

We finally got to see Aero, the Longhorn User Interface. Overall, my interest is in how the flashy graphics will help people get their job done.  Having movies display in a document, and showing them moving in the thumbnails doesn't seem that useful.  Video in general is hard to get information from - it's difficult to condense in time.  I'm concerned the focus is on cool rather than productive. Good features:

• The back button is visible at the top of most windows.  This is a good feature to come from the rise of web browsers, since we know the back button is the most frequently used button.
• There are navigation breadcrumbs at the top of each screen (e.g. my documents, my photos).  You can click on any of these links and get a drop down of other choices at this level.
• In the search results it is possible to get a group of results, called a stack, which is indicated with a pile of papers that varies its height by the number of documents, as well as providing a count.
• When sharing a document the menu shows the name of others on the network that you can share with.  I liked this.

More troubling usability points:

• The side bar at the side of the desktop.  This looked a lot like the Active Desktop from IE 4.0 days (ignoring the opacity of the window).  It displayed an RSS feed, buddy list and a slide show.  I'm not really sure how far this progresses things.  The buddy list was not realistically large, the slide show was irrelevant (in terms of helping people be more productive).
• The top of each window displays the actions that can choose from, similar to XP (except they were hidden on the left hand side).  I'm wondering how useful this will be (I'm imagining you can turn it off).
• The bar at the top of each window displays the name and the back button.  It takes up about 10 - 20% of the screen real estate.  I'm wondering whether the information content justifies thie size.
• The menu has slipped from the top of the screen to under the bar area at the top of the window.  I'm hoping there will be some mouse 'gravity' around these menus as it would seem easier to go to the edge of the window for these key features.

Well, we've had clapping so far for the following:

• The CTRL+ALT+DEL login prompt.  I'm serious.  I think some delegates were so excited they just had to get it out of their system.

My first Bill Gates keynote today.  It's amazing to sit amongst 7,000 developers watching this.  There are 16 massive video screens display shots of the presenters and the PowerPoint slides.

Here are some points that struck me from Bill's speech:

• Microsoft are serious about using software to help them improve any aspect of the user experience that in unsatisfactory.
• The crash reports have helped Microsoft work with video driver makes and computer manufacturers to improve the quality of drivers that ship on machine.  There was a graph showing a reduction from 80,000 crash reports to under a couple of thousand for a particular driver.  It's great to think that this number of computer crashes are being reduced.
• The application crash reports that are sent to Microsoft are available to application developers at winqual.microsoft.com
• The personal computer in 2006 will be a 4-6 GHz machine with 2GB of RAM a 1 TB disk with 1GB networking and 54 Mb wireless.  I'm already excited about asking for a new laptop with this spec from my boss.

A great video was shown on the history of the software  "Software Futures" with Bill Clinton (talking about the number of websites when he was present), Warren Buffet (on Bill Gates missing the software boat) and the inventor of the Newton (on how the modern handhelds).  He ended with a joke about a future episode showing the dangerous, challenging world of database development, over a shot of the Oracle yacht.

This session was on the Patterns and Practices Group at Microsoft.  It was hosted by Jackie Goldstein and included James Newkirk (originally ThoughtWorks, and now Dev Lead for the Patterns group.  Aside: he's writing an exciting looking book on Test First Development in .NET) and another guy from the team. 

Easier to Contribute
Several participants mentioned wanting to make it easier to contribute changes to the patterns and application blocks. So that if a company makes changes they don't need to maintain them separately in their own versions.  The team is looking at using the community workspaces.  James Newkirk mentioned using the Adapter pattern to switch between the shipped source code and any local revisions.

Improve the Help Files
The documentation is currently very class based, what the members and classes are, rather than on how to use them.  Sometimes the samples are too simple and don't show how to use the advanced features.

Some of the QuickStart/JumpStarts are too difficult, especially the User Interface Process (UIP) model based on the Model View Controller pattern.  One participant mentioned integrating the help files into the Visual Studio collections.

An MCT trainer asked for Microsoft Official Content (MOC) that used the patterns group.  The MS people said they are trying to get out there and integrate it with MOC courseware.

Conflict between RAD perspective and Architecture
Visual Studio promotes a RAD, drag-and-drop, visual-designer backed RAD tool.  One participant said they'd like a Visual Studio Add In to help integrate the patterns.  Often the keynotes at the PDC are the quick RAD solutions and this comes across as what Microsoft thinks is Best Practice.  Guidance is harder to market.  One of the Microsoft guys said that marketing the RAD features was a more important goal for Visual Studio than marketing the architecture.  Marketing the Architecture is harder.

Integration with the Visual Studio and Language Teams
Apparently the community around the patterns group (bloggers and speakers like Scott Stansfield from Vertigo) had forced the the Visual Studio and Language teams to work closer with the Patterns Group.  There is a disconnect between internal Microsoft Groups.  The Patterns group said they didn't know that the ASP.NET Starter Kits existed until after they were released).

FX Cop for Architecture
Someone asked for an Architecture Cop like a FX Cop.  Apparently someone in the patterns group also had this idea.  I'd like to see improved checklists as a first step on this one.

Why isn't there more focus on the GoF Patterns?
James Newkirk said they will highlight them as they use it.

Brad Abrams mentions at the Rotor BOF session mentions that Rotor (a free, fully functional implementation of the ECMA #335 standard for a common language infrastructure.) has moved from a skunkworks projects to being fully managed by the CLR team.  When code is checked into the CLR there are tests that determine whether it might break anything  in the Rotor Unix build.  They are looking to release a Whidbey version of Rotor after Whidbey has shipped (someone mentioned September 2004).  Other points:

• There's also a community site at http://sscli.net 
• There's a rotor list at the developmentor site.
• Intel does stuff with Rotor (some of the guys were in the session)
• It's focussed on academic, non-commercial use.  For acedemics and those that are interested in getting under the covers and understanding how .NET works.  The license forbids re-releasing or using it in a commercial product.
• I know a lot of people who use it to run the CLR on Mac OS X
• It's popular with grad students working on Rotor for thesis topics like garbage collection tuning.
• It's for people who want to 'fix' who the CLR, for example Chris Sells got some research funding to look at deterministic finalization.

Brad Abrams wanted to know whether anyone was interested in using the JIT compiler and making it available in the Rotor distribution - you couldn't modify it but it would allow for better performance.

It's interesting to see this effort from Microsoft based on building a community of interested people.  Quotes: 'If you blog it they will come'

I know that Developers aren't renowned for dress sense, but I've seen an alarming number of developers today wearing socks and sandals.  Now there's just no need for this kind of tragic fashion sense.  Just say no.

Tim was talking and Don was typing. I guess Marting was blogging (I couldn't see - I was on the floor at the back with the power outputs).

Aside: recently I've been watching lots of these presenters using Windows Media. It has an excellent - play at 1.4x button that means you can listen to an hours presentation in 43 odd minutes. It's great - the presenter's pauses go away and it's surprisingly understandable. However Tim Ewald is the only guy who this doesn't work for!

You can play at the Raw XML level in SOAP messaging
You can, but it's messy - you have to handle the SOAP processing rules (headers, actors, etc) yourself. The benefits are that you can play in XML rather than object land - you can use transforms, Xath queries etc.

Various ways of using the objects discussed in the first part of the day were mentioned. Essentially similar to Don's MSDN TV presentation.

But working this way in a live demo is hard
Much fun was had trying to map a WSDL schema back into an ASMX page with the correct WebMethod parameters. Don eventually made Tim go back to the PowerPoint slides while he had a go. By now (near the end) they still haven't got it working (showing that this is a hard core thing to do. Evidence: MSDN does it but required Tim Ewald to implement it . This is gratifying, as I spent a night trying to generate my own provider of the Amazon web service so that I could demo the Amazon web service at talks where there was no Internet, but I gave up after a couple of hours hassle.

SoapExtensions
A description of how to use SoapExtensions to ease the problems of processing the Mandatory headers in SOAP messages. See Tim's article Mandatory Headers in ASP.NET Web Services in May 2003 MSDN Magazine

The Do's of .NET Web Services

• Build web services using ASMX - it can support objects or XML focussed web services equally well.
• Enterprise Services are good within your service, but not exposed externally.
• .NET Remoting is for cross-application domains. Ergo, only with two .NET end points.
• Use WSE for advanced protocols support

The Don’ts of .NET Web Services

• Don't use SOAP formatter for .NET Remoting. This seems like an emerging theme of this PDC. Don't wrote "ever" in horror-film style red writing (the pen tool in PowerPoint) after this point. Remoting is about the .NET type system and not interoperability.  It's funny that in this sesssion we're being told about the limitations of Remoting, while upstairs Rocky Lhakota is talking about how to do it.
• Don't marshal object references in ES/COM+. A no brainer.
• Use RPC/encoded in WSDL. See Yasser's article RPC/Literal and Freedom of Choice on MSDN for the rationale (also see my post to the WSE group on why rpc/literal is not supported in .NET).

WSE is 100% Goodness
Tim showed how WSE provide filters in the input/output filter that serialize/deserialize objects and SOAP headers.  They built a sample project that modified the filters that are applied by default.  He also showed how to use the RequestSoapContext inside the ASMX WebMethod and how to set the client up to call this method using WSE.

WS-Addressing
Don mentions that interop with Tibco was one of the motivations.

WS-Security
5 slides, 20 minutes.  Brain is dead now.

The XML and Web Services Perspective continues with Don, Tim and Martin.  Heavy going after lunch,but much better than the first session.  This session had more useful content that matched the audiences level of understanding (a very advanced audience).

The future of Remoting: SoapFormating SOAP stack
SoapFormatter is dead.  It is the one part of the .NET platform that we'd recall if we were available.  It is the SOAP stack underneath .NET remoting.  .NET remoting works in situations where you have .NET on both sides of the pipe ('living the COM dream without reference counting' as Don say). is one part of the .NET platform that we'd recall if we were able to.

What is SOAP about?
SOAP is primarily about extensibility, it is designed to allow us to evolve services.  The service provider and consumer may evolve at different times.  It is important that the server is able to evolve the service without disrupting the established clients.

SOAP 1.2 will be the last version of the protocol.  Ever.
There's wont ever be another version of the SOAP protocol.  SOAP 1.2 is the last version that we will ever need.  Don justifies this with two arguments.  Firstly, no one gets a third chance at it.  SOAP 1.1 is here and will be with us for a long, long time, we wont get rid of it.  SOAP 1.2 is here and we should move to it but this will happen slowly (like the conversion of IPv4 to IPv6).  It wont be practical to support more versions of SOAP.

SOAP 1.2 is in the next version of .NET, would have been in earlier (Windows 2003) if it was in a final state as a specification.

SOAP is not just for serialized object graphs
SOAP can be used to serialize an object graph, but this is a lifestyle choice, a subject decision.  There's nothing about SOAP that says it has to be like this.

SOAP Headers and SOAP 1.2
SOAP has headers that are extensible.  They are meant for the ultimate receiver rather than any intermediaries.  The headers have the mustUnderstand element which means that it must be processed successfully, as well as an actor tag that specifies which intermediary is designed to process the message.

Because the headers must be processed before the body is processed, most of the SOAP stack implementations buffer the headers and then stream the body.

SOAP 1.2 adds the s:relay attribute which means that the header is targeted for the current intermediary, but that it can be ignored.  However, if it isn't processed it shouldn't be removed from the message - it should be passed on to the next intermediary (presumably changing the actor tag on the way).

There's also a well-known URI 'http://schemas.xmlsoap.org/soap/envelope/next' means the next intermediary should process it.  As Don says, 'everyone plays the role of next - it's the Iunkown of SOAP'.

WSDL
Don made us stand up and recite 'WSDL sounds really fun, please tell us how it works'.  WSDL is more difficult.  Don mentions several times that many of the flexibility points in WSDL were because they weren't sure that Web Services would end up using XML Schema as the type descriptions, and SOAP as the binding.  WSDL provides for other type descriptions and bindings, but XML Schema and SOAP are the most common.

Some very funny stuff when they went through Doc/Literal RPC/encoded choices in the WSDL.  Basically at each attribute Don said 'there is no other way'.  Good laugh, obviously everyone in the room understood that document/literal is the way to go.

Don also joked about the '.NET WSDL parser'.  If you run the WSDL.exe tool before adding the binding then if it's successful there will be a 'no classes generated' message, but at least no exception.

AXM Security and Web Services
Tim did some great debugging of IIS and the directory to solve a permissions problem.  When it failed first time, Don made the joke that it was not a failure but was 'locked down by default'.  Don also made the point that the way the problem was attacked was to change the server until the client message came through (through giving anonymous access to the virtual directory), rather than the better approach which is to give the security credentials to the client (through using the proxy object).

Polymorphic data and serialization
Tim made the point that WSDL generation mandates knowledge of all types at compile time.  If you want to use derived types then you have to use the [XmlInclude] attribute so that the SOAP receiver understands where it must look to see if a type has a derivation somewhere.  The alternative is that the SOAP stack would have to look through all of the referenced assemblies.

Wow, my first US PDC lunch.  The meal area is enormous, with teams of waiters running around like Ants.  I had the pleasure of dining with Ian Griffiths and Mathew Adams, authors of the great Programming .NET Windows Forms from O'Reilly.  Ian was one of my interviewers for my current job.  Getting interviewed by an O'Reilly author was certainly intimidating, lucky Ian's a top guy. 

I also saw Robert Hess from the .NET Show (he's looking older these days - I remember the launch of IE 3.0 hosted by him!) and Ingo Rammer around the traps.  Martin Fowler was even having lunch on his own (could this ever happen at a Java/XP/Agile conference?).  Hopefully I'll get the courage to talk to him later in the week (he's on the architecture panel on Thurs.)

Obviously there's a lot of camaraderie between these guys, all having worked at DevelopMentor together in the last millenium. While this adds for a good feeling between audience and presenters there's also an element of pranks and mucking around that sometimes has seemed more fun to the presenters than the audience.

At the most interesting point in the session, where Tim finally got away from the keyboard to talk passionately about Schema, the point was sabotaged by a sniggering Martin and Don typing behind Tim's back on the screen. This was OK, but we didn't get the benefit of hearing the end of Tim's point. I don't mind the presenters having a good time, but not at the expense of the audience.

Note: I missed breakfast this morning which may have contributed to these feelings.

This session was slow-moving in the morning. All of the content has been available on MSDN or shown in MSDN TV episodes (e.g. Passing XML data inside the CLR). However, as a colleague mentioned, the first 2 hours of this talk were the full day of a previous PDC pre-con session, so it shows how things have developed.

Here are some points that stood out:

• The XML stack is built on protocols in the following ways: unicode + uri, XML 1.0, XML Namespaces, XML Infoset, XPath, XML Schema and XSLT/ These map very nicely to System.Text, System.Uri, System.Xml, System.Xml.XPath, System.Xml.XmlSchema, System.Xml.Ssl
• The XmlReader API shows three things that are not part of the XML Infoset specifications:
  - IsEmptyElement (that can tell the difference between <tag></tag> and <tag/>)
  - QuoteChar (returns the quote character used around an attribute, such as single quote ' or double quote ")
  - WhitespaceHandler (gets or sets how the whitespace is handled - an enum that uses All, None or Significant). Tim mentioned this was useful in the MSDN xml work he's been doing.
   
• The XmlWriter is a stack-based approach to writing the XmlDocument.WriteEndDocument will close up any opened elements (stitch the patient up now that the operation is over).
   
• Implementing an XmlReader over data is a difficult job, using it is much easier.
   
• The design of the DOM classes is poor because it was written by people who wrote parsers. Some particularly nasty parts: having to create elements off the document, and having to use ImportNode to bring a document. Don also mentioned that XmlElement.InnerText is a shortcut for XmlDocument.CreateTextNode. It made me feel much, much better to know that Don thinks this was a crap API.
   
• Tim's rules for structuring schema documents: 
  - use BlockDefault="#all" to forbids substitution, extension, restriction
  - use only global elements declarations, so that the one element means the same thing regardless of where it occurs in a document (e.g. <person> means the same thing wherever it is in the XML document). See Ruminations on XML Schema from Don's blog in May.

The flight over seemed to be a good time for some people such as Tim Sneath to trying out noise cancelling headphones.  I'm afraid to admit it but I used the lo-tech ear plugs to get a couple of hours sleep, watched the movies on the back of the chair rather than from the DVD in a laptop and left my laptop in the overhead locker the whole flight.

I enjoyed the luddite pleasure of a good book, Design Patterns Explained.  It's written with Java and C++ in mind, but since C# is Java the examples are a breeze to work through.  It presents a good case of why functional-based programming, where analysis is looking for nouns and verbs to turn into objects and methods, wont cut it anymore.  I recommend the book to anyone looking for a good introduction to Design Patterns.  As they say, sentences like these from the GoF book make sense as individual words, but it's hard to really get what they mean:

Purpose of the Bridge pattern: To decouple an abstraction from its implementation so that the two can vary independently. source

The book does a great job of explaining this.

Random thought: I'd also forgotten how strange US cheese is.  I'm sure cheese isn't naturally orange.

Steven Maine describes a war story from a colleague about a client-run project using XP Methodologies.  It's a useful warning about the dangers of doing XP without understanding or using all of the practices.  The project Steve's talking about have been going 10 weeks with no releases and 'since the customer is using these so-called “XP methodologies”, there’s no hard and fast documentation as to what the agreed upon scope actually is.' 

In the XP Refactored: The case against XP the authors mention that one of the problems with XP is that it is a high-discipline methodology in that all of the core 12 XP practices need to be implemented if the project is to be successful.  I think the bigger risk with XP is that it's an excuse for crazy style project management (think glorified cowboy coding).  XP is not a methodology that validates projects that have no methodology.  For example the idea is not 'don't do any documentation', it's 'just do the documentation that it necessary'.  I'm not sure that any (sane) person would advocate not having some written form of customer requirements (even if they are just 3 x 5 index cards on a wall).

In the project Steve mentions there's no mention of any of the practices actually being used.  As he identifies:

XP might be great in theory but often times has issues with practical application. However, most horror stories I’ve heard that involve using “XP methodologies” are in fact about problems that stem from using “mostly XP” or “sort of XP”

Steve suggests that focussing on releasing to the customers is an important concept that would have reduced the risk of scope creep.  I agree that it's a good practice, but there's also the concept of the Planning Game, User Stories and the idea of project velocity.  Yesterday I found this  presentation from on how the BBC's interactive TV group used XP/Agile practices to negotiate the scope of projects.  Basically they tracked the project's velocity - how many user stories were being completed each week.  They estimated the cost of the features the customer was asking for and when it was clear the features were too ambitious they re-negotiated.   This is the same concept as principled negotiation that Steve McConnell mentioned years ago in his book Rapid Development

Hopefully this lack of understanding about XP wont rub off on the good ideas that the methodology advocates (especially test first development).  As the software reality site mentions:

Agile proponent Alistair Cockburn describes XP as a "high discipline methodology". In a discussion on the Wiki web, he also suggested that most teams that say they're doing XP don't actually do all the practices.

As XP increases in popularity and hits the mainstream, more and more teams will attempt XP, probably without a clear understanding of what is really involved. They will most likely be drawn in by XP's "low discipline" practices (such as no big up-front design and minimal documentation), but without applying the high discipline practices that act as an essential safety net (such as unit testing, pair programming, collective ownership and constant refactoring).

Rather than say thank you to Jeff, I thought I'd honour his wish to see photos of the t-shirts at unique landmarks as we make our way to the PDC:

My appetite has been whetted for Doug Purdy's XmlSerializer presentation 'A tale of two type systems' at the PDC next Tuesday.  I was talking with a customer today about how to version schemas in web services.  It's a problem they haven't addressed yet as everything is still in the first version.

I've seen Doug's TechEd presentation on loosely coupled web services and his MSDN TV episode.  I understand that changing the namespace is not a versioning mechanism - it changes the type system.

Doug's suggestion then was to use the open content model and author version schemas with a version attribute and places in the document where we can put any content.  Then clients can use the switch statement and decide how to handle the message using the highest version number they understand.

What I really miss with this approach is that it loses all of the goodness of schema type checking once the open content elements are used.  It's like you can have schema versioning only for the first version of message, once extra content is added it isn't described or validated.  I like the idea of a schema validation saving me write application code to achieve the same result (or in the case of XML firewalls, having them do the validation).

Radovan argued against this open content approach, saying that subtyping would be better. In his Doug says in his post:

The approaches that I suggest are the best ones using the existing Xml Serialization engine provided in v1 and v1.1 of the Framework. There are ways to "seal" off and extend an open content model in such a way that you don't really need to switch on a version element (although you may want to include the version information in the instance document regardless). But these mechanisms are not supported by the XmlSerializer currently.

I'm really hoping that more schema versioning options will be part of the surprises Doug's got in store in his Tuesday  talk "Indigo": Using XSD, CLR Types, and Serialization in Web Services should be informative.

Here's a good post to the microsoft.web.services.enhancements newsgroup on creating X.509 Certificates with the Open SSL toolkit that can interoperate between WSE and Java.

Open SSL is an open source tool that I've seen used in a couple of production situations and I mean to look into it more.

With the PDC sold-out, the rehearsals ongoing I think it's time to deal with the difficult issues: how to communicate the excitement about the event with loved ones.  Rory has already blogged about spending the night out at a bar thinking about his love for ASP.NET rather than talking with friends. 

Has anyone else found a successful way of communicating the pleasure of new concepts/technologies in development to their partners?  While on holiday last week I re-read Richter's applied .NET and Juval Lowry's fantastic .NET Component Development.  After a great Italian meal and a bottle of house wine I could contain my enthusiasm no longer and bored my pregnant wife with a passionate monologue about the 'fascinating' topic of generational garbage collection.

Does anyone else have any suggestions?

I'm hoping there won’t be too much sighing and spontaneous applause at new product features.  At the first PDC I went to in Australia in 1996 we watched a video of the US keynote where the speaker had to repeatedly stop while the audience applauded at the new features (cross-language debugging I recall).  This level of raw emotion is a bit embarrassing to an Australian audience.  After getting over the initial silence, eventually each applause moment was met with laughter.  Let's keep it in perspective: as good as the technology is, it's just technology and there's still (hopefully) a job for developers to do at the end of the day.

Understanding what .NET and the C# compiler are doing under the covers can be both useful and interesting.  While on holiday last week I was (geeking out) and re-reading Applied Microsoft .NET Framework Programming by Jeffrey Richter.  What I enjoyed about Richter's book was that he goes down to the Intermediate Language (IL) level to demonstrate the points.  He shows how to use these tools to better understand string handling in .NET and how the switch/case statement works under the covers.

When an assembly is compiled, the compiler examines the code for literal strings and places them into a metadata table.   This table is loaded by the framework as a hashtable (according to Richter) allowing strings to be compared based on hashtable references.  This is obviously much faster than comparing character values in strings.  The C# language compiler uses these techniques to make the switch/case statements more efficient. 

Here's an example that can be worked through using ILDASM and Reflector to make it clear what is happening under the covers.

using System;
public class StringIntern
{
  public static void Main(string[] args)
  {
    Console.WriteLine( 
      new StringIntern().ProcessBlogPost(args[0]) );
  }
  public enum PostAction
  {
    ReadNow, StudyLater, ReadWhenever
  }
  public PostAction ProcessBlogPost( string author )
  {
    switch ( author )
    {
      case "Don Box":
        return PostAction.ReadNow;
      case "Chris Brumme":
        return PostAction.StudyLater;
      default:
        return PostAction.ReadWhenever;
    }
  }
}

To see the string table metatdata that is created when this application is compiled, run the ILDASM tool with the /ADV switch, as follows:

ILDASM /ADV StringIntern.exe

Then choose the View -> MetaInfo -> Show! menu option.  The file that is displayed lists the metadata contained in the assembly.  The 'User Settings' heading shows the string metadata table contents: all of the strings used in the assembly.

User Strings
-------------------------------------------------------
70000001 : ( 7) L"Don Box"
70000011 : (12) L"Chris Brumme"

You can output this information to a file using the following command line:

IDLASM /ADV /METADATA /FILE:outputfile.txt Assembly.exe

This is a technique that Microsoft uses internally to discover code that might be susceptible to a SQL injection attack (where SQL strings are concatenated into SQL statements).

The String.IsInterned method can be used to work out whether a strings is stored in the assembly's metadata table. The method returns null if the string isn't in the metadata table, otherwise it returns a reference to the string (effectively the memory address of this string).  This allows string comparisons to occur with memory references that are much faster than character by character comparisons.

This method is used by the C# compiler to make the switch/case statement more efficient.  Using Reflector (and it's fantastic code IL tool tips that explain each IL instruction when you move the mouse over them) it is possible to see what is happening in more detail.  Here's the pseudo-code for what the C# compiler does with each switch/case statement:

1. load the strings used in the case statements from the metadata table
2. go to the default case if the switch variable was null
3. check whether the switch variable IsInterned, storing the resulting reference
4. compare this reference to the switch string with the references to each of the case statement strings.

public PostAction ProcessBlogPost(string author);
// Load the author parameter into a 'local variable'
L_000c: ldarg.1 
// Go to the default case if the parameter is null
L_000e: stloc.1 
L_000f: brfalse.s L_0032
// Check whether the string parameter is stored in the meta data string table
L_0012: call string.IsInterned
// Store the result (either null or a reference to the string in the metadata table)
L_0017: stloc.1 
L_0018: ldloc.1 
// Get the reference to the string stored in the metadata table
L_0019: ldstr "Don Box"
// Compare the reference to the switch string with the reference to the case string from the metadata table
L_001e: beq.s L_002a
// if they are not the same, repeat with the next case statement.
L_0020: ldloc.1 
L_0021: ldstr "Chris Brumme"

I'm off on holidays in Tuscany for the next week, getting enough sleep to survive the PDC.

I'm happy to have been 'Box'ed and 'Scobelized' (twice!) in the last day. I also managed to get a ticket for Radiohead's previously sold-out November concert in London.

Life is good.  More when I get back.

Alan Cooper introduced personas as a user interaction/product design technique a few years ago.  Here's a good definition:

"A persona is a user archetype you can use to help guide decisions about product features, navigation, interactions, and even visual design. By designing for the archetype—whose goals and behavior patterns are well understood—you can satisfy the broader group of people represented by that archetype." 

They are a very effective method of getting developers to focus on a particular person when building software, rather than a class of user (e.g 'How would Steve the crazy trader use this trading screen', instead of 'What features does a trader want?').  Microsoft have been a keen adopter, especially in the core Windows group as this presentation highlights (they go to the point of developer posters and even a live email account for their personas, and rate product features using a feature-persona priority matrix).

What I hadn't realised until recently was that they are using personas in the Visual Studio group.  They are often backed up by more hard-core usability work (such as this presentation BradA mentions on Describing and evaluating API usability at Microsoft). Walter Moise, a contract developer with Microsoft, writes about the personas:

"Every group has personas. In the developer tools, we have Mort, Elvis, and Einstein. These guys are respectively, the typical VB developer, the typical C# developer and the typical MC++ developer. We have a detailed description of them in very specific vivid detail, which include not only the relevant job habits, but also their lifestyles (how they have fun, what they do on weekends). These get very specific, that you wonder if they are talking about a real person.

Mort is your most common developer, who doesn't have a CS background, may even be a recent newcomer, and doesn't quite understand what the computer is doing under the covers, but who writes the dinky IT programs that make businesses run. Elvis, more knowledgeable, cares about code quality, but has a life too. Einstein writes some serious-ass piece of code like device drivers, wants to get things done, needs to be able to go low level and high level, needs a language without restrictions to get his job done."

Mort seems an unfortunate name for the VB.NET developers.  I can't imagine anyone aspiring to be a Mort.

I find it interesting that there isn't much talk of personas within the XP/Agile world.  The agile processes are 'people friendly' but this is mostly if those people are developers.  Admittedly personas may have more impact on consumer shrink-wrapped applications, but I believe that the investment is still worthwhile in enterprise software projects (it's not a big investment for the potential pay-back).  There's still a lot (too much) responsibility placed on the client representative to know what the clients actually want.  Personas seem like an incredibly easy, but powerful tool that would fit well into the XP/Agile arsenal and help ensure that what the developers built is likely to "delight the customer" (to steal Steve Balmer's phrase).

Somehow I'd failed to update my RSS feed for John Bristowe's site so I'd missed the last few months postings.  He's been done a heap of work with WSE.  John's presentations helped me get started with WSE.

The post that most caught my eye was on custom policy assertions.  This is a great piece of functionality that lets developers hook their own XML Security tokens into a WS-Policy xml file.  So you can write statements like 'only let in a SOAP message that has an X509 digital certificate and one of my own XML tokens' in an XML file rather than having to write any custom code (I know I bang on about this point, but it's such a good one).  There's very little documentation (say, none) on this one (I relied on Reflector, the copy and paste button and a judicious set of breakpoints to work out what was going on).  John also comments on using policy to describe roles. 

The observant amongst you may notice that my new site redesign has a resemblance to John's.  I'm hoping that John will be at the PDC so I can buy him a beer.

Why is always more important than what ...Technical people are smart and used to figuring out things on their own. ... What they can't figure out is what was going on in your [the designer's] mind when you wrote a feature, and knowing that [the designer's intention] is the most important part.

As an audience we can use this time before Microsoft open the Kimono to start thinking about what Microsoft's strategies are in each of the areas (OS/dev tools/Web Services) and what design challenges they have to think about.  This helps generate questions so that when we're listening to the endless days of PowerPoint we have a reason to listen and engage.  As Dare has mentioned there's plenty of opportunities to ask the Microsoft developers questions at these conferences (like at Tuesday night's Ask the Experts).  Doing some work before hand to develop understanding and frame some questions is a good investment.

Tim Sneath has already started the questioning, asking will Yukon kill the business tier and put in the database?  Mehran isn't convinced, but it is the dialogue that is important. 

Background to Indigo:

• Read the speculations, and more speculations and  work out what is known from the session outlines

• Try and understand the WS-* standards that Indigo will be based on, especially WS-ReliableMessaging.

• Look at the EAI vendors and work out what problems they are currently solving that Indigo will try and solve.  I suggest the CapeClear's whitepapers site especially the Web Services and EAI paper on Web Services technologies and it's impact on applicaiton integration and Web Services Messaging Strategy.  Jorgen Thelin CapeClear's Chief Scientist has recently joined the Indigo team. 

• Get up to speed on the Architectural buzz-words: Message Oriented Middleware (MOM), Service Oriented Architecture (SOA).  Roger Session's latest ObjectWatch newsletter has a crack at defining What is SOA.  Clemens is a great source of information, as is Ingo's recent architecture briefings: 'SOAP is not a remote procedure call' and one on using other message patterns than just request/response.

• Enterprise Integration Patterns - a site by Gregor Hohpe from ThoughtWorks, describing 65 patterns to do with Enterprise Integration in a vendor-neutral way.  Going through this material should help fill us in on the space that Microsoft are trying to move Indigo into.  For example, since we know Indigo is a message bus, why not find out what a message bus is and how they can be usefully used in projects.

Specific questions I've got based on WSE:

• We know that WSE is a small 'bouquet of flowers' for us as developers, but what have Microsoft learned from WSE that they are going to put into Indigo?
• Will Indigo have the same modular, open approach to its architecture as WSE?  Will it be made of the same 'pliable building materials'?
• Gregor mentions that 'config file hell' is a major problem in Enterprise Integration projects.  Will Indigo be doing anything to address this (like WSE's very helpful Visual Studio Add-In and user tools?

It's a good thing to hear Microsoft people asking what they could do better.  It’s important to note that the current situation isn't necessarily a criticism of anything Microsoft are currently doing.  Blogs are making a big difference to the Microsoft community (both the MS blogs and others), the conferences like the PDC are great, the material on MSDN (MSDN-TV, the full presentations from TechEd 2003), the MSDN newsgroups with responses from the development teams, the patterns and practices group are all great things.

I think Larry nailed it when he says that the Java community has grown organically, without central sponsorship, and that communities involve people communicating with each other.  I think it's a tough ask to say what Microsoft could do itself to overcome these obstacles.

What I like about the Java communities that I've seen so far:

• Open source development plays a large part in this.  The Java developers seem to be comfortable using Open Source technology.  They are comfortable finding and learning about new Open Source tools, or even writing them if they are not available.  I was surprised at the XTC group to find out how few of the Java guys dislike J2EE.  The view I got was that when they need any Enterprise Software they just download an Open Source piece of software that handles the function they need.
• There's more interest in how you develop software, with ideas like XP or Agile Development and the tools: Nant (which MS are finally catching up on with MSBuild), CruiseControl, NUnit and others.
• Here's an excample of the kind of community event that I think it is exciting.  A group of open source developers hold a  weekend in Amsterdam, which from reports sounds really interesting.  Or a weekly GeekNight (admittedly, sponsored by ThoughtWorks, a development services company) where developers get together with their laptops and code.

Here are some issues I think the Microsoft communities  have (based on my very self-focused point of view):

• All of the technology comes out of a central organisation with long release cycles, making it hard to dynamically incorporate new technologies.  Although the PDC is great for 'opening the kimono' it's hard to create a community around this (while the PDC bloggers is good fun, it's also pretty tiring when there's no concrete information about the new technologies). 
• The communities are mostly sponsored by Microsoft.  They focus is on everyone getting closer to the source, rather than establishing a community in the place where they are.  For example, the MVP program and Partner programs seem to be about connecting people up to Microsoft so that they can take that information and push it back out again.  This is another complex point to overcome - 'how can MS create communities without making them look created'
• There's so much good information available that it breeds a kind of laziness amongst developers.  We don't need to go out and learn about it, it will come to us when we need to.  I admit this is a tough criticism to overcome (don't do less, but find ways to encourage developers to engage and do more).
• Microsoft is good at making complex technologies simpler so that they can be accessed by a wider audience.  We've seen it already in areas like relational databases, OLAP technology, distributed transactions, hosted environments and we'll see it again with many of the new technologies like Indigo with its message bus.  The problem is that sometimes Microsoft over-evangalise the wrong message.  This leads to the situation where too many VB projects were using MTS when they weren't getting any benefit from it (or the converse now where COM+ seems to be ignored in favour of 'cooler' new technologies).

So, how could Microsoft improve? Here are some random thoughts:

• Provide more opportunities for developers to speak to each other.  Provide events where the focus is on getting the audience to talk rather than the traditional User Group Expert-Lectures-With-PowerPoint-For-2-Hours.  Perhaps use this strategy adopted by John Bristowe when he ran the .NET group in Melbourne:

"An independently run volunteer user group, MDNug holds informal gatherings once a month where the focus is not on one speaker or subject but on several. To do this, members break into groups gathered around whiteboards. In small groups members are more likely to ask questions, present ideas and professionally critique the work of others, says Bristowe." Source

• Encourage more local dialogues on practices and architecture.  Why not have a 'developer hypothetical' evenings with MCS consultants where a problem is raised and the group (or teams) have to come up with architectures?
• Provide developer drop-in centres - space where teams of developers could come and work on small public projects (e.g. improving DasBlog - why not sponsor Clemens a trip to London to talk to a developer group who would implement new features, similar to Erich Gamma's campaign for Eclipse addin developers)?
• Encourage more open projects.  What about having someone like Eric Gunnerson managing public projects for development tool add-ins.  Things that the MS team didn't have time to do, but were requested by customers?
• Encourage more public discussion about the direction of future tools.  So not just about the bugs in the product today, but the future directions and the advantages/disadvantages of various approaches?
• Provide more opportunities to talk with MCS developers about architecture and approaches.
• As I was writing this John Porcaro a Microsoft Marketing guy posted about this issue, saying its about:

"letting the customers--the ones who just love your products or services--do it for you. It's about giving them something to talk about and making it easy for them to do it (even rewarding). It's giving them permission and rewards and social standing (the MVP program). It's removing barriers and maybe just as important not standing in their way."

These are just my thoughts, I'm interested in what others have to say (especially on how things could be improved, this is the tough one).