Sketching Out of My Comfort Zone: A Type Design Experiment

For nearly three months last year, I drew some type every day. My “Daily Typesketch” was an experiment — in drawing, discipline, public practice, and in getting less fearful of process and paper.

Let me say this first: I know there are many designers who draw more and better than I; who have sketchbooks filled with lovely letters and exciting experiments. My hat is off to them, because I’m not like that. I’ve always thought of myself primarily as a digital designer — computers are my playgrounds, while paper usually instills in me a vague sense of dread (or at least, inconvenience). So it felt like quite an experiment last year when I committed to drawing some type every single day, on paper, and posting a photo of the sketch to a dedicated Flickr set.

I had been getting a bit frustrated in the months after finishing my first typeface, FF Ernestine. Over the course of three years, I had learned to draw type by making that typeface, and now every letter I drew still looked like it wanted to be part of that same family. I longed to diversify, but wasn’t sure how.

Process, Paper, Patience

At TYPO Berlin a year ago, I participated in Erik van Blokland and Paul van der Laan’s wildly popular TypeCooker critique session. I had known TypeCooker before — Erik’s “tool for generating type-drawing exercises”, which, in a manner of speaking, offers guided walks out of one’s type-drawing comfort zone. Pick a type of exercise and a level of difficulty, and the site generates a random combination of parameters, a “recipe” to follow. My TYPO submission was a narrow, tall, contrasted sans that was reasonably hard to draw, and I sweated over it for the better part of a week-end until I deemed it nice enough to show. “This is a very pretty sketch” was the verdict, “but where is the process?”

Craft is messy and dirty. Facing this is unsettling for a generation of designers raised with the shiny precision of computers.

That was when I realized I wanted (and needed) to get deeper into practice, into the process. Indeed process, like craft, seems fairly obvious to honor in theory and principle, but harder to embrace in practice. In-progress work is uncomfortable, it shows more open questions than answers; and “uncertainty”, as Paul Soulellis wrote in The Manual, “runs counter to how we’re trained to articulate our design values. We’re taught to express clearly and certainly”, but in-progress work is usually not clear yet, craft is messy and dirty, and sometimes you hit a dead end. Facing this is unsettling — maybe especially so for a generation of designers raised with the shiny precision of computers. We love that precision, even if deep down we know that it’s often a lie. The precise numbers of computers can make our work look like we’ve found answers when really all we have are questions, and the only truth we know is vague.

It is in this crucial point that paper is friendlier to the creative process than the screen: It supports (and renders) vagueness, sketchiness, better than computers do.

Type Cooker creator Erik van Blokland demonstrates the type sketching method passed down from Gerrit Noordzij and taught in the Type and Media program at The Hague.

Embracing the famed “inside out” drawing technique was a key to the whole exercise. The basic idea of starting with fuzzy shapes and gradually “bringing them into focus”, making the shapes cleaner as the ideas get clearer, is tremendously helpful (and can, I think, be applied to all kinds of shapes, beyond the classic application echoing the strokes of broad-nibbed or pointed pens). Thus one gradually progresses from general proportions to details. This is likely the correct hierarchy of decision making — first fixing what is most relevant and visible in type, even at text sizes (proportion, weight, contrast, the rhythm of black and white), before getting hooked on little details.

I am better at details than the “big picture” – better at refining than defining.

This was an exercise in patience, too. I am better at details than the conceptual “big picture”, better at refining than defining, and the computer makes it a little too easy to jump right into the details, with which you fiddle around forever until you realize something big is off anyway. (I’ve lost count of the times I had to redraw all the curves in Ernestine because I decided the x-height wasn’t right yet after all.)

Letting Loose

