Riding Herd

You too can look like MS Office 2007

Today we announced a new licensing program for the Microsoft Office 2007 user interface components.  Licensing UI in this way is something for new Microsoft, but it should work out well for developers who want to take advantage of all the research that went into the UI to improve the usability of their own applications (or who just want to make sure their apps look/behave like Office).

The license is short and simple (and royalty-free!), and it's accompanied by a detailed set of design guidelines that explain the finer details of implementing the UI controls in the same way as Office.  So you get all the tips you need on how to behave consistently with Office, plus a license that gives positive assurance that you have the right to use the UI in your app.  You can read more details here and on Jensen's blog, and watch us discussing the license on Channel 9.

I've been helping the Office team think through this licensing approach for a good long while now, and I think they came up with a great solution.

Setting AutoArchive properties on a folder hierarchy in Outlook 2007

Is there anything more fun than writing custom VBA macros to solve a problem you face in your favorite app?  Actually, I'm sure there's lots that's more fun.  But, since I went through the pain of figuring this out, I figured I'd post here for posterity and see if anyone else found it useful.

 The problem I faced was how to handle RSS feeds in Outlook 2007.  I love integrated RSS, but I hate filling up my server quota with tons of RSS items.  If I haven't read an RSS item after two weeks, it probably means I don't care about it and it can get permanently deleted.  AutoArchive would be great for this, except for two problems:

1. you can only have one autoArchive default setting, and a default of "permanently delete everything after two weeks" isn't what I want for the rest of my inbox
2. Outlook UI offers no way to recursively apply settings down a folder hierarchy.  So if you have 100 folders for RSS feeds, you have to click and update the properties on each one.

My solution?  A little macro to read the settings off a folder, then recursively apply those settings to all child folders.  You'd think this would be easy, and in fact the Outlook team wrote a nice help article that gets you 90% of the way there.  Unfortunatley, the help article is filed under "Auto-Archive", so if you search for "AutoArchive" as it appears in the Outlook UI, you don't find anything.  It took me a couple days of playing around with a MAPI store viewer and reading through old MAPI C++ docs to figure out how this all works.  In brief:

Folder archiving properties are not actually stored as properties on the folder item.  Instead, they are stored on a hidden item inside the folder of message class "IPC.MS.Outlook.AgingProperties".  Hidden items, by the way, are known in the old MAPI parlance as Associated Items (GetContentsTable(MAPI_ASSOCIATED)).  Also, in MAPI-ville, archiving is known as Aging, so all the properties reference aging rather than archiving.  Once you have found the item with the message class, there are 6 properties that seem to govern server archiving behavior.  They are documented in the code below, but not anywhere else as far as I can tell.

Caveat: This is VBA code for Outlook 2007, not nice VSTO managed code, and running it requires you to lower Outlook's macro security settings.  What's more, I'm sure that this is not best practice VBA code writing, is full of errors and bad assumptions, and has terrible error handling.  I'm dead certain that this is not a best practice example of automating Outlook.  That having been said, it worked okay in the limited scenario for which it was designed.

 

Option Explicit

'------------------------------------------------------------------------------
'
' Hex values for the Exchange properties that govern aging / archiving
'
'------------------------------------------------------------------------------
Public Const hexPR_AGING_AGE_FOLDER = &H6857000B ' BOOL Enable aging aka Archive for this folder: True = Enabled False = Disabled
Public Const hexPR_AGING_GRANULARITY = &H36EE0003 'LONG Aging granularity: 0 = Months 1 = Weeks 2 = Days
Public Const hexPR_AGING_PERIOD = &H36EC0003 ' LONG, duration from 1 to 999 (combined with AGING GRANULARITY)
Public Const hexPR_AGING_DELETE_ITEMS = &H6855000B ' BOOL FALSE = archive, TRUE = permanently delete
Public Const hexPR_AGING_FILE_NAME_AFTER9 = &H6859001E ' STRING Path and filename of archive file for Exchange version > Exchange 9
Public Const hexPR_AGING_DEFAULT = &H685E0003 ' LONG values unclear, seems like 3=do not archive, 1=archive according to defaults, 0=custom settings
' the values below are not relevant to folder settings
'Public Const hexPR_AGING_FILE_NAME9_AND_PREV = &H6856001E ' STRING Path and filename of archive file for Exchange version <= Exchange 9
'Public Const hexPR_AGING_DONT_AGE_ME = &H6858000B ' BOOL
'Public Const hexPR_AGING_WHEN_DELETED_ON_SERVER = &H685B000B ' BOOL
'Public Const hexPR_AGING_WAIT_UNTIL_EXPIRED = &H685C000B ' BOOL
'Public Const hexPR_AGING_VERSION = &H685D0003 ' LONG

