/var/log/tinkerhouse

Through the great Linux for Designers blog, we find some exciting developments scheduled for the next release of Gedit, the awesome Gnome text editor. Check out Eckhard’s post for news and links for more, but be sure to check this screencast showcasing a juicy new plug-in: Multi-edit!

Gedit’s great plug-in architecture (based on Python, of course ;o) makes it possible for us to switch the Shoebot IDE to Gedit. Before, we had hacked together the Shoebot GUI editor as a GTK application with a GtkSourceView widget, along with a few options and tools. Through a plug-in, we can just turn Gedit into a full-featured IDE, since we can include other plug-ins as well to make a coder’s life easier. And no re-inventing the wheel anymore!

Gedit is available for GNU/Linux (check your distro’s repositories, it’s surely there!), Windows and OS X.

Interrupting my silent streak (as this had to be blogged :) a
wonderful bit of [news][ospann]: the **Libre Graphics
Meeting 2010** will be held in Brussels!

Keep an eye on the [LGM][lgm] website for further news!

[ospann]: http://ospublish.constantvzw.org/news/libre-graphics-meeting-2010-in-brussels
[lgm]: http://www.libregraphicsmeeting.org/

A few days ago i heard that [lib2geom][lib2geom] came out with a new version.
The best news are that there are functional Python bindings available!

Lib2geom is an awesome library to deal with vector mathy stuff — points,
beziers, arcs, boolean operations and all those convoluted things that we take
from granted in WYSIWYG software, but are remarkably absent from the Python
world. Well, no more, now that py2geom is around!

For installing it on Debian-based systems, one just needs to track the dependencies:

sudo aptitude install libcairo2-dev cmake make libboost-dev libgsl0-dev

This will pull a *lot* of packages because you’re using development libraries.
But it’s worth it :) After that’s done, get the source from the SVN repository:

svn co https://lib2geom.svn.sourceforge.net/svnroot/lib2geom/lib2geom/trunk lib2geom

Now head to the lib2geom/src directory and type

cmake -i

Say No to advanced options, and then say yes to the ‘Python’ and ‘Shared’
options, which should be the first two that you’ll get asked. After that, just
hit enter to the other options and once cmake is done, do

make

My machine complained, giving out a lot of warnings on cmake, and make
eventually borked with some nagging about a missing ‘glib.h’.

After calling for help at the 2geom channel on Jabber, njh gave the great
advice to run

sudo apt-get build-dep inkscape

which will install all libs necessary for compiling Inkscape and thus 2geom
(and there’s an awful lot of them).

After make was finally done, just do the magic

sudo make install

To make sure stuff is in the right place, run python and try:

Python 2.5.2 (r252:60911, Oct 5 2008, 19:24:49)
[GCC 4.3.2] on linux2
Type “help”, “copyright”, “credits” or “license” for more information.
>>> import py2geom
>>>

If you don’t get an ImportError, perfect! Trying the example from the
[Inkscape wiki][inkscapeexample] shows the neat stuff 2geom can do:

>>> import py2geom as geom
>>> a = geom.Point(1,2)
>>> b = geom.Point(31,2)
>>> print a, b
(1.0, 2.0) (31.0, 2.0)
>>> print “Dot product:”, geom.dot(a,b)
Dot product: 35.0
>>> print “a times 2:”, a * 2
a times 2: (2.0, 4.0)
>>> print “Equal? (0 = no, 1 = yes):”, a == b
Equal? (0 = no, 1 = yes): 0
>>>

