Slashdot Mirror
HDTV Has Ruined the LCD Market
alvin67 writes "Microsoft Evangelist Pete Brown rants about the lack of pixels available in today's LCD screens: 'OK, that's it. I've had it. I want my pixels, damn it! For a while, screen resolution has been going up on our desktop displays. The trend was good, as I've always wanted the largest monitor with the highest DPI that I could afford. I mean, I used to have one of the first hulking 17-inch CRTs on my desk. I later upgraded to a 21-inch job that was so huge, that if you didn't stick it in a corner, it took up the whole desk. It was flat-panel, though and full of pixels. It cost me around $1,100 at the time."
After some years of improvements, we've regressed, in Brown's opinion: "At the rate we were going for a while, we should have had twice or three times the DPI on a 24- or 23-inch screen. But nooo."
You're doing it wrong. You should be increasing the DPI setting in your operating system, which will let you increase the size of things but will let them have far more detail. This should lead to a better browsing experience because the text will be more legible.
Display resolution and pixel pitch peaked back in 2001 with the introduction of IBM T220. Even now, no production display can top its resolution and pixel pitch.
Why aren't we all using WQUXGA, WHSXGA, or even WHUXGA display right now?
Simple, there's no demand for it.
Why isn't there any demand for it?
Because 90% of the consumers are still watching 480p DVD and DTV broadcasts.
Because lots of websites are still designed to be optimally viewing in 1024x768.
Because most operating systems and applications have their font sizes hardcoded (Windows 7 only allow system fonts to be enlarged by 150% while OSX cannot adjust its system font size at all).
The market is getting there. New 22" and 24" displays are coming out that have 1920x1080 (or 1200) resolutions, and recent 27" displays like on the latest iMac and a Dell 27" display have 2560x1440 (the 16:9 version of the 16:10 2560x1600 30" displays). You should be careful about some of these monitors, as many of them are large gamut displays that require calibration, and they're generally not going to be for gaming, as they're H-IPS panels. But they're really beautiful. I'm waiting for some detailed reviews on the new HP zr24w display - 1920x1200 (16:10 FTW!) with regular color gamut. I want the wide viewing angles, but I'm not _that_ picky about color. $425, I think.
16:9 and 16:10 screens actually kick ass for text, assuming you have the right setup.
Most programs and websites(in terms of sidebars and toolbars and stuff) are still laid out for screens that are wider than they are tall, so you do usually need one monitor in the usual configuration.
Your second monitor, though, you just rotate so that it is now taller than it is wide, and offers rather more horizontal resolution than any but the nicest 4:3 monitors ever did.
All but the cheapest video cards support dual monitors(and we are talking really cheap here. the 20-30 dollar card might not; but for $50 you'll have a hard time not getting dual monitor support, albeit often 1VGA, 1DVI), and the software is mature enough(you'll have to suffer through looking at your BIOS bootup sideways on one of the screens; but you'll survive).
Unless your environment is quite space constrained, or has to fit in a laptop bag and go with you, a second monitor, rotated so that its dimensions closely match those of your common paper document, is a fairly cheap way to make an office-type worker's life more pleasant and productive.
This only works, to varying extents, in the more modern OS's.
For example, the relevant application(s) has to be DPI aware as well as either have additional higher resolution raster based graphics or use something like SVG
This is just another in a long line of examples of why Flash is Evil.
Nathan's blog
This is a lot better on Vista/7. Legacy programs at high DPI are bitmap enlarged to maintain correct proportions. (Although yes, this does make some programs look fuzzy.) Smarter programs that handle DPI properly can set a flag in their application manifest if they handle different DPI properly. .NET programs written using WPF are entirely vector based, and so scale to any resolution.
This was wonderful for my grandparents - they had been running XP at 640x480 because of their poor vision. When they got a Windows 7 computer, we ran the screen at its native resolution and just turned the DPI settings way down.
DATABASE WOW WOW
Because NeXT is dead... :(
An explanation, for those who don't know:
NeXT supported "Display PostScript," which is basically what it sounds like. Thus, unlimited scaling and DPI, splines, fonts, etc.... Basically, applying laser printer techniques to your screen.
i'd hit it so hard, if you pulled me out you'd be the king of britain [bash.org]
.NET programs written using WPF are entirely vector based, and so scale to any resolution.
This is mostly correct, but (having worked on a large real-world WPF application) there is a catch. There's nothing precluding a WPF application from using bitmaps in its UI - there is full support for that - and, of course, the bitmaps can't be scaled smoothly. They will be scaled, but you'll get the same "blurred pixels" effect.
This is why VS2010 doesn't scale perfectly, to give an example. In contrast, Expression Blend uses XAML vector images for its icons - and therefore scales everything smoothly.
DPI is different than resolution. Think about it this way - imagine, the circle that indicates that you close a window is physically .25" in diameter at 640x480. (Obviously that's a made up number). Now imagine you have more pixels avaliable. You can either make that circle smaller (same number of pixels, but the pixels are a smaller size), or make that circle more detailed (increased number of pixels used to render the shape at the same size). Changing your resolution accomplishes the first situation - the higher you set your resolution, the smaller everything on your screen gets.
On an LCD screen, one issue that comes up is that the display looks "best" at it's native resolution. So making things bigger, also tends to make things blurry or ugly or distorted, etc. If you could make things bigger by adjusting the DPI, AND your operating system/application supported it, you could take advantage of those small pixels to render your big object more clearly.
On today's screens, if you have great eyesight you might say "So what? Things look pretty good right now... and I like how everything is small."
However, what some people want are high DPI screen - ie, screens where the number of dots per inch approaches the equivalent of printed text. So where a screen might have 72 DPI (lets say dots are pixels), so a native resolution of 72 pixels per inch, what some people want is a screen where that might be instead 300 DPI, or 600 DPI... or whatever.
The benefit of this would be that - if your screen has so many pixels that the eye physically can't distinguish one from the other, then text that's 1" high is gonna look smooth. A game rendered at the new ludicrously high resolution, wouldn't need anti-aliasing, because you wouldn't be able to distinguish between the pixels anyway, so stuff wouldn't render "blocky". Etc.
The problem is - when you can't adjust the DPI, instead of having something look crisp, you'd just have something that's really tiny. That .25" circle becomes too small to see. All that 12 point text becomes illegible greyish lines. However, the other problem is, when you CAN adjust the DPI, SO many applications break, because they've all been developed to ASSUME a certain DPI, so either the layout breaks, or the text doesn't flow properly, or raster graphics look ugly when scaled up, etc.
Which is why, say, Apple getting rid of the ability to change the DPI could be frustrating to people who want high DPI devices - because if the OPTION doesn't exist, then you can't even see what WOULD break. And it indicates that the developer of the OS probably doesn't care too much about things breaking.
Some apps just plain ignore the DPI setting, while others display funny, such as chopped-off text because it "grows" outside of intended sizing-box boundaries.
In Vista and above, the application has to explicitly say in its manifest that it's DPI-aware (i.e. the author has to claim that he understands the issues). This is a new manifest setting that wasn't present in XP. Any application that doesn't have that setting in its manifest will be treated as non-DPI-aware (even if it really is).
What this means in practice is that Windows will tell it to render at 92 DPI (the old default, to which everyone normally codes), and then scale the produced bitmap as needed - as a bitmap. The result is pixellated, of course, but at least the layout is completely preserved, so you won't see chopped-off text on controls etc.
Companies don't seem to test their apps very well at higher DPI, perhaps because they are multi-language apps, which means testing at both common and high DPI for every language.
Actually, multi-language apps are more likely to be handling high DPI better, because most languages have longer words compared to English. So those apps would either have to use flexible layouts (so that controls auto-adjust size to text labels) - which means that they will just scale up with more text; or they use fixed layouts, but upsize controls so that extra text on any localization would still fit - which means that text enlarged via DPI is more likely to fit, as well.
"Youll get the 4Kx2K monitor when 4Kx2K video becomes mainstream. Astro Systems DM-3400 56" Professional 4K LCD Monitor"
According to this calculator, 4000x2000 on a 56" is only 80ppi. He's already complaining about 96ppi so I'm sure he won't like 80.
my karma will be here long after I'm gone
I use high DPI settings on notebooks with small, but very high resolution screens. The result is beautiful and easy on the eyes. A bit like reading print.
Much popular MS software is DPI-aware. For example, IE8 is. Chrome and most applications by other software makers, unfortunately, are not.
It would be great if more software makers would make their products DPI-aware. Sometimes it can be done on the cheap. For example, all WPF applications automatically are DPI-aware.
Second this. Vista / Windows 7 were both scheduled to handle resolution-independent UI rendering, and neither of them can. Until the OS can render icons at 3/4ths of an inch at super-high DPI, most people will want a screen appropriately sized for their inputs. Similarly, web pages and other rendering will need to be resolution-independent... though the OS comes first.
Have you tried it in Vista/Windows 7? It's really, really good... I'm not sure exactly how they could improve it, frankly, except maybe increasing the possible magnification factor. (IIRC, it stops at 200% now.) Whenever I see complaints like yours, I have to kind of wonder if you've actually tried using the feature, or if you're just ranting from habit...
Either way, I think you're being really unfair, especially compared to Apple who has been promising the same thing in OS X since version freakin' 10.2 and hasn't shown the teeniest bit of progress in all that time.
Make sure you turn off "XP-style DPI scaling" when you set it-- the XP-style scaling still leaves layout up to the app, which is why apps that don't use native layout tools (like Adobe apps and GTK+ apps) will still look correct.
Comment of the year