Windows 7 Chkdsk Prompt Hangs At 1 Second: How I Fixed It

A few weeks back, something bad happened to my computer.  I’m not sure what, but my nightly backup reported a failure to run due to corrupted folders.  So I immediately pulled out the toolbox and scheduled a chkdsk for the next reboot.  And then I rebooted.

When Windows rebooted, I was greeted with the familiar notice, “A disk check has been scheduled.”  As anyone familiar with Windows knows, you then get a ten second countdown to abort the disk check.  I waited (10…9…8…) patiently (7…6…) while it ticked (5…) off (4…) every (3…) excruciating (2…) number (1…), and then … nothing.  I had one second left, permanently.  The computer had frozen, and hitting the any key did nothing.  Hitting CTRL+ALT+DEL did nothing, either, and so I was forced to hard-off the machine.

On reboot, I received the same prompt, and once again it hung at one second.  I couldn’t even get it to abort the disk check, the very purpose for the countdown prompt!  Woe is me!  I was stuck in a reboot loop.  At this point, I am going to fast forward over the gory details of booting the rescue tools off my install CD, unlocking my encrypted drive, fixing the disk, resetting my TPM state, and all that.  Trust me, it’s for the best.  But in the end, I had a working machine again.

Last night, and right before bed no less, I encountered the same problem.  Googling led me to the same results I had seen before.  But this time, reading through the top result, there was a new post.  The comment by Tayloradical on December 10 recommended removing all the peripherals, including any SD card.  I have lots of peripherals, including an SD card I use for ReadyBoost.  After a somewhat systematic cycle of decoupling and rebooting, the chkdsk finally kicked off normally after removing the SD card!

So, if you encounter this problem, try removing your SD card, and maybe some other peripherals as well.

2010-02-02 update: This is a known issue, and Microsoft has issued a hotfix.  Also, for my machine at least, the fix has been rolled into a update sp46718  from HP.

Living 64-bit: Why Windows Thumbnails Show Up Randomly

Windows Explorer has had support for showing thumbnails instead of icons for many years now.  Support is built-in for many common formats, like images or rich text, but it doesn’t know how to deal with more complicated formats like PDFs and ODTs.  To compensate for this lack of support, there is an extension mechanism that third-party applications can use to teach Explorer how to render thumbnails. Then, whenever you create or modify a file, Explorer notices that it has changed, recreates the thumbnail, and saves it to a cache file.  This behavior is very evident if you save files on your desktop, since it is one Explorer window that is always visible.

Unfortunately, in a 64-bit world, this approach often fails for the same reasons that Windows Search Filters often fail.  In 64-bit Windows, Explorer is a 64-bit process, but most third-party application programmers only provide 32-bit extension DLLs.  Since Explorer is unable to load the 32-bit DLLs, it cannot render the thumbnail – and you’re left with an ugly icon.  If you’re living 64-bit, though, you’ve no-doubt noticed that many of the thumbnails do get generated, but seemingly at random.  You might have a PDF sitting on your desktop for weeks, and suddenly one day it will switch from an ugly icon to a thumbnail.  What gives?

The secret is that Explorer is not just a running process for viewing your files and folders.  It is exists in a series of libraries and common controls that third-party applications use to provide common functionality with a familiar interface.  For example, almost all “Save” and “Open” dialogs either use or extend the built-in Windows versions, and those Windows versions use the same libraries as Windows Explorer to hoist some of that familiar functionality into the applications.  In a very real sense, Explorer is being embedded in these third-party applications.

But remember: These third-party applications are 32-bit.  That means that there are 32-bit versions of the Explorer libraries hanging around Windows, in case these applications need to use them.  So when a 32-bit application opens a “Save” dialog and you navigate to a folder, you’re essentially pointing a 32-bit version of Explorer at that folder.  Like usual, Explorer notices there are thumbnails that have not been generated, but now it can properly load the 32-bit third-party thumbnail extensions.  It renders the thumbnails and writes them out to the cache file.

Surprise!  Thumbnails for a file you weren’t even working on have suddenly been updated.  It’s not random at all, but because you were working on a different file, it just seems random.

The Web Paradigm Four Years Later: King Browser

In my first post in this series, we took a quick look at where we were at the start of 2006 in re-defining the Web, and then asked, “How are we doing?  Have we made progress during the intervening fourteen-hundred days?”  The answer is, “Yes, we’ve made a lot of progress on the web, but we have yet to take the big leap.  And we are in danger of taking some serious steps backwards.”

(Too Bad) The Browser Is Still King