There’s still some work to be done on the Python bindings (for example,
there’s still no binding to the Path object), but the future looks bright for
the vector scripting world (:

[lib2geom]: http://lib2geom.sourceforge.net
[inkscapeexample]: http://wiki.inkscape.org/wiki/index.php/Lib2geom_py2geom

Restrictions are known to breed creativity. Having dropped Windows two years
ago, and given that [OpenOffice Impress][ooi] is a bit too heavy for my tastes and
machine (a humble Eee), i had to look for alternative presentation tools.

I do like having full control of my presentation and loathe the template system
of Powerpoint and Impress for setting text. I was already used to making PNG
slides and make a presentation using simple image viewers.

The best thing that happened to me regarding this issue was running into
[KeyJNote][kjn], which can grab your set of PNG’s, JPG’s or even a PDF file and
provide you with a beautiful presentation with clean and smooth transitions.
Better: it’s scriptable, it has a friendly GUI but, most importantly, all of the
presentation’s properties can be set via command-line options. It’s now my
one-stop application for all kind of presentations: i make the slides in
Inkscape or Scribus, and then output PNG’s or a PDF and off we go.

And there’s some promising developments on this side of things:
[Prezi.com][prezi], still in beta (and unfortunately not free software) gives
you a new way of presenting using only one big diagram, and the progression of
the presentation is made by zooming and panning through the image. The
[inkscape-devel][inkdev] had some interesting discussion on how to implement
this kind of paradigm using SVG. I’m dying to see if there’s some progress in
this.

Lastly, and also via [inkscape-devel][inkdev], a great new Javascript app –
[JessyInk][ji] — was released, and it allows you to create a presentation in
Inkscape which can be viewed in your browser using neat SVG magics.

There’s certainly a bright future for presentation tools, especially now that
we’re slowly breaking free from the dull Powerpoint models that have been
haunting us all these years.

[ooi]: http://www.openoffice.org/product/impress.html
[kjn]: http://www.linux.com/feature/62278
[prezi]: http://www.prezi.com
[inkdev]: https://lists.sourceforge.net/lists/listinfo/inkscape-devel
[ji]: http://code.google.com/p/jessyink

After the Robothon, and being very impressed with the power of Robofab and its
associated toys, i was looking for a similar toolkit for GNU/Linux systems.

Didn’t have to look very hard — actually, only had to look back: i had dabbled
with the **python-fontforge library** some months ago while building
[Lettersoup][ls].

The fontforge Python module is a beautiful hidden treasure in the turf of FLOSS
typography. Going along with George Williams’s characteristic [subtlety and low
profile][gw], it’s hard to find any mention of it anywhere, even inside the
free software press.

Given the excitement surrounding Robofab, it’s only fitting that the FLOSS
typography camp takes the time to rear its head towards python-fontforge.
Actually, there’s a few reasons for it to be of interest to anyone remotely
interested in coding type, even those who are used to FontLab for that; here’s
a few reasons why:

* It snugly ties the loose ends to form a truly **free, non-proprietary
toolchain** for type design work. The Fontforge application is already a
wonderful and complete editor. With python-fontforge, scripting is no longer an
exclusive of FontLab.

* Unlike Python scripting in FontLab, scripts written using the fontforge
module can be run **independently of the GUI application**. No dialogues, no
drop-down menus, no chrome in the way — just as scripting should be.

* The **[documentation][doc]** is dense, packed into one big HTML page, but
very rich and complete; if one knows what’s needed but can’t find the right
command, it’s surely in there (and if not, the [fontforge-devel][ml] mailing
list will be quick to enlighten you).

* It’s totally ready to work with **Spiro splines**, a wonderful alternative to
bézier curves to design type and lots of other beautiful shapes. If you haven’t
heard of them, you [totally need to][spiro]. I mean, right now.

* There’s an embrionary **[repository][scripts]** of python-fontforge scripts
over at SourceForge. Hopefully, it will grow as more people notice the power of
this hidden gem.

Some months ago, i hastily made a script to turn a set of SVG files (named
[a-z].svg) into a .ttf file. Here’s the code, for what it might be worth.

#!/usr/bin/env python

# svg2ttf v0.1
#
# copyleft 2008-2009 ricardo lafuente
#
# generate a .ttf file from a set of .svg files with the lowercase alphabet
#
# before running this script, create a blank font file in Fontforge
# (make a New font and save it as it is) and change the BLANK_FONT location
#
# you might also want to edit the metadata (title, license, etc.) before
# saving it, or just edit the blank.sfd file afterwards
#
# finally, change the LETTERS_DIR value to the folder where your .svg
# files are; they ought to be named [a-z].svg

LETTERS_DIR = ‘~/Desktop/svgletters/’
BLANK_FONT = ‘~/Desktop/blank.sfd’

letters = ‘abcdefghijklmnopqrstuvwxyz’

# right-o, here we go
import fontforge

# open a blank font template
# TODO: dynamically generate the space character
font = fontforge.open(BLANK_FONT)

for letter in letters:
# make new glyph
font.createMappedChar(letter)
# import outline file
# notice that font[glyphname] returns the appropriate glyph
# fontforge is awesome :o)
font[letter].importOutlines(LETTERS_DIR + ‘/’ + letter + ‘.svg’)
# same spacing for each letter, this is a hack after all
font[letter].left_side_bearing = 15
font[letter].right_side_bearing = 15
# generate TrueType hints
# font[letter].autoInstr()

# create the output truetype file
font.generate(‘output.ttf’)

Have you worked with python-fontforge? Blogged about it? Made an awesome script
or two? Let me know in the comments section — i’m pretty sure i’m not alone in
my fascination :-)

