Finding Fonts – A Guide

0. Introduction

What typeface should I use?

I’ve lost track of how many times I get this asked. Probably twice a week, maybe more. Even in projects where I work as a consultant, this question is usually the first step — even with amazingly skilled graphic designers. Heck, when Michael Paul Young asked me to collaborate at YWFT‘s blog, this was the subject.

Whether a simple desire for novelty, a frustration of what they’re using is just not quite right or a total lack of sense of direction, this always, always gets asked. And it’s not out of inexperience or incapacity (you can relax, now): there’s a wide offer of typefaces, nowadays, as well as a high demand of visual singularity and novelty, where typography is in a all-time spotlight.

Sure, there’s more pressure, these days. Massimo Vignelli’s idea that you can get around with just five or so typefaces to all your projects is a very dated one — from a time where the offer wasn’t wide, either in quantity as in quality. I’d say it’s intellectually lazy, coming from a Modernist hegemonic standpoint. Still, this idea had its era.

But, at the same time, there are solutions. It was never this easy to find new typefaces, and font production technology has significantly improved since digital type’s dawn. Also, media have improved significantly, where resolution is becoming less of a problem, books are in their golden era (quality wise, I’m not talking about economics), what we can now do with the web is less and less archaic and the list goes on.

For the reasons above (and because the overwhelming majority of people in the mailinglist asked me to), I’ve decided to put up this little guide on how to find the typeface your looking for. Alright, let’s get this going.

1. Why Are You Concerned About It?

Wait, what? Come on, Fábio! After that introduction? Yeah. I mean, why are you really concerned about it? Font selection is mostly a decision-making process and, for that, you need specific problems.

So, this is usually my first question, or something along these lines. And I like to start here, because I want to know at what level people are feeling stuck. The replies go from I don’t know where to look to this one sort of works, I just don’t like the terminals. As you can imagine, the approaches to these two differ wildly.

But the most usual reason, from my experience, is that people have no idea about what to do, no research was done. They have no idea about how the project will look and feel. Or they’re just emotionally overwhelmed, daydreaming about and epiphany that will spare them from the lengthy process of finding the right typeface.

As a summary, ask yourself why: it’ll tell you what to tackle first and, most likely, the very core of your project needs.

2. Know Your Brief

A graphic composition is a sum of graphic components who mutually influence eachother. And this is highly quotable. Probably it was Einstein who said it.

As such, I think that it’s not relevant whether you start, you have to start somewhere. Still, having a good brief, one that gives you direction and keeps you from derailing, is paramount.

This brief should also help you a big deal when it comes to chosing a typeface (or more) for your project: it’ll give you your target market, the overall vibe of the project, the project goals, the current problems to solve, the scope of the applications and so on. You know the drill.

But having this beforehand — and I can’t stress this enough — is mandatory. Not that someone who is consulting for you as a type expert won’t help you to get, but this person won’t do it magically: if you don’t ask yourself these questions, someone will: or the project is set to fail, big time.

Hence, the more problems you have, the more constraints you have, the better. Seriously. This will help you tremendously down the road, when it comes to do binary decisions.

3. What Kind Of Vibe Are You Looking For?

This is probably the first question, after having your brief. Skip the latter and, all of a sudden, you’re elaborating it: I mean, you can’t really skip the brief; one way or another, you’ll have to do it, or redo it.

The whole process of typeface selection involves a lot of guessing, so we want to make it as educated as we possibly can. So when you ask yourself this question, it should be somewhat obvious. And what I mean by obvious isn’t something as a 16th century Dutch with baroque italics (although it’s as valid as anything else, since everybody thinks differently), but more of an emotional tone.

What we want here is to start broad and funnel down to as little options we can. But at this stage, the feeling we want people to have while reading already chops a sea of typefaces in more than half.

Think of typefaces as a subtle visual cue that should act as an emotional reinforcement to the trance-like state that happens while reading.

I mean, the experience of reading, lengthy or brief, is some sort of assisted hallucination, where we internally emulate the discourse someone wrote. So, as a hypnotist of sorts, we want to associate that experience with a set of emotions, and we do this by the visual choices we do, not just with type.

So, if we’re aiming for something that feels serious, professional, respectful and trustworthy, we’re not choosing Comic Sans, are we? (And no, Internet, I don’t hate Comic Sans. It’s beautifully made.)

4. A Needle In A Haystack

How do we find a needle in a haystack? With a fucking big magnet.

Now that you have your set of feelings and emotions (I know how it sounds, thank you), you probably have some idea on how to translate these visually. This is where your research stage kicks in.

Diogo, a graphic designer friend, has an hilarious expression for when, in a project, one has too many options and is trying to figure out what to decide: swimming in mayonaise. I’ll spare you the physics of trying to swim in a non-Newtonian fluid, but you get the idea.

There are a lot of options. And this is good, although it can feel overwhelming. So, try to amass potential candidates, leaving out what doesn’t fit the tone of the project (even if you really like that new typeface).

Start with a big chunk of typefaces. And then, exclude, exclude, exclude. This initial stage consists in leaving out the ones that, at first glance, the ones that do not serve your project’s vibe.

But how do you know what kind of typeface serves certain vibes? Well, tough question, tough answers. You’ll have to trust and train your gut: the more experience you have, the more sensitive to subtleties your intuition is. Not the most charming and life-changing answer, but hey, it’s the truth and it works.

Still, you don’t have to be a ultra-geek of type anatomy. Some knowledge helps, sure, since those little feet refering to serifs might not be a tag in a font search engine; but being fairly educated in type classification will help you a lot. Go to a font retailer and check how foundries have tagged their typefaces. Chances are, most of them have highly subjective/emotional tags, hence the whole vibe talk above.

But the most important thing is to have an idea of what you want, and let that guide you.

5. Survival Of The Fittest – The Process, Tech & Paper Shredders

In practical terms, here’s the process: you get your brief, set your tone, have an idea of what you want and you start looking for it. You get a fuck ton of options, and you start reducing that amount by quick elemination. So, let’s say you end up with 20 candidates (this seems like the mid-range scenario, to me); so, what’s next?

Testing, my dear friend, testing.

Print them all (or make digital mockups if it’s for screen, or anything else that is closer to your final medium), see if they fit with the rest of your visual elements, see if they perform on the size you want (assuming that you know that type isn’t drawn the same way for every size). If not, toss them out of the list, thus reducing it.

Over time, the more you have worked with typefaces, stress-testing them constantly, the more you’ll have a sophisticated hunch of what works or not. For me, while interacting with Graphic Designers and Art Directors, this is the biggest tell on how experienced they are: they say stuff like something close to Arnhem, but with a bigger x-height, a bit wider and teardrop terminals instead a fancy, classic but contemporary serif for small sizes.

The mindset to adopt while excluding cases is to be over-critical. And that’s why good designers fail to have a lot of matches on Tinder. With this said, exclude options at the slightest doubt: you can always get back to them, and it makes choosing manageable. When it looks good and feels good, well, it’s good.

So, the only way to do this fast is not to skip it. In time, you’ll be faster; once your visual type culture and experience has expanded.

6. Where’s the Haystack?

Right. The amount of channels in the industry is growing exponentially: more and more foundries are offering typefaces outside of resellers, if not stepping away from them completely.

So, yes, you’ll have to widen the number of channels where you search for typefaces, and you’ll also have to curate them.

Resellers are still an excellent way to search for fonts (with some more picky on the quality of typefaces they sell than others), since they have a huge database of stuff and decent searching tools.

In addition to this, be sure to follow some typedesigners and/or foundries who’s work you admire. Especially when it comes to pairing typefaces: it’s common for foundries to release typefaces that work well together, as well as, due to personal style, there’s usually something familiar between type families.

7. Font Pairing 101

Since we’re on it, we should talk a bit about font pairing.

The Internet is crowded with decent articles on this, so I’ll concentrating on the stuff you shouldn’t be paying attention. Maybe in another article, perhaps?

For starters, forget about pairing lists, especially if they don’t tell you why two given typefaces work together. These will keep you ignorant and won’t help you next time you have to solve a similar problem.

With this, I’m not saying these are useless. Typewolf‘s collection, for example, is absolutely stellar, and it’s database of pairings is enourmous. Still, it doesn’t pretend to give you suggestions nor “definitive pairings”: it simply shows you want people are selecting, in a very tasteful curation; if you want to expand your visual culture in type pairing, go there. Seriously.

Font pairing usually deals with factors as style contrast or similarity, vertical proportions (not vertical metrics, since you can adjust those), texture’s colour, construction and so on. The best advice I can give for now (since this subject deserves a separate article) is go and read about how type designers make superfamilies, while also checking for patterns with font pairings.

8. Wrapping Up

I hope you found something useful in this article. Again, this is my view on the selection process, and there’s room for a lot of funk when it comes to this.

Hence, I’d like to encourage you to try stuff out and see what resonates with you, without being accritical. If you want to be good at this, learn as much as you can about type, while putting ideas to test.

For more articles, new releases and random stuff about type, be sure to subscribe in the form below, or follow me on Facebook, Twitter or Instagram. Happy stalking!

The Art Of Eyeballing – Part V: Stroke (Modulation: Introduction)

Part I: Introduction | Part II: Learning To See | Part III: Overshooting | Part IV: The Stroke (Optics)

0. Introduction

Welcome back!

I’ve been rewriting this article for ages now, so I’m glad to finally share this with you!

Today we’re going through a subject that it’s apparently simple, but the degree of complexity and abstraction can escalate pretty quickly, so I’ll be dividing this article in four sections: Introduction, Translation, Expansion and Scatter.

So this first part deals with the basic concepts that we need to understand this matter thoroughly; some structural, some a bit more abstract.

Scared? Great: it means that this will be easier than what you’re thinking. Let’s get this started!

1. Modulation

So, what the heck is modulation? Let me try to give one of my famously cryptic definitions:

In type, modulation is the register of a given tool on a given surface, through a given gesture, or the emulation of this.

Dude, you should write poetry. Yeah, I know.

In the human-friendly version, when you draw a letter with – let’s say – a ball-point pen, you make a certain gesture with your hand that, on a piece of paper, makes the pen release ink and produce a certain shape. Obvious stuff.

Now, let’s say you use a pointed brush instead of a pen. Depending on the pressure, angle and surface (imagine doing this on wood, for example), even if you make the exact same gesture, the shape produced will be different: there will be thicks and thins, rough edges and so on.

Or, if you’re drawing in a digital environment, you’ll be emulating this result.

So, modulation is the way a tool creates variation in a stroke, whether analogue (via calligraphy) or emulated (via lettering or type design). Or the variation of the stroke itself.

2. Gesture and Ductus

I guess I don’t have to explain what gesture is, since it’s not a matter of type-specific jargon. But when you do a gesture, it follows a path. To this path, we call it ductus.

The ductus is the skeleton of a letter. Although an abstraction, think of it as the path from where the stroke expands, or as the path of a writing tool.

Some definitions will tell you that you can get to the ductus by a reduction of the stroke towards the middle of the letter, but this is an imprecision: this might work in the case of translation (as you’ll see later on), but in most situations, especially when it comes to drawing glyphs by outlining them, the modulation around the ductus is assymetric.

3. Velocity, Pressure, Angle and Rotation

Especially in the translation model, angle is commonly treated as being fixed. This means that the writing tool (i.e. broad-nib pen) will be held at a certain angle and this won’t change while it propagates through the ductus. Still, every calligrapher knows that “rule” is just for comprehension sake; in fact, the angle can change a lot, even with a broad-nib pen.

How the angle of the tool changes in the gesture is vital to understand velocity and rotation: rotation is the variation of the tool’s angle, while velocity is the speed of which this rotation happens.

As you can see above, these factors have a huge impact on the shape of the stroke.

Finally, let’s consider pressure. Though we can almost ignore pressure in the case of translation and/or pushy people, it plays a big deal in the expansion and scatter models.

This item on our list will be explored further in the series (pretty much as any of the others), but here’s a simple explanation: the force exerted by the writing tool against the surface may influence the stroke. Take a pointed brush or nib, for example: as further pressure is applied, the stroke expands accordingly.

