Instead of perfect circles, we use a shape that is taller than it is wide; instead of splitting the space in half, cross-strokes should be higher than the middle; different strokes need to be different widths in order to appear the same, etc.
There are plenty of actual scientific studies and theory behind this. See Ruder's Typography [0] and Hochuli's Detail in typography [1] for more info.
[0] http://www.amazon.com/Typographie-Manual-Design-Emil-Ruder/d...
[1] http://www.amazon.com/Detail-Typography-Jost-Hochuli/dp/0907...
I know different things are important to me when viewing programming text than reading. A simple, somewhat contrived example would be whether 'r' and 'n' together are easily discernible as 'rn' or 'm' (which is mostly a non-problem with mon-spaced fonts). When reading text, I can infer from context what the word most likely should be, but when programming, that's an error waiting to be found at some point.
To expand on this, different programming languages may stress different qualities of a font. From experience, I find when parenthesis look like curly braces in a font, it increases my frustration as it causes ambiguity where there should be none. This may be less of a problem in a language that uses fewer braces.
The 'rn' case is one of kerning, and is an issue independent of the mono- or proportional-ness of the font; it's one of kerning. You can have 'r' and 'n' at full width for the font, and they'll look very 'm'-ish. If you have 'rn' looking like 'm', it's just as awful when you're reading a novel as when you're reading code.
This is OK virtually 100% of the time, in that there are no circumstances where you'd be confused over which was meant. In contrast, I write 1 and l exactly the same way under most circumstances. That could be pretty annoying if, say, I was doing a geometry problem involving a line named l, since numbers frequently appear in math problems. In fact, I suspect that many other people have had that same problem, since high school geometry textbooks, while they still like to name lines l, use a cursive font for it.
It's very rare for a literary work to feature e.g. one character named Oscar and one named 0scar.
No. Kerning applies to proportionally spaced fonts, not monospace fonts. See, e.g., http://en.wikipedia.org/wiki/Kerning Designing monospace fonts so that character combinations are more readable has nothing to do with kerning.
Right, but not for comprehension the way you read prose, but for technical accuracy of an input to a mechanical system that will read it and which is intolerant of errors even when the meaning is clear from context. For human consumption of prose, fonts that can sometimes create ambiguities of individual characters that are easily resolved from context but which keep the overall shape of morphemes recognizable are mostly fine, for creation of content -- particular content to be read by a machine, they are not.
> General readability matters -- when is it OK for a regular font to be unclear about which character (a zero or 'O') you're looking at?
For readers, quite a bit, because for most purposes, the meaning is clear from context (same with 1/I/l), and because people with more than marginal literacy mostly are recognizing the visual shape of (approximately) whole morphemes, not individual characters.
> If you have 'rn' looking like 'm', it's just as awful when you're reading a novel as when you're reading code.
For the reasons stated above, that's not really true.
The difference in mix of characters reflects on the design decisions made for the font type. Target use is important. Some types are great for titles, some for text bodies, some for logos. It makes sense to me that code is another category.
Yes, readability is important, but it's not binary. The level and aspects of readability required for a novel body are not the same as for an article title.
Differentiating between zero 0 and uppercase O is critical for code (and work terminals, and perhaps data tables), but IMHO isn't interesting when designing for text bodies. Same goes for 'rn' and other issues that have ever annoyed only programmers.
This makes the door spacing look equal from our usual standing position.
What sounds good on paper/design (Make the spacing equidistant) can often look terrible in practice.
I think the font looks ok, but the "d" looks bad to me. And I'm not convinced about the "t". Maybe they make sense on paper, and have very nice mathematically correct proportions, but they still don't look right to me.
Just don't get why it's on the front page before release though. I guess for comments, but add a place where I can sign up to be notified when it's done or something...
[Edit: I think the rest of this comment was too negative, and the guy submitting it doesn't seem to be the author of the font, which I didn't realize, so was perhaps not really applicable. Never mind!]
Just a shame the '8' character looks a bit like an upside down snowman is all I would add.
Then again, my first question upon seeing this on HN was "how on earth is this relevant/interesting? It's not even finished!" so discovering that the source for the submission was a tech subreddit is unsurprising.
Plotter fonts are intended to exactly communicate important technical information. They are designed to be highly legible, irrespective of whether you think they look nice.
It's the same with old-school pixel fonts, which had to exactly communicate easily confusable glyphs, instantly, on a low-bandwidth communications channel (an 8x8 or even 9x16 monochrome character cell is very low bandwidth). So a lot of them looked butt-ugly. But they were easier for a programmer to read than if he had been doing all his code in Helvetica Neue.
That's why I do all my hacking in Glass Tty, Terminus, or good old 7x14. As for this font -- it's nice, but not Terminus nice.
Legibility isn't the same as readability. ALL CAPS is highly legible, and so are freeway billboards - neither are optimized for high comprehension, high speed, and minimal fatigue during extended sessions.
For example, exaggerating key elements on select glyphs (compare Glass TTY's counter in '4' to AutoCAD's Big Type '4', or the beak on '1') can help at-a-glance perception of plotter output, but exhaust quickly in longer documents.
Actually, plotter fonts are optimized for pen movements, not legibility.
The entire Metafont collection, was designed by a programmer.
The OP font, was designed by a programmer.
I come to the conclusion that fonts designed by programmers make more sense than database libraries by font designers, unless Hermann Zapf wrote a framework and I've never seen it.
[1] http://www.robofont.com/ [2] http://letterror.com/ [3] http://www.petr.com/ [4] http://en.wikipedia.org/wiki/Web_Open_Font_Format
Similar goals, but different philosophies.
While I applaud his effort, this is why wonderful movies aren't musically scored by the director or writer - they may know what they want, but that doesn't give them the ability to create it.
Like medicine "created by a school teacher".
If designers want so much that programmers get their fonts from them, they should try to create something that's suitable for programming. That does not seem to be happening now.
And, yes, I quite liked it. If I hear about it again when the author releases it (why didn't he already?), I'll probably try it.
I agree with your general point though, a collaboration between the "user" and "expert" will generally produce something superior; but sometimes there can even be a little bit of a liability having the other party around.
The school teacher thing is a poor example though - that's just marketing trying to make an appeal to authority. Something like if a teacher had designed a desk or chair would be better because their job gives them insight into that as opposed to say, a mail carrier.
PS: I'm a programmer and find the font attractive and easy to read, go figure.
All that said, this font looks pretty good to me as a programmer, (12 point version, at least), and I'm going to try it out when it's available. I've been looking for a good font to use in emacs on OS X and have never found one that I liked. (On Linux, my preference is 9x15.)
I've put 9x15 for Windows here: https://dl.dropboxusercontent.com/u/19746944/cheever.fon (I can't remember how I got it)
I think I even found some unicode support in one or two at some point (technically impossible with the Windows bitmap font formats), but I can't seem to find any right now, bah.
Having said that, I will not use this particular font, because I like others more, not because of the degree his creator has got.
What i would like to see from someone like you, that criticises the work on display, in this instance, would be:
-what font do you currently use?
-what evidence do you have that it was 'designed by a font designer'?
-what evidence do you have that such and such designer made decisions that are more accurate than the ones made here and for what reasons?
-is there a write up by said designer that describes those decisions and possible alternatives and reasons for doing one while avoiding another? .. this is my issue with the post, i feel it is too sparse on self addressed argument ..There are blogs dedicated to the process that help you learn about the process and decisions being made.
For example:
http://ilovetypography.com/2009/12/15/font-design-vesper-typ...
http://ilovetypography.com/2010/10/10/the-making-of-acorde-2...
1. The lowercase 'm' is muddled and looks bad without anti-aliasing, downright horrible with anti-aliasing. 2. The lowercase 'k' is "too unique" and distracting (personal taste) 3. The lowercase 'e' is too squished and doesn't read well at small point sizes.
Overall, this font is not horrible. But with every "programmer-centric" new font that gets a bit of buzz, I always end up going back to non-anti-aliased Monaco within a day or two. It just seems like one of those perennial non-problems people keep having a go at.
This font that OP is showcasing isn't terrible, for a first pass, but there are some problems (funny lower case f curve really bugs me. It's overly pronounced) that need to be ironed out.
The former in Notepad++, the latter is perfect for Eclipse, because Eclipse has a very small spacing between the lines (not configurable) and many other fonts look too condensed due to that.
It doesn't look terrible, is have to try it out on a computer to see if its useful.
This is wrong, and misleading.
Monospaced fonts are usually designed with specific usage in mind. Come one, font designers don't live in a cave. They are usually briefed for how this font is intended to be used.
See, for example, a Consolas case study:
http://www.lucasfonts.com/case-studies/calibri-consolas/
>The first typeface Luc(as) was invited to work on was Consolas, a monospaced font (a face in which all glyphs have equal width).
>Intended for use in programming environments and other circumstances where a monospaced font is required, Consolas has proportions that are closer to normal text, and is therefore more reader-friendly than many other monospaced fonts. OpenType features include hanging figures or lining figures; slashed, dotted and normal zeroes; and alternative shapes for a number of lowercase letters, notably the most problematic character in any monospaced font, the ‘i’. The look of the text can be tuned to personal taste by varying the number of bars and waves in these letters.
>De Groot teamed up with a programmer to test the use of Consolas as a font for coding. “Having a programmer involved,” says Luc(as) with a smile, “I could preview hardcore use on the light-weight notebook chosen to represent his species’ preferred tool.” As the default monospaced font in Windows Vista as well as the Office Suite, Consolas became the de facto successor of the ubiquitous Courier.
(emphasis mine)
> Every glyph was carefully planned and calculated, according to defined principles and rules. For this reason, Hermit is coherent and regular.
I hate to say this, but a font by a programmer makes as much sense as a database library by a font designer. Good font design is not about calculations or following principled rules; it's about what looks good to the eye, and it takes a tremendous amount of skill and experience.
And to my eye, at least, the font is incredibly difficult to read. It literally looks like a font designed by an engineer for a plotter, not something designed for the human eye or legibility.
Good fonts follow intuitive rhythms, they focus on word shapes (not just letter shapes), natural curves, there's a tremendous amount of subtlety that goes into achieving a proper sense of balance between letterforms, and a lot of things are actually different between letters/curves/etc. so that they look the same to the eye in the end. Even with "utilitarian" fonts like monospace ones.
"Carefully planned and calculated" is a great recipe for building a bridge, but not for building a font, unfortunately.