So I started drawing, and I drew every day. Most of the sketches were based on TypeCooker, which made me draw things I wouldn’t usually draw, or even think of as good ideas. It asked for wide seriffed faces and compressed sans serifs, but also such strange things as a monospaced upright italic for TV subtitles, a wide light monoline serif with swashes but no ascenders, or a grunge monospaced Helvetica as drawn by Gerard Unger. (Making sense of these turned out to be interesting.) I drew with an x-height of 4cm on an 11×14 inch pad of transparent marker paper, tracing over the drawings in multiple steps when necessary. Typically I’d do 5–10 letters, a variable basic set that could form the basis for a typeface design (for lowercase this was typically an ‘o’ or maybe ‘e’, at least one arch, something with an ascender, something with a descender, one bowl-and-stick letter, and of course some diagonals and special favorites like ‘a’, ‘s’, or ‘g’). Usually I first made a quick, rough pencil sketch of the approximate structures and proportions, then started working with a pen as soon as I dared, sketching rough proportions and areas before filling in outlines and details. (I never quite lost my urge to add outlines prematurely, but doing this too soon invariably derailed the sketch.)

The best parts of daily sketching: slowly sensing better where black needs to go, and understanding I can build outwards from that fuzzy vision.

The learning curve was noticeable. A good month into the experiment, I tweeted: “Best parts of #dailysketching: Slowly sensing better where black needs to go; & understanding I can build outwards from that fuzzy vision.” It still took courage to lay down ink; applying a dab of slow-drying Tipp-Ex is not the same as hitting Cmd-Z, and having to cut up a drawing to get the spacing right does not feel the same as adjusting sidebearings on screen, where space is elastic and erasure leaves no marks. But my fearfulness of the physical process was evolving into thoughtfulness, my dread into respect.

I learned to think about type in new ways, practiced looking at it differently. I squinted, “unfocused” my eyes, and used a reduction glass. I learned to see the space between the letters as an inherent part of the design. I tried lots of different pens and attempted (mostly in vain) to trim the Tipp-Ex brush just the right way. And I began to feel more free to take on new ideas and try them out on paper without over-thinking details right away. Six weeks into the experiment I was “letting loose on … things I’ve exactly never drawn before”, as I wrote happily in the caption to a funky, brushy, reverse-contrast script sort of thing that I wouldn’t have conceived of trying to draw before. I had finally stopped worrying so much, and I was making letters, every day. Letters that didn’t look like Ernestine. Letters that didn’t look like they were finished, or had to be.

Public Practice

The decision to make drawing practice a daily exercise was a trick to make me stick with it. Keeping it up was a challenge sometimes, but it also brought beautiful opportunities, like drawing together with friends I happened to be visiting. In a similar way, publishing the work online was intended to up the pressure and confirm my commitment, but I also hoped it could trigger discourse that might prove helpful to me and maybe also inspiring to others.

Sometimes polish is simply not the point.

Of course, if embracing sketchiness and vagueness on my desk was hard, sharing it publicly was really scary. But I felt I needed to overcome the anxiety of showing something that isn’t as “clean” and “finished” as can be — for sometimes polish is simply not the point. In contrast to other “daily” doses of impressively final-looking work (like Jessica Hische’s famed Daily Drop Cap), sketchiness and roughness are at the heart of my experiment. My sketches are snapshots from a process, stills from a learning curve.

The project ended about as spontaneously as it began. After almost three months of daily drawing, and quite a bit of welcome input and exchange, I went on a vacation with a barely functional internet connection and the desire to disconnect from my routine for a bit. I look back fondly. I’ve learned a lot: much about the myriad shapes that type can take; some sketches have spawned little digital typeface prototypes; and I got out of my deadlock and frustration. While there remains so much that I haven’t yet learned, there is this: It’s true that if you want to draw type, then go draw type. Every day, if you have to. Try doing it loosely, looking beyond your own preferences, and resisting the pressure of polish. You will find new answers — and, what is more, new questions too.

Robothon 2012, RoboHint, and the Gerrit Noordzij Prize


Most of the Robothon 2012 presentations were streamed live and archived online. This article, therefore, isn’t an event summary, since the conference’s main content is still watchable. Rather, this is an attempt to explain things one might miss as a virtual attendee.

What is Robothon?