4.  Some considerations

Before we move on, there’s a couple of things that I’d like you to keep in mind.

First of all, if you’re still a bit confused, things will become more obvious in the next articles, where you’ll see these concepts in action. So pat yourself on the back and plow through.

Second, you don’t have to become and expert calligrapher in order to produce good lettering or type designs. In fact, you don’t have to do calligraphy at all, although it wouldn’t hurt. The goal here is to understand where letterforms come from and to know how writing tools work, so you can analyse form in a more knowledgeable way, developing your sensibility.

Third, purely emulating these concepts and processes won’t produce satisfactory end results. There’s a lot more to do on top of this, such as optical corrections, curve quality, formal consistency and such. Still, knowing this will, for sure, aid you in achieving better end results.

Fourth, read Gerrit Noordzij‘s The Stroke. Really, get it and read it: it’s a fascinating read.

5. Wrapping up

I hope you’ve enjoyed this article, since you’re at the doorstep of some very interesting stuff: we’re going to put these concepts to work in the next few articles, so subscribe below to get notified and see you in the next chapters!

Making Grafista

1. Concept

Grafista is (semi-)monospaced typeface that has two sets: a text typeface and a texture library.

The reason why I called it semi-monospaced is because these two sets have different widths: the text set’s width is half of the textures’ one, making it possible to combine both in the same text box.

The idea behind Grafista was to “challenge” the standard notion of what a typeface is for: basically, a typeface is a collection of box and forms in those implicit boxes: not necessarily something to compose text with.

With this, I’m not claiming that this is something new: throughout history, numerous punchcutters and type designers have included texture or tile sets in their typefaces, whether for borders, pictograms, ornaments or any other non-letter elements.

At the same time, the format of a font makes a texture bank easily accessible through a glyphs panel or a OpenType feature, spanning through a wide variety of software or applications.

2. Genesis

Grafista is a reincarnation of a failed incarnation called Maoos.

The idea behind Maoos was to create a typeface that had the primary focus of being a texture bank, a library of pre-made graphic tiles that one could use to create images, not necessarily text.

But the reason why Maoos never got to see the light of day was that something was wrong. Sure, the tile part was working: the idea behind it was tested and it was working. The text part didn’t.

The letterforms were nice-ish; I mean, they were congruent as a whole, but these two parts (textures and text) were two separate things, with no connection what so ever.

So, I’ve tried several approaches to Maoos, trying to blend the letterforms with the textures: several line width, multi-layering sets where textures only lived in the counters, alternative glyphs; it was always a mess and adding layers of complexity to it wasn’t helping – it soon became one of those typefaces in the drawer (or in a backup disk, to go with the times).

Some years passed (I started tinkering with Maoos in 2013), Maoos had many problems: the letterforms weren’t neutral, comparing with the textures, so both sets would live in different realms; proportional forms would make side-by-side use with the tiles dodgy and to be avoidable at all costs; multi-layering sets is a production headache for the end user, among other small bits.

So, I ended up trying to cram way too many things in a single typeface, without realizing that beef and deodorant in the same package wasn’t a sensible deal.

A couple of months ago, while working in a monospaced typeface (news on that to be announced), it hit me: if I could do something fairly neutral, sturdy and monospaced, it might work with the textures. And it did: Grafista was born.

3. A typeface with letters

Monospaced typefaces have a mechanical vibe to them. Even the typewriter ones, with all their nostalgia, still feel technical, due to the fixed width. They have an implicit and very obvious system that implies a mechanism, while most proportional typefaces try to fight the technical nature of the composing system in order to achieve reading comfort.

Sure, readability and legibility were considerations while drawing the roman, but they weren’t the main goal: the however you do it, it works motto was the main focus while developing Grafista; I wanted you to have the freedom of using it without the concerns of micro-adjusting your compositions.

On the formal side, the choice of borrowing traits from grotesque and coding typefaces were due to the simplicity of the tile elements: in Grafista, complexity comes from the add-up com combinations, not the tiles themselves. So, considering how simple the tiles are, as a single element, the letterforms should follow the same logic.

I wasn’t looking for a fit-for-everything text typeface, I wasn’t looking for solving a technical problem and I certainly wasn’t looking for nostalgia. However, I was certainly looking at the text part as something heavily graphic, where text and textures could be used at the same time, whether in single or multi-line compositions.

“A typeface is a beautiful collection of letters, not a collection of beautiful letters.” – Matthew Carter

Or, in this case, a beautiful collection of letters and forms.

4. Making tiles

Tiles should be, huh… tilable.

Maybe I’m biased in this: I’m Portuguese, a culture with a centuries-old obsession with tiles. Tiles are everywhere, in an impressive array of shapes, colors and applications. We’re probably as obsessed with tiles as we are with food: and our food is awesome.

In Grafista, every texture glyph is treated as a tile: you can seamlessly repeat each block vertically or horizontally. Or use it as some sort of pixel. Or pre-made graphic elements to play with. Or as a way to reach enlightenment, if that’s your sort of thing (e-mail me if it happens).

Still (and it sort of comes without saying), you can cannibalize the textures to your liking and treat them as pure graphical elements.

5. Wrapping Up

Grafista is now out! Grab your copy and contact me to show me what you’ve done with it!

I hope you’ve enjoyed knowing a bit more on how Grafista came to be! See you in the next article!

5 Typography Tips, From a Type Designer’s Point of View

It’s been some time!

To take some time off the oh-so-many huge projects in the making and craft something for you that’s worth your while, today we’ll be talking about some typography tricks that I find helpful and that I haven’t seen anywhere or that I’ve found the information available unsatisfying.

Another plus for you, some of these came out of designing type, i.e., out of looking constantly at type at a micro level.

So, while I’m satisfying my inner megalomaniac, here’s a small post of some things I’ve learned along the way.

1. Contrast Too High?

This one has a story.

While I was waiting for a meeting at We Came From Space, my curiosity won me over and I had a peek at what Joana Sobral, from one of the studios there, Non-Verbal Club, was doing. She was designing a newspaper and was having trouble with the body typeface.

The typeface was Hercules, set in a very small point. The copy was gigantic, the line-spacing as tight as it could be and the thinner parts of the typeface would simply disappear under 8 points (the point size was 7.5 points).

A bit after I told her “that cut clearly wasn’t designed for such a small size”, it hit me: if a really thin stroke was added around the letterform (in that case, it was something like a 0.05 point stroke), it might do the trick. And it did, along with a slight increase in the tracking to compensate the x-axis growth.

You see, typefaces are designed for a specific size (or, at least, they should). When drawing for small sizes, one of the good practises is to decrease contrast. Other things should be also done, but we were looking for a quick and dirty solution on the spot.

The addition of such a thin outline wouldn’t compromise counters, it would just steal some white space (solvable with the loosening of tracking) and rescue those vanished thin lines.

2. x-Height and Weight (Pairing)

“When pairing typefaces, adjust the size to match the x-heights”.

This is a good advice, but incomplete: it does not consider weight. But let me explain this from another perspective:

The lighter the type, the taller it seems; so, bold cuts are designed a bit larger than their lighter counterparts, to compensate for that optical illusion. Have a look:

So, when pairing typefaces, we should do the same as above. As an example, here’s Minion Pro Regular paired with Futura Bold, first with the same exact x-height, and second with the correction:

3. When Possible, Tint Your Black

When I was starting out as a graphic designer, I had the privilege of working with a printing house composed of a handful of old guys. It was a very small print shop with a lot of old-school machines.

But the better part was the people. They had years and years of manual printing, lots of metal type blocks, a letterpress in the corner, a rusty inoperative Linotype in the backyard and a kind and patient heart to deal with my curiosity.

I’ve learned a big deal with them: they gave me free reign to test everything, while suggesting me small alterations to improve the works in hand.

One of the most precious teachings I got from them was to compensate the text colour with the paper colour, which one can easily extrapolate to other mediums.

3.1 Printing

The principle is simple: if you have a coldish background (paper colour), add a bit of a warm colour to your black. If the background is warmer, add a cold colour. Simple.

What it does is that it improves the silhouette of the letters, sharpening the text, by colour contrast.

Be aware that this only works with direct colour; do not use it by mixing multiple colours, use a dedicated spot color for this instead. So, if you’re printing in offset, only use one composite layer for this, or the overprint will make your text blurry.

3.2 The Screens

The same principal can be applied to screens. I never use pure white or pure black on a screen, and it has its perks:

• No White Burning, No Black Staining: I find the pure white/black combo quite aggressive on screens. When I worked in television, I had the opportunity to colour test a lot of television sets (from plasmas to CRTs, LEDs and the state-of-the-art OLEDs, back then), and one of the first things I did was to test how much they could handle the whites without burning, as well as how much black could you go before shutting the pixels completely.
• Better colour harmony: Using a bit of colour to something apparently monotone gives a more tactile, natural-like feel to the design.
• Sharpening of letters: Like in print, it improves the silhouette, adding clarity to the texture.
• Increased viewing angle: Specially in LED and OLED monitors, not burning the whites and keeping the blacks from staining increases the monitors viewing angle, when it comes to text.

4. Tracking and Size

Default values are not sacred.

I’ve read so many times do not use optical kerning! that is pointless to think that you use it. But the truth is: sometimes you have to (to get closer to a desirable result, you should not take it for face value).

Sure, type designers spend a lot of time around metrics and kerning, to the point of being the most usual complaint in our métier. But expecting to fire up a DTP software, pasting a text and choosing a typeface with no further adjustment is naïve.

Back on track: as we discussed in §1, typefaces are designed for a specific size. And apart from other formal considerations and adjustments, tracking and kerning is also size-specific.

If you’ve already read On Legibility – In Typography And Type Design, this isn’t new to you: if we consider a “medium” point size as our size reference, the bigger the size, the tighter the tracking. And as type size shrinks, tracking should grow.

There are two reasons for this: one perceptual, another one technical:

• Perceptual: The actual physical amount of white space varies according to size. It’s easier to recognize a silhouette when it’s big than when it’s small, so adding white space between glyphs when they’re tiny improves that silhouette-reading process. When it’s big, as long as you retain some white space around the letterform, it will still be recognizable without much deciphering.
• Technical: Not everyone has 20/20 vision (ah, those times!), printers aren’t perfect, screens aren’t perfect. These factors, among others, make the tracking issue, specially at small sizes, paramount. Someone who deals with typography, has to think and deal with deterioration and bad reading conditions, whether is low resolution, ink spreading or a bad rasterizer.

As I’ve mentioned in the readability and legibility article, a good test for deterioration is the Gaussian Blur / Threshold one. Have a look:

5. Justification, Hyphenation and Other Fairy Tales

Composing a block of text isn’t a straightforward nor simple task. There are a lot of factors to consider (mediums, resolution, letter size, leading, paragraph navigation, microtypography, rags, widows and more) as well as technical limitations.

Every solution is, therefore, object(piece)-specific.

With that said, you can imagine my expression when I read/hear people say to never justify text, because font metrics are sacred. Or when I bump into a website with justified paragraph text.

Don’t get me wrong: these scenarios are possible to pull off in an impeccable way; I just find disrespectful to the craft of typography and centuries of test-and-try knowledge.

Let’s get to the point: justification is a matter of navigation, more than a matter of style.

5.1 Justified Text

This is a book style classic, because it’s the most versatile and economic way to compose text. And also the hardest.

The beauty of justified text is that, regarding composition, is a very stable form that relates to the page format and, in a glance, it tells you when a paragraph starts and when a paragraph ends.

The problem is (and I believe this is the reason why some people bluntly tell others not to do this) that it takes time, effort and knowledge.

In order to achieve a good texture with justified text you need to pay attention to hyphenation, rivers, line-breaks, optical margin balance, widows and orphans, line number and text flow: all of this means you’ll find yourself doing letter-by-letter micro adjustments very often.

Note: The reason why I strongly discourage justified text on the web is due to the lack of control you have, specially regarding hyphenation. Sure, there’s manual hyphenation in CSS (and the auto feature is a no-go), you never know if the text block width will remain the same, with responsive sites. So, better safe than sorry.

