I hold an MA in Typeface Design with distinction from the University of Reading, UK. My MA typeface design is called "Arrotino". My dissertation included an experiment measuring reading speed in text which was negatively tracked. I am interested in empirical methodsʼ potential to contribute to typography and type design.

Sorkin Type Co. is providing a large number of fonts for the Google Web Fonts including the typeface Merriweather. Other fonts provided to Google include:

Stream

Peter - It looks like you have spoken to Octavio about curving the interpolation. That’s great. Now I also hope we can allow interpolation curves to be assigned to specific parameters of the glyph.

I also see that the pen tool I was thinking of in my comments is in fact not not Noordzij-like with Metapolator but Knuth-like. So I don’t need to worry about an overly deterministic quality taking hold via ‘pen’.

Here are the things that seemed especially worth while to bringing up next.

• Unlike Latin type which moved somewhat away from a relationship to writing most non-Latin scripts still have a close relationship to the written form.

This is why I would also love for there to be an option or ability to render strokes via a Noordzij-like pen because so many non-Latin scripts would benefit from it.

You might say - “How important is that?" So allow me give a bit of context. Whereas today there are more Latin Type designs than can be reliably counted, non-Latin scripts sometimes have only four styles to choose from if they are lucky, and more often there are two, one, or even (shudder) no fonts at all. There is a real poverty of options. Also this isn’t just a Libre fonts issue. It is true for but all the different kinds of licenses.

While I am personally very excited about Metapolator for Latin for a series of purely selfish and also intellectual reasons I have to admit that in terms of doing the most good for the most people in the world, the biggest win is almost certainly in making design and design for families of a Non-Latin scripts more likely. Having a Noodzij Pen option with the ability to deviate afterwards would make this more likely.

Having multiple styles in non-Latins has huge value. One really big reason is that having multiple styles to choose from makes a huge difference to the ability to auto-translate texts. This is because implied semantic distinctions that are signaled by the change in type style can be better, or in an ideal case, totally retained.

Changes in style are useful in order to create enhanced function from an purely optical perspective as well. Tiny text can be read better; large letters feel more comfortable; white letters on a dark background seem to have the same weight as the dark ones when illuminated - and so on. These are all things we take for granted as readers of Latin script but which are impossible for scripts with no or a severely constrained number of typefaces.

* I have been thinking a lot about the value that parameters give us as designers. So while I think Peter and others may be doing this already but I wanted to check:

- Will we be able to assign a relationship of one parameter to another? For example: It would be great to set the stem of the I and then use that stem again in the H but use the stem at say 96% for the R. How many levels deep could this go? I suspect that 10 or so would cover all but 1-2% of design scenarios.

- It would be great to be able to assign these relationship differently in different masters or states. Let’s use the stem example again. It would be great to assign it to 100% in the R (Same as the I ) for a very thin weight but to a smaller % than 96% still in a very heavy weight.

- It would be great to be able to lock a part of a component to another part for interpolation purposes. For example we might want a terminal to always grow larger from a baseline and never cross it. This might be solved by making sure of the relationship in all masters but it would be nice to be able to assign an absolute rule.

- A related idea - It would be great to allow movement of points but only within in a constrained space.

- It would be nice to be able stack parameters in terms of priority. The simplest example is an angular serif and the distances between points. One might assign a set of values to each part but sat some point one of these values might conflict with another one. If we allow priority of one parametric assignment over another then higher priorities can be respected. This would allow the user to err without breaking the design.

- It would be great to allow for discontinuity. For example perhaps you are designing for very large and very small sizes. You might want to opt for one kind of terminal for the very small optical sizes. As you rise in size it may make sense to swap to a different one altogether. This would mean not having to have multiple metapolations for a family.

• I love the way that Peter is taking about an organic UI that lets you stay "in one place” while calling up access to tools for testing letter relationships, adjusting outlines, and tweaking contrast. If I can be helpful in testing please let me know. Perhaps I can helping to figure out how to stack up what is revealed and at what view.

I think in general we could be able to express this kind of things. But how exactly a feature can be accomplished, I can't say that right now. We have to learn what needs to be done and then create the tools. This is why I want to create those plugin APIs, to define the ways how to extend metapolator. The question to answer any "Can I do X ..." requestfor us is at which point in the system we need to do adjustments etc. Do we need a new parameter and a way to render it, Is it just a new operator for compound values, do we need a new MOM element to expresscertain things. We need to learn how the system we are building works best.

*Will we be able to assign a relationship of one parameter to another? For example: It would be great to set the stem of the I and then use that stem again in the H but use the stem at say 96% for the R. How many levels deep could this go? I suspect that 10 or so would cover all but 1-2% of design scenarios.*

