A few weeks ago, just before my keyboard died, my monitor momentarily flickered ever so subtly between displaying white as full white and white as soft pink. It happened so quickly, and the change was so faint, that at first I thought my eyes were playing tricks on me. Fortunately, a day or two later the same thing happened, allowing me to determine that the monitor itself was hinky.

While I have no qualms about opening up a keyboard to see if I can rectify a problem, or just about any other gadget you could name, I draw the line at messing around inside devices that contain potentially lethal capacitors. Combine that reticence with the flickering I had seen, and the low, staticky hum that had been building up in my monitor for the past year or two, and it suddenly seemed prudent to once again peruse the state-of-the-art display offerings available in the market before the very device I would need to rely on to do so failed completely.

(There are all kinds of things that can go wrong with a computer, and the most maddening aspect of all of them is that those issues immediately make it impossible to access the internet, which is where all the solutions are. If your operating system locks up you need to access another computer to research the problem. If your monitor dies you need to have another display on hand in order to order a replacement, which you would not need if you already had one on hand. Speaking of which, even if you use an add-on graphics card, the motherboard in your computer should always have its own graphics chip for exactly that reason. If your card dies — and graphics cards are always dying, or freaking out — you can still drive your monitor and access the web.)

As was the case with my venerable old keyboard, I was not at all surprised that my monitor might be at the end of its useful life. In fact — and you will no doubt find this amusing or absurd — I am still using a second-hand CRT that I bought in the mid-aughts for the lofty price of twenty-five dollars. While that in itself is comical, the real scream is that the monitor was manufactured in 2001, meaning it’s close to fifteen years old. Yet until a couple of weeks ago it had been working flawlessly all that time.

The monitor is a 19″ Viewsonic A90, and I can’t say I’ve ever had a single complaint about it. It replaced my beloved old Sony Trinitron G400, which borked one day without the slightest hint that something might be amiss. Scrambling to get myself back in freelance mode I scanned Craigslist and found a used monitor that would allow me to limp along until I found a better permanent solution. Eight or so years later here I am, still using the same A90. (In internet time, of course, those eight years are more like eight hundred. Not only were LCD’s, and later, LED’s, pricey back then, yet quite raw in terms of performance, but you could also reasonably expect to use Craigslist without being murdered.)

Between then and now I have kept track of changes in the price, size, functionality and technology of flat-panel monitors, and more than once researched display ratings with the thought that I might join the twenty-first century. Each time, however, three issues kept me from pulling the trigger.

First, while all that snazzy new technology was indeed snazzy and new, relative to CRT technology it was still immature, requiring compromises I was not willing to make in terms of display quality and potential effects on my eyes. Having always been sensitive to flickering monitors, I was not eager to throw money at a problem I did not have — or worse, buy myself a problem I did not want. (As a general rule, putting off any tech purchase as long as possible pays off twice, because what you end up with later is almost always better and cheaper than what you can purchase today.)

Second, at the time I was primarily freelancing in the interactive industry, which meant I was working with a lot of beta-version software that had not been fully tested with every conceivable display technology. Using lagging tech at both the graphics and display level meant I could be reasonably confident that whatever I was working on would draw to my screen, at least sufficiently to allow me to do my part.

Third — and this relates somewhat to the second point — one advantage CRT’s had and still have over LCD/LED displays is that they do not have a native resolution:

The native resolution of a LCD, LCoS or other flat panel display refers to its single fixed resolution. As an LCD display consists of a fixed raster, it cannot change resolution to match the signal being displayed as a CRT monitor can, meaning that optimal display quality can be reached only when the signal input matches the native resolution.

Whether you run a CRT at 1024×768 or 1600×1200 you’re going to get pretty much the same image quality, albeit at different scales. The fact that I could switch my A90 to any resolution was a boon while working in the games biz, because I could adjust my monitor to fit whatever was best for any game while still preserving the detail and clarity of whatever documents I was working on.

While imagery is and always has been the lusty focus of monitor reviews, there is almost nothing more difficult to clearly render using pixels of light than the sharply delineated, high-contrast symbols we call text. Because LCD/LED monitors have a native resolution, attempting to scale text (or anything else) introduces another problem:

While CRT monitors can usually display images at various resolutions, an LCD monitor has to rely on interpolation (scaling of the image), which causes a loss of image quality. An LCD has to scale up a smaller image to fit into the area of the native resolution. This is the same principle as taking a smaller image in an image editing program and enlarging it; the smaller image loses its sharpness when it is expanded.

The key word there is interpolation. If you run your LCD/LED at anything other than its native resolution what you see on your screen will almost inevitably be less sharp. While that may not matter when you’re watching a DVD or playing a game, interpolating text is one of the more difficult things to do well. Particularly in early flat panels the degradation from interpolation was considerable, making anything other than the native resolution ill-suited for word processing.  [ Read more ]

A week or so ago I was bashing away at my keyboard when I suddenly began producing g’s that looked like this — ‘g — and h’s that looked like this: -h. Having spent a fair amount of time working with computers I knew there were various reasons why my keyboard might suddenly become possessed, none of them even remotely exciting. Because those multi-character glitches were crippling my ability to type, however, I quickly set about diagnosing the cause.

Occasionally, when my mind is firing faster than my fingers can move, I’ll accidentally enter a key combination that performs some automated feat I did not intend to perform. Worse, because I don’t know which keys I hit in which order, I won’t know if some preexisting configuration was altered that will trip me up later. If I’m lucky the result will be something obvious, as happens from time to time with Google Mail, which seems to delight in auto-sending messages before I’m through with them. And of course there’s the perpetually irritating StickyKeys feature, which, as far as I know, exists only to remind me that my left pinky is loitering on the shift key while I’m thinking about what I want to type.

Because there are so many default key combinations that come with any word processing software, to say nothing of the keyboard software itself, and because it’s possible to invoke such macros by accident — including changing the output of specific keys — my first diagnostic act was to uninstall both Intellitype and the keyboard driver to see if that solved the problem. Which it did not.

My next concern — which grew rapidly — was that the errant behavior I was seeing was the result of a virus or malware. After running scans for both, however, my machine was deemed clean, which meant, almost certainly, that I was having a hardware problem.

My keyboard of choice is the Microsoft Natural Ergonomic Keyboard 4000 (MNEK4K), which also has, I believe, the longest name in the history of keyboards. The model flaking out on my desk was the most recent incarnation of the same split-board device I had been using for close to twenty years, since just after the MNEK4K debuted. It was at least six or seven years old, had seen regular use almost daily over that time, and given how loose and clicky the keys had become I wasn’t particularly surprised that it might have reached the end of its useful life. (Conservatively, total key presses on that board easily topped ten million, with the bulk taking placing on the most-used letter keys. Speaking of which, years ago the A, S, D and arrow keys lost their labels due to repeated use, and the M key only displayed the upper-left corner of that letter.)

As with any keyboard, from time to time a key had gotten stuck, so that was my first thought in terms of mechanical failures. Close inspection turned up nothing obvious, however, so my next idea was that six or seven years worth of wayward hairs, lint and food debris might be causing trouble I could not see. And that meant I would have to open up the board.

Now, if you’re not used to taking things apart, the idea of opening up a keyboard may seem fraught with risk. Fortunately, I had two things going for me. First, I’ve taken a lot of things apart over the years, from computer tech to automobile engines, so I have some familiarity with the procedures and practices involved. Second, my keyboard had been out of warranty for years, meaning I could hardly make things worse. If I didn’t open it up I would have to by a new one, and if I broke it by opening it I would have to buy a new one, so there was literally nothing to lose other than time and a little DIY dignity.  [ Read more ]

Speaking of graphics software, by pure chance recently I ran across the obvious and thus embarrassing solution to a problem that has vexed me for quite some time. Not only have I wrestled with this conceptual beast on multiple occasions — and lost, even after spending hours using imprecise or generic keywords, thus inevitably drowning in the sea of noise that is rapidly rendering search itself almost useless — but I’ve known for several years that I would have to slay said beast in order to design a graphic for a book I was working on.

Thankfully, said book has proceeded at a snail’s pace, giving the world time to help me despite my obliviousness. (That I came upon the answer by mere happenstance is disheartening given the implications for other aspects of my future, but still — I’ll take it.)

The problem arises when trying to show a single text color across a full background gradient. While it’s likely in practice that such a problem would occur on a page featuring many words, here’s an example using a single word in black text against a full gradient from white to black:

As you can see, on the right side the black text is swallowed by the black background. Just as obviously, switching to white text only shifts the instigation of the problem:

The temptation on a page with many spread-out words would be to switch text colors midway through the gradient, but at best that’s a hack. The simple and elegant fix — which it pains me I was unable to arrive at on my own — is to add a contrasting border around the text:

And here’s the same solution for white text, using a black outline:

If completely bounding your text seems heavy-handed, here’s a slightly offset version that is still readable but also conveys a sense of mood:

The solution also works for two colors, assuming sufficient contrast:

As to how to implement such changes in most graphics programs, the simplest workflow seems to be duplicating the text, changing the color in the copy, then slightly expanding or shrinking one copy until the two can be arranged one on top of the other, thus revealing a consistent border. In Inkscape, however, because all text can be either stroke or fill, you can simply change the fill to one color and stroke to another.

If you’re a total beginner, here’s a GIMP video and one for Inkscape. If you have a little experience with GIMP, here’s a shorter video.

(Note: the current version of Inkscape is 0.91. Prior to version 0.91 the previous stable release was 0.48.5 in July of 2014. Inkscape version history here.)

— Mark Barrett