5.2 Side Aligned Text And Rags

The nice thing about left aligned text is that the only thing that you have to control in the texture is your right rag, so the micro editing consists in line breaks. It also makes the text block a bit more dynamic.

But, as you can see in the image above, when scanning through the right margin, you don’t have any clue on where the paragraph ends (and the next one starts), specially if the last line of the paragraph is a longer one. One actually has to find a period and check the identation of the next line to now if one is dealing with a paragraph or not.

A solution for this is to separate each paragraph with a margin, as you can see below:

This has become the de facto standard for the web, but by doing this you loose a third level of hierarchy in the text, where you could divide the paragraphs by groups, for some reason. Sure, you can add marks – and in the web is a good solution, since there’s no constraint about how much vertical space you can use -, but when you have physical constraints, such as in a book (page count, line count), this can become a problem.

In the image above, you can see an example of when a paragraph ends a line above of where it should, if line count is desired to be respected.

6. Conclusion

I hope you found these tips as valuable as I do!

If you did, please be so kind to share it among those you think that will enjoy this too!

For more goodness, subscribe in the form below!

Cheers from Portugal!

Making a Font: Maximal – Part III

Part I | Part II | Part III

Welcome back to this series about the production of Maximal. If you’re a newcomer, don’t forget to check Part I and Part II, so you know where you’re at; or better, what we’re talking about here.

This article is about programming. Since we’re dealing with such a massive amount of glyphs, developing/adapting some tools to make production easier is a big deal. Besides, the (pseudo-[we’ll get to that]) randomness of this typeface involves – you got it – programming.

1. Generating Glyphs

Let’s start with something not so code-y.

As planned, we need 30 glyphs per letter, apart from the main glyph. For organization and management sake, if the base glyph is E, for example, I want to call the variations E.ss01, E.ss02, E.ss03 and so on.

Why? Well, I use FontLab Studio, and it lets me batch generate glyphs. At the same time, it ignores what’s after the period and generates a component with the letter E, which is handy to start editing. So, in FontLab Studio, if I want to generate a whole bunch of glyphs, I need to input something like this:

E.ss01 E.ss02 E.ss03 E.ss04 ...

Writing down 30 of these, one by one, for hundreds of glyphs, is tiresome. So, I’ve made this little app, just for this project, that does just that. Feel free to use it for your own needs, since I’ve thought that you might just do that and made it in a way that you can choose your own prefixes.

I won’t go over the app’s programming, though, since it’s plain old HTML + Javascript (something very easy to find on Google for clarification) and you can check the source code on the spot.

2. Making Classes

Most of OpenType features work by substitution glyphs and/or groups of glyphs. For example, if you have a f+i ligature – and let’s say that that ligature has the name f_i – your code to display the ligature whenever you type fi would look like this:

sub f i by f_i;

Simple, right?

Now, as we’ve settled on Part II, we have 30 variations of each glyph, which leaves us with a bit more than 13.000 glyphs to manage. Can you imagine coding everything glyph by glyph? Not a very appealing idea, right?

Well, we have classes at our disposal. Basically, we can grab a bunch of glyphs and store them in a class, repeat that for every style set (while keeping the same order) and instead of substituting the glyphs, we substitute the class. For those staring and blinking: instead of coding 13.000 times, we’ll just make it 31. Bear with me.

In OpenType coding, a class is identified by the prefix @. So, let’s say we have two classes, class1 and class2. If we want to substitute all the glyphs stored in class1 by the glyphs in class2, it would something like this:

sub @class1 by @class2;

If it’s your first time tinkering with OpenType features (or not, anyway), have a look at Tal Leming‘s The OpenType Cookbook and bookmark it. Seriously: it’s that awesome (and did I mention free?).

2.1 So, What’s What?

So now that we know how classes work and the basics for writing OpenType substitution routines, lets go through the classes in our font. Here’s how I’m naming them:

ss00 => Our default glyphs
ss01 => Stylistic Set 01
ss02 => Stylistic Set 02
...

And so on. My main goal here is to draw your attention to ss00, which is our non-modified glyph set. This class will be the default one and no glyph substitution will be applied.

The reason for this is, well, people might want to use it without the pseudo-random craziness, as well as any other style. At the same time, you might want to change a glyph or two, without the program changing it back to some other glyph.

With this said, we have three features in our OpenType code:

1. Default: how the font behave out-of-the-box;
2. Stylistic Sets: the 30 different glyph sets;
3. Contextual Alternates: where the pseudo-random magic happens, with glitter and fairies.

I won’t dwell into the first two, since they are very simple and a lot of people around the interwebs have already documented it way better than I could. Again, I recommend Tal Leming’s OT Cookbook.

3. OpenType Random?

OpenType does have a rand feature, introduced by Adobe (S3), but it remains largely unsupported (yes, even by Adobe). XeTeX seems to support it, though, since it allows raw OpenType features.

The usual way type designers go around this, is by creating a pseudo-random glyph substitution routine that cycles throughout.

3.1 True Random vs. Pseudo-Random

So, why isn’t rand widely implemented? Adam Twardoch, in this Fontlab Forum thread, has some very insightful points:

• Each time you open a document (or every time it refreshes the viewport), the rand feature alters your text completely;
• If the alternate glyphs have different widths and/or metrics, the text length also changes (day 1 – 20 pages, day 2 – 19 pages);
• Manual adjustments, such as letter-spacing or line breaks, would have to be done every single time you open a document;

So, pseudo-random code, instead of pure randomness, grants control, it’s predictable and avoids headaches in processing power and editing. Sure, there might be situations where a full-throttle random implementation is desired but, hey – you can always code your own to tailor-suit your needs.

3.2 Pseudo-random Substitution

Pieter van Rosmalen, in this thread on Typophile, shares the code that will be our basis for this font. Here’s the code that we’ll be using as a starting point:

feature salt {
   lookup rotate {
      sub @ss00 @ss00' by @ss01;
      sub @ss01 @ss00' by @ss02;
      sub @ss02 @ss00' by @ss03;
      sub @ss03 @ss00' by @ss04;
      sub @ss04 @ss00' by @ss05;
   } rotate;
   lookup rotate;
} salt;

There are only 5 classes, instead of 30, because I want you to understand this: making this work with 30 or more (and we’ll get there), is simply a matter of extending this logic.

So, first of all, pay attention to the single-quote mark. In OpenType, this means change just this one. Let’s imagine this scenario: we want that everytime that we type EE, we want the last E to be substituted by the glyph E.ss01. The code would look something like this:

sub E E' by E.ss01;

Simple, right? Let’s move on.

3.3 Extending the Code

I did mention that our final code would be an extension of this. So, we want the following to happen and in this order:

1. Check the first pair and change the last glyph with another one;
2. Store the last glyph of the first pair and use it as the first of the second pair;
3. Change the last glyph of the second pair;
4. Do this throughout the algorithm.

This doesn’t seem random at all, right? Well, the trick here is to appear random: so if we have an algorithm that is complex and big enough, it will appear random.

So how will we make this algorithm easily? Automation, again, for the win: I wrote another HTML/Javascript program just to do this task. You can find it here.

And again, the source code is viewable, so use it however you want to.

So now, when we type something in, our font looks like this:

4. Wrapping Up

I hope you enjoyed this post! If you did, you can always share by using the buttons below. For more juice, scroll down and subscribe to the mailing list!

See you in Part IV! Cheers!

References:

1. Thomas Phinney on Pseudo-Random OT code – Adobe Forums;
2. Tal Leming’s The Open Type Cookbook;

Making a Font: Maximal – Part II

Part I | Part II | Part III

I hope you guys had a great Easter (if you’re culturally inclined for such practice – if not, I hope you had a great week).

So, here we are, back on track. In the previous post, we talked about some preparatory steps regarding the conceptualization of the font in hand. Today, we’re going to start analysing an initial prototype, so we can make some early choice of the development to come.

But before we dive into it, I want to thank you guys for such an overwhelming response to the first post. I was really shy to promote it, since I thought it was a very initial approach to this subject, and I thought it was best to leave a more intense promotion to later on, when there was more reading material.

I’m humbled that you guys found a preparatory post interesting enough to share it so much, so my deepest thank you for your attention! I owe my motivation to you and your kindness, so I have nothing to do but my best! Thank you all!

So, to avoid more sappiness from my behalf, let’s get to the point.

1. How many styles?

At this point, this is the most crucial decision to make. As we are going to see in §4, this factor determines how lengthy this process will be.

The only reason why I should be concerned with the time this will take to make is that I want to keep you interested. Since most of you guys are casual visitors (meaning not subscribers [but you can subscribe at the bottom of this page]), this attention can easily go into the void.

To avoid that, I have to consider time. Or you can simply scroll down and subscribe to the newsletter.

Let’s say that we don’t have to worry about time. In this scenario, if we consider the “repetition” model (read about it in the previous post, §3 and §5), a linear incrementation would be the best one, right? Well, sort of.

Yes, it would give you more manual control, but the point here is about random substitution. And the glyph width variation should be extreme enough, since this is not about subtlety, but boldness.

Still, a natural or organic progression, although extreme, is welcome. So, here’s the solution: the Fibonacci sequence. The sequence goes like this:

1, 1, 2, 3, 5, 8, 13, 21, 34, …

The logic here is that any number is the addition of the previous two. In our case, we can skip the 1’s, since that’s our base glyph. And since we want 5 variations of expansion/repetition to each side (and both), we’ll use the numbers from 2 to 13.

So, we have 1 (our base glyph), 2, 3, 5, 8 and 13. The variations look something like this:

Then, as you saw in the image that opens this section, the same happens to the other side of the glyph and then to both sides. And then we make the “expanded” variations, using the repetition as the base. We’ll talk about that in a tick, in §3.

So, with 5 variations to each side, as well as 5 for both, in two sets (“expanded” and “repetition”) we have 30 stylistic sets, apart from the default glyph. That means 31 variation per letter. *heavy breathing*

2. The Base Glyphs

I have only two characters drawn, at this stage: E and F. And their 30 variations.

Now I’m more concerned with prototyping it, or better, to get the tech stuff sorted out before the drawing process; that’s why you’re seeing the same letters over and over again.

As this series go through, expect the tech geekness to decrease (although the next post or two will be about OpenType programming and maybe some Python macro stuff) and the drawing aspects to be mentioned more and more.

But as formal characteristics, the E can tell a lot, in our case. It can tell us quite nicely how the serifs will work, as well as how these elements work with the expansion/repetition. Of course, I’m still in the dark about the curved and diagonal shapes (although they’re playing cheerfully in my head, but that doesn’t mean it will play out properly once drawn).

I’m hoping to draw some very classic, rational and somewhat bland capitals. I want the magic to occur with the variations, not with the base forms.

3. Expanding Processes

After we have the base glyph, the expansion is pretty simple.

Each glyph is divided in two components: one for the left repetition, another one for the right one. Have a look:

I’m sure you can tell where this is going now: the components are propagated, on top of the base shape, to left, right or both sides, and so we get the “repetition” styles:

For the “expanded” set, we take the corresponded “repetition” glyph and simply delete what’s not needed. Here’s an animation of the process:

Et voilá!

4. The Math Of Going Overboard

As I’ve mentioned in the previous article, this font will be Latin-only. So, how many glyphs will it have?

I could go for a basic Type 1 Western/Roman character map (256 glyphs), but that would leave some languages aside. So, after the usual checking of language support tables, I’ve decided to go for the OpenType Latin Pro encoding (433 glyphs). If you think, as I do, that this is an OK character table, let’s make some further calculations.

Let’s consider a basic character map (Type 1 Western/Roman): 256 glyphs. As we saw on §2, we have something like 30 stylistic sets. Added with the default glyph, we have 31 variations of the same letter. How many glyphs are necessary for this? Here you go:

256 × 31 = 7.936

7936 glyphs. Ouch. And what about the OpenType Latin Pro?

433 × 31 = 13.423

Holy s***. Well, this might take a while.