' Properties for aging granularity
Public Const AG_MONTHS = 0
Public Const AG_WEEKS = 1
Public Const AG_DAYS = 2

Public Const strProptagURL As String = "http://schemas.microsoft.com/mapi/proptag/0x"

'------------------------------------------------------------------------------
'
' String values for the Exchange properties that govern aging / archiving
'
'------------------------------------------------------------------------------
Public Const strPR_AGING_AGE_FOLDER As String = strProptagURL + "6857000B"
Public Const strPR_AGING_PERIOD As String = strProptagURL + "36EC0003"
Public Const strPR_AGING_GRANULARITY As String = strProptagURL + "36EE0003"
Public Const strPR_AGING_DELETE_ITEMS As String = strProptagURL + "6855000B"
Public Const strPR_AGING_FILE_NAME_AFTER9 As String = strProptagURL + "6859001E"
Public Const strPR_AGING_DEFAULT As String = strProptagURL + "685E0003"
'Public Const strPR_AGING_FILE_NAME9_AND_PREV As String = strProptagURL + "6856001E"
'Public Const strPR_AGING_DONT_AGE_ME As String = strProptagURL + "6858000B"
'Public Const strPR_AGING_WHEN_DELETED_ON_SERVER As String = strProptagURL + "685B000B"
'Public Const strPR_AGING_WAIT_UNTIL_EXPIRED As String = strProptagURL + "685C000B"
'Public Const strPR_AGING_VERSION  As String = strProptagURL + "685D0003"

'------------------------------------------------------------------------------
'
' UpdateFolderTreeArchiveSettings
'
' Asks the user to choose a folder, reads that folder's auto-archive settings,
' and then applies those settings recursively to all child folders
'
'------------------------------------------------------------------------------
Sub UpdateFolderTreeArchiveSettings()
    Dim ns As NameSpace
    Dim oRootFolder As folder
    Dim oFold As folder
   
    Dim AgeFolder As Boolean, DeleteItems As Boolean, _
        FileName As String, Granularity As Integer, _
        Period As Integer, Default As Integer
   
    Set ns = Application.GetNamespace("MAPI")
    Set oRootFolder = ns.PickFolder
   
    GetCurrentAgingProperties oRootFolder, AgeFolder, DeleteItems, FileName, Granularity, Period, Default

    RecursivelyApplyChanges oRootFolder, AgeFolder, DeleteItems, FileName, Granularity, Period, Default

End Sub
'------------------------------------------------------------------------------
'
' RecursivelyApplyChanges
'
' The tail-recursive procedure
'
'------------------------------------------------------------------------------
Sub RecursivelyApplyChanges(oFolder As Outlook.folder, AgeFolder As Boolean, DeleteItems As Boolean, _
                                FileName As String, Granularity As Integer, _
                                Period As Integer, Default As Integer)

    Dim oCurFolder As folder
   
    ChangeAgingProperties oFolder, AgeFolder, DeleteItems, FileName, Granularity, Period, Default
   
    For Each oCurFolder In oFolder.Folders
        RecursivelyApplyChanges oCurFolder, AgeFolder, DeleteItems, FileName, Granularity, Period, Default
    Next oCurFolder

End Sub

