Times and Helvetica are two the standard PostScript fonts, and required by many formatting and style guides. Since official versions of these fonts are expensive and not freely distributable, GhostScript (the standard PostScript interpreter on Linux) and LaTeX installations typically include clones of them from URW (Nimbus Roman No9 and Nimbus Sans). Unfortunately, the URW fonts are Type-1 fonts that do not have good hinting for on-screen display, resulting in misaligned text.

Modern TeX distributions also include updated remakes in OpenType format - the TeX Gyre family of typefaces. TeX Gyre Termes and TeX Gyre Heros replace Times and Helvetica, respectively. These fonts seem to render better on-screen, so I want to use them in my documents. There is also a companion math font for TeX Gyre Termes; its Greek letters are a bit on the ugly side, but it gets the job done and flows nicely with Termes (or other Times fonts).

XeTeX and LuaTeX both have the ability to use OpenType and TrueType fonts, in addition to the Postfix and Metafont fonts used by other TeX engines. To use TeX Gyre’s Times and Helvetica, put the following in your preamble:

% import font loading packages
\usepackage{fontspec}
\usepackage{unicode-math}

% set up Termes (Times) and its companion math font
\setmainfont[Ligatures=TeX,
Extension=.otf,
BoldFont=*-bold,
UprightFont=*-regular,
ItalicFont=*-italic,
BoldItalicFont=*-bolditalic,
SmallCapsFeatures={Letters=SmallCaps}]{texgyretermes}
\setmathfont[Ligatures=TeX]{texgyretermes-math.otf}

% set up Heros (Helvetica)
\setsansfont[Ligatures=TeX,
Extension=.otf,
BoldFont=*-bold,
UprightFont=*-regular,
ItalicFont=*-italic,
BoldItalicFont=*-bolditalic,
SmallCapsFeatures={Letters=SmallCaps}]{texgyreheros}

I’ve been working through some of my backlog of started-but-not-yet-finished books and finally finished Asimov’s Robot Dreams collection.

I’ve read a fair amount of Asimov before — robot stories, novels, the Foundation trilogy (which I greatly enjoyed), the Foundation sequels (Foundation and Earth accomplished the rare feat of retroactively damaging the trilogy; I prefer to pretend it does not exist) — but this collection would stand as my recommendation for someone seeking a starting point for Asimov. At least if they don’t want to dive into the world of Foundation. It has a smattering of robot stories, Multivac stories, and other things, many of them excellent.

Some highlights:

• ‘The Martian Way’ is a fascinating medium-length piece (nearly a novella) on the political turmoil leading to the independence of the Martian space colony.
• ‘Eyes Do More than See’ and ‘Does a Bee Care’ are slight, haunting pieces with grand themes. Brilliant examples of what can be done in 6 pages of well-chosen sentences.
• ‘The Feeling of Power’ is strange and fun — what happens in a future where we have computers but forgot how they work, and basic mathematics are rediscovered?
• ‘Jokester’ — where do jokes come from? What happens when we find out?
• ‘Franchise’ is premised on the perfection of social psychology, but in a lighter-weight fashion than Foundation. If we can thoroughly understand people, do we need elections?

I had a great time this week at Computer Supported Cooperative Work and Social Computing. Met lots of interesting people, heard good talks, enjoyed Baltimore.

One of my favorite papers of the conference was AskSheet: Efficient Human Computation for Decision Making with Spreadsheets by Alex Quinn and Ben Bederson. The concept is brilliantly simple: embed crowdsourcing capabilities in a spreadsheet, allowing decision makers (and others) to use the tools they already know to solicit information via Mechanical Turk and process the responses. To make it all work, they did some very interesting work on batching queries, estimating the likelihood of actually needing a piece of data and using this to order the crowd data requests, and other things to improve the efficiency of an application’s use of the crowd.

It’s not hard to envision an extension of this work into functional programming more generally. Someone could create a Crowd monad with an API something like this:

--| Create a crowdsourced query.
ask :: String     --^ Descriptive text for this query.
    -> Schema a   --^ Schema for user responses.
    -> Crowd a
--| Run a crowdsourced query, returning the results (after processing).  Runs in
-- IO because it needs networking, etc.
crowdsource :: CrowdProvider -> Crowd a -> IO a

Academics — at least those actively involved in computer science research — do a fair amount of travel. Making this go smoothly is something of a learned and practiced skill. Here are some things that have helped me.