But giving it a second thought, this font is all-caps, and that means that half of the alphabet is a duplicate. So, instead of 433 glyphs to draw, we have 310:

310 × 31 = 9.610

OK, this looks more manageable. *sighs*

5. Wrapping Up

This is all for today! I hope you’ve enjoyed the article!

If you’re a newcomer, be sure to read the previous post of this series an, while we’re at it, check the rest of the blog for some more juice! Oh, and don’t forget to subscribe at the bottom of this page, as well as to share it, if you think it’s valuable!

Thanks for your attention! Cheers!

Making a Font: Maximal – Part I

Part I | Part II | Part III

0. Introduction

Today, while I was waking up, I came up with an idea on how to do something that I’ve been wanting to do for a while. But before I tell you what the idea was, let me contextualize you.

I’ve been wanting to cover, log or to make a some sort of journal of the development of a typeface, to share with you guys. Instead of a “that’s how you make this”, I was wondering about a “that’s how I’m doing this”.

It sounds quite simple, right? Just writing small posts about what you’re doing as you go. Seems tangible, not very time consuming and interesting.

And when I say for a while, I mean for months. So why haven’t I’ve done it yet? Well, there’s a lot of factors to the mix, so bare with me:

1. I’ve been working in huge projects. If I want to write about something that won’t bore you to death, super families is a no-go. And to talk to you about custom client work would be impossible until released, separating us (me and you) from interacting while something is being made.
2. It has to be simple enough. For comprehension sake (and, again, to fight reader’s boredom), the project has to be simple enough. The main goal here is to let you learn something and let us happily discuss it, so I don’t want to push you away with hyper-complexity.
3. It has to be complex enough. Am I paying attention to what I just wrote? The answer is yes. The web is flooded with articles on how to do typefaces, so I have to throw something worthwhile to the mix. Also, some tech-geekness can’t hurt.
4. It has to be relatively fast to produce. Because type design deals with a monstrous amount of repetition, so I don’t want to ask you to dedicate yourself to pay attention to the same thing, over and over again. And those huge projects need my attention too. *wink*

So, points 1 and 2 have been the major setbacks, which leads us to:

1. So, When I Woke Up…

I love those moments when we’ve been thinking about something in a long time and then, suddenly, it all makes sense. And our subconscious is kind enough to provide pictures along with the solution.

So, I jumped out of bed and doodled in a piece of paper, before I did anything else (and yes, even before I went to the bathroom). Oh, and with my glasses off.

I wanted to get the idea down before I gave it a chance to fade away. And, while I was having breakfast, I decided to do today’s Typecooking image with this idea, so I could test it out. The result is what you can see above.

The result is far from perfect (and it’s not supposed to, as I explained in the previous article), but it did motivate me to get further with this.

2. Concept

There are three (at least that I can think of right now) main influences to this typeface:

• Ondrej Jób’s Woodkit. I love how this one comes together, as a type system: Jób was brilliant in how he used disparity and historical references to make this typeface work;
• DSType’s Diversa and LettError’s Beowolf. I’ve been wanting to do OpenType pseudo-random glyph substitution for a while, and these two are brilliant examples on how to achieve this.

Worthy of mentioning, I also had the pleasure to see some unreleased work from the super-talented calligrapher Hugo Moura (Facebook, Behance) that also played a part on getting to this idea. Since I can’t provide a hyperlink, check his work for some other stuff.

Back on track: the idea is to make a typeface where it’s glyphs grow unevenly in the cartesian x axis, either by stretching or by element repetition, as shown above. And, as the cherry-on-top, the glyphs will randomly change, as you type! Bam!

3. Developing A System

It’s easy to go crazy with this. Not that one shouldn’t, but we surely need a roadmap.

Although a lot can change during the production, I find that the clearer the notion of what we’re doing, the better, since we don’t want to bump into a I’ll have to redo this all over again crisis. I had my fare share of them (and I’m glad I did) and I also don’t want to keep you waiting for a long time.

So let’s enumerate decisions through a question and answer scheme:

• Intended usage? Display. Again, we want this to be fast. Also, this kind of trippy-ness is not very text friendly.
• Gauges/Optical Sizes? 1. For now, since there’s not much of a need for gauges in display sizes.
• Weights? Single. Besides, the distortion here already acts as weight.
• Construction? Capitals. Although slightly weird, I want it to be fairly legible/readable, and lowercase letters would suffer a whole lot more that capitals.
• Where to grow? Sides, for now. Although I haven’t ruled out a middle expansion yet. But I do have the feeling that it isn’t as easy (read fast) as it might seem, specially in vertically symmetric shapes. Again, for now, expansion of the side stems, one at a time.
• Style? Didot / Bodoni. Vertical stress (or 0º axis) seems perfect for this kind of distortion and the serifs add elements to keep things more interesting.
• Stylistic Sets? Indeed / I’ll have to test it out. This typeface will rely heavily on stylistic sets, at least the one with the glyph substitution. The question how many?, however, will only be solved in the prototyping stage.
• Language Support? Latin. Greek and Cyrillic capitals’ construction would welcome this sort of distortion but, for time constraints, let’s stick to Latin.

4. Imagining Processes And Tools

What strikes me as the most obvious way to do this is to start by drawing the unadultered shapes, i.e., the classic capital forms. Since the stylistic variations are distortions of these forms, we need them first to distort, otherwise there is only void. And yes, I’m stating the obvious, again; but bare with me, this will make sense.

After these initial forms, I’ll step to the “repetition” set. Although the “expanded” set is actually easier to produce (heck, I could even just draw two of them and interpolate the rest), the “repetition” set has more constraints when it comes to expansion.

What I mean is that, in the “repetition” set, we can only iterate in specific steps: one bar, two bars, three bars and so on. Here’s an image to ilustrate the idea:

Once these are done, I’ll move on to the “expanded” set. And if I use the “repetition” set as a base, I can simply delete stuff or add stuff to get the effect I need. But the main reason is that I would maintain a width consistency between the two sets.

Although this coherence might seem like something odd in a typeface as crazy as this one, I still want all the sets to speak to each other in a similar language, so they should have common characteristics throughout.

Here’s a thing that I might have mislead you to a erroneous interpretation: when I say that I’ll go through these steps, I mean that I’ll go through them glyph by glyph, not character set per character set. Doing it the latter way would be very dumb of me, since I would be postponing testing and prototyping to later stages of development, what could lead to having to through a lot of work through the window.

So, I like to deal with problems early on. There, I said it.

4.1 Metrics & Kerning

This should be as complicated as if two one set, since the left and right sidebearings, as well as it’s outward shape, doesn’t change. Class kerning, on this one, is a way to go: and the number of stylistic variations of one letter is irrelevant, here.

4.2 Macros

Nothing fancy, here. In fact, right now, I think that I need only one that I already use: a rounding corner script that I modded from this one from Betatype. It’s not flawless, specially with curves, but it’s awesome: it can spare you from some 8 steps and you can tweak the curve tension programatically.

4.3 Encoding

This one will be a tough baby. The glyph map is going to grow lightning fast and it might be wise to keep things under control. Maybe this is the reason I need to update my Font Encoder tool (if any of you wants to help me out with this tool, please let me know!).

5. Wrapping Up

At this point, I believe that we have enough to get this started. And that’s material for our next article!

Thanks for your time and attention, and I hope this article has been insightful for you!

See you in the next article!

On Legibility – In Typography And Type Design

If you’re following me on Facebook, you probably know that I’ve recently asked for suggestions on what should I write about. Michał Jarociński suggested that I should do something about legibility, wayfinding and signage.

Curiously enough, not so long ago, I’ve started a thread on Typophile (and a discussion on Reddit’s Typography board) about the function/use of serifs, and, to my surprise, it escalated very quickly to a derby between serif and sans-serif type and which one was the most legible: but I’ll get back to you on this, in a bit.

But this led me to Kevin Larson, Microsoft’s researcher on reading, who was kind enough to exchange some e-mails with me, happily providing me some papers on the matter.

So, since you now know the path leading here, I hope provide you with some insightful knowledge about legibility — or what makes type more legible —, in order to help you improve your type designs (if you’re a type designer or letterer) or to help you refine your typeface selection process (if you’re a graphic designer).

And cabbages. Low in fat.

Without further ado, here’s the juice:

1. Letter, Word, Paragraph

First of all, it should be a no-brainer that, when we talk about rapid-letter recognition, there are multiple levels of the letters’ context (or, let’s say, relationship between other letters) that have an effect on how we recognize letter-forms.

So, as you might have wondered, a single letter should be recognized faster than one within a word. And its position in the word affects it’s recognition. And leading has an effect on this too.

Edit: Hrant Papazian has already provided some insights in my first article about Bézier Curves, and he did it again.

In spite of the previous statement, reading is a way more complex event than simple letter-by-letter construction. The bouma model suggests that we read through clusters of letters and only go through the letter-by-letter process in case of uncertainty.

I sympathize with this idea because it’s more economic, brain processing wise. To keep it simple, while reading, factors like grammar, word expectancy, word form and so on, are not to be excluded when we think about the reading experience.

*edit end* 

Keep also in mind that, by definition, legibility is not the same as readability, although, in practical terms, they are particular focus lenses of the same thing. We’ll talk primarily about legibility (the formal properties of a glyph that improve their instant recognition), but it would be a major fault not to mention readability issues (such as spacing, texture and so on).

Edit: This kind of research is still on its infancy, so keep in mind that these suggestions are a mix of what has been researched, empirical experience and my own opinions on the matter.

At the same time, the parallel-letterwise model that you can find in the third reference is still disputed, and very brightly, by Papazian, in Typo13.

*edit end* 

But how to improve this? Well, I’d like to talk about something else, first.

2. Familiarity

I have a memory of when I started tying my shoes, without an adult to help me out: I remember being the the kindergarten’s corridor, puzzled, trying to figure out how to do a neat bow and how the laces could make such form. It took me a while, I guess. I remember it as being a challenging task, since I was alone (yes, you could be alone in kindergarten, in the 80’s [well, at least here in Portugal]), and I was trying my best. I don’t even know if I’ve managed to do it properly, I just remember that I did something with it and that it filled me with proud.

Today, I don’t even remember when I tied my sneakers.

It’s part of our cognitive process to forget that we know how to do something: we end up just doing it without thinking. That’s why we can talk and write, for example, without a colossal effort to construct meaning, spelling, grammar and so on.

And the same applies to reading, i.e., recognizing letters. The more we are exposed to a certain typeface and the more we interact with it, the easier it is to rapidly recognize it.

I know this sounds like I’m stating the obvious, but consider the implications that this has on any study about legibility. Imagine gender differences on this matter. Cultural differences.

So, we should be very careful to engage extrapolations on legibility and readability, because this factor alone can sabotage our conclusions, so address this article (and others) with a critical mind.

Edit: Kevin Larson directed my attention to an issue regarding familiarity: even though we read best with typefaces we know best, we’ll do just fine at reading well-designed brand new typefaces. *edit end* 

But before you go and use Helvetica on everything from now on, please read along. *wink*

3. Spacing & Kerning

As was implied in §1, the amount of white space around to a letter influences it’s legibility, thus having an impact on readability.

But what effect? Well, if the tracking is too tight, letters will clutter and we might mistaken two or more character for another one; if too loose, we might have a hard time figuring out if a character is in a word or not.

Here, have a look:

As you can see in this example, in the first row, it wouldn’t be odd to mistaken the c and the l as being a d. And even by knowing that it’s the same word, probably you slowed down while reading the last line.

Spacing should be set to produce an even rhythm throughout the texture; altering this rhythm produces a reading experience similar to a ride in a car that has a choked engine, prone to hiccups.

3.1 Size-specific Spacing

Loosening the tracking slightly is not always a bad thing to do. In fact, in order to improve legibility and readability, it’s a good practice to open the tracking as you go down or/and if you’re working with very small resolutions.

Here’s a quick test to see how legibility survives deterioration: Gaussian Blur + Threshold.

As you can see in the image, the top-right word is spaced to loosely for such a big size; but its reduction (bottom-right) keeps a better quality of letter-recognition.