Saying something should be at 96% will be possible and components will come. How much control we wan't to have over components in their context makes huge differences. At the moment, when borrowing the commonly used component concept, a component would not be changeable according to its context (like being used in an R glyph). But this could be build, I think. Another way would be to describe the stroke width directly. We'd need a pen like the penstroke pen in metafont for this (which we are planning, currently we have just a "metapolator" pen, which is similar, but not equal). But this would not be the same stem anymore, just the same parameters, or "StemWidthOf_I * 0.96" or so.

Depth would not be an issue, I think, as long as it's not infinite(a recursion). Maybe because of execution speed at some point, but not technically. No one programs 10 iterations by hand and then stops at 11. You just let the code get the references until everything is fetched.

It would be great to be able to assign these relationship differently in different masters or states. Let’s use the stem example again. It would be great to assign it to 100% in the R (Same as the I) for a very thin weight but to a smaller % still in a very heavy weight.

This should be possible. But isn't this exactly what a master is all about, setting different parameters?

It would be great to be able to lock a part of a component to another part for interpolation purposes. For example we might want a terminal to always grow larger from a baseline and never cross it. This might be solved by making sure of the relationship in all masters but it would be nice to be able to assign an absolute rule.

We can bind points to other points or baselines etc., that's included. We can do more complicated stuff, too. One problem I see is, that this kind of stuff is getting complex the more rules we apply. So I think weneed to develop tools/working styles/whatever to keep to complexitycontrollable.

The next question is how we can realize such hight level tools, like you describe it as an "absolute rule". I hope we will have a powerful enough plugin system eventually, that makes it possible to just add high level abstractions.

A related idea - It would be great to allow movement of points but only within in a constrained space.

Like a threshold max and min? We can include this into the "Compound Types" for example. These ideas, we should collect them and with some knowledge think about how/where to include that the best. We should have detailed descriptions for such things, to make shure we understand each other.

It would be nice to be able stack parameters in terms of priority. The simplest example is an angular serif and the distances between points. One might assign a set of values to each part but sat some point one of these values might conflict with another one. If we allow priority of one parametric assignment over another then higher priorities can be respected. This would allow the user to err without breaking the design.

But, I think, you can't make a working design without the power of creating a broken design.To err is part of it.

* It would be great to allow for discontinuity. For example perhaps you are designing for very large and very small sizes. You might want to opt for one kind of terminal for the very small optical sizes. As you rise in size it may make sense to swap to a different one altogether. This would mean not having to have multiple metapolations for a family.*

You have to keep it somewhere. Maybe we could create two glyphs, but then one new type of swapping glyph, that knows the rules, when to swap. The swapping glyph would be at the code point of the final glyph, the two sources would maybe not get exported directly.There are other ways to accomplish this, too, like a "display:none" for contours and then aclass that is used for switching (I like this approach more). Also, I think I remember that the latest version of superpolator has a swapping mechanism, too. This seems like a very useful thing.﻿

The event is designed to give someone who works with type insight into the why and how type is so powerful. We do this through short targeted lectures and direct hands on making of fonts. It is both a theoretical and a technical class. The event is intensive (all day for 3 days). It is admittedly a bit challenging because it is a lot of information to assimilate but also very rewarding and ultimately quite fun. Usually the class is 40 people but this time because of the limits of our host it is just 20.

If you have questions feel free to write back or call 1-617-309-8243.

Our instructors are

• Dave Crossland who consults with Google for their Web Fonts project and• Eben Sorkin who has provided numerous fonts for the Google fonts library including Merriweather and Merriweather Sans.

Both instructors have MA degrees in Type Face Design from the University of Reading.

This class has been taught in Seattle, Boston (2x), Kiev, Singapore, Dublin, Chicago (2x) and Edmonton.

Vernon Adams just helped me get a GUI on the latest version of TrueType Autohint v0.92!!! This is awesome. If you make fonts you will want this to make your TTFs render nicely in Windows and GNU linux. I will be working with Vern to offer a how-to document soon because it requires some significant in-terminal expertise. I will be posting before and after images to show why this tool is so great later this week. Here is what the GUI is like.﻿

The event is designed to give someone who works with type insight into the why and how type is so powerful. We do this through short targeted lectures and direct hands on making of fonts. It is both a theoretical and a technical class. The event is intensive (all day for 3 days). It is admittedly a bit challenging because it is a lot of information to assimilate but also very rewarding and ultimately quite fun. Usually the class is 40 people but this time because of the limits of our host it is just 20.

If you have questions feel free to write back or call 1-617-309-8243.

Our instructors are

• Dave Crossland who consults with Google for their Web Fonts project and• Eben Sorkin who has provided numerous fonts for the Google fonts library including Merriweather and Merriweather Sans.

Both instructors have MA degrees in Type Face Design from the University of Reading.

This class has been taught in Seattle, Boston (2x), Kiev, Singapore, Dublin, Chicago (2x) and Edmonton.

Crafting Type is making the rounds again and is landing in Chicago soon and then in Boston. It is a lot of work and last 3 full days. That said people have a great time and leave feeling proud, insightful and more skilled! Check it out and get your tickets!﻿