'------------------------------------------------------------------------------
'
' ChangeAgingProperties
'
' Cribbed mostly from help topic ""
' http://officebeta.iponet.net/client/helppreview.aspx?AssetID=HV100458931033&ns=OUTLOOK.DEV&lcid=1033&CTT=3&Origin=HV100433811033
'
' But fixed two apparent bugs
' 1) should use PR_AGING_FILE_NAME_AFTER9 for file name
' 2) set PR_AGING_DEFAULT, since that's what Oulook does when using the UI
'
'------------------------------------------------------------------------------
Function ChangeAgingProperties(oFolder As Outlook.folder, _
                                AgeFolder As Boolean, DeleteItems As Boolean, _
                                FileName As String, Granularity As Integer, _
                                Period As Integer, Default As Integer) As Boolean
   
    Dim oStorage As StorageItem
    Dim oPA As PropertyAccessor
   
    Debug.Print "Updating " + oFolder.Name
   
    'Valid Period 1-999
    'Valid Granularity 0=Months, 1=Weeks, 2=Days
    If (oFolder Is Nothing) Or _
    (Granularity < 0 Or Granularity > 2) Or _
    (Period < 1 Or Period > 999) Then
        ChangeAgingProperties = False
    End If
       
    On Error GoTo Aging_ErrTrap
   
    'Create or get solution storage in given folder by message class
    Set oStorage = oFolder.GetStorage( _
        "IPC.MS.Outlook.AgingProperties", olIdentifyByMessageClass)
    Set oPA = oStorage.PropertyAccessor
   
    If Not (AgeFolder) Then
        oPA.SetProperty strPR_AGING_AGE_FOLDER, False
    Else
        'Set the 5 aging properties in the solution storage
        oPA.SetProperty strPR_AGING_AGE_FOLDER, True
        oPA.SetProperty strPR_AGING_GRANULARITY, Granularity
        oPA.SetProperty strPR_AGING_DELETE_ITEMS, DeleteItems
        oPA.SetProperty strPR_AGING_PERIOD, Period
        If FileName <> "" Then
            oPA.SetProperty strPR_AGING_FILE_NAME_AFTER9, FileName
        End If
        oPA.SetProperty strPR_AGING_DEFAULT, Default
    End If
    'Save changes as hidden messages to the associated portion of the folder
    oStorage.Save
    ChangeAgingProperties = True
    Exit Function
   
Aging_ErrTrap:
    Debug.Print Err.Number, Err.Description
    ChangeAgingProperties = False
End Function

'------------------------------------------------------------------------------
'
' GetCurrentAgingProperties
'
' updates ByRef paramaters with values of the indicated folder
'
'------------------------------------------------------------------------------

Function GetCurrentAgingProperties(oFolder As Outlook.folder, _
                                ByRef AgeFolder As Boolean, ByRef DeleteItems As Boolean, _
                                ByRef FileName As String, ByRef Granularity As Integer, _
                                ByRef Period As Integer, ByRef Default As Integer) As Boolean
   
    Dim oStorage As StorageItem
    Dim oPA As PropertyAccessor
   
    Debug.Print "Fetching values for " + oFolder.Name
       
    On Error GoTo Aging_ErrTrap
   
    'Create or get solution storage in given folder by message class
    Set oStorage = oFolder.GetStorage( _
        "IPC.MS.Outlook.AgingProperties", olIdentifyByMessageClass)
    Set oPA = oStorage.PropertyAccessor
   
    AgeFolder = oPA.GetProperty(strPR_AGING_AGE_FOLDER)
    Granularity = oPA.GetProperty(strPR_AGING_GRANULARITY)
    DeleteItems = oPA.GetProperty(strPR_AGING_DELETE_ITEMS)
    Period = oPA.GetProperty(strPR_AGING_PERIOD)
    FileName = oPA.GetProperty(strPR_AGING_FILE_NAME_AFTER9)
    Default = oPA.GetProperty(strPR_AGING_DEFAULT)

    PrintFolderSettings oFolder

    GetCurrentAgingProperties = True
   
    Exit Function
   
Aging_ErrTrap:
    Debug.Print Err.Number, Err.Description
    GetCurrentAgingProperties = False
End Function

'------------------------------------------------------------------------------
'
' PrintFolderSettings
'
' Utility procedure for printing current folder settings to console window
'
' Unlike the functions above, which get the archive settings row via GetStorage,
' this procedure uses a closer-to-the-metal approach of querying the folder for
' its hidden items.  No reason for this, other than I wanted to learn more about
' how these archive items really work.
'
' Note that this function assumes that the only hidden item in a folder is the
' IPC.MS.Outlook.AgingProperties item.
'
'------------------------------------------------------------------------------