**Update**: Dear feed readers, please pardon my multi-post ineptitude; i’m
still trying to get the hang of posting through [vim](http://www.vim.org) –
one less mistake i’ll be making in the future.

[nudge]: http://betatype.com/node/18 (Interpolated Nudge macro)
[ls]: http://tinkerhouse.net/lettersoup
[gw]: http://ospublish.constantvzw.org/type/i-think-the-ideas-behind-it-are-beautiful-in-my-mind
[doc]: http://fontforge.sourceforge.net/python.html
[ml]: https://lists.sourceforge.net/lists/listinfo/fontforge-devel
[spiro]: http://www.levien.com/spiro/
[scripts]: http://fontforge.wiki.sourceforge.net/scripts

## GNP: Tobias Frere-Jones exhibition ##

The Gerrit Noordzij Prize seminar was a side-event going on Saturday,
following the award ceremony and exhibition opening on Friday. The
exhibition, dedicated to Tobias Frere-Jones’s work, was stunning — huge
posters with beautiful specimens of his myriad typefaces along with some
delightful curios (such as a sample of the restaurant napkins where he
usually sketched his first ideas).

The seminar started with an enlightening perspective on British
historical typefaces by *Paul Barnes* , who went through many revealing
details and differences among time periods to find the appropriate
references to his own type design work.

Following up was House Industries’ *Rich Roat* , going through the history
of their type foundry, encompassing the days of hotrod customising until
their beautiful OpenType contemporary script faces. Rich’s talk was
filled with delightful anecdotes from their work at House Industries,
and among all the great work he showcased, their work from Alexander
Girard’s designs — going from airline corporate ID to shiny children’s
puzzles — was in my humble opinion the gem of the talk. It was also
awesome that Rich had set up a makeshift House Industries store outside
the conference room, with some wonderful freebie mini-catalogues,
stickers and posters (one of which now hangs in my place), and i
couldn’t resist shelling a bit for one of their beautiful Girard tees.

After an introduction by Chris Vermaas, where he playfully recounted
some stories of his working process with ‘Tobi’, it was the turn of
*Tobias Frere-Jones* to hop on the stage. Instead of assuming his (totally
deserved) center-stage role, he went on to humbly but exhaustively
describe the design process of the ___ font he designed for Martha
Stewart Living, taking cues from radically different approaches to type
design, combining slab serifs with ball terminals and thin letterforms.
The final result, as you would expect, was remarkably elegant. The low
profile he showed while going through his presentation totally
contrasted with the notable work of assembling a meaningful and balanced
typeface out of a Frankenstein-like set of inspirations.

The finale would be presented by *Piet Schreuders* , who began by showing
some of his album cover designs but quickly shifted to his interest in
musical research, which often builds the basis of his creative work.
From there he proceeded to tell his wonderful tale of recollecting the
lost remains of Leroy Shield’s musical heritage — Shield was the
composer of the ‘Laurel and Hardy’ movie soundtracks. Among some
impressive stories, including his masterful splicing together of film
parts to obtain full versions of those lost songs, he eventually found
his way to the original sheets of Shield’s creations. A Dutch big band
orchestra, The Beau Hunks, took upon re-recording those jolly songs,
gathering the interest of old-schoolers such as Robert Crumb, who
contributed the artwork to Schreuders’s covers.

The seminar drew to a close with a beautiful surprise — four sax
players went up the stage to play a few of Shield’s songs, and you
definitely had to be there to feel the magic of the moment: a gathering
of typographers being presented with the happy tunes of the American
thirties; i saw a few bemused faces in the audience, but this was the
perfect way to underscore the trans-disciplinary aspect that was present
throughout the Robothon and the seminar, bringing together code, music,
prose, poetry, pictorial archaeology and history to lend meaning to the
ever-exciting fields of typography and type design.

Just van Rossum: TTX and FontTools

TTX is the XML-based file format that Just van Rossum’s FontTools package likes to operate with. It is also the name of the command-line application used to convert font files into this format.

Running ttx Arial.ttf on the command line produces a .ttx file with all the dumped tables and features, as well as disassembled TrueType instructions. The TTX command-line tool also works for OpenType fonts, and there’s also the option to dump each table onto a separate font file. After tweaking the resulting TTX files, they can be re-assembled back into the TrueType format.

TTX’s soul is the ttLib library, which unfortunately is not very well documented (even though the Python docstrings inside the code are really detailed). It deals with various TrueType tables, binary and other internal data. Just went through the code, showing some parts of ttLib such as the transformation module and the Pen element, which is used to draw Bézier data.

After some technical details, Just proceeded to demo fontTools using DrawBot through a small script he wrote on the spot to draw a glyph into the DrawBot canvas using the FontTools library.

He also showed a Robofab module which implements the Pen object in the Quartz backend. Pens are abstractions of the drawing process and do not necessarily draw stuff on screen; there’s many pens available in Robofab, which is based on FontTools — MarginPen, PointPen, PointToSegmentPen, DigestPointPen, ControlBoundsPen, TransformPen, ThresholdPen, FlattenPen. The ‘pen’ abstraction is a bit confusing in the sense that it corresponds to any path operation, not only drawing; after Just’s explanations, it looks like a very clean-cut and Pythonic way to control Bézier drawing — maybe there’s something for Shoebot here.

After the talk, Gustavo pointed out a detail that i had missed — that there’s an FFPen by Erik van Blokland which is made for Fontforge; this is something i totally have to dive in when i get back to Rotterdam.

More: FontTools Sourceforge page

Georg Seifert: Glyphs

Glyphs is a font editor made by Georg Seifert made for the purpose of trying out new ideas, editing stuff in context and mainly showing that font editors can look nice. It’s not complete yet and some features are yet to be implemented, but there’s already a good plugin interface, UFO support, Python and AppleScript scripting, Unicode glyph info, and most of the final GUI is already done. Now we switch to a demo of the app.

The app looks really minimal, but the interface is actually very well thought out, unlike the usual large toolboxes of Fontographer and Fontforge. There’s also very good typographic taste in the UI.

Now things are getting really interesting: there’s multi-glyph editing! One can type the characters to see in the glyph window, just like a text editor, and they can be edited separately while the others sit there for comparison — a deceptively simple feature but the kind of thing you’d ask “Why don’t other editors do this?”. Inside this multiglyph window, kerning can also be set without switching to another part of the interface — this is really clever.

Murphy reared his ugly head and forced Georg to do a quick live debug of his application, which was fun and impressive :-)