As for tight tracking in big sizes (you were wondering about it, weren’t you?), it’s sort of a different case. Is not as damaging, of course, since there’s more room for outlining the letter with the eyes, but it’s not actually an improvement; just more tolerable.

Still, since big type takes more room, it’s tempting to reduce the tracking: it’s OK, but don’t go wild with it; you’ll know some more tricks to go around this as you read along. And cabbages.

4. x-height And Vertical Proportions

It’s a widespread idea that a big x-height improves legibility/readability, but I have to say that this idea is an over-simplification. Not wrong, but a distortion by simplification, nonetheless.

Imagine that you’re designing a newspaper. Or a typeface family for a newspaper, same story. While it’s desirable to have a large x-height in the text typeface, it’s kind of irrelevant to do the same for the headline cut, right?

Now imagine that a newspaper contacts you to tweak their typeface. They want to keep the same char count, the same number of lines, but they feel that their text typeface is too small. Increasing the x-height seems logical.

But here’s the drill: the ascenders and the descenders, in proportion, as well as the caps, will shorten, considering that you want to keep your line-gap free from clutter. And you should be careful with this because…

4.1 Ascender And Descender Retraction Takes A Toll

… on cabbages. Er… I mean, on legibility and readability.

Consider the following animation:

As the x-height increases, the Futura-like d slowly starts to resemble a single-story lowercase a, increasing the probability of mixing those two.

And be aware that, since we scan words from their top, we leave the bottom of the words to a more peripheral part of our focus; this means that the descenders should be slightly longer than the ascenders.

Or, as Kevin Larson, via e-mail, has told me:

“We found in our studies of Sitka that a large x-height came with a trade-off; While the large size helped the neutral height letters, it hurt the ascending and descending letters.”

Note: let me remind you that this is not an absolute truth – in §6 we’ll cover another aspect that can compensate this retraction: it’s always a compromise of multiple factors. 

5. Counters

Open those counters!

This is actually one of the beefs I have with Helvetica, so you can imagine my surprise when Apple chose it as it’s UI font. But my jaw dropped when Apple stated the following:

In OS X Yosemite, fonts have been refined systemwide to be more legible and consistent across the Mac experience.

More legible? Seems like I missed a breakthrough research paper that contradicts centuries of type production. *long live sarcasm!*

But lets give the benefit of the doubt and round our quick Gaussian Blur + Threshold test, and pair Helvetica with another UI font: Microsoft’s Segoe UI (because it’s Apple’s main competitor and has a bigger counter aperture).

Here’s Helvetica:

And here’s Segoe UI:

If you’re still not convinced, step away from you computer and squint your eyes, shake your head, look away and back for a glimpse, decrease your monitor’s brightness, print it in a bad inkjet printer at a very small size and see which one performs better.

So, for low road mortality and low carbon-emission sake, keep Helvetica out of roadsigns. And cellphones – because no matter how stupid it is to text and drive, people will keep on doing it. Or get hit by a car while crossing a street without looking away from their cellphone, who knows.

Cabbages don’t cross the road staring at their cellphone.

6. Character Variation

This is one of the most important aspects of type design, regarding legibility.

While this is somewhat self-explanatory, here’s the rule of thumb:

The more distinct the glyphs are, the better.

It’s harder to tell twins apart, even though they have differences. So, as you can see in the images in §5, it’s easy to mistaken characters if they’re formally too similar.

Edit: Although obvious, this has an effect on the word level: glyph variation also increases variation in the word form, reducing ambiguity. *edit end*

But try not to build a Frankenfont: changing letterforms too radically, style-wise, creates confusion, slowing fast-recognition big time. And in the same idea, be sensitive about the amount of elements added to letterforms, since it might produce cluttering.

6.1 Serif versus Sans-serif

Remember, in the introduction, where I mentioned the discussions about serif’s functions on Typophile and Reddit that ended up in a derby between serif and sans-serif type? Well, now we have enough information to discuss this properly.

So, the answer to the question Which one is more readable, serif of sans-serif type?, the answer is No.

Following the motto there are no bad answers, only bad questions, this question is one of the bad ones. Serifs don’t automatically make type more legible (although they can help with character variation) and sans-serif simplicity is not always a plus.

It’s always a contextual matter and we have no empirical evidence that suggest the superiority of one of the styles.

So, why are sans-serifs almost universally used in signage and serifs in books? The answer is: available space and clichés.

Don’t get me wrong: clichés are a good thing, in this subject. If we’re aiming for legibility/readability, not clashing with people’s expectations is a good thing: we don’t want people crashing in the highway because a sign is set in Sabon, neither we want to read a romantic novel set in Comic Sans (although better than in Helvetica). *now I’m imagining the interwebs going rage on me!*

As for available space, serifs take more space than sans-serifs. Simple. And we want street signs to have big type on it, so we can read them from afar; in the same logic, in small type and longer lines of text, sans-serif create a kind of moiré effect in the texture, which is undesirable, since it requires effort.

Edit: And type size and word amount! I’m sorry for leaving this one out (props to Hrant Papazian, again)!

While we’re driving, it’s logical that a special focus on letter-by-letter recognition is paramount. Type is huge, and only one or two words are set per line, so it’s fast enough to decipher form and meaning.

But while reading a book, where there are a lot of words in a texture and type is set in a much shorter viewing arc, the bouma model fits best.

So serifs, in large chunks of text, have several advantages over sans: letters are “fused” together, the word shape has variety, white-space vs. rythym has diversity, and so on.

But I might be wrong.

*edit end* 

7. Width

This is another size-specific subject, under the condition of legibility improvement; I mean, if we set aside aesthetic considerations, some width adjustments can help with legibility.

Lets say that every time that you need to move your head (while looking at large type) or move it forward (in the case of tiny type), glyph width can help. With this said, we can conclude that small type is more welcoming of wide glyphs, while big type is more welcoming to condensed ones; although the case where the latter most benefits is when really, really large type is used and at a very short viewing arc.

And this leads us to…

8. Weight & Contrast

As you might have guessed by now, finer details don’t survive deterioration.

And if you think that this is a technological problem, such as pixel density or printer resolution, think again.

Imagine the following scenario: you have three different size circles and you want them to have the same stroke width, like this:

If I asked you to scale the circles to the same size, would they have the same stroke width? Of course not.

With a font, the exact opposite happens: if you have three circles with the same stroke width and scale them to different sizes, what happens?

If you think that I’m stating the obvious, man, I’m with you. But as simple as this might seem, it’s a good reminder of the kind of compensation necessary for different type sizes and a good starting point for size-specific designs.

In fact, I usually start a typeface by printing a bunch of circles and squares with different stroke widths at different point sizes, just to see how thin can it bear. And I do it again once I start adapting it to smaller and bigger sizes.

So, as a rule of thumb:

The smaller you get, the lesser should the contrast be.

But this doesn’t mean that you shouldn’t pay attention to the thicker parts of your strokes; in fact, you should thicken them even a bit further.

It’s like having a stroke around your design: comparing the thicks and thins, the thinner parts will thicken more in proportion than the thicks.

To illustrate this idea, remember the image that opened this section? Here’s how it looks if we scale the type to the same size:

9. Conclusion

I hope that you’ve enjoyed the article and the cabbages!

I’d like to thank Michał Jarociński, for the suggestion, Kevin Larson and Hrant Papazian for the helping hand and you, for your attention!

So, if you found this helpful, please be so kind share the article with your friends or go shopping for some fonts, so I can keep writing these!

And don’t forget to check the Further Reading and References section, below: there’s more awesome stuff there!

Cheers to you!

Further Reading and References

• The Aesthetics of Reading – Larson, Kevin & Picard, Rosalin (PDF)
• Size-specific Adjustments to Type Designs – Ahrens, Tim & Mugikura, Shoko
• The Science of Word Recognition – Larson, Kevin
• The Development of the Signage Typeface Wayfinding Sans Pro – Herrmann, Ralph

The Art Of Eyeballing – Part IV: The Stroke (Optics)

Index

Introduction | Learning To See | Overshooting | The Stroke: Optics

This is the first article of three, in our series, to talk about the stroke.

We briefly introduced the idea (in the previous article) that the stroke width has an effect on perception and, for this reason, should be adjusted. So, this article is just about that: optical adjustments to stroke.

May I state it right now: this is not rocket science and the more elaborated considerations about stroke (such as modulation, for example) will be covered in the next articles. For now, we want to approach a very simple case – a monoline construction – and try to achieve balance.

And without further ado (and because I’m starting to feel way to serious while writing this), let’s skip to the good part.

1. Horizontal vs. Vertical

Let’s get right to it: in the image above, which are the thickest strokes? Vertical or horizontal? Take your time. Horizontal, right?

If you thought “they’re equal”, you’re right. But do they seem equal? To me, they don’t. And to most people, they also don’t.

But for many years, I simply trusted the computer. And, as always, the computer was right, so who was I to judge mathematical perfection? Well, this is about perceptual balance, not the first. Again, trust your eyes.

And here’s a correction (with horizontal strokes being about 1% thinner than the vertical ones):

But why does this happen? In honesty, I don’t really know, although I have some theories about it:

1. We have two eyes, distributed horizontally, making our area of eyesight wider than taller; and this might add relevance to vertically distributed elements;
2. In type, we have millennia of broadnib and flat brush writing, usually with 30 to 40º angle from an horizontal position, making horizontal strokes wider than vertical ones. But again, this could be due to a perception/optical/neurological phenomena.

If you’re wondering about how this works in typefaces, have a look here:

2. Orthogonal vs. Diagonal

Consider the following example:

Again, all the 3 lines have exactly the same stroke width. We already talked about how to compensate the horizontal line, so let’s just do that:

If it wasn’t obvious in the first image, now it is: the diagonal line also looks heavier than the orthogonal ones.

So, for comprehension’s sake, let’s give the diagonal line the same stroke width has the (already compensated) horizontal line:

… which makes the diagonal line too thin.

Before we get into the solution, I’d like you to consider a couple of things:

• This example is not random, i.e., I’ve picked a 45º angle to the diagonal line for a reason that you’re about to find out;
• We can only apply this to monoline fonts, although this is just a starting point (the next articles will cover more cases and correspondent corrections).

So, if neither of the horizontal nor the vertical strokes’ width is applicable to the 45º diagonal (which, again, is half-way rotated between the orthogonal axis), what happens if we pick the exact in-between stroke width? Here you go:

Does it look alright? *wink*

And now, you might be asking about other angles. If we apply the same width stroke to any diagonal, we get this:

If you compare the first two lines, the second looks too thin; and if you compare the last two, the former looks too thick.

So here we can start to acknowledge that the thickness of a diagonal line should vary according to it’s angle, and that it’s a progression between the horizontal and vertical widths.

Here’s a linear progression of angles and widths:

2.1 Tackling Slants and Widths

If you’re anything like me, by now you’re doing some stressful mental schemes on how to calculate the exact width of a diagonal, depending on the horizontal and vertical strokes’ widths.

So, in order to save you some stressful times, here’s a quick and dirty way to do it:

1. Draw an ellipse that has the same width as the vertical stroke and the same height as the horizontal stroke;
2. Adjust the strokes to be tangents to this ellipse.

Two steps method. This is what I call workflow optimization! Here’s a visual representation of the method:

And, to implement a tradition, here are these principles applied to type:

3. Straight vs. Curve

And we’re coming closer to an end.

Let’s start with the following image, where all the strokes are exactly the same (and the O is already overshot):

And now, let’s make the corrections that we already know about (horizontal and vertical, in this case):

Same kind of question: do the straight and curved strokes feel equal? You might want to take a step back it see the images from afar.

The H seems to pop out more that the O. And, as I mentioned, the O is already overshot, so it’s not a case of overshooting. Or is it?

Well, curves seem thinner that straight lines for the same reason we have to overshoot them: a lot of white space is created and positive mass is decreased, so we have to compensate for that.

