Riding Herd

You too can look like MS Office 2007

2006-11-22T01:43:00Z

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

2006-10-31T02:11:00Z

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:

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
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

2006-07-14T21:50:00Z

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

2006-05-05T21:38:00Z

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

2006-03-31T23:45:00Z

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

2006-02-17T23:44:00Z

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

2006-01-04T23:44:00Z

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)

2005-10-26T00:53:00Z

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

2005-09-13T07:07:00Z

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

2005-09-12T21:59:00Z

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

2005-09-11T06:38:00Z

The PDC content team is on site in LA! It's been an intense last month getting ready for the event, which explains the absence of any interesting blog posts from me. If I have some time in the next few days before the show starts, I will try to write up more of what we've been up to. In the meantime, however, I wanted to send along a heads up on some recent changes to our session list.

We have been constantly fine tuning the session list and room assignments over the past month, in large part based on attendee data from the personal calendar tool. The most current session list is always available on CommNet, and changes are pushed via our RSS feed. As it turns out, though, the mini-guide, the pocket-sized list of all session times and room assignments that attendees receive at check-in, had to go to print in August. We tried really hard to avoid making changes after the print date, since we know many attendees rely on the mini-guide as their PDC bible. But when the personal calendar data showed us that our room size was really far off base, we decided it was more important to have the right size room than to have the mini-guide be 100% accurate.

So, for your reference, here is the list of sessions which have changed since the mini-guide was printed. We'll provide a printed copy of this as well at the registration desk.

COML02: Tips & Tricks: System.NET
Change type:	Originally scheduled:	Updated room:
Room change	9/13/05, 11:45AM, 404AB	9/13/05, 11:45AM, 403AB

COM311: Developing P2P Applications Using Windows Vista and the Windows Communication Foundation (“Indigo”) PeerChannel
Change type:	Originally scheduled:	Updated room:
Room change	9/13/05, 2:45PM 409AB	9/13/05, 2:45PM, 403AB

FUN403: .NET Compact Framework 2.0: Optimizing for Performance
Change type:	Originally scheduled:	Updated room:
Room change	9/13/05, 2:45PM 403AB	9/13/05, 2:45PM, 409AB

PRS327: Windows Presentation Foundation ("Avalon"): Optimizing Applications for Performance
Change type:	Originally scheduled:	Updated room:
Room change	9/15/05, 5:15PM 411	9/15/05, 5:15PM 408AB

FUN319: Windows Vista: Developing Power-Aware Applications
Change type:	Originally scheduled:	Updated room:
Room change	9/15/05, 5:15PM 408AB	9/15/05, 5:15PM 411

DAT321: XML Tools: Future Directions for Leveraging Advanced XML Tools and Building Custom XML Solutions
Change type:	Originally scheduled:	Repeat added:
Repeat added	9/15/05, 3:45PM, 409AB	9/13/05, 1:00PM, 501ABC<

DAT323: Using the .NET Language Integrated Query Framework with Relational Data
Change type:	Originally scheduled:	Repeat added:
Repeat added	9/16/05, 8:30AM, 408AB	9/15/05, 2:15PM, Hall F

PRS321: Windows Forms: Integrating Windows Forms and Windows Presentation Foundation ("Avalon")
Change type:	Originally scheduled:	Repeat added:
Repeat added	9/15/05, 11:30AM, 404AB	9/16/05, 10:30AM, 501ABC

OFF405: Windows SharePoint Services: Using ASP.NET 2.0 Technology to Extend Pages, Sites, and Server Farms
Change type:	Originally scheduled:	Repeat added:
Repeat added	9/14/05, 11:00AM, 409AB	9/15/05, 2:15PM, 518

DATL07: Tips & Tricks: 10 Tips for Extending Your System to Windows Mobile Devices
Change type:	Mini Guide Says:	Actual Scheduled Time Is:
Mini Guide Error	9/14/05, 12:30PM, 403AB	9/16/05, 12:00PM, 402AB

TLNL11: Case Study: Tuning MSN Performance Using Load Testing Tools
Change type:	Originally scheduled:	Updated schedule:
Cancellation	9/16/05, 12:00PM, 408AB	cancelled

FUN200: Windows Vista: Taking Advantage of Windows Vista in Your Application
Change type:	Originally scheduled:	Updated schedule:
Time change	9/13/05, 1:00PM, Hall EF	This content will be delivered as part of Jim Allchin’s keynote on 9/13 (as explained here)

PRS223: Getting Users to Fall in Love with Your Software: 2005 Edition
Change type:	Originally scheduled:	Updated schedule:
Time Change	9/15/05, 2:15PM Hall F	9/13/05, 1:00PM Hall EF

In addition, there are a few sessions we planned a while back, but did not put onto CommNet for various reasons. We're starting to upload those sessions now. The first two (which you will find in your mini-guide, but are now also available on CommNet) are

PRSL02: Case Study: How Hotmail Used Atlas and ASP.NET to Build a Great User Experience

PRSL04: MSN: Extending Start.com Using Startlets

tag: PDC05

PDC session list now in XLS and RSS formats

2005-08-23T02:47:00Z

Sometimes it's the little things that make a difference...by popular request, the current list of PDC sessions is now available as an Excel spreadsheet, or as RSS^H^H^H Web Feeds ;). Any changes we make to session titles, speakers, timeslots, etc (and I'm sure there will be some) will be auotmatically reflected in these links.

The Register gets two facts wrong about IE 7 TechBeta

2005-07-29T07:12:00Z