Georg keeps the good stuff coming: when working with slanted characters, the kerning bounding box is slanted as well, which frees the user from having to compensate for the extra space at one side of the glyph. There’s also wonderful features for accented characters — their anchor/reference points can be manipulated and the result can be seen live in the other glyphs inside the glyph window.

More:

• schriftgestaltung.de
• reets.de

Yanone: Autopsy

Autopsy is a set of font auditing tools for use with FontLab.

There’s some pretty graph generators for getting specific features and variations inside a font family. Yanone showed the installation procedure and went on to show how Autopsy can work with a Multiple Master font; running Autopsy offers the option to generate a PDF with the final report; this report can include graphs for widths, bounding box properties, spacing, metrics and guidelines, as well as a selector for specifying the Multiple Master instances to compare. There’s also an X-Ray mode to check for outline errors.

Some fun can be had with the PDF comments feature in Adobe Reader to send messages and indications back to the font designer. The tool is made particularly for quality assurance and design help, and takes advantage of the PDF notes to facilitate communication between designer and client.

Apparently it was downloaded over a thousand times but only 2 licenses were ever purchased. You could feel his frustration, and he went on to announce a cut on the app’s price (now 49euro) and that he will open source Autopsy after 20 licenses were acquired.

Yuri Yarmola & Adam Twardoch: The reason is not clear (a message from the Russian programmers)

Adam Twardoch fell sick and joined the conference via Skype; Yuri Yarmola is the main Russian programmer of FontLab and developed FontLab on Windows.

