Never "Just Fonts" – Don’t Pirate Them!

I’ll never forget the first time type on a computer screen made me sit up and take notice. It was 1991, and I was working in Edinburgh, Scotland, where we had set up the European subsidiary of Aldus Corporation, whose PageMaker desktop publishing package had established a whole new market and turned the traditional printing industry on its head.

For us at Aldus, fonts were about printing, since that was the final output of our software. Screen fonts were pretty crude, and really only meant to give an impression of the final output so you could do layout work on the screen before proofing pages on a laser printer and then perhaps sending them to a high-resolution imagesetter for final quality output.

Then one day I installed a new piece of software on my PC. The fonts on screen were stunningly readable by comparison with what I was used to – so much so, that I called over the boss of the company and pointed out how much better these PC fonts looked on screen than anything I’d ever seen before on a Macintosh.

The new software I’d installed was Windows 3.1 – the first version of Windows to ship with TrueType. The fonts were Times New Roman, Arial and Courier New – the new operating system’s core fonts.

TrueType was Apple’s creation, of course. But Microsoft had licenced it and put a lot of resource and some of its best engineers on integrating it into Windows and creating a new set of core fonts, working in collaboration with Monotype, one of the oldest and most-respected font houses in the world.

Central to the creation of great onscreen versions of those fonts was the fact that TrueType had its own programming language, very powerful but not much friendlier than assembler.

I get mad when anyone says computer type is “just fonts”, or when they think that fonts are basically just graphical characters mapped to the keyboard.

In the past, fonts all originated in the print world. That was what they were designed for – a world of high resolution. To make a font for a computer, you design the shapes (there’s a huge amount of skill required and rules to be followed). These are then turned into outlines, which are simply mathematical equations which describe the bounding lines of the shapes. PostScript’s bezier curves or TrueType quadratic b-splines are both systems for doing this. The lines begin and end at “control points”.

To create a printed font, you have to rasterize it, or fill the outline with dots. That’s an easy task when you’re rasterizing for print, where you have at minimum 300 dots per inch and perhaps up to 2500 in high-resolution imagesetters.

The real problem arises when you try to rasterize it for the screen, because the screen pixels (the dots) are in many cases larger than the features you’re trying to fill. It’s especially complicated because humans need (not want, need) to read type which is between 9 and 13 points high. This dimension is dictated by the size of the foveal area in the retina of the human eye, which is only 0.2mm in diameter, with about 1.5 degrees of visual arc.

Down at those sizes, at screen resolutions which in the 1990s were around 72 dots per inch and are still today in most cases less than 120, the problems of rasterizing characters are immense. How do you decide, when a pixel falls partly inside and partly outside the outline, whether that pixel should be filled with a dot or left blank? If the wrong pixel is turned on, it may create a weird “bump” in a character and make it hard to read. If the wrong one’s turned off, then you get a gap (technically called a dropout)

Then there are rounding errors. A good example is the letter “m”. When you place the virtual “rasterizer grid” over it, you have to decide programmatically which pixels to turn on to make the stems or uprights. But since you can’t use fractions of a pixel (or couldn’t, before ClearType), you have to mathematically round up or down to the nearest integer. In most cases, at reading sizes, that means stems which are either one or two pixels wide. But some stems might round down to one pixel, some round up to two, and the result is an “m” which looks horrible.

Droputs and rounding errors

For a fuller description of The Raster Tragedy, with illustrations, see the article of the same name at:

http://www.microsoft.com/typography/tools/trtalr.aspx

The process used to correct all of the rasterization problems is called “font hinting”, which means providing “hints” to the rasterizer as to what to do in specific problem situations. There are hints which are global in a font, such as always keeping all stems the same width and allowing them to go from one pixel to two only once the type is being scaled to a size where they can all change. There are hints which are specific, for example, a set of rasterizer instructions which amount to”at 10point on a 100ppi screen, turn on this specific pixel in the lower-case letter ‘a””.

It’s an incredibly detailed and time-consuming process getting all this right across the hundreds of characters in a typical font. Even in those early days of the Windows 3.1 core fonts (when font hinting was a very new science, and rather “brute force” compared to today’s more subtle – but more complex – methods) each of those core fonts shipped with around 25,000 lines of programming code inside it.

The people who do it require both the skilled eye of the artist and typographer, and the programming ability of the software engineer. And the process requires lots of other layers of complexity; for instance, making sure all the table data in the font is accurate, that Unicode is properly supported, etc etc etc.

This article has only skimmed the surface. Books have been written about this subject, including a five-volume set by mathematician and programmer Donald Knuth.

A great place to find lots of resource, tutorials, tools, SDKs etc to let you understand this arcane world – and who knows, maybe even enter it yourself – is the Microsoft Typography website at:

www.microsoft.com/typography

There’s a handful of people in this world who can do this work really well.

In 1994, one of those strange – and for me, really fortunate – coincidences happened in my life. I was still working for Aldus in Edinburgh, Scotland right at the time Aldus was being taken over by Adobe.

I went into my office one morning and found three voicemails, all the same. “This is Microsoft Corporation in Redmond, Washington. We have a job we think you should be doing. Can you give us a call?”

The job was running the group which had been responsible for that great work in Windows 3.1.

After the strenuous interview procedure, I was offered the job.

Of course I took it.

Advertisements

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s