Robothon 2009: day 1 afternoon
Note: The Robothon is actually being live-broadcast over at http://18.104.22.168/kabklivestream.sdp
The whole conference organisation is great, coffee hasn’t run out and lunch included kipfilet met pestomayo en pijnbonen sandwich. I missed the Neds :-)
Tal Leming: UFO2 Launch
UFO is the file format developed by Letterror and Typesupply to provide an XML representation of fonts. Tal will present version 2 of UFO.
UFO2 was made with a focus on interoperability, touching hands with AFDKO, FontLab, Superpolator et al. It borrows the font features syntax from AFDKO, has a much bigger namespace and now caters to most (all?) OpenType features.
I couldn’t help but notice that UFO has a “copyright” field instead of “license”. Later, a remark by Tal that “Python ought to have smart quotes” was greeted by a “woo!” from the audience. The presentation ended quickly (ahead of schedule, actually), something that would be happenning through the rest of the afternoon — how common is that?
Tal Leming: Area 51
“XML is fine, but I like to see what a glyph looks like, instead of what it reads like”
Tal built a wonderful editor for UFO fonts, with a beautiful Cocoa interface and some neat tools — a full functional code editor, notes for individual glyphs (does Fontforge do this?) and also acts as a frontend to AFDKO (using makeotf); it isn’t designed to do point manipulation, though.
It was pointed out that the glyph previews were rendered onscreen as bézier paths, via the NSBezierPath Cocoa object — this reminded me of sleepless nights reading Nodebox‘s code.
So, thanks to Tal’s generosity in sharing his code, the Mac world now has a GUI for doing UFO to OTF conversion (even though it’s apparently beta), through the ‘Generate OTF’ menu option; there’s also the chance to do batch conversion from inside Area51.
Tal Leming: MetricsMachine 4
No one likes kerning! MetricsMachine is the tool Tal’s come up with to ease typographers’ pains and wasted time on repetitive editing.
It’s designed for doing a whole family’s kerning in a consistent manner — it groups accented glyphs (changing A’s kerning also changes ÁÀÃÄ[...]) and similarly shaped ones (V and W can be kerned as one).
It makes smart pair lists, handles exceptions (for example, the special case where an ogonek A clashes with a y) and does proportional transformations for cases such as adapting capital letter kerns to small caps. A feature that the beta testers loved was the progress bar which indicates how far you are from completing the kerning job for the whole font.
There’s a beautiful visualisation of all the kerning relationships in a two dimensional heat map, to which my photo unfortunately doesn’t do justice.
Erik van Blokland & Tal Leming: Interpolating with Prepolator and Superpolator
Tal Leming is now showing Prepolator 2, a tool that can load a group of UFO fonts and set them up for generating interpolated derivatives. It has a rather user-friendly interface to solve contour-matching conflicts that usually result in distorted output. Moreover, it has a handy ‘Deduce’ feature which, automagically and appropriately, tries to discern the correct placement of the contours (it brings to mind the gnarled shapes of Flash shape auto-tweening).
There’s some wonderful features in Prepolator, such as a Preview-like slideshow for proofing the outputs, not to mention its simple and pretty Cocoa interface with carefully designed icons.
Erik now stepped up to showcase Superpolator, the tool to actually process and output interpolation-based fonts. He went back to recap previous software interpolation strategies — Fontlab blend, Multiple Masters, straight interpolation (using Robofab scripts) and, finally, Glyphmath, which is a Robofab component which operates mathematically on glyphs (e.g. dividing a glyph by 2). Erik had worked with Apple to develop for its TrueType GX format, coming up with a ‘superpolation’ algorithm with an unlimited number of interpolation axes and masters (unlike Adobe’s Multiple Masters), partial masters, kerning, font.info and UFO2 compatibility. He then explained why he wasn’t happy with the constraints placed by Multiple Masters and went on to design his own interpolation system.
The notion of ‘designspace’ came up to explain his engine: it’s essentially based on an n-dimensional matrix which can be populated with masters and, unlike Adobe MM, it allows for extrapolation (that is, deriving forms outside the space between the masters, filling it in through magicmatics). From there, one can just adjust the parameters and navigate the infinite variations to finally end up with the desired weight and dimensions. Erik then treated the audience to some stunning animations showcasing the Superpolator engine.
[for some reason i'm not able to upload my videos; not sure if this has to do with the KABK network, will try again when the day is over]
A demo of Superpolator ensued, with Erik showing how it works (using Gustavo Ferreira’s Publica typeface) by setting some axes and UFO masters. Afterwards, it’s necessary to assign coordinates in the design space for each of the masters. Nothing else is needed.
This is where extrapolation shines: one can have values beyond the -1 to 1 range and Superpolator will calculate how that would look. After adding a width axis to the design space, stuff becomes beautiful.
Extrapolation allows for extreme values and fun experiments. After playing with the sliders and animations, we move on to generate instances — new fonts based on interpolating the masters. As one would expect, instances are generated in the UFO format (v1 or 2). More fun is to be had if the new instance is set as a master, which makes it possible to refine the design space.
Superpolator’s features don’t seem to end — it can generate PDF specimens of different instances, it has a few preview modes (inverted, outline), it can ignore certain axes for certain characters for selectively preventing some characters to be altered by the interpolation process.
It’s incredible how Superpolator achieves all of this based on extrapolation of character outlines — the animations appear so smooth that one would think that we’d be looking at a Metafont-like parameter based system.
Tal Leming: Building Apps
Tal has been building Cocoa applications for a long time and has laudably open-sourced the frameworks he built to ease his tasks — these are Defcon, DefconAppkit and Vanilla. Robofab was built as a scripting library placing comfort over speed, while Defcon values speed over comfort, providing a foundation with a strong API to build an application on.
He went on to explain the relationship between interface and object, and the pitfalls of establishing connections between both, as complex applications tend to tangle up those links. He then explained the ‘observer pattern’, which adds a dispatcher to mediate the relationship between interface and object. This way, the object doesn’t have to contact the ‘outside world’, using the dispatcher as a bridge; this model allows for having multiple interfaces connected to the same dispatcher (which in turn is connected to an object). If one takes out parts of the interface, or revamps it, its relationship with the object isn’t affected (= stuff doesn’t break).
Tal then explained the issue of representation — how to present data. For instance, fonts can be presented as images to avoid constant redraws; this doesn’t change their font-ness but is rather important when considering interface matters. He went on to explain how these concepts relate to the Defcon system: glyphs need flexible representations for performance reasons. This is why Defcon caches the font images and is smart enough to not let the user be bothered with what goes on under the hood.
The subject shifts to the interface part. Defcon is based on Cocoa and PyObjC. Instead of dealing with those directly, Tal uses Vanilla, a wrapper around Cocoa to provide a simple means of creating windows and widgets via Python (‘I’ve been using it for 5 years without anyone noticing it’). Vanilla makes GUI management a lot more straightforward, with many ready-to-use widgets. Apparently, Cocoa’s InterfaceBuilder is awesome but requires you to deal with C directly, which is why this custom interface library came up.
Moving on to DefconAppkit, it provides functionality over the interface builder, like selections, previews, glyph windows, config dialogs and code editors. It’s a set of custom widgets for use with Defcon.
Some other libraries Tal created were glossed over: Fontmath, Compositor (an OpenType layout engine) and UFO2FDK.
Finally, how does he design and build apps? He brought up the example of Area51 as a demo app, which was built in a week thanks to the use of all the building blocks described before. Such an approach is fundamental to go on making applications [it's about DRY -- Don't Repeat Yourself]. Tal seems happy to describe himself as a nerd who loves coding his own libraries and at the same time keep a purpose; the advantage of that totally shows.