When you think of the applications with the most impact on people’s day-to-day lives, chances are many of them will start with the letter ‘G’.  Google has done an amazing job pushing the limits of what applications in a browser can do.  They have pioneered new frontiers in web standards, compatibility, scripting, and browser user-interface capabilities.  All of this has taken place inside of a web browser which is essentially unchanged since its inception.  The browser is still king of the Web.

And yet, for all the advances in web user interfaces, they still suck.  Take Google Calendar, for example: The CSS-styled interface is flat and ugly.  Your options for different views are severely limited.  Right-clicking brings up a context menu devoid of any calendar-specific context.  Printing is a crapshoot, at best.  When you have a meeting in five minutes, Google Calendar can’t interface with your desktop to provide a nice notification (like Growl or the Balloons); instead you get a ugly JavaScript pop-up and the default system sound.  (And that’s not to mention more complicated issues like process isolation and window sizes and task switching!)

Need I go on?

Where Does Value on the Web Come From?

So why bother to use a web application like Google Calendar at all?  It’s certainly not because we like the poor interface or lackluster usability.  Rather, we get value comes from the accessibility of the important information it contains.  Who gives a damn about a fancy calendar interface if it forgets your wife’s birthday!  What’s more, we want access to our data.  We want it to be available and accessible when we need it, in a format most appropriate for the access mechanism.  Whether we’re scheduling our next hair cut on the iPhone, planning a trip home on our PC, or booking a meeting room at work, it has to be accessible any place and any time. A calendar in the cloud does that.

And it is easily shared with people you know and other systems you use.  Metcalfe’s Law predicts that the value of our individual applications goes up exponentially with the amount of sharing we can do.  The accessibility of the information gives a crappy interface connected to the web greater value than a fantastic – but lonely – user interface.

If we do value the connectedness of our data more than the interface in which its presented, then Google’s success with products like Docs, GMail, and Calendar are easily explained.  That their interfaces happened to suck less than competing web applications merely gave them the leg up needed to take the majority of the market.  So far.

Having And Eating Our Cake

Twitter shows us the future of the Web.  The user interface on Twitter’s home page is as technologically up-to-date as any of Google’s applications: it’s a full-on CSS-styled, HTML-structured, JavaScript-driven, AJAX-enhanced web application.  And it looks just as lackluster as GMail or Google Calendar.  But Twitter isn’t about HTML and CSS – it’s about data and the APIs to access and manipulate it.

More than 70% of users on Twitter post from third-party applications that aren’t controlled by Twitter. Some of those applications are other services – sites like TwitterFeed that syndicate information pulled from other places on the web (this blog, included).  Others are robots like JackBot, my Java IRC bot which tweets the topics of conversation for a channel I frequent.

Most, however, are specialized user interfaces, designed for humans to read, write, respond, dm, link, post pictures, and otherwise poke at their Twitter accounts.  Each one is unique, and each one has specific features that particular users find the most useful for their purposes.  Clients like TweetDeck target the power-tweeter with multiple columns and advanced features for multiple accounts.  Other clients, like Tweetie, aim to provide a full-featured interface within the limits of a mobile device.  Still other clients, like Blu (my personal choice), are full of fancy graphics and animations.

These applications successfully meld the web and the desktop.  They harness the value of Web-connected data while in rich, interactive experiences.  And its not just flash and bling.  By leveraging their platform’s capabilities, each application can be tailored to the needs of its users, making it possible for each person to extract the most value from their data.

So if Twitter is the model for how Web applications should be written, then why aren’t we there yet?  In the next post, I’ll discuss why we’re so far behind, and why I see Chromium OS as a step in the wrong direction for web-centric applications.

The Web Paradigm Four Years Later: Where We Started

Everything old is new again.  The advent of Chromium OS, and discussions at work with David, have prompted me to dust off these old posts and revisit my positions, arguments, and examples.  This is the first of a multi-part series, and is intended as a refresher (mostly for myself) on my past posts on the topic.

Long-time consumers of my site might remember a four-part series from 2006 entitled “What Does ‘Web Paradigm’ Mean, Anyway?”  In Part 1, I described how the web browser has been struggling – and mostly failing – to replicate the desktop user’s experience.  That’s not what the Web was designed for.

Notice that web applications have always striven to behave more like desktop applications. Since the very beginning, any web application of any complexity yearned to present a stateful, responsive, user-driven application flow. Sessions, cookies, and Javascript were all created with this in mind. Witness the advent of Ajax as the latest effort in this campaign to make the web more like the desktop. It’s the next logical step in a path that began with the <form> element all those years ago.

In Part 2, I took the path of the web browser as the canonical application platform to its logical conclusion – complete reinvention of the operating system – and discussed the folly of re-implementing decades of established engineering.