But the thing to retain here is that curves seem thinner than straight lines and the amount of compensation needed isn’t as extreme as the one we do in the verticle / horizontal cases, so it’s closer to an overshooting compensation.

Let’s correct our example:

4. How Much?

If you’ve noticed, I wasn’t blunt about how much to compensate; in fact, I only gave one example in §1.

I could provide rules-of-thumb that would be percentage ranges of compensation, but I feel that this is a trap.

First (and again), I advise you not to make calculations; providing you such rules (on how much to compensate) would oblige you to make these calculations and I want you to design as freely as you can.

So take what you’ve learned today and trust you’re eye. If it looks awkward, well, it’s awkward. Teach yourself to pay attention to the forms, counterforms and whitespace. Inspect the curve/line segments on by one and compare them to the whole form. And to the whole group of forms.

Even if we dabble in maths and geometry, here, keep in mind that these are means to an end, not the end itself.

I hope you’ve enjoyed this article, see you in the next one! Cheers!

References:

• The Stroke – Noordzij, Gerrit (Hyphen Press, 2005);
• Size-specific adjustments to type designs – Ahrens, Tim / Mugikura, Shoko (Just Another Foundry);
• Make Your Fonts Suck Less – Phinney, Thomas (video)

Bézier OCD Or Why You Should Know About Point Placement

0. Introduction

If you’ve been visiting this blog, you might be wondering why I’m writing another article about this subject.

You’ve probably read Bézier Curves And Type Design: A Tutorial and Bézier Curve Quick Tips: Two Methods For Smooth Curves, along with AGSC’s article So What’s the Big Deal with Horizontal & Vertical Bezier Handles Anyway?, and you might think that, for graphic designers and related métiers, things are pretty much covered.

Well, they’re not. The suggestions to keep nodes at extrema, handles vertical or horizontal, use explicit inflection points, balance the handles and so on aren’t just workflow optimizations: they’re methods to overcome technical problems.

So, today, I want to give you the reasons why these point-placement methods should be used extensively, in a more in-depth way than in the previous two articles (and again, here and here, because I strongly suggest you to read them before reading this one).

Ready? Go!

1. It Reduces Point Placement

This one is a no-brainer. As discussed before, in cubic Bézier curves, the most simple way to describe a curve is with two nodes and two handles, and if we keep angles smaller than 90º, we can easily draw any curve. So, working with extra points doesn’t seem much of an advantage, since it ends up with you having more stuff to deal with.

1.1 And Thus, It Reduces File Size

Less points, less coordinates. Less coordinates, smaller file size. Done.

2. Rasterizers Are Dumb

This section and §3 are this article’s gem: the stuff that you don’t usually see being talked about.

In Bézier Curves And Type Design we barely scratched the surface on this. Remember how a cubic Bézier curve is constructed? The animations there show how a Bézier curve rasterizer builds a curve through a method called linear interpolation. Let’s start there.

2.1 Linear Interpolation

Linear interpolation is a method of curve fitting that uses linear polynomials (read line segments joined together to fit a curve), and this is how computers draw Bézier curves, because De Casteljau’s algorithm (the one used in Bézier curves) was made to do precisely this.

So, as we know the Bézier Curves And Type Design‘s animations, the curve is broke into several linear steps. Have a look:

Fibonacci FTW!

Be aware that the subdivisions are per segment: from anchor point to anchor point.

So, with this said, how would the previous animation look with odd point placement? Here you go:

As you might have guessed, the perceptual smoothing of each segment through the various iterations differ quite a bit:

• The shorter the segment, the quicker it appears to be smooth;
• Since the segments differ in size, the smoothing appears to be uneven.

Ever worked with splines in 3D software? If you have, you know the pain it is (or used to be, rasterizers did get better) to convert it to a mesh, with steps unequally distributed along the spline. Or Flash, that converts the curves to line segments for processing and file size’s sake. Now you know why.

How to solve this? Same recomendations:

• Keep smooth nodes at the extrema;
• Keep smooth nodes’ handles straight vertically or horizontally;
• Balance the handles;
• Use explicit inflection points.

2.2 And Rasterizers Should Be Dumb; You’re The One Who Should Be Smart

Why? Because linear interpolation isn’t the only thing to worry about, when it comes to rasterizers.

We want our vector drawings to be cross-compatible between formats, rasterizers, hinters, printers, parsers, and the list goes on. So it’s our job to know a little bit more and try to minize conversion errors. Just because something looks good in Illustrator, it doesn’t mean that it will look good in an old printer.

And if you convert your drawing from cubic to quadratic and back to cubic and then interpolate it, welcome to hell.

3. Hinting

Though this part is somewhat related to §2, it deserves a different section.

Let’s get this straight: hinting is not exclusive to type design; in truth, every printer, for example, only prints bitmaps, i.e., it hints the vector artwork first. And printers may have their own rasterizers and hinters, and the way you draw can make a difference.

The reason why it’s an obvious type concern is that we (type designers) deal with a finer degree of detail in way smaller sizes.

But, in spite of rasterizers becoming better and better, it doesn’t mean that graphic designers shouldn’t be concerned about it too.

And with this I don’t mean that we should rasterize vector work and start editing pixels: you should, however, try to draw vector art as fool-proof as you can.

Can the way you draw influence hinting? Yes, very slightly, but yes. And the smaller you get, the more crucial it becomes.

4. Conclusion

I hope you’ve enjoyed reading this! Happy drawing!

Cheers!

Bézier Curve Quick Tips: Two Methods For Smooth Curves

Fixing curves, for me, is an every day activity. Sometimes they look oddly pointy, too steep or too wide, guiding my eyes to awkwardness.

And since I’m an optimization freak (as you could tell on my previous article on Bézier curves), I end up using some procedures to tackle problems.

So, today I want to share with you a couple of techniques I use a lot. Here we go!

1. Method 1

If you’ve read my article on Bézier curves (and you should for the sake of understanding this article), you’ve noticed that I stressed on how important point placement is. Here’s a summary of what I recommended:

1. Keep nodes at the extrema;
2. Keep handles vertical or horizontal (with the obvious exception of corners);
3. Use explicit inflection points.

But this doesn’t mean that you should immediately start drawing this way; these are only requirements for you final work.

With this said, consider the following lowercase n:

As you can see, those curves are in terrible shape, due to unfortunate point placement, resulting in pointy areas. So, how do we solve this?

Let’s start by fixing the top curve:

Here’s what happened:

• Figure 1: The first step is to bring a guideline to mark where our extreme-top point is, for overshooting purposes;
• Figure 2: Then we remove the extreme point and adjust the curve to out liking, while using the guideline as a reference for how much up the curve can go. The gray dotted line is just the previous curve;
• Figure 3: And finally, we add the extreme point. You can eyeball this, it’s nothing fancy. The extreme point should just be where the curve touches the guideline.

And here’s the same process for the inside curve:

And a comparison between our original n and our corrected one:

So, what happened here? Here’s some observations:

1. Manipulating two handles is way easier than four handles and an anchor;
2. This method provides us a way to find the optimum position for where the extreme anchor should go;
3. We let the point addition algorithm find out the best handle position for us;
4. Even if we need to do some minor adjustments, it’s easier and safer to adjust a respectable curve than a clumsy one (I know I’m personalizing the curves, I know).

1.1 Problems With This Method

This has some limitations, of course:

1. It’s not adjustment proof: You might still need to do adjustments to the curve. But hey, you’re closer than you were! And prepare yourself for §2, it might come in handy;
2. It doesn’t work very well with angles above 180º: For the same reason that we can’t use this method with quadratic Bézier curves, we would need 4th or higher-order Bézier curves to use this method with a fair degree of control. And in plain English: this works with parallel handles or with a smaller angle, because otherwise, you’re no able to control the curve’s extension and steepness. And here’s an animated GIF, because you guys love these things:

2. Method 2

And here we are. *awkard stare*

So, back to business: how do the point-addition algorithms distribute the handle length? Well, they keep the handle length proportionally equal, to keep the curve as smooth as possible.

With this in mind, when we have our handles in a 90º angle, we can fit our 4 points in a square. And with less than 90º, a trapezoid:

Let’s stick with the rectangle, for simplicity’s sake.

By now, your inquisitive mind might be asking:

What happens to the curve if one handle grows from the minimum to the maximum length, inscribed in the rectangle, while the other does the opposite?

And now you must be thinking how did I read your thoughts, right? Right.

But let’s not deviated from the subject; here’s what happens:

As you can see, the curve bulges slightly in the extended handle’s side and gets steeper in the retracted one.

Now, what happens if both handles go from minimum to maximum length?

You probably saw this coming.

Well, first of all, I apologize for the slow build up, but I wanted you to be aware of the two factors, because you’ll be dealing with them with this method.

By the way, I don’t know if you keep the habit of click-and-dragging curves, but if you don’t, start doing it. And in most drawing applications, holding the Shift key down keeps the handles in the same vector.

If we want to keep the handles’ lengths proportionally equal, the rectangle from their maximum length point to their actual position has to be proportional to the anchor’s rectangle. Here’s an image to clear this out:

The effect that this has on this curve is minimum, but it distributes the curvature evenly.

So, here are the steps to do this:

1. Get an unevenly distributed curve;
2. Extend the handles to their intersection point;
3. Press the Shift key (to keep handles straight), click on top of the curve and drag it back. Gently tilt to the sides, trying to get both handles proportionally equal until you get the curvature you desire.

With practice, you’ll be able to eyeball the entire process and still get some sweet and smooth curves.

3. Final Thoughts

I hope you’ve found this article helpful, since I find these make me work faster (I struggle less to achieve satisfactory results), while it keeps the overall look of my work consistent.

Thanks for reading this and if you like it, share the knowledge! Cheers!

So, How Much Is An Em?

With the implementation of the em unit in CSS and it’s handy use in responsive webdesign, all of a sudden it got famous outside the typographic realm.

1. The Simple Answer

An em is the same size as the font’s point size. There, as simple as that.

But if we already have the point unit, why would we need the em?

Well, the em unit is a relative unit, while the point is a fixed one. This means that a point will always be 1/72 of an inch, so a 12pt font will have (in height) 1/6 of an inch (or one pica, but that’s another story); on the other hand, 1em in a 12pt font is equal to 12pt and 2em will be 24pt (1/3 of an inch) – but in a 72pt font, 1em corresponds to 72pt (1 inch) and 2em to 144pt (2 inches).

Back to why, a good example of the use of the em (and probably where it’s mostly used) is on setting the line height (leading): imagine that you want to use a font in 24pt and you want the leading (font height + spacing) to be 1 and 1/4 of the font size; doing some calculations, you’ll find that it’s 30pt. Now imagine that you have a title, a subtitle and a quote deck to go along with your text body, and you want to keep the same relative space between the lines of text.

Instead of having to calculate every leading measure in points, wouldn’t it be more simple just to say “125% of the font height, please“? Well, the good news is, you can, specially in CSS:

body, html { line-height: 1.25em; }

Done.

2. History

First of all, why the name, em?

If you thought that the em has anything to do with the letter m, you got it wrong. But if you thought that it has something to do with the letter M, you got it right. *smile*

Smartassery aside, the em got its name from the width of the letter M. As you may guess, this would easily escalate to a major headache, since the unit would vary with the typeface being used at the moment and, as we already saw above, with the point size as well.

But why the width of the letter M? How did it go from width to height?

The answer to these two questions is the same: traditionally, in metal type, the letter M was cast in a square block (a.k.a. em-square and/or em-quad), so the height and width were the same measure.

3. Em = Distance From Ascender to Descender? Not Really.

In digital type development, there’s a thing called UPM: Units Per Em. As you might have figured out from it’s name, the UPM sets the amount of subdivisions of the body size, i.e., its em.

The rest of the font’s metrics are set in relation to this matrix. Take the following case:

As you can see on the right, the UPM is set to 1000 units and if we add up the distance between the ascender and the descender, the value is 1050 units, hanging below the em height. So, if we set the line-height or leading to 1em, the ascender and descender will overlap. Take a look:

But pay attention to the line gap, in first image of this section. From the ascender to the line gap bottom, its 1200/1000 units, the same as 1.2em.