FontLab 3 was released in 1998; in 3 years version 4 came out, and finally FontLab Studio 5 was revealed in 2005. Other apps like TypeTool were made by the Russian programmers at FL.

TransType 4 will be released this year, as well as Fontographer 5 and FontLab Studio 6. In parallel, FontLab are working on what they call the ‘Victoria codebase’, which appears to be a deep rewrite of parts of the code (which will be integrated in Fontographer 6 and FL Studio 7). Their wishlist includes universal binaries for OSX, preinstalled Robofab, native reading and writing of UFO2, Robofab compatible pen objects, AFDKO integration, streamlined font naming and auto-generation of OpenType features.

Yuri now moved to ‘his’ presentation, and is now talking about Python integration in Studio 5. This is important for having direct access to FL’s internal data structures, UI integration, dialog construction (which is still quite limited) and platform independence. Stability is desired but not always a reality.

‘Fontlab Soon’/Leningrad, the codename for the current FL engine, will have Photofont plugins (free, for QuarkXPress and InDesign), zipfile support and improved UI in TransType 4. Studio 6 will not be a major release, ‘just’ an upgrade: it will have FDK 2.5 support, AFS (?) will be dropped, Fontographer code will be gradually integrated into FLStudio; in the metrics field, it will have bettter OpenType feature support, kerning classes preview and Multiple Master axis preview (maybe an algorithm for auto detection of kerning exceptions will come up); there will be better support for keyboard input (shortcuts), a Unicode database will be included, the notes feature will have a nicer interface and glyph preview will have the option for multi-coloring for reference. There will also be point-level interpolation, Fontographer algorithms for bold and simplify will be included, true hinting samples will be introduced (with source code from Microsoft) and FontAudit will be augmented.

‘Fontlab Next’, based on the Victoria codebase, will come with a total redesign and new UI, engine, tools, storage and more. Their aim is for maximum freedom (no integer point values anymore) and a lean, minimal and non-intrusive user interface. The production part of the application will be automated — no need to think about OpenTypeXXXXname and so on, this should all be done behind the scenes. The current messy UI will be revamped — no more windows, no more toolbars: the UI ought to be task and content-based. Storage will be based on open standards and support versioning and collaborative work, as well as online access. All this Victoria code is still in the design stage, and user feedback is welcomed.

Most of the media aimed for print uses color; FL has been considering color fonts support for 10 years, and that is still under the works.

Adam is now coming back to the screen to help answer questions.

The internal format could be switched to SVGfont (wow, did i get this right?) — Adam clarified that they really care about interoperability, and a format for storing font sources that can be shared with different applications (Fontforge, DTL Fontmaster); apparently switching to UFO would be a problem, and there is the need to find a standard way to support proprietary extensions [XFO], for which there will be a meeting tomorrow with the font vendors and producers.

FontLab and Fontographer will be brought together into a common engine, with Fontographer focusing on design — no worries about internals –, while FL Studio will include this hardcore technical stuff in addition to FOG’s capabilities. FLS is a lab, FOG would be a design studio (they distinguish between type designers and font engineers).

Frederik Berlaen: UFO Stretch, RoundUFO and friends

‘Type&Media hero’ Frederik Berlaen is first showing roundingUFO, an application to automatically round the corners of a font (Beowolf rounded was interesting :-)

A demo ensued: one opens a UFO and tweaks the sliders for black corners, white corners and inktrap length. Besides rounding one can ‘spike’ the corners. Then, Superpolator can be used to refine the rounding operations. Glyphs can also be individually tweaked in addition to the global parameter settings.

We move to UFOoutliner, which is meant to create outline fonts, with sliders for thickness, contrast, miter limit and rotation. After creating the outlined font one can place it back into roundingUFO and make even more pretty stuff. RoundingUFO and UFOoutliner are built around Robofab’s pens.

Now, UFOstretch: this tool was created to solve the small caps issue; one loads two interpolatable masters, defines a ‘stretch set’ (a list of glyph names) and then on to the sliders: possibilities are scaling, interpolation, tracking, skewing and baseline shifting. It’s remarkable how smooth the application responds. There’s also a great feature for measuring each letter’s thickness with a draggable guide that returns the glyph section widths.