Andrew Orlowski, of The Register, recently posted a very short blurb about problems with IE 7. He makes two significant errors that I want to clear up here. It took my all of 3 minutes to refute these statements on my XP SP 2 box running IE 7 TechBeta version 7.0.5112.0. I showed my results to Scoble, but wanted to post here as well.

Orlowski writes:
"IE7 integrates search into the browser, but the only option is Microsoft's own MSN Search"

Fact: IE 7 TechBeta contains the following providers for its search box (this is a verbatim listing from looking at my machine): AOL search, Ask Jeeves, Google, MSN Search, Yahoo! Search. Installing the most recent Yahoo! toolbar build then adds another search provider labelled "Yahoo!"

Fact: IE 7 honors the user's preference for default search provider. In Corey Gouker's screenshot, you can see that Google is selected as the default provider. To choose a different provider, you just click the little magnifying glass to the left of the search box.

Orlowski writes:
"Microsoft disabling third-party toolbars" and "it does raise ominous echoes of Microsoft previous tactics of foreclosing competition by hiding the alternatives"

Fact: As Scoble notes, the general manager of IE has said that there is nothing in product that blocks Yahoo! or Google toolbars from working. Nobody is hiding any alternatives.

Fact: the following toolbars are working correctly on my machine right now

Google toolbar: version 2.0.114.9-big/en (GGLD)
Y! toolbar: version 6.1.1.0

Fact: older versions of the Y! toolbar (I believe version 5.6 and earlier) do have issues that prevent them from working in IE 7 TechBeta. These issues were fixed in Y! toolbar versions 6 and above.

Orlowski writes: "Users with search toolbars from Yahoo! and Google have discovered that these vanish"

Fact: Some users evidently have run into problems. But plenty of other users, including the IE test team, have not

If you are experience any issues with Yahoo! or Google toolbars, I repeat Scoble's plea: send us specific version information of your OS, IE 7 build, and toolbar build.

Update: check out Tony Schreiner's post from May about how he implemented tabs in IE. Note where he says:

One design decision worth calling out is that our current implementation is fully multithreaded. Each tab is on a separate thread, and the frame is also on its own thread. This has some impact on the overall footprint of IE, but we believe this will allow IE7 to feel faster and provide an overall better user experience. Internally this creates some additional complexity as we have to deal with a lot of cross-thread communication, but it also gives us a way to do things we wouldn’t otherwise be able to do with a single-threaded approach.

If you have a browser extension, like a Toolbar, that wasn't designed to be multi-thread safe, IE 7's multi-threading might cause some compatability issues. That having been said, Tony also writes "one of the deciding factors for our design was to preserve compatibility with 3rd party applications", and I know the team has been doing a lot of test work to verify that as many extensions as possible are able to work unaltered on IE 7.

Update 2: I've been told by the IE team that the code to migrate toolbar settings when upgrading from IE 6 to IE 7 was one of the later items checked in for the TechBeta. So users with older interim builds of IE 7 might have seen a problem where toolbars weren't migrated properly. But again, all evidence I have is that this is working great in the actual TechBeta release.

Update 3: If you're having toolbar problems, let us know the following (as of right now, I only see know of one person reporting an issue in Scoble's comments):

1) what version does IE 7 report? (Help->About IE)
2) go to Tools->Manage Add-ons. do you see entries for Google (of type Toolbar) and Google Toolbar Helper (of type Browser Helper Object), or Yahoo! Toolbar? If so, what status do they report? If you right click on the IE toolbar area, do you see your toolbar show up in the context menu? can you enable it that way?
3) what version of the toolbar are you running? if you managed to get the toolbar working, use it get the version number (Google: click the Google drop down, Help->About Google Toolbar, Yahoo!: click the pencil, choose About Yahoo! Toolbar). If not, the version number of the DLL would help (on my machine, Google is in program files\google\googleToolbar2.dll, Y! in program files\yahoo!\companion\installs\cpn\yt.dll)

Update 4: Orlowski has updated his post to correct the claim about only using MSN as search provider, and to agree that the latest version of Y! toolbar works fine. But he still says "The default search engine is MSN Search", which isn't what I saw on my machine (neither did Adam), and I'm still looking for anyone who has experienced a problem with the Google toolbar to let me know.

Why do we care so much about this? Because 1) if there's a problem, we want to fix it, and 2) misinformation spreads

Windows Vista dev overviews now up!

2005-07-27T21:04:00Z

check it out, http://msdn.microsoft.com/windowsvista/

Avoiding memory leak patterns in your IE script

2005-06-22T02:17:00Z

Justin Rogers, a dev on IE's object model team, posts about his recent MSDN article on leak patterns in IE.

If you're doing serious DHTML development for IE, this article is a must read. Says Justin:

let's look at the following patterns:

Circular References—When mutual references are counted between Internet Explorer's COM infrastructure and any scripting engine, objects can leak memory. This is the broadest pattern.

Closures—Closures are a specific form of circular reference that pose the largest pattern to existing Web application architectures. Closures are easy to spot because they rely on a specific language keyword and can be searched for generically.

Cross-Page Leaks—Cross-page leaks are often very small leaks of internal book-keeping objects as you move from site to site. We'll examine the DOM Insertion Order issue, along with a workaround that shows how small changes to your code can prevent the creation of these book-keeping objects.

Pseudo-Leaks—These aren't really leaks, but can be extremely annoying if you don't understand where your memory is going. We'll examine the script element rewriting and how it appears to leak quite a bit of memory, when it is really performing as required.