Sub PrintFolderSettings(oFolder As Outlook.folder)
   
    Dim oTable As Outlook.Table
    Dim oRow As Outlook.Row
   
   
    Set oTable = oFolder.GetTable(TableContents:=olHiddenItems)
   
    Debug.Print ("Values for hidden items in folder " + oFolder.Name)
    
    
    oTable.Columns.RemoveAll
    'Specify desired properties
    With oTable.Columns
        .Add (strPR_AGING_PERIOD)
        .Add (strPR_AGING_GRANULARITY)
        .Add (strPR_AGING_DELETE_ITEMS)
        .Add (strPR_AGING_AGE_FOLDER)
        .Add (strPR_AGING_FILE_NAME_AFTER9)
        .Add (strPR_AGING_DEFAULT)
        '.Add (strPR_AGING_FILE_NAME9_AND_PREV)
        '.Add (strPR_AGING_DONT_AGE_ME)
        '.Add (strPR_AGING_WHEN_DELETED_ON_SERVER)
        '.Add (strPR_AGING_WAIT_UNTIL_EXPIRED)
        '.Add (strPR_AGING_VERSION)
    End With

    If Not (oTable Is Nothing) Then
        Do Until (oTable.EndOfTable)
            Set oRow = oTable.GetNextRow()
            Debug.Print ("PR_AGING_PERIOD: " + CStr(oRow(strPR_AGING_PERIOD)))
            Debug.Print ("PR_AGING_GRANULARITY: " + CStr(oRow(strPR_AGING_GRANULARITY)))
            Debug.Print ("PR_AGING_DELETE_ITEMS: " + CStr(oRow(strPR_AGING_DELETE_ITEMS)))
            Debug.Print ("PR_AGING_AGE_FOLDER: " + CStr(oRow(strPR_AGING_AGE_FOLDER)))
            Debug.Print ("PR_AGING_FILE_NAME_AFTER9: " + CStr(oRow(strPR_AGING_FILE_NAME_AFTER9)))
            Debug.Print ("PR_AGING_DEFAULT: " + CStr(oRow(strPR_AGING_DEFAULT)))
            'Debug.Print ("PR_AGING_FILE_NAME9_AND_PREV: " + CStr(oRow(strPR_AGING_FILE_NAME9_AND_PREV)))
            'Debug.Print ("PR_AGING_DONT_AGE_ME: " + CStr(oRow(strPR_AGING_DONT_AGE_ME)))
            'Debug.Print ("PR_AGING_WHEN_DELETED_ON_SERVER: " + CStr(oRow(strPR_AGING_WHEN_DELETED_ON_SERVER)))
            'Debug.Print ("PR_AGING_WAIT_UNTIL_EXPIRED: " + CStr(oRow(strPR_AGING_WAIT_UNTIL_EXPIRED)))
            'Debug.Print ("PR_AGING_VERSION: " + CStr(oRow(strPR_AGING_VERSION)))
        Loop
    End If

End Sub

How I think about the Windows Vista platform

There are a ton of new features in the Windows Vista platform (thousands of new APIs), some of which are accessible on Windows XP and Server 2003 via redistributable runtimes.  Because of those runtimes, we often hear confusion from partners about how exactly we define the Windows Vista platform and how developer should think about it.  Here’s a summary of the talking points I use to describe the Windows Vista platform.  Because I wrote this to be shared broadly, it’s more formal and less conversational than a typical blog entry, but I hope you find it useful none the less.

 

My elevator pitch for how developers should think about the Windows Vista platform:

 

·         Great user experience matters

o    Faster, cheaper, better solutions for your users

·         Deliver great UX faster with the Windows Vista platform

o    Comprehensive platform for developers and designers

·         Great UX runs best on Windows Vista

 

1) Great user experience matters:

When your customers are evaluating purchasing your app, their most likely looking for you to deliver value in one of three areas: productivity gains, reduced operational costs, or strategic new capabilities.  So it’s trite but true that new solutions have to be faster, cheaper or better.  Those kinds of improvements are driven by great user experience – not simply great user interface, but a focus on complete end to end experiences that help users deliver better results.

 