FontBridge (open source) is a helper Python tool to dynamically activate and deactivate system fonts. UfoText is a small and lean UFO text previewer.

Mini is a promising tool to generate HTML layouts, sporting a canvas with the ability to place primitives, images, PDF import and text; but the most interesting part is importing a font for use in a text field, along with an OpenType feature list generator. The HTML output is remarkable, rendering character sets as images and including some fancy AJAX controls.

TypeCast is a visual type design version control system; you input a zipped UFO and can manipulate points and features from inside a browser, keeping revisions as you go. For type designers, there’s a ‘animate revisions’ feature to generate an animation from all existing versions. It also works from inside FontLab via a 5-line Python scripts. It’s still a proof of concept, no support for kerning.

TypeActivator, also in proof-of-concept stage, is an app to allow one to upload OTF’s and access them using a local application from a remote server.

More:

• roundingufo.typemytype.com
• ufostretch.typemytype.com (not online yet?)
• py.typemytype.com
• typecast.typemytype.com
• typeactivator.typemytype.com

Tim Ahrens: Font Remix tools

Tim came up with a few FontLab macros not only intended for programmers but any FL user. Because of the word ‘macro’, he named his collection a set of ‘plugins’, which is a term more palatable to a larger audience. Installation is simple: drag the .flw to FL Studio, accept the license (free for personal use, pay for commercial) and you’re done. He keeps making the point that people are scared of new stuff (the reason for him not working with Robofab since it’s not that easy to install).

The installation file (.flw) is a simple Python file which includes all subscripts inside it as text. The installer takes those text strings and writes them into files.

He mentioned how design notes for production are usually not accurate or objective (he gave the example of Zapf’s notes on Optima). The ___ plugin’s function is to add a Multiple Master width axis for automatic condensed/expanded instance generations. Apparently his RMX tools are mostly dependent of Multiple Masters.

He went to delve on technical details regarding Multiple Masters and interpolation in general. He presented a wonderful cocktail metaphor to explain interpolation, in the sense that you weigh the amount of each ingredient to have an optimal mix. Interpolation is ‘stupid’, in the sense that it doesn’t take into account what a letter or its features are, it just shifts points; this stupidity makes, however, for a powerful tool. RMX Scaler uses this principle to, through some proportion control, generate proper small caps by interpolating widths and thicknesses.

My head was feeling very heavy at this point — too much input! — so i jotted down a few loose notes on the remainder of Tim’s talk:

• anisotropic interpolation (non-proportional x/y scaling)
• lots of math and geometry
• Tuner (sliders), Slanter (italic maker), Monospacer (good for tabular figures), MultiUpdater (merge tool)
• a novel approach to color specification: ‘YYR’ = orange! (as in two portions of yellow and one red, genius!)
• New stuff: Preparing for interpolation. De-kinking mechanism. Meet RMX Equalizer: it corrects the handle lengths between two glyphs to be interpolated.
• How to make nice curves: RMX Harmonizer. Automagic curve improvement. Beziers are always beautiful, problem shows when many are joined together. Shift or rotate the node according to the curve radius solves this.
• Telling the design intent to the computer.
• RMX SpotOn: auto curve fitter; shifting the node creates a smooth curve; smart outline drag (drag lines instead of points according to cursor position)

More:

• remix-tools.com (there’s some good screencasts there)

I was totally exhausted by the end of the talks and had to skip the Gerrit Noordzij Prize ceremony and exhibition opening.

In a moment i’ll be filling this post with photos, as well as a wrap-up of my thoughts on the conference and the Saturday GNP seminar.

Note: The Robothon is actually being live-broadcast over at http://194.171.57.63/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.

All the new UFO namespace elements

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”

Area51's glyph viewer

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.

Code editor

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.

Live coding!

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.

More: http://tools.typesupply.com

Tal Leming: MetricsMachine 4

smallca0s, yeah

No one likes kerning! MetricsMachine is the tool Tal’s come up with to ease typographers’ pains and wasted time on repetitive editing.

Letters can be grouped according to their shape

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).

Ogoneks and y's don't go well together

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.

Are we there yet? The MetricsMachine progress bar

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.

Kerning topography

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 design space representation

More masters = exponential fun to be had

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.

[video]

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.

[video]

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.

The design space editor

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).