In the short-term, it allows for a quick path to closer web integration. In the long-term, however, it leads you down a slippery slope, demanding the question, “How far do you take it?” An IRC plugin may as well connect to AIM, Y!, and MSN. It’s only a short step from a peer-to-peer application to an Apache extension. After that, why not integrate file-level security and access control into your browser? With all of these different plugins, though, we can’t allow one malicious or buggy extension to monopolize the browser’s resources; so we’ll need to write a fair preemptive scheduler and memory manager.

In Part 3, I charted a path that allows us to combine the Web’s strengths with the Desktop’s strength’s.

There must be things we can do to more effective use the web in our daily lives than Firefox and Internet Explorer, right? We’ve taken pretty good advantage of the hyperlink, but can we finally take full advantage of the common languages and ubiquitous protocols, the final two things the web offers to us?

Finally, in Part 4, I gave some examples of how that might work, and what kind of platform and tools we need to make it happen.

We need a platform, independent of any particular application, that makes obtaining, parsing, transforming, aggregating, and forwarding XML as natural as displaying a window. Web integration needs to be a first-class citizen.

Projects like XULRunner are very strong steps in that direction. Microsoft is getting awfully close with .NET 2.0, and maybe we’ll see the first real platform in this space with Vista and WinFX. Finally, like Firefox, the ideas behind Smart Clients and Java Web Start are a good intermediate step, but they are not the future.

So, four years later, how are we doing?  We’ve made some bold steps in the right direction, but we have yet to fully harness the potential of the web in our daily experience.  In my next post, I’ll talk about the limitations of the status quo, and the model we should strive to emulate.

Living 64-bit: Search Filters for Windows

One of the greatest features in Windows Vista that carries forward to Windows 7 is the Windows Search-In-The-Start-Menu.  Just hit the Windows key and start typing, and voila! you are instantly graced with search results.  Suddenly desktop search is useful!

Unfortunately, the utility of the search is greatly limited by whether or not an appropriate filter exists for a particular file type.  Windows ships with filters for various barebones formats, such as text files and web pages, as well as Microsoft Office documents (of course).  Though filters for some formats can be found on the web, normally it is the job of the installer to properly configure filters to handle the application’s file types.

And herein lies the problem.

You see, when you’re running a 64-bit OS, most application programs you have are actually running in 32-bit mode.  Why?  Well, from an end-user’s perspective of the application, there is usually no difference between 32-bit mode and 64-bit mode.  There are virtually no performance differences, no look-and-feel differences, and no functional differences.

But from an application vendor’s perspective, 64-bit support requires often drastic API changes, as well as compiling, testing, and releasing a 64-bit version.  It’s a lot of work to support something that your customer probably won’t even notice, and that’s not to mention having to explain to a confused grandmother that she downloaded the 64-bit version for her 32-bit machine and could she please try again.  So for most application vendors, 64-bit is something only done when absolutely necessary, and thus most applications get released in 32-bit versions only.

So back to search filters:  One of the gotchas of 64-bit is that you cannot load 32-bit libraries into a 64-bit process, and on a 64-bit machine, the Windows Indexing Engine is a 64-bit process.  Thus most 32-bit applications will be unable to properly install their search filters on 64-bit Windows unless they go out of their way to do so.  OpenOffice currently suffers from this problem, as does Adobe’s PDF Reader.

Fortunately, it has been recognized as a problem, and applications are fixing it.  OpenOffice is supposed to have it fixed in version 3.2, and Adobe offers a free 64-bit version of their PDF filter.  And in the meantime, you can often find good filters for free on IFilter.org, or some for free and for sale on IFilterShop.com.

Just Because You Can Doesn’t Mean You Should

How many is a quadrillion, again?

Fun Little Bug In Windows 7: Control Panel Back Button

Here’s a fun little bug I stumbled across in Windows 7: It appears that the back button in the control panel does not properly update the quick navigation links on the left-hand side bar.

1. Open Control Panel.
2. Click on Appearance and Personalization.
3. Click on Preview, delete, or show and hide fonts (under Fonts).
4. Click the Back button (far upper left).
5. Click on Network and Internet in the left-hand side bar.
6. WTF?!

Here’s a video of the bug in operation.  This is using the fancy new HTML 5 video tag, so if you can’t see it, here’s a lame Flash version instead.

Interestingly, I’ve never before encountered a bug this obvious in Windows. Normally bugs in Windows are erratic and impossible to reproduce on demand, but this one happens every time, and has been confirmed to occur on at least one other not-owned-by-me Windows 7 install.

Fun!

Chronicles of Windows 7 Part 3: From Release Candidate to Final Version

I was running the Windows 7 Release Candidate for many months prior to the October 22 public release.  I had pre-ordered the new version, and it conveniently arrived on the release day.  Anxious to see what was changed, I promptly set about upgrading.