Since the line gap acts as a default leading parameter, leaving the leading untouched or setting it to 120% (or 1.2em) produces the same result (in this case, of course):

One thing that is worth mentioning is how the line gap is handled. In most DTP software and browsers, the line gap is divided in half and distributed on top and bottom of the em square, as you can see above. This is why you usually have to nudge your text box a bit down in order to make your baseline hit the grid.

4. Wrapping up

So, now you know what an em is, how the font’s body height is calculated and how leading works.

Hope you enjoyed the article!

References & Further Reading:

• Em (typography) – Wikipedia
• Point (typography) – Wikipedia
• Typographic Unit – Wikipedia
• The Elements Of Typographic Style – Bringhurst, Robert

The Art of Eyeballing – Part II: Learning To See

Index

Introduction | Learning To See | Overshooting | The Stroke: Optics

1. We don’t see with the eyes

In 1963, David H. Hubel and Torsten Wiesel, two neurophysiologists that won the Nobel Prize in Medicine in 1981 for their work in information processing in the visual system, conducted a somewhat bizarre experiment: they sewn one eye shut to newborn cats and waited three months.

After the wait, they went to see what happened to the kittens’ brains: vision only developed in the open eye. In fact, the brain zone that was supposed to be dealing with the processing of information from the sewn eye was overtook by the neurons for the vision in the open eye.

In mammals (and this puts us on the list), vision is only developed after birth and – as Hubel and Wiesel demonstrated – is dependent of the constant signal reception from the eyes.

To this time frame, where the brain develops sensory skills, we call it the critical period.

Babies born blind from cataracts, for example, if immediately put under surgery, are likely to have normal vision. On the other hand, subjects who were treated after the vision’s critical period, often remain blind, even with functioning eyes.

2. What seeing is

So what does than mean, to see?

As we saw above, seeing has nothing to do with perfectly functioning eyes.

Let’s think of the eye as a lens and a sensor combined. Light gets inside through the lens and hits the sensor in the back of the eye, and the latter translates the received light to electric and neurochemical signals, sending these through the optic nerve (and adjacent blood vessels) to the brain.

Then, the brains receives this information and makes it believable to our conscious mind. So seeing is not just the hard acknowledgement of the outside world, but a mental process that cares with data analysis, structure, interpretation and so on. That’s why a blind man can say “I see” when he understands something. Seeing is being aware of something.

And I say believable for many reasons, but we’ll get to that.

2.1 You see what you know

Some years ago I saw a news report about some charity for the blind people, on the TV. By the end of it, the reporter asked a 10-year-old-ish blind kid what is like to be blind. Very candidly, the kid replied “well, you tell me how it is to see: I was born blind, this is what I percieve life as it is”.

It’s like having a deer looking at me and thinking “poor guy, how can he get around only in two paws?”.

But what happens if a blind person gets his eyesight back, after decades of blindness? Does the brain, way passed it’s critical period, develop the skills needed to see? Well, it might.

One fascinating case is the one of S.B.. Albeit the paper being from 1963, it was not the first time of blind people regaining their vision. But what makes this fascinating is the documentation of his case on how the development of his vision skills, by asking him to draw. Have a look at his drawings:

In the first drawing, according to the report, S.B. “expressed dissatisfaction with his drawing because he found himself quite unable to draw the bonnet, or radiator” because “it would be the principal part that he would not have touched to any great extent when blind”, for it was a dangerous thing to do. And through time, S.B. still wouldn’t draw it.

Another curious thing about the first drawing: he drew the wheels with spokes. S.B.’s explanation was that although he knew that buses had hub wheels, he was more familiarized with the feel of cart wheels.

He also always drew the same view of the bus. Why? Because that would be the way that the bus would be presented to him, in a tactile way (he was English, so the bus would be driving in the left side).

Until his death, S.B. maintained is “blind lifestyle”, since vision never became predominant. He would still use a cane, touch people’s faces to recognize them and so on.

But if we think that the increasing quality of his drawings is due to his restored vision, well, we should think again: blind people who can accurately draw what they touch exist. Even surprising cases like the one of  Eşref Armağan, who can draw in perspective.

2.1 Not good but good enough

First of all, our eyes cannot collect all the information that is in front of them: the place where the optic nerve – that sends the electric impulses to the brain – connects to the eye has no photoreceptor cells. This area is called the blind spot, as you can see below.

But why can we stuff around us so clearly? Well, there’s two reasons:

1. The image we actually see is a composite image. Since each one of our eyes has a different angle from the lens to the optic nerve, what we can’t see from our left eye is in the right’s eye viewing angle, and vice-versa. So, the brain picks up the two images and makes a composite, so that we have the most accurate image possible.
2. “But if I close one eye, I can see all of it”, you might say. Well, truth is, you can’t. And this is the second reason: without enough information, the brain makes stuff up, so that you don’t walk around with a black dot in the middle.

In case you still don’t believe this, try the following: click the image below, cover your right eye and look at the L. If you move your head towards and away from the screen, at some point, the R will disappear. Have a try:

No black holes, right?

3. Developing super-powers

A while ago, someone posted an image on Facebook that made me grin. It was something like this:

Most people can’t tell the difference between the two glyphs. Why? Because if the brain doesn’t see a need to tell them apart, it won’t. Our subconscious, as was stated above, works based on the believable or the good enough: it’s build to operate in the midst of an overwhelming quantity of stimuli, so it aims to produce a convincing notion of reality, not a perfect one. We just couldn’t handle it, absorving and processing it all; not consciously neither consciously.

So, to what extent can we improve our ability to spot detail?

One of the things that our brain excels in is recognizing faces: it has to deal with a lot of details, within a very extensive catalog of faces, and yet we recognize people we barely know in a split second.

I’m sure everyone knows identical twins. If we don’t know that someone has a twin, we easily mistake two people as being the same. But if we know that someone has an identical twin and never met them, chances are, we can spot the difference. And by spending time with one or the two of them, it gets easier and easier to tell them apart, up to the point of saying “but they’re so different!”.

So, with type, it’s the same thing: the more of your time you spend looking at subtle differences, while preserving a need to spot them, the better you get.

Some people can’t see the difference between Arial and Helvetica, some get enraged when someone can’t tell them apart. And I say this from experience: I’ve replaced Helvetica with Arial and got away with it, when a client stated bluntly that Helvetica was very readable.

But as you develop this skill, it’s a joy to look at type. In a single glyph, there’s so much to be observed that seeing is an act of fruition.

The Art of Eyeballing – Part I: Introduction

Note: This series of articles are a work in progress. It’s in the process of being written, so there might be corrections along the way, as well as new articles.

Index

Introduction | Learning To See | Overshooting | The Stroke: Optics

I own a lot of books. It’s my consumerist pitfall: whenever I go to a bookshop and don’t find anything of my liking, I get upset. And since I rarely read fiction, my collection ranges from neuroscience to economics, from art theory to politics, from hypnosis to type design.

And, maybe for professional reasons, typography books are the ones that annoy me most. With all the hype of typography around the web, type-related publications are everywhere. But most of them are superficial font catalogs, recipe books that tell you not to use Adobe’s optical kerning and other things like “this is a stem, this is a bowl” – “and now that you know this, you’re in the 1% of the graphic design population that are good in what they do”.

But I always have a look on what bookstores have on typography. And there are priceless gems: The Elements of Typographic Style is a must have, Counterpunch is a delicious read, The Stroke is fascinating from start to end, Size-specific Adjustments to Type Designs is worth every penny, Cómo Crear Tipografías is a good read, and the list goes on.

Every time I feel that these books give me some insight, no matter how niche they are, I get happy. Maybe the feeling that a 40-year-old woman gets out of the latest Richard Bach book is the same that I get out of a ultra-niche type-related technical book.

And yet, I still have lots of doubts.

The métier of producing type is a constant doubt-and-choose-and-doubt process. So, this series of articles is my personal view on how I tackle (or try to!) these daily things, an ongoing exercise on thinking what I do.

Hope you enjoy it!

10 Tips On Kerning And Metrics

This is a brief collection of quick tips on kerning and metrics, as the title may have suggested, that I find valuable.

Although this is intended for Type Design, this article should be valuable for DTP software kerning or Logo Design. Or anything that has to do with letters.

And if you’re wondering what’s the font in the image above, here it is.

All set? Let’s go!

1. Proper Spacing Means Less Kerning

This should be a no-brainer. If your font looks good overall, you’ll have to kern less.

So, try to keep your metrics as consistent as you can, well overshot and only go for kerning when you feel that there’s no other way to space it better. I usually space the letters as I am drawing them, to see if I have a good flow and I might solve some spacing problems in the letter form itself.

2. Classes

Use kerning classes. There.

In case you are wondering why, it’s just way easier to grab a bunch of glyphs of the same group (for example a and all it’s diacritic marks), assigning them to the same kerning class and then kerning them than doing it pair-by-pair. Even if you have to deal with some collisions, it’s a lot less work.

3. Kern First, Ligatures Afterwards

As much as kerning is tedious and I love to push it to the end of the production, it’s not a bad idea to do the ligatures after you’ve already kerned at least the alphabet: in that way, you avoid having to correct bad spacing to your ligatures, saving you some time and some eyeballing doubts.

4. Mirroring

Mirror, mirror, mirror. Horizontal and vertically. At the same time and with just one axis mirrored.

The goal here is to step yourself away from text as more as you can, and trying to see “pure” forms. It lets you approach the design as an abstract composition, making it easier to balance your spacing.

And this is not just for kerning and spacing: it helps you to get a good flow in your design and it’s easier to perceive not-so-obvious design flaws.

Also, I’ve recently found that I can read fluently upside down or when the text is mirrored: it’s like having a super-power!

5. Straight Neighbours, Round Neighbours

Before going for text-string kerning (I use Just Another Foundy‘s Test Text Generator, by the way), I start doing kerning with straight and round neighbours (and/or a mix of both) in both sides of the pair I’m working on.

For example, if I’m kerning A/V, I’ll have something like HHAVHH OOAVOO HOHAVHOH. And I just noticed that the font I’m using here is not properly kerned. See? It works.

6. Pay Attention To The Space Width

This one is often neglected.

Most of the times, if you space your sidebearings right while your drawing, usually you don’t have to kern the space glyph at all. So, you have three options:

1. Set your space width and do your metrics accordingly;
2. Do your metrics and set the space width accordingly;
3. Ping-pong between the two.

In my opinion, go for option number 3.

Metrics and kerning deal with the space between letters – and that includes the space between words.

7. Blur your eyes

This one is related to §4, the goal is the same than in mirroring.

8. Keep Rhythm Consistent

While kerning, try to keep equal perceived space between the letters. Not mathematical.

All letterforms are different (I like to state the obvious), no there’s no equal solution to every single pair. Even if we think that we shouldn’t kern n/h, I believe that we should check it out anyways. In this example, the top right curve of the n can be creating too much white space, for instance. And it only takes a second.

9. Don’t Forget The Left Side, Jedi

One common thing to forget is to pair lowercase on the left with the uppercase on the right.

While this should be going without saying, when you’re kerning hundreds or thousands of pairs, you can easily forget this. Your end user might want to use your font to write something like YoU’rE sO fLuFfY and you’ve might have just lost a client for not having those pairs kerned. Or saved the world. Who knows!

Anyway, lowercase/uppercase pairs are not uncommon at all, specially in logo design. So keep this one in your to-do list.

10. Trust The Eye

Well, this is the most valuable advice on type and graphic design. It’s very usual to be insecure and trying to find some über-rational process, way or calculus to make you feel that your choices are the best, but hey: type is for the eye, not for the computer.

If what you see feels good, then it’s good. If it doesn’t, then it’s not. It’s that simple. You’ve looked at type your whole life, even before you could read, so just assume that your subconscious is a very well trained machine for eyeballing these things. And the more you try, the better you become at it.

And trust me about this: I’m a optimization geek. I spend a lot of time trying to perfect the way I do things (as you might have noticed while reading my article on Bézier curves) and the better it looks, the less I’m concerned with geometry or space rationalization.