Faster

Great UX improves personal productivity – not just completing the same task in less time, but actually helping users make better decisions.  Researcher Colin Ware has written that “the human visual system is a pattern seeker of enormous power and subtlety.”  His research (examples here and here) shows that well-designed use of light, color, depth and motion can significantly increase the amount of information a user can visualize and process.  Dell, for example, found that a new integrated call center application enabled sales representatives to sell more offerings per call while still reducing average call duration by 10 percent.  The intuitive interface also “decreases the time it takes for new sales representatives to perform at levels that are comparable to their peers by 50 to 65 percent.”  Apps that deliver great UX enable quicker data analysis, and optimize the process of sharing, collaborating and acting on information.  The Scripps Research Institute’s Collaborative Molecular Environment is an example precisely such a user experience.

 

Cheaper

Great UX reduces training and operational costs.  Intelligent use of network and services infrastructure increase application responsiveness and availability (including offline use, of course) while reducing network bandwidth.  Well-integrated identity and security features reduce the need for VPN infrastructure.  Advances like these make Windows apps more cost effective than web applications, and ClickOnce and WPF Express mitigate the historical deficit in ease of deployment and update between Windows and Web apps.  As one example, a recent case study from a Monsanto .NET project showed productivity increasing “by 40 to 50 percent, equivalent to millions of dollars in annual cost savings.”

 

Better

For digital customer relationships, your online presence is the only face most of your customers will ever see.  Servicing customers with novelty, speed, and simplicity creates an affinity that goes beyond graphics and logos.  The convenience of UX that’s fully integrated with your customers’ desktop and peripherals promotes loyalty and use of your services.  Check out the in-store kiosk that Fluid built for The North Face to get an idea of the potential here, or Lee Brimelow’s blog to see how a designer approaches the capabilities of the platform.  The MyYahoo! demo we showed at Mix is another example worth looking over.

 

We think the technologies in the Windows Vista platform are particularly well suited to improving the following aspects of user experience:

High fidelity UI	Span form factors, input methods, and media types with seamless access to full client API
Increased customer connection	Provide more value, more of the time
Connected Systems	Fast and flexible integration via Service Orientation, WS-*, and workflow
Smart Mobility	Network, power and pen aware
Security and Identity	Simple and secure access with built-in WS-* coordination, on an improved foundation
Search, Organize, Visualize	Pervasive desktop search and integration with Windows Shell

 

 

2) Deliver great UX faster with Windows Vista:

Do more: Completeness and integration

To deliver on the promises of faster/cheaper/better, apps need to integrate a broad range of functionality: animated user interface, highly readable text rendering, visually adaptive data binding, web service integration, identity, workflow, and more.  The Vista-era platform is unique not only because of its comprehensive feature set, but also because its depth and consistency make it practical to deliver the end-to-end integration required by next-gen UX.

 

Do it faster: Developer productivity

The Vista-era platform builds on the power and productivity of Visual Studio and managed code, making it possible for developers to deliver complete solutions in months, rather than years.  Solutions that might previously have required expertise across Win32, DirectX, COM+ and more can now be addressed within the consistent framework of .NET Fx 3.0.  XAML makes it possible to import high-fidelity UI directly from the applications graphic artists use create their designs, rather than today’s clumsy method of design/print/re-implement in code.

 

Together, the combination of more productive tools for coding and design achieve our goal of “democratizing rocket science”: making great UX achievable to a broad base of software developers.

 

Mitigating adoption blockers

We know developers appreciate the Web’s ease of deployment, security and ability to manage data and enforce corporate policy – areas where Windows needed to catch up.  In the Vista era, we have caught up.  WPF Express, ClickOnce, Code Access Security and broad Fx deployment mitigate key adoption blockers for building Windows applications.  The adoption issue has been addressed by making .NET Fx 3.0, Desktop Search, IE 7, RSS and other key platform components available on Windows XP and Server 2003.

 

 

3) Great UX runs best on Windows Vista

Users will find that running next-generation applications on Windows Vista provides the following advantages:

·         Performance