Unfortunately, there is no easy upgrade path from the RC.  The process forces a complete re-install (although there are some work-arounds).  I’m okay with that, though, since I had beat my RC install to a pulp experimenting with different drivers and hacks to get my Qualcomm Gobi 3G card working.  (I never really did.)

My Upgrade Process

The upgrade process I took was simple: Plug in my external hard drive, back up my machine using Windows Backup – including a system image – and then wipe the drive and start from scratch.  I had used similar processes in the past, although usually using a Linux Live CD and dd.  However, the Windows 7 Backup creates system images in a VHD format, and Windows 7 can also mount VHD images natively, making this a much simpler solution.  Also, it neatly sidestepped any issues I might have had with my encrypted Bit Locker hard drive.

I’m pleased to report that the re-install process was a cakewalk, and the recovery of my data was virtually flawless.  The only hiccups were caused by my own stupidly.  I limited the files I had backed up in order to speed up the process, and found out later I wanted them.  Fortunately, they were still on the system image, and the VHD mount worked as-expected.

Though my technique may not be for everyone, it works for the tech-savvy control-freak like me.

Stuff That’s Fixed

The good news is that HP’s new drivers for the Qualcomm Gobi 3G modem work flawlessly in the final version of Windows 7.  Hopefully they’ll eventually switch to use the new broadband driver stack built in to the new OS, but I’m not holding my breath.  They do work, though, and that’s enough.

The VMWare NAT issue was actually cleared up by an update to VMWare while I was still running the RC.  I am mentioning it here to close the loop on the earlier post.

And that’s it, really.  It’s not that there aren’t any more fixes, but that the RC was so solid for me that I had no gripes worth mentioning.  For those who suffered through Vista’s growing pains, this is a huge step up for Microsoft.  I suspect the large beta program and massive release candidate program helped immensely in this area.

Wish List

Here is my one gripe: Windows sizes the desktop background based on which monitor is designated as your “Primary”.  I dual monitor using my wide screen laptop display and a 4:3 stand-alone monitor, and I prefer the stand-alone screen as my primary.  Thus, I often get stupid black bars surrounding the background on my laptop display, because the image has been sized for the non-wide screen.

I am hard-pressed to think of a situation where this makes sense.  Hopefully Microsoft will make the “Fill” desktop background option actually fill on differently sized screens.  But in the meantime, this is a minor, minor thing.

And it should tell you something that such a ridiculously minor thing is all that I can find to complain about.

How To Load Bundled Images In A Prism Webapp

One of the features in the Prism Webapp Bundle for Google Wave is a toaster pop-up notification of unread waves using the window.platform.showNotification() method.  The third parameter is named aImageURI, and is described by the nsIPlatformGlue IDL as, “The URI of an image to use in alert. Can be null for no image.”

Which is great, except … what URI scheme and path does one use?  Every example I could find always passed null for the image, so after giving up on the web I joined the Prism mailing list and posted a question.  The first response was to use the inline data scheme, with a base64-encoded image.  It was ugly, but it worked.

A later response, however, yielded the proper way:

resource://webapp/path/to/image.png

A Prism Webapp Bundle For Google Wave

Though Prism and Google Wave go great together simply creating a web app from the Prism Firefox add-on, Prism supports some script extensions that allow for more desktop-like integration of apps running inside it.  For example, you can call the window.platform.showNotification() method to cause a little toaster pop-up with the number of unread Waves.

I’ve created a webapp bundle that does just that.  Unfortunately, such bundles at present only work with the stand-alone version of Prism.  The Firefox add-on is really a better way to run Prism, but if you’re using it you’ll need to do a little manual mucking in your webapp profile to use this bundle.

Stand-Alone Bundle

So, if you just want the bundle, here you go.  Note that I haven’t really tested it on the stand-alone version, so please let me know if something is broken.

Hack Your Webapp

As I said, if you’re using the add-on version, you’ll need to do a little manual hacking.  After you create the webapp, as described in my earlier post, open up Explorer and navigate to your Prism webapp bundle cache.  On Windows, this is in %APPDATA%\WebApps (something like C:\Users\Brian\AppData\Roaming\WebApps); on Linux, it is ~/.webapps.  You should see your Google Wave webapp in that directory.  Add the webapp.js script to that directory, and also add in images/google-wave-52×32.png.  Now you should get a toaster pop-up and task bar notification when there are new waves.

It would be nice if Google were to add a <link rel=”webapp”> to Wave, referencing an appropriate bundle.  If anybody there sees this and cares to use my code as a crude starting point, I am releasing this code under an MIT license.