11. Final Thoughts

I wrote this because kerning is one of the things type savvy people complain the most about, but I think it’s not that hard. And yes, after some hours doing it, I also complain about it.

But it doesn’t take as much as you’d might believe it does, time-wise or knowledge-wise.

I hope this has been valuable for you, somehow!

And feel free to drop me a word! Cheers!

Bézier Curves and Type Design: A Tutorial

[2026/09/14]: This article became the most popular I've ever written. Since it was written a long time ago, I decided to rework it: polishing the wording to facilitate comprehension, fixing dead links and typos, and adding interactivity. Still, it remains faithful to the original — a lot of people discussed it and helped me flesh it out into what it became, and I want it to continue reflecting that process. Enjoy!

Whenever I am asked to assess the quality of a typeface or logotype, or when someone asks me for help with their typefaces, one of the most common problems I find is bad Bézier curve design.

And every single time this happens, it’s not people’s fault. It is a fatalism of existence: if people knew better, they’d do better. Surprisingly, it seems that a lot of people have trouble wrapping their heads around this: students struggle with it, fellow lecturers despair.

And then there’s that heart-stabbing situation when someone drops by and says “Hey, I just finished this font, can you have a look and see if something’s missing?” and I feel obliged to say, with grief, “You have to redesign it all over: it’s poorly designed, Bézier-wise”.

So, in order to save some people from this hassle, read along.

1. Problems

First of all, we should understand that each piece of desktop publishing software is going to compile the font files in its own way. Moreover, each one of them is going to convert the curves through its unique algorithm, sometimes unleashing hell.

Flash IDE [now Adobe Animate], for example, is notorious for wrecking curves. It does so based on the size of your vector artwork in order to keep the file as small as possible. If fonts are not embedded, the same happens.

Some programs, like 3D applications, simply break the curve into several facets. So even if you are doing something in Illustrator to use in 3DS Max, for example, read on; it might save you some trouble.

2. Reasons

Usually, all of this revolves around how PostScript and TrueType deal with outlines: TrueType uses quadratic Bézier curves, and PostScript uses cubic Bézier curves.

I know, I know, geek stuff. Here’s the simple explanation:

• A quadratic Bézier curve (read TrueType) has 3 points: an insertion point, a control point, and an end point.
• A cubic Bézier curve (read PostScript) has four: an insertion point, an end point, and two control points [also referred to as handles].

And for the visual type of person, here’s an image:

So, if we were to draw a circle in both curve equations, they would be drawn the following way:

Let’s count the number of points needed for each circle:

• Quadratic: 8 anchor points + 8 control points = 16 points;
• Cubic: 4 anchor points + 8 control points = 12 points.

Counting points might seem unpractical and silly, but it can tell you a couple of things right away:

• The most obvious is about file size: fewer points, fewer point coordinates, mean a smaller file size. Cubic curves win in this matter;
• Two control points per node allow more freedom while drawing, since it gives more control on the curve itself. Quadratic curves force the user to add more anchor nodes¹ (since the addition of every angle per curve can’t be bigger than 180º), adding difficulty to the process of drawing a clean curve.

If this is so, it seems that cubic curves win over quadratic ones; so why aren’t quadratic curves obsolete?

3. Digging deeper

But how are Bézier curves calculated? Let’s start with quadratic curves.

3.1 Quadratic Curve rasterization

We have our three points: two anchors (in and out) and one control point. Let’s call the anchors A1 and A2, and call the control point C. Next, let’s connect A1 to C and C to A2 with straight lines, as shown below:

Now, we’ll add two points: one that travels from A1 to C and another that travels from C to A2, and they’ll take exactly the same time to make their trip. And for the sake of this exercise, we’ll also add a straight line that connects the two traveling points (shown in black, below):

Again, let’s add a new point, one that travels between the two black points, taking the same time to travel from one point to another (shown below in white). If we track its path while traveling, voilà, we have our quadratic curve rasterized:

OK, so now you know how a computer renders a Bézier curve:

• It’s not actually a curve, but several iterations of straight line segments, smaller than pixels, that create the illusion of a curve. It’s what a 3D application does while smoothing a mesh — it breaks it exponentially, until the mesh seems smooth, when, in truth, it is just a bunch of tiny, tiny planes.
• The same applies when you zoom in or out, or when your printer’s rasterizer prepares a document to print: it rasters the curve to the intended resolution.
• This is why older vector drawing applications would break fonts’ curves in bigger or smaller iterations, depending on the size that one would convert them to outlines — the raster algorithm would iterate depending on the size needed, because processing power and file size were limited;
• Still, applications have their own rasterization algorithms, and this is still needed. InDesign, for example, deals with huge amounts of text (meaning lots and lots of points and curves), so it provides different levels of rasterization resolution, so it doesn’t get sluggish. Sub-pixel rendering, on the other hand, might do three or four different rasterizations and combine them, or nudge one in different ways. Simply put, ClearType would kill your 386 machine.

3.2 Cubic Curve rasterization

So, what about cubic curves? Is the rasterization done the same way?

Well, yes, sort of. It just adds another level of our “traveling points”. Have a look:

See what they did there? Right, a moving quadratic curve inside a cubic one!² Here’s some deductions on cubic curve rasterization:

• We’ve noted that cubic curves reduce the file size by 1/8, but the demands on processing power triple.
• While a ceiling of 180º is possible with quadratic curves, we can go up to 360º with cubic ones.

3.3 Going back and forth

The addition of multi-order intermediate points can go down to infinity, and it’s possible to break cubic curves into quadratic with minimal loss in quality. The other way around, well… it gets tricky.

Quadratic curves are always conic sections, while Bézier curves that have more than one level are a result of curve funkiness, meaning, a collage of cone sections’ sections.

So if we were to write an algorithm to convert cubic curves to quadratic, we would have no problem: we would just check for cone sections that would fit on that curve.

But if we were to write one to convert quadratic to cubic, the best the program could do is an approximation of the original outline, usually keeping the anchor points it already had, but adding one more control point per anchor. So, file size wise, not a good idea; processing power wise, even worse.

Edit: As it was stated over at Hacker News by simias and jacobolus, and kindly explained by nanofortnight, the above statements are wrong — in fact, the truth is the very opposite.

If we were to convert a quadratic curve to cubic, it would be the exact same curve, as nanofortnight demonstrated. But, as jacobolus pointed out, due to the integer structure of font compiling, this conversion might not be exact.

And when we go to convert cubic curves to quadratic, it’s not as easy-peasy as I stated above. For further reading on this, check this out.

Is this a problem, then? Well, these conversion issues are the reason why DTP software and printers favour PostScript, i.e., cubic Bézier curves. If the drawing was provided in quadratic curves, the software could easily convert them to cubic; if it was already in cubic, it would simply keep it that way.

So, while designing type, you opt either for TrueType or PostScript. And, while this makes me favour PostScript, if you start with one, stick with it.

But why do type design applications offer cubic curves only or have them as default, as a drawing method? Well, as debated, conversion from TrueType to PostScript is optimal and the other way around is not. And the third reason comes next.

4. File Size

We already know that you can draw the same thing with cubic curves using fewer points, but there are also some other things that we can take into consideration, regarding file size.

4.1 Always work with integers

FontLab [Studio³], for example, doesn’t even let you use decimal coordinate data, and no sane developer will build a vector drawing application that would allow point data to infinity. Since we still need a worldwide network of computers just to find some more pi digits, no one gets to treat themselves to perfect circles.

But then again, if your eye can’t tell the difference and, in fact, you still have to cheat the circle to make it look like a circle (when you adjust forms optically), using decimal numbers on type design is just some sort of geek stubbornness.

And there’s the workflow issue: ask any professional type designer if they use Illustrator — or another vector drawing application that uses decimal numbers by default — and you’ll find that very few say yes; and even those who do still have to adjust their drawings in a font editor.

It’s way easier to nudge with the keyboard arrows than to use a text box to input integer values. On the other hand, a lot algorithms used for font handling in DTP software simply round the points to integers, so they can handle them with less storage and processing resources.

Edit: And, as Pomax kindly pointed out, the OpenType specs only allow for integer point coordinates anyway.

But the big issue here is file size: if you have a file with integers and 4 points, it will be smaller than a file with two decimal figures and 2 points. Make some thousands of points and the difference in file size balloons, as well as processing requirements.

5. Always work with cubic curves

Cubic curves win, for all the reasons mentioned above: easier to draw with [there are more reasons for this, keep reading], better conversion to quadratic than the other way around, smaller file size. You know the drill.

But it is also worthy of note that this is why cubic is the safe default when we start drawing fonts — conversion to quadratic is lossless, so your outlines are always reproducible by other tools and designers.

6. Keep anchor points at extrema – and handles straight

This is a big one. Most of the time, the most common problem I see is that the anchor points are haphazardly positioned, spread all over the place. This results in jagged lines, poor rasterization, bigger file sizes (who hasn’t tried to fix something by adding more, right?), increased difficulty in drawing, and the list goes on.

If you want to draw a smooth curve, having the anchor points at the horizontal and vertical extrema and keeping the handles vertical or horizontal is enough. It gives you better control over the curve path and less stuff to adjust: it keeps most of your curve segments under 90º and transitions predictable.

Edit: And, although implied above, is good to mention: do not invert the path direction with your handles (thanks to Pedro Amado for pointing that out). Here’s what I mean:

Keep in mind that we’re talking about what should be in your final output. Although I recommend keeping your placements tidy and as close as possible to what it should be, inverting the direction like in the image above can be a way to draft quickly⁴.

Edit: 7. Explicit Inflection Points

Hrant Papazian made me notice, on Twitter, that I’ve missed a point (pun intended!). The example above, on the right, lacks an explicit inflection point.

“What the hell is that?”, you may ask. Well, in an ideal scenario, all points should alternate between vertical and horizontal handle position. Why? Because we want to keep each curve segment without inflection points, in order to have an optimal conversion from cubic to quadratic.

“OK, lovely, but you haven’t explained what an inflection point is”. True. Here it is: the inflection point is where the curve changes direction. So, if you’re walking from left to right and start leaning to the left, the place where you start doing so is your path’s inflection point⁵. Simple.

So, in the example in §6, the curve changes paths between the two horizontal handles, creating an inflection point. How to avoid it? Well, make it explicit; i.e., add an anchor point in that location. This way, the curve is split into one-direction-only segments:

For more  information on inflection points, have a read here.

Edit: Also worthy of note, pay attention to how the handles retract at every step of the way. Even if you thought “Yeah, of course it does” — kudos to you, tap yourself in the back on my behalf — the bounding box for coordinate control also got smaller. This makes our life easier while editing: we get a better view to what we’re doing.

8. Final considerations

I know this was lengthy and somewhat technical, but I believe it’s important to know why instead of just how. Computers have limitations – and will always have – so it’s important to make the best of it; and for that, knowledge is key.

I hope you had as much fun reading this as I had making this article. Thanks for your time!

References:

• Bézier Curve, Wikipedia
• PostScript, TrueType and OpenType: Curves and Outlines
• So What’s the Big Deal with Horizontal & Vertical Bezier Handles Anyway?, The AGSC [Wayback Machine]
• Inflection Points of a Cubic Bézier, Caffeine Owl [Wayback Machine]
• Bezier Curves and Picasso, Jeremy Kun

1. Anchor node is a general term for insertion and end points of a curve segment. Since the curve always goes through these, they “anchor” the curve to it. ↩︎
2. This algorithm for drawing/splitting curves is de Casteljau’s algorithm. ↩︎
3. FontLab has supported floating point coordinates since version VI. But it still compiles to integers. Just a relic of how long ago this was written. ↩︎
4. Let me also state that whenever I do this, I add the extrema points right away: there’s not much control in drawing such a huge angle and inversion with just two points, especially when it comes to curve tension. ↩︎
5. I encourage you to go back to §3.2, where you have the interactive cubic curve animation. Drag points around so that you have a curve and countercurve and pay attention to the gray line — you can see exactly when the curve “flips” direction. ↩︎