Changing one detail can cause some redrawing headaches -- caching to the rescue

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.

Window showcasing the Defcon/Vanilla widget set

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.

DefconAppkit widget goodness

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.

More: http://code.typesupply.com

I just got to Den Haag for the Robothon 2009 conference, and will be writing down my impressions and rundowns of the event and talks (which will be inevitably biased by my personal take on software and design issues). The programme is loaded with type hacking heavyweights — Just van Rossum, Erik van Blokland, Tal Leming, Frederik Berlaen, Miguel Sousa from Adobe, Yanone, Georg Seifert, Yuri Yarmola from FontLab, Tim Ahrens and Frank Blokland will show the super typo-tinkering things they’ve been cooking.

The auditorium entrance, with the beautiful Type&Media course exhibition posters

I sort of parachuted into this tight gathering of type ninjas and enthusiasts, and there’s loads of smiles around; i spotted Jonathan Hoefler and couldn’t help thinking about going over and quip “Hey, you’re that guy from the Helvetica movie!” — a thought quickly discarded as i feel like a small alien in the middle of this type-savant, Macbook-wielding crowd.

At the registration, the organisers handed some beautiful UFO2 t-shirts and snazzy oversized badges. Spirits are high and people really seemed to be excited and running into each other; i was happy to have my strangerness feeling weathered down by Gustavo Ferreira, who came up and started a wonderful conversation — hearing Portuguese (especially sunny Brazilian) in Northern Europe made my day already! Looking through the Type&Media exhibition , i stumbled upon his great work with the Quantica font, made for screen use; i’ve always been terrified of anything that has to do with hinting, and his work looked really, really impressive — it’s a fun and revealing sight to find a printed version of hinted and rasterised fonts.

The Quantica font, by Gustavo Ferreira

After wandering around and making some acquaintances with great people (fun how common ground in our type passion brings people together), i spotted Jos Buivenga from Exljbris and couldn’t help going over and pestering him with some questions regarding his stance on the font business — he’s the awesome type designer who rocked the blogosphere and designersphere after releasing many of his beautiful fonts free of charge in his website. His business model definitely works (he’s selling hundreds of copies of Museo), despite it challenging a rather strong taboo inside the professional type design field (that fonts are refined work meant to be sold), especially when one takes into account that he comes from the ‘traditional’ typography side. He’s incredibly nice and gracious, and we went together into the conference room to see Erik van Blokland’s opening talk.

I can’t help feeling butterflies in my stomach sitting in a conference with Jos Buivenga, and having the charming Vera Efstafieva (whose beautiful cyrillic calligraphy blog i’m addicted to) sitting right in front of me.

Opening

Erik van Blokland welcomed the crowd with a great presentation on the logistics and housekeeping details of the conference, how to access the KABK wireless and where all the fun will be had — there’s apparently a party at Petr van Blokland’s later tonight!

The masochism chart

We were afterwards presented with the statistics on the masochistic tendencies of Robothon attendees through the event’s history. The lovely Dutch ‘droge humor’ (dry humour) was present all over Erik’s talk. He was careful to remind the audience that “this is an art school: before you sit down make, sure the paint is dry”. After the introduction, Erik went on to present Robofab.

Erik van Blokland: Getting started with Robofab

Erik started by asking ‘Why make new tools?’, given that ‘off-the-shelf’ solutions work fine. The role of new tools would be to make things easy, reduce distractions and hassle. It’s also about making new things possible and not falling into compromises. Finally, it’s about ‘mak[ing] the damn thing work for you’.

Erik van Blokland tells the reasons to make new tools

Robofab is, in Erik’s words, “glue”; it’s about sharing data between applications using the UFO file format — setting up your workflow for type design. For example, using  the ‘Python mojo’ to create and manipulate OTF, UFO, FEA (metrics) and FDK (Adobe’s font devkit format) by jumping around different applications (FontLab, AFDKO, TTX FontTools, Super/Prepolator, MetricsMachine, TypeMyType and FontForge) and gluing their strengths together. Erik then announced the UFO to FDK bridge, which means one can now output OTF files from UFO through ADFKO.

The Robofab API map

Robofab is available for Mac systems, and works alongside FontLab Studio. (before the talk, Gustavo Ferreira told me that there’s a FontForge port which isnt ready yet; i’ll have to take a look into this). Robofab works tightly with the UFO format — which you don’t have to be a coder to grasp — and (sadly IMO) depends largely on interaction with FontLab Studio.