·         Windows Vista supports a new display driver model (WDDM) specifically designed to optimize next generation UI.  WDDM treats the GPU as a scheduled resource which can be assigned prioritized rendering tasks, just as Windows can prioritize how CPU time is allocated to multiple applications.  This allows multiple high end user experiences to run simultaneously with better performance and memory usage than what is possible under the existing Windows XP display driver model.

·         WDDM interfaces were designed to provide high reliability under the heavy GPU loads of next generation applications, enabling advanced features such as hardware accelerated rendering and 3-D anti-aliasing to be available by default on Windows Vista, whereas on Windows XP only select new video drivers that have gone through extra qualification testing will have these GPU features enabled.

·         The entire Windows Vista OS has been tuned and optimized to deliver consistently high performance.  From the updated memory manager (SuperFetch) which pre-loads the most commonly used data, to I/O prioritization (faster access to disk for the foreground application,) to the streamlined networking stack (better TCP/IP performance) to “glitch-free” media (tuned audio and video stack), users will find that applications will be most responsive when run on Windows Vista.

·         Windows ReadyBoost™ makes lets users make their PC more responsive by using flash memory on a USB drive, SD Card, Compact Flash, or other memory form factor to boost system performance.

·         Windows System Performance Rating (WinSPR) provides a simple, single numeric rating to express system performance capabilities, so that users can understand how capable their PC is and whether it meets the suggested requirements for a particular applications.

·         Security:

·         The Windows Vista engineering team followed the Security Design Lifecycle during the development of the product, reviewing each component to determine mitigations for the most likely security risks.  The combination of automated tools analyzing every line of source code for potential design flaws, compilation tools to prevent buffer overflows, and support for Data Execution Protection make Windows Vista less vulnerable to security risks than even Windows XP SP 2. 

·         One of the most significant improvements in Windows Vista is User Account Control, which increases security and manageability by enabling applications to run without administrator privileges.  This helps reduce the impact of malware, unintentional application defects, and unapproved system changes.  File and registry virtualization will enable many applications to automatically work on Windows Vista with standard user privileges.  With the Administrator Approval Mode feature, even users with Administrator accounts can run most applications with limited privileges, only elevating when necessary to perform specific administrative tasks.

·         IE 7 uses Windows Vista’s Mandatory Integrity Control infrastructure to run in a low-rights protected mode.  By running in a context with even fewer rights than a normal user, the risk of exploitation via malicious web sites is reduced even further.  By running at the low integrity level, IE will not be able to modify any of the user’s data or the Windows binaries on the machine.  Any files that are written will also be marked with the low integrity level, so downloaded apps in turn run at low integrity, adding an extra layer of security.

·         Windows Activation Service (WAS) provides a central broker that can take incoming network requests and route them to the appropriate service or application, reducing the need for developers to write custom NT services to manage their own service activation.  Having fewer services running with high local system privileges reduces the potential attack surface of the system.  WAS also provides process health monitoring and failure recycling for a more robust system.  Built-in support of poison queues for receiving messages that cannot be processed makes building fault-tolerant systems easier.

·         Users with x64-based systems gain the additional protections of 64-bit driver signing and patch protection, ensuring that users know which drivers, from which companies, are installed on their system.   Patch guarding prevents kernel-mode drivers from extending or replacing other kernel services, helping protect against malware such as rootkits.

·         TPM-based Services allow developers to enforce security with the support of dedicated Trusted Platform Module chips, reducing the risk of system compromise even if an attacker has access to the physical hard disk or PC.

·         The new Windows Firewall with Advanced Security integrates host-based network port filtering with IPSec to enable easy-to-create, comprehensive security policies, while the improved Filtering API allows applications to narrowly specify which network traffic should be allowed through.

·         Management and reliability:

·         Windows Vista introduces a number of new features to improve management and reliability.  From improvements in imaging and deployment, to backup technology, to a redesigned, schematized event infrastructure and reliability and performance monitors, to asynchronous I/O cancellation, to policy-based Quality of Service, to power management, users and IT pros alike will notice improvements in the overall reliability of the system and applications running on Windows Vista.

·         Applications will be less likely to require a reboot upon installation thanks to Restart Manager.  When a reboot cannot be avoided, applications can use Smart Relaunch capabilities to let users continue working exactly where they left off. Application Recovery help preserve application state and unsaved changes in case of an unexpected application termination.

·         Transacted File System and Registry allow developers to ensure the integrity of multiple updates to files and registry keys, reducing the likelihood of leaving the application in a partially updated or unstable state.

IE 7 security is already making a difference

I've been using various beta builds of IE 7 for several months now, and I am really impressed with the new security features and default settings.  I've seen gold bar and address bar warnings that highlight real issues with real commercial sites as I've been using the web.  It's really amazing to find big commerce sites that don't have their SSL certs set up correctly, for example.  I've seen multiple sites running with expired certs, as well as sites that have mismatched certs (so the cert for foo.company.com is used on bar.company.com, which IE flags as a potential security issue).  I even discovered a Microsoft product (in beta) that ships an unisgned ActiveX control.  In each case, when I send an email to let the owners know of the problem, they fix things up, but it's really been interesting seeing how many folks just don't get this right.  I think IE 7 will raise awareness of these issues, which is a good thing.

 

 

Using App Verifier to catch dangerous C++ code

One of the very cool things about the Visual Studio Team System 2005 release is that it includes a number of tools for code robustness that were developed for internal use at Microsoft.  Many of the same tools that the Windows team and others use to improve their code quality are available to the broader community.

One of the niftier tools is App Verifier.  I just happened to stumble across the docs for this tool in MSDN, so I figured I'd throw a link here for those who haven't heard of it before.  App Verifier helps you catch heap corruption, lock contention/corruption, and invalid handles.

App Verifier does its magic at runtime, but there is also a cool suite of static code analysis tools (for both native C++, as well as managed code)

Windows Vista software logo guidelines draft available

I just discovered that an early draft (version .5) of the logo guidelines for Windows Vista software is available here.  It's only a draft, but it gives you a good idea of the basics you have to implement in order to qualify for the Windows Vista logo.  Enjoy!

Developer's guide to new Vista APIs

Last month, the MSDN team published a doc that's long been in the works -- a developer's introduction to some of the new APIs in Windows Vista.  The real meat is in the .chm file (self-extracting exe), with some sample code and detailed API info.

This is only a start, and it covers only a small portion of the new platform features in Vista, but it's a good place to start learning about how to make applications really light up on Vista.

PDC 05 videos online (with a few issues)

Many folks have noticed that Mike Swanson's weeks of hard work have paid off, and the full video, PPT and demo recordings of PDC 05 sessions are now online (and that the DVD sets for attendees will be on the way soon as well.)  Seems like the videos are quite popular.

With great popularity comes great responsibility, though...or something like that.  We know of two issues so far.

First, performance has slowed considerably.  Our vendor knows about the issue and they are trying to add bandwidth now.

Second, we've heard that the site doesn't work if you're not using IE.  We're going to look into that also.  The history of the the HTML up there is that it started life as an .hta application that we use as the auto-run experience.  I don't think anyone on the content planning team ever specifically asked in what browsers the site would be tested, but we're catching up now ;)  I'm waiting to hear back from the vendor to figure out what quick fixes, if any, we can make.

Another mini-guide update

We heard from some attendees that they were having a hard time choosing between DAT209 (WinFS Future Directions: An Overview) and TLN306 (The .NET Language Integreate Query Framework: An Overview) in the Wednesday 1:45pm timeslot.  To make it a little easier on folks, we scheduled a repeat of DAT209 for 5:15PM on Thursday.  Now those who wanted to catch both sessions have a way to make it work.

How to build a great Windows Vista app

One of the goodies that PDC attendees will find in their swag bag is a poster called "Lighting up on Windows Vista".  It lists the top 10 things developers can do to build apps that will run like a dream on our new OS release.

We've now posted a short whitepaper that adds some technical background and documenation to that poster.  If you're looking for a good quick answer to the question "is there anything new or interesting in Windows Vista?", this is a pretty good place to start getting answers.  We have lots of PDC sessions that drill deeper into these technologies as well, and as the week progresses we will be making the slides from those talks available.

 

tag: PDC05

PDC mini-guide updates