Robothon is a font technology conference that takes place every three years at the Koninklijke Academie van Beeldende Kunsten (Royal Academy of Art) in The Hague, the same school that organizes the Type and Media masters degree course in typeface design. Type design education at KABK is particularly influenced by Gerrit Noordzij, the Dutch designer who taught at the school for decades. This year’s Robothon even included a short presentation about Noordzij and Type and Media, for those who might be unfamiliar with them. In recent years, the Academy has organized a Gerrit Noordzij Prize and, since 2006, Robothon conferences coincided with awarding the prize.

By just watching the conference videos, one misses Robothon’s laid-back feeling. The main activities only lasted for two days, and although the program started early each morning, presentations ended early, too. The schedule included several long breaks, giving attendees the opportunity to discuss the applications, ideas, and scripts presented during the lectures.

Organized by Erik van Blokland and Paul van der Laan, the lion’s share of Robothon work was undertaken by the current Type and Media class. These students dedicated about a month of their short (about ten months’) time at KABK to work on Robothon and the Gerrit Noordzij Prize festivities. This included the design of an exhibition and catalog to honor the previous prize winner, Wim Crouwel.

RoboHint

My favorite Robothon presentation was Petr van Blokland’s Building a TrueType Hinting Tool. It seems to me to be a general consensus, based on reactions in The Hague and online, that this was the highlight of the conference. Petr’s ideas also point directly at the kind of designer that Robothon is aimed at. For instance, during his talk, Petr asks the rhetorical question: why is auto-spacing considered not OK, but auto-hinting is? Why should a designer surrender the way work appears onscreen? Controlling the rendering of a typeface is a much better tactic than surrendering to a mechanism one did not create.

Robothon primarily speaks to an audience convinced that spacing and kerning are part of the design process. While there were attendees present that rely on services like iKern, the more popular solution is to tackle kerning oneself via class kerning in FontLab, Glyphs, or Metrics Machine. Writing scripts to speed up the process is a great timesaver; but relying on an “auto” tool is a step too far.

Since 2009, with the broader adoption of webfonts, TrueType hinting has risen in our parlance. More graphic designers, type designers, and web designers talk about it now than ever before. Unfortunately, most industry discussion of hinting seems to take one of three paths at the moment. The font maker may:

  1. develop one’s own TrueType hints in FontLab, or in Microsoft’s VTT application. While some font developers see these as the ideal solutions, many designers claim to not have the resources or knowledge to undertake this step for themselves.
  2. make use of an auto hinting tool. These tools generally take a TTF file, analyze its settings, generate hints, and write these into the font. Auto-hinting tools may be part of a font development application, or be a proprietary resource of a single company, or take another form, such as ttfautohint or the FontSquirrel web font generator. Depending on the amount of preparation, as well as the quality of the “auto” programming, widely varied results may be achieved.
  3. choose to not hint one’s fonts at all. Here, one either hopes for the best, or is certain that the font will be used only (or primarily) in an environment or a size where hinting isn’t necessary. Certainly, things seem to get a little better on this front, if one considers improvements in rendering like the Retina display iPad, DirectWrite in Windows 8, or MacOS ignoring TT hints by default.

All of these solutions present a problem — one that Petr wants to solve. In these scenarios, TT hints are applied via a process that typically begins after the design of a typeface is finished. Except for TT hints added to FontLab’s VFB files, these hints are instructions that are written into final TTF files, not into design source files. TrueType hints are attached to points on TrueType outlines; if one edits a glyph’s design further in a font editor, one will lose the hints. This is bad.

Microsoft’s VTT — the current heavy-hitter among hinting tools — uses a vocabulary that is separate from what a designer uses while drawing glyphs in a font editor. While RoboHint has not yet been released, it seems from Petr’s presentation that the still-in-progress application (or RoboFont add-on) will allow you to add hints to source files in a way that is more malleable; your application should convert what you do into the hinting instruction language. This conversion should take place in the background. Should one make changes to the glyph later, the application should re-hint the glyph on the fly. You still have to define hints yourself, of course, but your font editor should understand what they are, and be able to adapt them to reflect your changes to glyph outlines. This would make hinting part of the design process, rather than a production step. Fonts could be TT-hinted from the design of the very first glyph onward.

If you care about the way that your typeface rasterizes, it should be important to you to determine how hints are placed. This kind of application-sensitive decision-making should be the same as every other decision, like what your stem thicknesses are in the first place, or how wide your letters should be, how much contrast they should have, and how much space comes between each pair of letters.

UFO Recap

At the beginning of the Robothon conference, Tal Leming was proclaimed “Benevolent Dictator of the UFO for life”. You can see this at the end of Erik van Blokland’s “the State of RoboFab” presentation. This article is a good opportunity to touch on the UFO format again: UFO — and the RoboFab Python library, another Tal and Erik collaboration — were the foundation for most of the ideas presented during Robothon. It is difficult to imagine font development today without their work.

What will one do with a library of VFB files if something were to happen to FontLab Studio? What happens to all digital data as technology and software move on? Sure, font files exported from FontLab — TTFs and OTFs, etc — should be openable by future font drawing applications, just like files from older apps are. However, your native work files may not be readable by future programs, as FontLab Studio’s VFB-format is proprietary, and currently only supported by FontLab products. This could mean having to accept the loss of outlines you saved in other layers, not to mention placed images, or guidelines. What if one wants to be able to access these in 10–20 years? If you are part of a company with a library of dozens, or thousands, of fonts to manage, you may need to be able to reopen older projects in years to come. Surely OpenType and webfonts won’t be the last format shifts for which legacy typefaces will need to be converted.

The UFO format tries to solve this problem. Tal discusses the evolution of UFO in his presentation on the recently published UFO3 format. The format stores your font in a human-readable manner, rather than in binary code. Already, FontLab Studio supports UFOs with the help of the RoboFab script libraries. But, because they are not native to FontLab, users have to actively install these tools themselves. Glyphs has UFO support built into the application. With RoboFont, work files are UFO files.

Although the UFO format was first introduced in 2004, I first began to take serious notice of it in 2009, at the previous Robothon conference. All of the presentations from Robothon 2009 may be downloaded as video podcasts from iTunes. While I had already used a small bit of the UFO-based applications Metrics Machine and Superpolator, seeing presentations on Tal’s Area 51 and ufo2fdk resources, as well as apps like RoundingUFO from Frederik Berlaen, finally woke me up. Using the UFO format opens up a whole new ecosystem of font development possibilities. Already at that conference there was talk of the “missing UFO font editor” — whoever would program this would enable an entire circuit of design and PostScript-based OTF font production on OS X, bypassing FontLab Studio altogether (Glyphs had not yet been publicly released). That “missing UFO font editor” came to market in 2011: RoboFont.

Don’t Stop Here

As I come to a close, I’m already worried about having cherry-picked my way through the conference. My best advice to readers is to work your way through the online Robothon 2012 talks on your own. If Robothon 2009’s media is any guide, these will probably stay online for quite some time. Several of the videos are good references to return to later, if you are looking for a specific way to bring scripting into your workflow, or if you want to work with a specific tool, like Superpolator or Speedpunk (video not yet available). The PostScript hinting information presented by Miguel Sousa is always relevant to font production, whether it is just to get your designs looking right onscreen in PDFs or Adobe Applications, or to use as a step on the way to auto TrueType hinting. Finally, for those considering whether or not to switch from FontLab to Glyphs, there is a 50-minute Glyphs demo that you can check out, too.

The Gerrit Noordzij Prize 2012

Gerrit Noordzij Prize winners receive their exhibitions at the end of their three-year tenures. This year, the prize was passed on from Wim Crouwel to Karel Martens, the renowned Dutch book designer. Previous winners include Tobias Frere-Jones, Erik Spiekermann, Fred Smeijers, and Gerrit Noordzij himself. The award ceremony took place immediately following the end of Robothon’s second day of program. On the day afterward, the Gerrit Noordzij Prize festivities went on to include an afternoon lecture series of its own, whose speakers included Jost Hochuli. Jost traveled all the way from St. Gallen, Switzerland to rock the house with his lecture on the roots of Swiss Typography, which he read in perfect English.

Photos by Tânia Raposo. More on her Flickr »