Robofab is also a hammer, sporting a Python object API with standard objects and methods; this means that we can use Robofab outside FontLab (not sure i got this right). Erik then proceeded to describe Robofab’s API and some basic usage, going on to demonstrate FontLab’s Python macro console. Erik has a great, relaxed and friendly style in explaining the basics of Python coding; i’m not a FontLab user, but he’s making font-coding look a lot of fun — which is quite rare when you stop to think about it.

Erik went over the basics of RoboFab, showing its methods to access glyph properties like names, spacing, kerning, UFO properties, and how to query and manipulate those via Python. Robofab also allows for the creation of dialogs (through Tal Leming’s dialogKit). This great tool will come up later in the conference — not so great that i can’t use it in my GNU/Linux system, but hey, remarkable nonetheless.

More:

• Robofab
• Robofab SVN repository
• Typesupply
• Fontlab docs on Python scripting (outdated?)

Miguel Sousa: Adobe Font Development Kit for OpenType — intro and new features

Miguel Sousa from Adobe Systems stepped up to show how AFDKO works. It’s a rather low-level tool for tweaking and setting OpenType features. It’s not a font editor, but rather a framework for dealing with those pesky OpenType particularities.

I didn’t pay a lot of attention to his introduction as i’m still pretty slow with writing; Miguel showed what the AFDKO workflow looks like, and demo’ed some of its commands. AFDKO is apparently only accesible via a command-line interface (he’s using a bash terminal) or FontLab macros. The whole of AFDKO seems to revolve around text files describing a font’s OpenType properties (kerning, features, etc.). I’m not so into the intricacies of the tools — i learned not to depend on Adobe or any proprietary tools, but that is a story for another post — so i can’t really make a lot out of the technical details. AFDKO involves a rather specific file structure and syntax for its style and properties files, which kind of brings up the contrast between Adobe’s sleek and user-friendly GUI tools like Photoshop, and this kind of specialist tool with a minimal interface.

AFDKO is an exhaustive framework to access and work with the most obscure details of OpenType hacking, full of cryptic 4-letter table names and strange scripting conventions. Again, i’m definitely biased, but i’m wondering if i’m the only one in the room that finds all these quasi-secret OpenType manipulation techniques too cryptic. Miguel’s slides are also rather dry and incredibly technical, but it’s clearly a powerful tool for those who would dare to dip their feet in this specialist field of font fine-tuning — which, unlike the mainstream Adobe apps we’re used to, is made a lot more involved by the lack of a straightforward UI. The names for the AFDKO’s smaller tools — sfntdiff, stemHist, tx, spot — sound a lot more like traditional GNU tools than the neat, shrink-wrapped and shiny apps that Adobe has gotten us used to. In the end i’m left wondering if this is a kind of intentional obscurity.

We use the distutils module to package Shoebot. Recently we’ve been discussing to replace it with setuptools, particularly because of its simple-as-pie uploading to the Python Package Index (the CPAN for snakes), as well as some other fine goodies. I hit the wall when i noticed setuptools didn’t support the data_files option, which is present in distutils. This simple option enabled us to, among others, place the examples dir in /usr/share/shoebot/examples (the same for docs) when the install script is run.

I got kind of baffled after reading docs and threads when looking for a way to place files into arbitrary directories — setuptools seems to have dropped this functionality; this absence is described as ‘a feature, not a bug’ in the setuptools documentation. Apparently, there’s no ‘standard’ way to package docs in setuptools.

What confuses me is that i really don’t get the design choice to remove a really important feature from the setuptools package creator. I couldn’t discern the reasons for this either — is it to protect users from lazy developers who want to copy evil data files into the sacred system dirs? (isn’t that why ‘sudo’ is required for installing?)

I’m really hoping that i misread the docs or got something really wrong; since the alternative provided in the thread above mentioned would be to make custom scripts that the users would run if they so wanted. It really doesn’t sound like proper behaviour for a user-friendly (and dev-friendly) package manager — one can only love easy_install. If any Python hacker runs into this rant, this humble coder would really love to be enlightened on this.

Sadly, Shoebot will have to wait a bit longer for the day it reaches PyPI /: