Turns out that a large percentage of people adjust their monitors to use a resolution that's lower then the native resolution. As many as 55%. What does that tell us? Well the most likely thing is that people are having trouble reading the tiny text. The other thing it tells us is that display architectures aren't designed right.
Resolution explained simply is the size of the pixels on the screen. On a printer, digital camera or on a TV you want the best resolution possible. You want the pixels to be really small so that you get a sharp image. Unfortunately computer's aren't designed like this and higher resolution on your monitor results in smaller text.
In the physical world there are two pays to make something appear bigger. You can bring it closer, or you can stretch it. The way windowing systems are setup, the only option you get is to stretch.
The problem with the classic stretch is that it takes more screen space. For some applications the increased space provides more area for document data but it usually doesn't improve the legibility of the data.
To compensate application developers have started adding zoom controls to their applications to give the effect of scale & stretch.
While this is a great feature for applications that support it there is still a huge problem. The entire operating system does not deal with high resolution correctly or uniformly. The Start Menu, Finder, Explorer, Preferences across all modern operating systems have a coupled relationship between the on-screen text size and resolution.
It's a really hard problem and to date the only solution has been a bizarre dialog that asks you to hold a ruler up to your monitor to adjust the dots per inch that a font takes up:
class="img-link shimmer" >
The dialog makes an attempt to address the high-DPI font issue but anyone with experience in High DPI knows that changing these settings can have all sorts of undesirable effects on applications.
What we need is to decouple the application layout and positioning from the rendering that can be done resolution independently. This will allow us to have 300dpi monitors that are crisp as paper with fonts that are sized appropriately for reading.
The upcoming version of Windows (#7) claims to be going down this path and it's exciting to see. The key that I don't think they've touched on is having the application scale be variable per-application.
- The idea is that the monitor always runs at native resolution.
- Each application window can be stretched (traditional edge-dragging) or scaled (new multi-touch pinch)
- The application can render normally without the application developer being aware that the application is being streched. The key is to make the font API's be smart under the covers to render to the native resolution font. For this to work fonts have to scale in a linear way. (Currently a problem on Windows because of hinting)
I'd love to see something like this on both Windows 7 as well as future version of OSX. The existing architectures have held back high DPI monitors since 2000 when I first started looking at this problem.