Here’s an example from the code for the home page on this blog:

...
◊for/splice[[(post (in-list (latest-posts 10)))]]{
   <article>
   ◊(hash-ref post 'header_html)
   ◊(hash-ref post 'html)
   </article>
   <hr>
}
...

It’s very useful, but I’m sure you’ve noticed something about this code: many many parentheses in the arguments list for for/splice. Well, it is the way it is, because the for/splice function is a direct analogue of Racket’s for/list function, which supports looping through multiple lists at the same time. It’s nice to have the flexibility. But there’s no denying the readability of the code suffers in the most common use cases.

If, like me, you usually only need to loop through a single list, you can put a macro like the one below in your pollen.rkt:

(require pollen/core)

...

(provide for/s)
(define-syntax (for/s stx)
  (syntax-case stx ()
    [(_ thing listofthings result-expr ...)
     #'(for/splice ([thing (in-list listofthings)]) result-expr ...)]))

This cuts down on the parentheses quite a bit:

...
◊for/s[post (latest-posts 10)]{
   <article>
   ◊(hash-ref post 'header_html)
   ◊(hash-ref post 'html)
   </article>
   <hr>
}
...

By creating my own cache system using a SQLite database, I was able to drop those times to less than a second each.

My old approach, which used only Pollen’s functions for retrieving docs and metas, had some pretty glaring inefficienciesFor example, in the code for my RSS feed, I was fetching the docs and metas from every document in the entire pagetree (that is, every post I had ever written) into a list of structs, even though I would only use the five most recent posts in the feed itself.—so glaring, in fact, that I probably could have cut my render times for these “problem pages” down to 3–6 seconds just by addressing them. But I thought I could get even further by making my own cache system.

Pollen’s cache system is optimized for fetching individual docs and metas one by one, not for grabbing and dynamically sorting a whole bunch of them at once. Also, Pollen’s cache doesn’t store the rendered HTML of each page. There are good reasons for both of these things; Pollen is optimized for making books, not blogs, and the content of a book doesn’t often change. But Pollen was also designed to be infinitely flexible, which allows us to extend it with whatever facilities we need.

Here is the gist of the new approach:

1. Create anAfter hearing SQLite’s author on this podcast I fell into the habit of pronouncing it the way he does: S-Q-L-ite, as though it were a mineral. Hence, “an”. SQLite database
2. In the template code for individual posts (i.e. at the same time the post is being rendered to HTML) save the post’s title, date and a copy of the rendered HTML in the database.
3. In the “combination pages” (such as index.html and feed.xml), query the SQLite database for the HTML and spit that out.

By doing this, I was able to make the renders 50–80 times faster. To illustrate, here are some typical render times using my old approach:

joel@macbook$ raco pollen render feed.xml
rendering feed.xml
rendering: /feed.xml.pp as /feed.xml
cpu time: 51819 real time: 52189 gc time: 13419

joel@macbook$ raco pollen render index.html
rendering index.html
rendering: /index.html.pp as /index.html
cpu time: 39621 real time: 39695 gc time: 7960

And here are the render times for the same pages after adding the SQLite cache:

joel@macbook$ raco pollen render feed.xml
rendering feed.xml
rendering: /feed.xml.pp as /feed.xml
cpu time: 659 real time: 660 gc time: 132

joel@macbook$ raco pollen render index.html
rendering index.html
rendering: /index.html.pp as /index.html
cpu time: 824 real time: 825 gc time: 188

This still isn’t nearly as fast as some static site generatorsHugo has been benchmarked building a complete 5,000 post site in less than six seconds total.. But it’s plenty good enough for my needs.

Creating the cache

I made a new file, util-db.rkt⊕You can browse the source code for this blog on its public repository. to hold all the database functionality and to provide functions that save and retrieve posts. My pollen.rkt re-provides all these functions, which ensures that they are available for use in my templates and .pp files.

The database itself is created and maintained by the template.html.p file used to render the HTML for indivdual posts. Here is the top portion of that file:

...
◊(init-db)
◊(define-values (doc-body comments) (split-body-comments doc))
◊(define doc-body-html (->html (cdr doc-body)))
◊(define doc-header (->html (post-header here metas)))
◊(save-post here metas doc-header doc-body-html)
<!DOCTYPE html>
<html lang="en"> ...

The expression init-db ensures the database file exists, and runs some CREATE TABLE IF NOT EXISTS queries to ensure the tables are set up correctly. The save-post expression saves the post’s metas and rendered HTML into the database.

Some more notes on the code above: The split-body-comments and post-header functions come from another module I wrote, util-template.rkt. The first separates any comments (that is, any ◊comment tags in the Pollen source) from the body of the post, which lets me save just the body HTML in the database. The second provides an X-expression for the post’s header, which includes or omits various things depending on the post’s metas.

Database design

Internally, util-db.rkt has some very basic functions that generate and execute the SQL queries I need.

If you watch the console while rendering a single post, you’ll see these queries being logged (indented for clarity):

CREATE TABLE IF NOT EXISTS `posts`
  (`pagenode`,
   `published`,
   `updated`,
   `title`,
   `header_html`,
   `html`,
   PRIMARY KEY (`pagenode`))

CREATE TABLE IF NOT EXISTS `posts-topics`
  (`pagenode`,
   `topic`,
   PRIMARY KEY (`pagenode`, `topic`))

INSERT OR REPLACE INTO `posts`
  (`rowid`, `pagenode`, `published`, `updated`, `title`, `header_html`, `html`)
  values ((SELECT `rowid` FROM `posts` WHERE `pagenode`= ?1), ?1, ?2, ?3, ?4, ?5, ?6)

DELETE FROM `posts-topics` WHERE `pagenode`=?1
INSERT INTO `posts-topics` (`pagenode`, `topic`)
  VALUES ("posts/pollen-and-sqlite.html", "SQLite"),
         ("posts/pollen-and-sqlite.html", "Pollen"),
         ("posts/pollen-and-sqlite.html", "Racket"),
         ("posts/pollen-and-sqlite.html", "programming")

The schema and queries are designed to be idempotent, meaning I can safely run them over and over again and end up with same set of records every time. So, no matter what state things are in, I don’t have to worry about ending up with duplicate records or other out-of-whacknesses when I render the site.

The database is also designed to need as few queries as possible, both when saving and when fetching data: for example, using a single query to either create something if it doesn’t exist, or to replace it if it does exist. Also, where applicable, creating multiple records in a single query (as in the last example above).

Finally, in the interests of keeping things “simple”, I have tried to keep the database disposable: that is, no part of the site’s content has its origin or permanent residence in the database itself. I can delete it at any point and quickly rebuild it. That way my use of it remains limited to my original plan for it: a speed enhancement, and nothing more.

Building the site: order of operations

Since home page, RSS feed, and other aggregation pages are now getting all their content from the SQLite database, it’s important that the database be up to date before those pages are rendered.

I already use a makefile to make sure that when things change, only the parts that need updating are rebuilt, and only in a certain order. I won’t go into detail about how the makefile works (a topic for another post, perhaps), but, in short, when I run make all, it does things in roughly the following order:

1. If any of the “core files” have changed, force a re-render of all individual posts.
2. If any individual posts have been changed or added, render just those to HTML. (This step is automatically skipped if step 1 was run, because that step will already have brought all the posts up to date.)
3. If any posts or core files have been changed or added, force a re-render of the “aggregation pages”, such as the home page, the Topics page, and the RSS feed.

This way, the pages that update the cache database are rendered before the pages that draw from the database, and everything is hunky-dory.

The Topics system

This blog makes use of “topics”, which are basically like tags. A post can have zero or more topics, and a topic can have or more posts.

This many-to-many relationship is another good fit for the database. You’ll have noticed above that I store the topic/post relationships in a separate table. With each topic-post pair stored in its own row, it is fast and easy to fetch them all out of the database at once. The util-db.rkt module provides a function, topic-list, which does this. Here’s what you see if you call it from DrRacket:

> (topic-list)
"SELECT `topic`, p.pagenode, p.title FROM `posts-topics` t INNER JOIN `posts` p ON t.pagenode = p.pagenode ORDER BY `topic` ASC"
'(("Active Directory" ("posts/laptop-user-not-authenticating-in-nt.html" "Laptop User Not Authenticating in an NT Domain After Changing Password"))
  ("Apple" ("posts/siri-slow-unreliable-and-maybe-not.html" "Siri: Slow, unreliable, and maybe not a priority at Apple"))
  ("audio"
   ("posts/how-to-convert-mp3-files-for-use-as-on-hold-music.html" "How to convert mp3 files for use as on-hold music")
   ("posts/how-to-record-with-a-yeti.html" "How to Record With a Yeti and Audacity (and eliminate background noise)"))
...

The SQL query uses INNER JOIN to link the posts in the posts-topics table with their titles in the posts table, resulting in a list of rows with three columns each: topic, pagenode (the relative path to the HTML file), and title. The topic-list function then groups these rows by the topic name and returns the resulting list.

The topics.html.pp file can make use of this nested list with some help from Pollen’s new for/splice function (Thanks Matthew!):

...
<table>
◊for/s[topic (topic-list)]{
  <tr>
    <td><a name="#◊(car topic)">◊(car topic)</a></td>
    <td><ul>
     ◊for/s[post (cdr topic)]{
      <li><a href="/◊(list-ref post 0)">◊(list-ref post 1)</a></li>
     }</ul></td>
   </tr>
}
</table> ...

Removing a post

One last consideration: removing a post is no longer as simple as deleting its Pollen source document. I have to remove it from the SQLite database as well, otherwise it will continue to appear on the home page, RSS feed, etc.

There are a few ways I could do this. The simplest would be to delete the database file and rebuild the site from scratch. Or I could open the database in a program like DB Browser for SQLite and delete the rows manually. Or I could write a script to automate this. I don’t often need to delete posts, so I’ll probably put off writing any scripts for now.

Although the book’s cover is not very complex or impressive, creating it was the biggest detour I took. I didn’t just want a cover, I wanted better tools for making covers for future books as well.

I’ve made a few books for fun over the years, and creating the cover was always my least favorite part of the process. I had to fire up a graphics program, calculate the size of everything, and click around until I had what I wanted. If my page count changed, I’d have to recalculate everything and manually futz with it some more. This kind of activity always felt wrong in the context of the rest of the project, the whole point of which which was to automate book production with code, not clicks.

So for this project, I created bookcover: a Racket language for writing book covers as programs. Check out the examples in the documentation to get a feel for how it works.

Writing and packaging bookcover was a fun publishing exercise in its own right, and it deserves its own blog post. I learned a lot about Racket in the process.⊕The web book Beautiful Racket, and the post Languages as Dotfiles from the Racket blog, were a huge help in learning and understanding the concepts I needed to write this package. Also, I’m a documentation nerd; I love that Racket’s documentation system is itself a full-powered Racket language, and I love the fact that they have such well-considered and accessible style guides for code and prose. It was great to have an excuse to use these tools and to contribute to the Racket ecosystem in some small way.

But the best part is that I now have a way to crank out book covers for future books.⊕I have wanted to have this kind of tool ever since I read about Faber Finds generative book covers. And, if you use Racket, you do too.

As with previous projects, I used LaTeX to produce the book’s PDF. LaTeX is itself a programming language, but, like most people, I find its syntax grotesque and arbitrary (kind of like its name). So for just about all the interesting bits I used Pollen as a preprocessor.

For example, here’s the part of my LaTeX template that sets the book’s measurements:

% Here is where we configure our paper size and margins.
◊(define UNITS "mm")
◊(define STOCKHEIGHT 152.4)
◊(define STOCKWIDTH 105.0)
◊(define TEXTBLOCKHEIGHT (* (/ 7.0 9.0) STOCKHEIGHT))
◊(define TEXTBLOCKWIDTH (* (/ 7.0 9.0) STOCKWIDTH))
◊(define SPINEMARGIN (/ STOCKWIDTH 8.0))
◊(define UPPERMARGIN (/ STOCKHEIGHT 9.0))
◊(define (c num) (format "~a~a" (real->decimal-string num 3) UNITS))

\setstocksize{◊c[STOCKHEIGHT]}{◊c[STOCKWIDTH]}
\settrimmedsize{◊c[STOCKHEIGHT]}{◊c[STOCKWIDTH]}{*}
\settypeblocksize{◊c[TEXTBLOCKHEIGHT]}{◊c[TEXTBLOCKWIDTH]}{*}
\setlrmargins{◊c[SPINEMARGIN]}{*}{*}
\setulmargins{◊c[UPPERMARGIN]}{*}{*}
\setheadfoot{13pt}{2\onelineskip}  % first was originally \onelineskip
\setheaderspaces{*}{\onelineskip}{*}
\checkandfixthelayout

The first part of that is sensible Pollen code, the second part is LaTeX with Pollen functions wedged in.

I can’t tell you how many times I had to read the LaTeX documentation and scratch my head in order to understand how to code that second half. Looking at it now, I’ve already forgotten how it works exactly. But thanks to the crystalline little safe space of Pollen written above it, it’s easy for me to come back to it, understand what is happening, and how to change it if I want to.

Further down, there is also Pollen code that slurps up the raw raw word list text file from the EFF’s website, cooks up LaTeX code for each line, and inserts it all into the book’s middle. This means that in future I could simply substitute a different word list and easily generate a book for it.

I wrote a short preface to the book with some (I hope) fun and useful information in it: how to use Diceware, how secure is it really, all that sort of thing. But security and word list design are really deep topics, and I wanted some good way of referring the interested reader to more informative reads on these topics.

The problem is, if you put a URL in a printed book, sooner or later it will break: the web page it links to is going to disappear, or the information in it is going to go out of date. Plus, some URLs are really long. Who’s going to bother typing in a long web address?

The gods of the internet have provided the solution to the broken link problem in the form of PURL: the Persistent URL, a service of the Internet Archive. PURL works like a URL shortener such as bit.ly or goo.gl: it lets you create a short URL, and say, in effect, “make this short URL redirect to this other, long URL.” But unlike other URL shorteners, PURL isn’t a profit center or a marketing tool: it’s a service of the Internet Archive, a nonprofit whose whole raison d’être is preserving the Internet, and who will (likely, hopefully) be around for many more decades.

So I made some PURLs of the links I wanted and put them on the last page of the preface as QR codes.

Open the camera app on your phone and point it at one of the codes: it’ll take you right to the web page. If any of those pages ever disappear, I can redirect the PURL to a snapshot of it on the Internet Archive, or to another page. This way the links will be good for at least as long as I’m alive, which is more than can be said for the URLs in 99% of the other books in the world.

I’m kind of shocked that more people don’t know about and use PURLs. They could, for example, be used as your main “web presence” address, since they are more permanent than even domain names.

There is also surprisingly little guidance from the service itself about how it should be used. The “top-level directory” portion of a PURL (the jd/ part in the last two PURLs shown above) is called a “domain”. PURL domains seem like they should be an incredibly important, protected resource, since they are permanently tied to the account that created them (once you claim a domain, no one else can create PURLs in that domain)—and, once created can never be deleted! Despite this, creating a PURL domain is easy, too easy. Almost the first thing you see when you log in is a prompt and a form for creating new domains in one click, with no confirmation, no indication that you are doing something permanent. It’s like PURL’s design is begging you to mindlessly create as many domains as you can think of.

Before I realized this, I had created two PURL domains, one each for the two sites I was linking to: purl.org/eff and purl.org/stdcom. I’m somewhat embarrassed that I now apparently have permanent irrevocable ownership of these “domains”, and am still trying to find out who to contact to remedy this. Meanwhile, I did claim the jd domain and will probably be using solely that domain for all the PURLs I create for my own use, for the rest of my life.

Back to the book: here’s the LaTeX code I used to generate and place the QR codes:

% In the header:
\usepackage{pst-barcode}
\usepackage{tabularx}

% …

\newcommand\qrlink[2]{%
    \begin{pspicture}(0.6in,0.6in)%
        \psbarcode[rotate=-25]{#1}{width=0.6 height=0.6}{qrcode}%
    \end{pspicture}%
    & #2 \par {\tiny \url{#1}} \\[0.55cm]%
}

% … and in the document body:

\begin{tabularx}{\textwidth}{m{0.8in} X}
    \qrlink{https://purl.org/eff/2016wordlist}{Article by Joseph Bonneau etc etc.}
    % … etc …
\end{tabularx}

I have no wish to explain this in detail, but if you are attempting to do something similar and are already poring over the manuals for the pst-barcode and tabularx packages, hopefully this will give you something to go on.

I licensed two weights of the Halyard Micro typeface for the book, and wanted very much to use it for the headings on the website as well. But this one-page website has only three headings total—not enough to justify the overhead (both technical and financial) of an embedded webfont.

This is where Pollen came in handy again. ⊕I used Pollen as a static site generator for the book’s website as well as for the pre-processing of the book itself. The fonts’ standard EULA says it’s fine to use images of the font on a website; so I wrote a function that takes a string, sets it in Halyard Micro, and saves it as an SVG. I then wrote some tag functions that make use of that function. In case it can be of use to anyone, here’s all the relevant code:

(define heading-font (make-parameter "Halyard Micro"))
(define heading-size (make-parameter 20))
(define heading-color (make-parameter "orangered"))
(define heading-sizes '(42 30 24))

(define (normalize-string str)
  (let ([str-nopunct (regexp-replace* #rx"[^0-9a-zA-Z ]" str "")])
    (string-join (string-split (string-foldcase str-nopunct)) "-")))

(define (make-heading-svg level txt)
  (define heading-filename
    (format "img/h~a-~a.svg" level (normalize-string txt)))
  (define heading-pict
    (colorize (text txt (heading-font) (heading-size)) (heading-color)))
  (define the-svg (new svg-dc%
                       [width (pict-width heading-pict)]
                       [height (pict-height heading-pict)]
                       [output heading-filename]
                       [exists 'replace]))

  (send* the-svg
    (start-doc "useless string")
    (start-page))

  (draw-pict heading-pict the-svg 0 0)

  (send* the-svg
    (end-page)
    (end-doc))

  heading-filename)

(define (make-heading level attrs elems)
  (define h-size (list-ref heading-sizes (sub1 level)))
  (define h-str (apply string-append (filter string? (flatten elems))))
  (define h-tag (format-symbol "h~a" level))
  (parameterize ([heading-size h-size])
    `(,h-tag ,attrs (img [[src ,(make-heading-svg level h-str)]
                          [class "heading-svg"]
                          [alt ,h-str]]))))

(define-tag-function (h1 attrs elems) (make-heading 1 attrs elems))
(define-tag-function (h2 attrs elems) (make-heading 2 attrs elems))

Let’s get into the weeds for a bit here:

The first section sets up some parameters⊕Parameters are kind of like Racket’s thread-safe equivalent of a global variable, although they work a little differently. You can use parameterize to change their value temporarily for a given scope; at the end of that scope the parameter automatically reverts to its previous value. to use as defaults.

The normalize function transforms "My Heading!" into a string like "my-heading", making it ready to use as the base part of a filename—just tack .svg at the end.

The make-heading-svg function creates the SVG file and saves it in the img/ subfolder.

This in turn is used by the next function, make-heading, as it generates what becomes the <h1> or <h2> tag.

Finally, Pollen’s define—tag—function sets up the h1 and h2 tags to call make-heading with the appropriate heading level.

The upshot is that when, in my source markup, I write:

◊h2{Need Dice? Get the Good Dice.}

…it becomes, in the output:

<h2><img src="img/h2-need-dice-get-the-good-dice.svg" class="heading-svg" alt="Need Dice? Get the Good Dice."></h2>

…and of course, when the site is generated, the .svg file magically appears in the img folder, and everything looks awesome.

Maybe this seems like a lot of code for three headings.⊕The basic technique of using an image of text instead of just the text is basically how we used to use non-standard fonts on the web before @font-face. It’s bad and dumb in most cases. Don’t do it. As with the book’s cover, I could have just made the images by hand in a graphics editor like Pixelmator. But, as with the book cover, since I did it with code rather than by farting around with a mouse, it’s very easy to change the headings or make new ones if I ever want to.

There you have it! A little book produced entirely with code. If you have an idea for another one, let me know.

An aside: on the web, footnotes are something of an oddity. HTML doesn’t have any semantic notion of a footnote, so we typically make them up using superscripted links to an ordered list at the end of the article. I’m sympathetic to arguments that this makes for a poor reading experience, and am convinced that they are probably overused. Nonetheless, I’m converting a lot of old content that uses footnotes, and I know I’ll be resorting to them in the future. Some newer treatments of web footnotes use clever CSS to sprinkle them in the margins, which is nice, but comes with downsides: it isn’t accessible, it’s not intuitive to use and read on a phone, it renders the footnotes inline with the text in CSS-less environments (Lynx, e.g.) and the markup is screwyThese reasons are listed in decreasing order of importance for the particular application I have in mind.. So I’m sticking with the old ordered-list-at-the-end approach (for this project, and for now, at least).

So I get to design my own footnote markup. Here’s what’s on my wishlist:

1. I want each footnote’s contents to be defined in a separate place from the footnote references. This will keep the prose from getting too cluttered.
2. I want to be able to define the footnote contents anywhere in the document, in any order, and have them properly collected and ordered at the end.
3. I want to be able to use any mix of strings, symbols or numbers to reference footnotes, and have these all be converted to ordinal reference numbers.
4. I want to be able to refer to the same footnote more than once.It was this requirement in particular that steered me away from using the otherwise-excellent pollen-count package. (Rare, but useful in some cases).
5. If I should happen to refer to a footnote that is never defined, I want a blank footnote to appear in the list in its place. (On the other hand if I define a footnote that isn’t referenced anywhere, I’m content to let it disappear from the output.)
6. I want the footnote links not to interfere with each other when more than one footnote-using article is displayed on the same page. In other words, the URL for footnote #3 on article (A) should never be the same as the URL for footnote #3 on article (B).

In other words, I want to be able to do this:

Here is some text◊fn[1]. Later on the paragraph continues.

In another paragraph, I may◊fn[2] refer to another footnote.

◊fndef[1]{Here’s the contents of the first footnote.}
◊fndef[2]{And here are the contents of the second one.}

But I also want to be able to do this:

◊fndef["doodle"]{And here are the contents of the second one.}

Here is some text◊fn["wipers"]. Later on the paragraph continues.
◊fndef["wipers"]{Here’s the contents of the first footnote.}

In another paragraph, I may◊fn["doodle"] refer to another footnote.

And both of these should render identically to:

<p>Here is some text<sup><a href="#550b35-1" id="550b35-1_1">1</a></sup>. Later on the paragraph continues.</p>

<p>In another paragraph, I may <sup><a href="#550b35-2" id="550b35_1">2</a></sup> refer to another footnote.</p>

<section class="footnotes"><hr />
<ol>
  <li id="550b35-1">Here’s the contents of the first footnote. <a href="#550b35-1_1">↩</a></li>
  <li id="550b35-2">And here are the contents of the second one. <a href="#550b35-2_1">↩</a></li>
</ol>
</section>

⊕You may be wondering, where did the 550b35 come from? Well, it’s an automatically generated identifier that’s (mostly, usually) unique to the current article. By using it as a prefix on our footnote links and backlinks, we prevent collisions with other footnote-using articles that may be visible on the same page. I’ll explain where it comes from at the end of this article.

This style of markup is a little more work to code in pollen.rkt, but it lets me be flexible and even a bit careless when writing the prose.

The output for footnotes (given my requirements) can’t very well be handled within individual tag functions; it demands a top-down approach. [Again, this turns out not to be true! see the Pollen group discussion.] So I will be leaving my ◊fn and ◊fndef tag functions undefined, and instead create a single function do-footnotes (and several helper functions nested inside it) that will transform everything at once. I’ll call it from my root tag like so:

(require txexpr
         sugar/coerce
         openssl/md5
         pollen/decode
         pollen/template) ; That’s everything we need for this project

(define (root . elements)
  (define footnoted
    (do-footnotes `(root ,@elements)
                  (fingerprint (first elements)))))

The do-footnotes function takes a tagged X-expression (the body of the article) and a prefix to use in all the relative links and backlinks. ⊕You may have surmised that the fingerprint function call above is where the 550b35 prefix came from. Again, more on that later. Here are the general stages we’ll go through inside this function:

1. Go through the footnote references. Transform them into reference links, giving each an incrementally higher reference number (or, if the footnote has been referenced before, using the existing number). For later use, keep a list of all references and in the order in which they’re found.
2. Split out all the footnote definitions from the rest of the article. Get rid of the ones that aren’t referenced anywhere. Add empty ones to stand in for footnotes that are referenced but not defined.
3. Sort the footnote definitions according to the order that they are first referenced in the article.
4. Transform the footnote definitions into an ordered list with backlinks, and append them back on to the end of the article.

Here is the code for do-footnotes that implements the first stage:

(define (do-footnotes tx prefix)
  (define fnrefs '())

  (define (fn-reference tx)
    (cond
      [(and (eq? 'fn (get-tag tx))
            (not (empty? (get-elements tx))))
       (define ref (->string (first (get-elements tx))))
       (set! fnrefs (append fnrefs (list ref)))
       (let* ([ref-uri (string-append "#" prefix "-" ref)]
              [ref-sequence (number->string (count (curry string=? ref) fnrefs))]
              [ref-backlink-id (string-append prefix "-" ref "_" ref-sequence)]
              [ref-ordinal (number->string (+ 1 (index-of fnrefs ref)))]
              [ref-str (string-append "(" ref-ordinal ")")])
         `(sup (a [[href ,ref-uri] [id ,ref-backlink-id]] ,ref-str)))]
      [else tx]))

  (define tx-with-fnrefs (decode tx #:txexpr-proc fn-reference))
  …)

Looking at the last line in this example will help you understand the flow of control here: we can call decode and, using the #:txexpr-proc keyword argument, pass it a function to apply to every X-expression tag in the article. In this case, it’s a helper function we’ve just defined, fn-reference. The upshot: the body of fn-reference is going to be executed once for each ◊fn tag in the article.

By defining fn-reference inside the do-foonotes function, it has access to identifiers outside its scope, such as the prefix string but most importantly the fnrefs list. This means that every call to fn-reference will be able to check up on the results of all the other times it’s been called so far. And other helper functions we’ll be creating inside do-footnotes later on will also have easy access to the results of those calls.

So let’s examine the steps taken by fn-definition in more detail.

1. First, using cond it checks to see if the current X-expression tx is a fn tag and has at least one element (the reference ID). This is necessary because decode is going to call fn-reference for every X-expression in the article, and we only want to operate on the ◊fn tags.
2. Every time fn-reference finds a footnote reference, it has the side-effect of appending its reference ID (in string form) to the fnrefs list (the set! function call). Again, that list is the crucial piece that allows all the function calls happening inside do-footnotes to coordinate with each other.

3. The function uses let* to set up a bunch of values for use in outputting the footnote reference link:

   1. ref-uri, the relative link to the footnote at the end of the article.
   2. ref-sequence, will be "1" if this is the first reference to this footnote, "2" if the second reference, etc. We get this by simply counting how many times ref appears in the fnrefs list so far.
   3. ref-backlink-id uses ref-sequence to make an id that will be the target of a ↩ back-link in the footnote definition.
   4. ref-ordinal is the footnote number as it will appear to the reader. To find it, we remove all duplicates from the fnrefs list, find the index of the current ref in that list, and add one (since we want footnote numbers to start with 1, not 0).
   5. ref-str is the text of the footnoote reference that the reader sees. It’s only used because I wanted to put parentheses around the footnote number.
4. Then, in the body of the let* expression, the function outputs the new footnote reference link as an X-expression that will transform neatly to HTML when the document is rendered.

So after the call to decode, we have an X-expression, tx-with-fnrefs, that has all the footnote references (◊fn tags) properly transformed, and a list fnrefs containing all the footnote reference IDs in the order in which they are found in the text.

Let’s take a closer look at that list. In our first simple example above, it would end up looking like this: '("1" "2"). In the second example, it would end up as '("wipers" "doodle"). In a very complicated and sloppy document, it could end up looking like '("foo" "1" "7" "foo" "cite1" "1"). So when processing ◊fndef["foo"], for example, we can see by looking at that list that this should be the first footnote in the list, and that there are two references to it in the article.

All that said, we’re ready to move on to phase two through four.

(define (do-footnotes tx)
  ; … stage 1 above …

  (define (is-fndef? x) (and (txexpr? x) (equal? 'fndef (get-tag x))))

  ; Collect ◊fndef tags, filter out any that aren’t actually referenced
  (define-values (body fn-defs) (splitf-txexpr tx-with-fnrefs is-fndef?))
  (define fn-defs-filtered
    (filter (λ(f)
              (cond
                [(member (->string (first (get-elements f))) fnrefs) #t]
                [else #f]))
            fn-defs))

  ; Get a list of all the IDs of the footnote *definitions*
  (define fn-def-ids
    (for/list ([f (in-list fn-defs-filtered)]) (->string (first (get-elements f)))))

  ; Pad the footnote definitions to include empty ones for any that weren’t defined
  (define fn-defs-padded
    (cond [(set=? fnrefs fn-def-ids) fn-defs-filtered]
          [else (append fn-defs-filtered
                        (map (λ (x) `(fndef ,x (i "Missing footnote definition")))
                             (set-subtract fnrefs fn-def-ids)))]))
  ; … stage 3 and 4 …
)

We define a helper function is-fndef? and use it with splitf-txexpr to extract all the ◊fndef tags out of the article and put them in a separate list. Then we use filter, passing it an anonymous function that returns #f for any fndef whose ID doesn’t appear in fndefs.

Now we need to deal with the case where the ◊fn tags in a document reference a footnote that is never defined with an ◊fndef tag. To test for this, we just need a list of the reference IDs used by the footnote definitions. The definition of fn-def-ids provides this for us, using for/list to loop through all the footnote definitions and grab out a stringified copy of the first element of each. We can then check if (set=? fnrefs fn-def-ids)—that is, do these two lists contain all the same elements (regardless of duplicates)? If not, we use set-subtract to get a list of which IDs are missing from fn-def-ids and for each one, append another fndef to the filtered list of footnote definitions.

(define (do-footnotes tx)
  ; … stages 1 and 2 above …

  (define (footnote<? a b)
    (< (index-of (remove-duplicates fnrefs) (->string (first (get-elements a))))
       (index-of (remove-duplicates fnrefs) (->string (first (get-elements b))))))

  (define fn-defs-sorted (sort fn-defs-padded footnote<?))

  ; … stage 4 …

The helper function footnote<? compares two footnote definitions to see which one should come first in the footnote list: it compares them to see which one has the ID that appears first in fndefs. We pass that function to sort, which uses it to sort the whole list of footnote definitions.

We are almost done. We just have to transform the now-ordered list of footnote definitions and append it back onto the end of the article:

(define (do-footnotes tx)
  ; … stages 1 to 3 above …

  (define (fn-definition tx)
    (let* ([ref (->string (first (get-elements tx)))]
           [fn-id (string-append "#" prefix "-" ref)]
           [fn-elems (rest (get-elements tx))]
           [fn-backlinks
             (for/list ([r-seq (in-range (count (curry string=? ref) fnrefs))])
               `(a [[href ,(string-append "#" prefix "-" ref "_"
                                          (number->string (+ 1 r-seq)))]] "↩"))])
      `(li [[id ,fn-id]] ,@fn-elems ,@fn-backlinks)))

  (define footnotes-section
    `(section [[class "footnotes"]] (hr) (ol ,@(map fn-definition fn-defs-sorted))))

  (txexpr (get-tag body)
          (get-attrs body)
          (append (get-elements body)
                  (list footnotes-section)))
  ; Finis!
)

We need one more helper function, fn-definition, to transform an individual ◊fndef tag into a list item with the footnote’s contents and backlinks to its references. This helper uses let* in a way similar to fn-reference above, constructing each part of the list item and then pulling them all together at the end. Of these parts, fn-backlinks is worth examining. The expression (curry string=? ref) returns a function that compares any string to whater ref currently is.⊕curry is basically a clever way of temporarily “pre-filling” some of a function’s arguments. That function gets passed to count to count how many times the current footnote is found in fnrefs. The list comprehension for/list can then use that range to make a ↩ backlink for each of them.

In defining the footnotes-section we map the helper function fn-definition onto each ◊fndef tag in our sorted list, and drop them inside an X-expression matching the HTML markup we want for the footnotes section. The last statement adds this section to the end of body (which was the other value given to us by splitf-txexpr way up in stage 2), and we’re done.

All that remains now is to show you where I got that 550b35 prefix from.

Ensuring unique footnote IDs

As mentioned before, I wanted to be able to give all the footnotes in an article some unique marker for use in their id attribute, to make sure the links for footnotes in different articles never collide with each other.

When the topic of “ensuring uniqueness” comes up it’s not long before we start talking about hashes.

I could generate a random hash once for each article, but then the footnote’s URI would change every time I rebuild the article, which would break any deep links people may have made to those footnotes. How often will people be deep-linking into my footnotes? Possibly never. But I would say, if you’re going to put a link to some text on the web, don’t make it fundamentally unstable.

So we need something unique (and stable) from each article that I can use to deterministically create a unique hash for that article. An obvious candidate would be the article’s title, but many of the articles on the site I’m making will not have titles.

Instead I decided to use an MD5 hash of the text of the article’s first element (in practice, this will usually mean its first paragraph):

; Concatentate all the elements of a tagged x-expression into a single string
; (ignores attributes)
(define (txexpr->elements-string tx)
  (cond [(string? tx) tx]
        [(stringish? tx) (->string tx)]
        [(txexpr? tx)
         (apply string-append (map txexpr->elements-string (get-elements tx)))]))

(define (fingerprint tx)
  (let ([hash-str (md5 (open-input-string (txexpr->elements-string tx)))])
    (substring hash-str (- (string-length hash-str) 6))))

The helper function txexpr->elements-string will recursively drill through all the nested expressions in an X-expression, pulling out all the strings found in the elements of each and appending them into a single string. The fingerprint function then takes the MD5 hash of this string and returns just the last six characters, which are unique enough for our purposes.

If you paste the above into DrRacket (along with the requires at the beginnning of this post) and then run it as below, you’ll see

> (fingerprint (txexpr->elements-string '(p "Here is some text" (fn 1) ". Later on the paragraph continues.")))
"550b35"

This now explains where we were getting the prefix argument in do-footnotes:

(define (root . elements)
  (define footnoted
    (do-footnotes `(root ,@elements)
                  (fingerprint (first elements)))))

Under this scheme, things could still break if I have two articles with exactly the same text in the first element. Also, if I ever edit the text in the first element in an article, the prefix will change (breaking any deep links that may have been made by other people). But I figure that’s the place where I’m least likely to make any edits. This approach brings the risk of footnote link collision and breakage down to a very low level, wasn’t difficult to implement and won’t be any work to maintain.

Summary and parting thoughts

When designing the markup you’ll be using, Pollen gives you unlimited flexibility. You can decide to adhere pretty closely to HTML structures in your markup (allowing your underlying code to remain simple), or you can write clever code to enable your markup do more work for you later on.

One area where I could have gotten more clever would have been error checking. For instance, I could throw an error if a footnote is defined but never referenced. I could also do more work to validate the contents of my ◊fn and ◊fndef tags. If I were especially error-prone and forgetful, this could save me a bit of time when adding new content to my site. For now, on this project, I’ve opted instead for marginally faster code…and more cryptic error messages.

I will probably use a similar approach to allow URLs in hyperlinks to be specified separately from the links themselves. Something like this:

#lang pollen

For more information, see ◊a[1]{About the Author}. You can also
see ◊a[2]{his current favorite TV show}.

◊hrefs{
[1]: http://joeldueck.com
[2]: http://www.imdb.com/title/tt5834198/
}

Since we finished the basement and installed a 55″ TV, however, I’ve had my eye on some drastic improvements and additions to our home’s IT capabilities. I will outline the overall plan in another post, however, to get things rolling I thought I’d just write about the first small step in that plan, which I took today: I bought a monitor.

I have almost zero spare computer parts lying around my house, which is surely strange for an IT manager. I’ve made a point of getting rid of stuff I don’t need, which means I get to start from scratch.

This tiny used monitor will sit on my new IT “rack” when I need a direct-attached display for setting up or troubleshooting servers. It’s perfect for my setup for several reasons:

1. It’s small
2. It’s cheap ($20 on Craigslist)
3. It has both HDMI and VGA inputs, so it will work with any computer, old or new, without any converters
4. It also has a TV tuner, so I can use it to watch broadcast television on the rare occasions where that might come in handy (weather emergencies, etc)

The same thing happens whether I’m at work, at home, or on public wifi (using a VPN of course). I’ve tried disabling all extensions and I’ve also tried using Chrome. So this was mystifying to me.

But I think I might have finally found the source of the problem. I was in Safari’s preferences window and noticed this little warning on the Security tab:

I unchecked that box, and the problem seems to have disappeared.

Now, I haven’t yet been able to find any official information on exactly how Safe Browsing Service works, but it’s not hard to make an educated guess. If it’s turned on, the first time you browse to a website, the name of that website would first get sent, in a separate request, to Apple’s servers, which would return a thumbs up/thumbs down type of response. A problem on Apple’s end would cause these requests to time out, making any website’s first load terribly slow. And as the screenshot shows, clearly there is a problem on Apple’s end, because the Safe Browsing Service is said to be “unavailable”. (It says it’s only been unavailable for 1 day but I have reason to believe that number just resets every day.)

The fact that disabling the setting on Safari fixed the problem in Chrome too leads me to believe that this is in fact an OS-level setting, enforced on all outgoing HTTP requests, not just a Safari preference.

Anyway, if you are having this problem, see if disabling Safe Browsing Service solves it for you.

Impact

1. All of my websites that still use Textpattern were broken from 11pm Jan 31 until about lunchtime the next day. (The Notepad does not use Textpattern and was mostly unaffected, except for #2 below.)
2. All the traffic logged on all sites during that time was lost. So I have no record of how many people used my websites during the time that my websites were unusable.

Timeline

(All times are my time zone.)

1. Tuesday Jan 31, late evening: I logged into my web server and and noticed a message about an updated version of my Ubuntu distribution being available. I was in a good mood and ran the do-release-upgrade command, even knowing it would probably cause problems. Because breaking your personal web server’s legs every once in a while is a good way to learn stuff. If I’d noticed that this “update” proposed to take my server from version 14.04 all the way to 16.04, I’d have said Hell no.
2. In about half an hour the process was complete and sure enough, all my DB-driven sites were serving up ugly PHP errors.

Recovery

1. Soon determined that my Apache config referred to non-existant PHP5 plugin. Installed PHP7 because why the hell not.
2. More errors. The version of Textpattern I was using on all these sites doesn’t work with PHP7. Installed the latest version of Textpattern on one of the sites.
3. Textpattern site still throwing errors because a few of my plugins didn’t like PHP7 either. Logged into the MySQL cli and manually disabled them in the database.
4. Textpattern’s DB upgrade script kept failing because it doesn’t like something about my databases. I began the process of hand-editing each of the tables in one of the affected websites.
5. Sometime around midnight my brother texted asking me to drive over and take him in to the emergency room. I judged it best to get over there in a hurry so I closed up my laptop and did that. His situation is a little dicey right now; it was possible that when I got there I’d find him bleeding or dying. That wasn’t it, thankfully. By four in the morning they had him stabilized and I was able to drive home.
6. Morning of Feb 1st: I got out of bed at around eight on the morning of Feb 1st, made myself some coffee and emailed my boss to tell him I wouldn’t be in the office until nine-thirty.
7. After driving in to work, I remembered almost all of my websites were still busted. I started to think about the ramifications. I wondered if anyone had noticed. I opened Twitter for the first time since before the election and closed it again, appalled.
8. At lunchtime I drove to the coffee shop for some more caffeine and a sandwich. I remember it got up to 30º F that day so I almost didn’t need a coat. After I ate my sandwich I pulled out my laptop and resumed poking around the same database and trying to swap in all the mental state from before the hospital trip.
9. Towards the end of my lunch hour I decided that this wasn’t fun anymore. Maybe I could poke this one database until Textpattern would stop whining about it, but there was still the matter of the broken plugins, and then I’d have to go through the same rigmarole for the other three sites.
10. Sometime between noon and 1pm I logged into my DigitalOcean dashboard and clicked a button to restore the automatic backup from 18 hours ago. In two minutes it was done and all the sites were running normally.

Problems Encountered

1. In-place OS upgrades across major releases will always break your stack
2. Textpattern 4.5.7 doesn’t support PHP7
3. Textpattern 4.6.0 needs a bunch of hacks to work with newer versions of MySQL
4. Emergency rooms always have so much waiting time in between tests and stuff

Post-Recovery Followup Tasks

1. Leave the goddamn server alone
2. Revisit shelved projects that involve getting rid of Textpattern and MySQL.

Since I’m also using this as a way of learning a little about literate programming, the programs I write are also web pages describing themselves. I’m uploading those web pages to a subsection of this site, where you can read my solutions and watch my progress.

In this form, a web site can run for decades with almost no maintenance or cost. It will be very tedious if you ever want to change it, but that is fine because the whole point is long-term preservation. It’s a considerate, responsible thing to do with a website when you’re pretty much done updating it forever. Keeping the site online prevents link rot, and you never know what use someone will make of it.

How to Flatpack

Before getting rid of your site’s CMS and its database, make use of it to simplify the site as much as possible. It’s going to be incredibly tedious to fix or change anything later on so now’s the time to do it. In particular you want to edit any templates that affect the content of multiple pages:

• Strip out all external dependencies, such as TypeKit and any script-based analytics. In place of Typekit I used a self-hosted font for the headings and just switched to Georgia for the body text.
• Removed unneeded sections and internal links from the page templates. For example, on my site I eliminated any reference to the privacy policy and the “different ways to subscribe” guide. I also made the “episodes” page one giant list of all the episodes instead of being broken up into 20 pages.
• Finally, wherever appropriate, edited text in the page templates to make the site’s “archival status” clear. Remove anything that could give the impression that this place is still a going concern.

Next, on your web server, make a temp directory (outside the site’s own directory) and download static copies of all the site’s pages into it with the wget command:

wget --recursive --domains howellcreekradio.com --html-extension howellcreekradio.com/

This will download every page on the site and every file linked to on those pages. In my case it included images and MP3 files which I didn’t need. I deleted those until I had only the .html files left.

Digression: Mass-editing links and filenames from the command line

This bit is pretty specific to my own situation but perhaps some will find it instructive. At this point I was almost done, but there was a bit of updating to do that couldn’t be done from within my CMS. My home page on this site had “Older” and “Newer” links at the bottom in order to browse through the episodes, and I wanted to keep it this way. These older/newer links were generated by the CMS with POST-style URLS: http://site.com/?pg=2 and so on. When wget downloads these links (and when the --html-extension option is invoked), it saves them as files of the form index.html?pg=2.html. These all needed to be renamed, and the pagination links that refer to them needed to be updated.

I happen to use ZSH, which comes with an alternative to the standard mv command called zmv that recognizes patterns:

zmv 'index.html\?pg=([0-9]).html' 'page$1.html'
zmv 'index.html\?pg=([0-9][0-9]).html' 'page$1.html'

So now these files were all named page01.html through page20.html but they still contained links in the old ?pg= format. I was able to update these in one fell swoop with a one-liner:

grep -rl \?pg= . | xargs sed -i -E 's/\?pg=([0-9]+)/page\1.html/g'

To dissect this a bit:

• grep -rl \?pg= . lists all files containing the links I want to change. I pass this list to the next command with the pipe | character.
• The xargs command takes the list produced by grep and feeds them one by one to the sed command.
• The sed command has the -i option to edit the files in-place, and the -E option to enable regular expressions. For every file in its list, it uses s/\?pg=([0-9]+)/page\1.html/g as a regex-style search-and-replace pattern. You can learn more about the details of this search pattern if you are new to regular expressions.

OK, digression over.

Back up the CMS and Database

Before actually switching, it’s a good idea to freeze-dry a copy of the old site, so to speak, in case you ever needed it again.

Export the database to a plain-text backup:

mysqldump -u username -pPASSWORD db_name > dbbackup.sql

Then save a gzip of that .sql file and the whole site directory before proceeding.

Shutting down the CMS and swapping in the static files

Final steps:

1. Move the HTML files you downloaded and modified above into the site’s public folder.
2. Add redirects or rewrite rules for every page on your site. For example, if your server uses Apache, you would edit the site’s .htaccess file so that URLs on your site like site.com/about/ would be internally rewritten as site.com/about.html. This is going to be different depending on what CMS was being used, but essentially you want to be sure that any URL that anyone might have used as a link to your site continues to work.
3. Delete all CMS-related files from your site’s public folder (you saved that backup, right?) In my case I deleted index.php, css.php, and the whole textpattern/ directory.

Once you’re done

Watch your site’s logs for 404 errors for a couple of weeks to make sure you didn’t miss anything.

What to do now? You could leave your site running where it is. Or, long term, consider having it served from a place like NearlyFreeSpeech for pennies a month.

Normally when targeting multiple output formats in Pollen, you’d write a tag function something like this:

; …

(define (strong . xs)
  (case (current-poly-target)
    [ltx (string-append "\\textbf{" ,@xs "}")]
    [else `(strong ,@xs)]))

; …

Here, everything for the strong tag is contained in a single tidy function that produces different output depending on the current output format. This is fine for simple projects, but not ideal for more complex ones, for a couple of reasons.

First there’s the issue of tracking dependencies. Let’s say every Pollen file in your project gets rendered as an HTML file and as part of a PDF file. Then one day you make a small change in your pollen.rkt file. Does this edit affect just the HTML files? Or the PDF files? Or both? Which ones now need to be rebuilt? If you’re doing things as shown above, there’s no straightforward way for Pollen (or make) to determine this; you’ll have to rebuild all the output files every time.

Then there’s the issue of readability. Even with two possible output formats, pollen.rkt gets much more difficult to read. I didn’t even want to think about how hairy it would get at three or four.

I decided to address this by having each output format get its own separate .rkt file, containing its own definitions for each tag function, prefixed by the output format:

(define (html-strong attrs elements)
  `(strong ,attrs ,@elements))

(define (pdf-strong attrs elements)
  (string-append "\\textbf{" ,@xs "}"))

That part is simple enough. But you also need a way for pollen.rkt to branch to one tag or the other depending on the current poly target.

To handle this part, I wrote a macro, poly-branch-tag, which allows you to define a tag that will automatically call a different tag function depending on the current output format. The macro is rather long, but you can view it in the polytag.rkt file of this blog’s source code at Github.

Defining tag functions with poly-branch-tag

To use this macro, first copy the polytag.rkt file from this blog’s source code into your project.

You then include polytag.rkt and declare your Pollen tags using the macro. The first argument is the tag name, optionally followed by a single required attribute and/or as any number of optional attributes with default values:

#lang racket
(require pollen/setup)
(require "polytag.rkt")
(require "html-tags.rkt" "pdf-tags.rkt")

; Define our poly targets as usual
(module setup racket/base
    (provide (all-defined-out))
    (define poly-targets '(html pdf)))

; Simple tag with no required or default attributes
(poly-branch-tag strong)

; Tag with a single required attribute
(poly-branch-tag link url)

; Tag with required attribute + some optional attrs w/defaults
(poly-branch-tag figure src (fullwidth #f) (link-url ""))

For every tag function declared this way, write the additional functions needed for each output type in your (setup:poly-targets). E.g., for strong above, we would define html-strong and pdf-strong inside their respective .rkt files.

These tag functions should always accept exactly two arguments: a list of attributes and a list of elements. The macro will ensure that any required attribute is present and any default values are applied. Here’s an example:

(define (html-figure attrs elems)     ; Important! Tag name must have html- prefix
  (define src (attr-val 'src attrs))  ; You can grab what you need from attrs
  (if (attr-val 'fullwidth attrs)     ; (I made (attr-val) to accept boolean values in attributes)
      (make-fullwidth)))              ; [dummy example]

The benefits, reiterated

If you use a dependency system like make in your Pollen project, you now have a clear separation between output files in a particular format and the code that produces output in that format. An edit to html-tags.rkt will only affect HTML files. An edit to pdf-tags.rkt will only affect PDF files. You can see this blog’s makefile for a detailed example.

It’s also easier to add output formats without losing your sanity. Each output format gets its own .rkt file where you can define your tag functions all the way up to root, and the logic for each output format is much easier to follow than if they were all jammed in together in one file.

Finally, I found that there’s a third benefit, delightful and unintended, that comes with this approach as well: pollen.rkt, stripped of all function definition code, becomes essentially a very readable, self-updating cheatsheet of your project’s tags. See what I mean in this blog’s pollen.rkt. This alone might almost tempt me to use poly-branch-tag even in projects where HTML is the only format being targeted.

We ordered two more of these switches off eBay (a replacement plus a spare), and those arrived today. After testing both of them, I was able to swap out the bad one and figure out exactly what had happened to it.

How I test a switch

This is pretty basic and generic, but maybe someone will find it useful.

1. Grab the reference manual and hard-reset the switch to factory defaults.
2. Connect directly to the switch with an ethernet cable. Does the port light up?
3. Manually set your computer’s IP address to correspond to the switch’s defaults. In this case, the Netgear’s default IP is 192.168.0.239 with a subnet mask of 255.255.255.0, so I set my computer to 192.168.0.20 and the same subnet.
4. Try to ping the switch at its default address. Does it respond? If not, plug in another computer and set its IP address manually as well. Can you ping it? Try it across several ports.
5. From your browser, try to log in to the switch’s web interface. In this case I browsed to http://192.168.0.239 and was greeted with the login screen.
6. Try transferring data between two computers connected through the switch. In my case I was testing with two Windows machines, so I used NetCPS to benchmark these transfers. Again, use several different ports. If the ports are visibly divided between “banks” of 4 or 8 ports, test each bank. (Testing each individual port is overkill in most cases.)
7. Managed switches⊕The GS748T doesn’t have a separate console port or a CLI, so this point wasn’t applicable in this particular case. On another occasion though, when I had an HP ProCurve switch that was acting up, connecting via the console port revealed a barrage of error messages and an endless cycle of rebooting. Having a saved copy of this output was very helpful when I was on the phone with the manufacturer demanding a warranty replacement. usually have their own OS with a command-line interface that you can open by connecting through a separate “console” port (either RJ-45 or serial DB-9). Try to log in through this interface and poke around. Refer to the switch’s manual for details.

So what happened here?

In the case of our failing Netgear GS748T, after I pulled it out I found it was still “working”: I could connect to its web interface, and even send data between a couple of computers connected via the switch, but several things indicated something was wrong.

First of all, pinging the switch itself while plugged into it directly was yielding response times of 7–14ms. This may seem pretty fast, but an acceptable response time is more like 1ms, max.

Second, by looking at the error counters in the switch’s web interface, I noticed Rx errors piling up after only a few minutes:

An acceptable number of errors is zero, assuming there is no problem with the cables themselves.

All of this points towards some degradation that destroys performance when traffic increases past a certain point.

Finally, just for the heck of it, we opened up the switch’s casing and took a look at its innards.

The capacitors with flat tops (such as the group of four on the left) are in good shape, but the ones with bulging, rounded tops (there are three in this pic) have definitely gone bad. Hardware companies often try to save money by getting cheap, low-quality capacitors, and when they fail, they start to bulge like this.

The failed capacitors definitely seem to explain our problem. Personally, I would not have bothered unscrewing the casing on the failed switch⊕Nor would I have ordered the same make/model as a replacement. The “new” switches are a later revision than the originals, though (GS748Tv3H1 vs GS748Tv1H3) so hopefully that represents some improvement., but it was a good way to confirm that we were in fact dealing with a hardware failure. You might also want to do this if you ever order used network gear; if any of the capacitors are bulging like this you know to return the item immediately.

happy birthday to former President James Garfield, mortally shot in the patoot

reminder that one time we shoved whiskey and beef bouillon up a president’s butt until he died nytimes.com/2006/07/25/hea…

• On my own computer, the problem surfaced as a DNS_PROBE_FINISHED error when I tried to load any websites in Chrome (sometimes instead the error would be DNS_PROBE_STARTED or DNS_PROBE_NXDOMAIN).
• I would then open up my command prompt and attempt to ping google.com—sometimes this would result in unable to find google.com and sometimes it would find a specific IP address to try but none of the pings would go through.
• I also tried ping 8.8.8.8 (Google’s DNS servers) or ping 75.75.75.75 (Comcast DNS)—interestingly, the first 4-6 pings would fail, and then the rest would go through reliably at about 10ms every time thereafter.
• Ping traffic between any two points within the LAN (including the firewall) was completely unaffected.

Troubleshooting

Google searches for the DNS_PROBE_FINISHED error invariably lead you to advice suggesting that you perform a netsh winsock reset and restart your computer. However this didn’t work in our case, unsurprisingly. The problem began affecting everyone at once, so unless there had been a bad Windows update or something (our IT support agency hadn’t heard of any) this would be unlikely to help.

We also ruled out the ISP as the cause. We have two WAN connections–one fiber and one cable–and switching to one or the other exclusively did not resolve the issue. Support tickets with ISPs confirmed there were no upstream connection or network problems.

Examining Switches

We had just that day moved a bunch of desks around one part of the office. Our IT support agency suggested we had some kind of switch-level spanning tree problem–a switch plugged into itself, perhaps, in some roundabout way. I tried rebooting the main switch used for non-VoIP traffic, and the problem immediately cleared up–for about ten minutes, and then it returned. We also tried disconnecting all the jacks for each person who had been affected by the move to rule out any subtle looping issues created (even though only one or two jacks had been affected); no dice.

I opened a support ticket with the switch company (Extreme Networks). They had me telnet into the switch and capture the output of a bunch of commands and send it to them, which allowed them to rule out any configuration or looping issues on the switch.

We upgraded the firmware, which dated from 2011, and restarted the switch. Again the problem cleared up and did not recur for the rest of the day. But by this point most people had gone home or to find somewhere else to work. I was curious if the problem would recur on Monday when everyone came back; sure enough, with 10 people in the office at 8:00 am Monday everything was fine, but by 8:30 we were having the same problem again.

At this point we were ready to try unplugging every person, port by port, waiting 5 seconds, and pinging google, to see if we could narrow the problem down to a particular network jack/user. Thankfully it didn’t come to that.

The culprit

This time on our firewall I noticed that the “connection count” was hovering close to or even above the stated maximum of 10,000. Occasionally the connection utilization would drop to 5–6% and then the problem would go away. I used the firewall’s “packet capture” interface to look at a few seconds’ worth of network traffic and noticed a high number of UDP packets coming from a particular LAN IP address, with sequential foreign destination IPs.

I was able to track down the computer with this IP address, it happened to be one of our sales people. The laptop was a Lenovo running Windows 8. In Task Manager I saw that it was sending 1.5 MBps over the wired Ethernet interface and 800–900 Kbps over the wireless interface, even with no apps running. (Task Manager did not show which process was casuing this.) Upon disconnecting the CAT5e cable the connection utilization on the firewall dropped to 40%. Disconnecting the wifi dropped it further to 7%.

By looking at the CPU usage it appears that the process discovery.exe was abnormally high. A Google search finally turned up this article: Excessive network traffic and wifi drops linked to LenovoEMC Storage connector, which stated:

Corporate networks or ISPs may detect an excessive amount of unusual network traffic coming from ThinkPad systems preloaded with Microsoft Windows 8.1. The network traffic may be interpreted as a network flood or denial-of-service attack. As a result, the system may become restricted on the network or the network may stop functioning normally.

“LenovoEMC Storage Connector” is preloaded on some ThinkPad models to help customers discover and connect to LenovoEMC storage devices on their network. The process causing the network flood is discovery.exe, which is a component of “LenovoEMC Storage Connector”.

Uninstalling the Lenovo EMC Storage Connector from the offending laptop finally fixed the issue.

However, when I did this on one particular Scrivener file, the Marked preview came up blank–even though I had plenty of Markdown-formatted content project.

I finally found the solution, after checking other thingsIncluding whether “Include in compile” was turned on for each document within each document in the Scrivener project—if it’s unchecked, Marked does exclude it from the preview, even though no “compile” is actually taking place from Scrivener’s perspective.. When you create a new “blank” Scrivener project, it gives you a couple of default folders; one of those is named Drafts and contains a blank text document. That Drafts folder, it seems, is actually supposed to be the root folder of all your project’s content.

What I had done was create a folder outside the Drafts folder and create all of my content there. Marked will not preview content located outside the Drafts folder.

The solution is to rename the original Drafts to something else like Content, and create a separate Drafts folder under it. Then make sure everything you might want to preview in Marked is located under that Content folder.

I’m using the latest version of Marked 2 (2.4.10) and Scrivener (2.6)

Webfonts have gotten much easier to implement. Because nearly all browsers support WOFF, you no longer need to supply four different file formats for each font in order to be sure it will be supported on all browsers. You can simply convert any binary font file into Base64 encoding and embed the resulting text/data right into your CSS file. However, there are additional steps you should take in order to optimize the size and downloading of your webfonts.

Base64 Encoding

This part is easy. The command base64 filename will take any file and encode it. This works on Linux and Mac OS X.

With this info, we can create a quick shell script that will take any font file and convert it into a webfont embedded right in a snippet of CSS:

#!/bin/bash

fontName=$1
fontFace=$2

WOFF=`base64 $fontName`

echo @font-face {
echo font-family: \'$fontFace\'\;
echo font-weight: normal\;
echo font-style: normal\;
echo font-stretch: normal\;
echo src: url\(\'data:application/font-woff\;charset=utf-8\;base64,$WOFF\'\) format\(\'woff\'\)\;
echo }

Save this to a file called webfont-encode and make it executable:

chmod u+x ./webfont-encode

You can then use it to create the webfont from any font file and append it to your CSS file, like so:

./webfont-encode AlegreyaSans-Reg.otf alegreyasans-1 >> fonts.css

On OS X, you can also copy the result to the clipboard if you wish:

./webfont-encode AlegreyaSans-Reg.otf alegreyasans-1 | pbcopy

Most times you’ll need to do this four times for each typeface: once each for the regular, italic, bold, and bold italic versions of the font. For each one, edit the font-weight and font-style CSS attributes to reflect the actual attributes of that font.

Once you’ve done all that, you can include the above stylesheet in your HTML (make sure it comes before any other stylesheets) and reference the font in your other CSS styles.

Note: The original font file needs to have its “embeddable” flag set to 0x0000 or the font loading will fail in Internet Explorer (at least in versions 9 through 11). Other browsers do not seem to check for this value. If your font license allows embedding, you can find some more Python code for modifying the flag here: http://www.typophile.com/node/102671.

Subsetting your fonts

If you create your own webfonts using only the above steps, your files will be huge–likely around 1 MB per typeface once you include bold and italic versions. This is because most typefaces (the good ones, at least) include characters for Russian, Greek, Hebrew, Arabic, and many other character sets. You can speed up your site a lot by whittling each font down to only the characters you’re likely to need.

For this part I’m assuming you’re on OS X. You’re going to need Homebrew and Python installed.

First, install the fontforge python extensions with brew install fontforge. Then:

export PYTHONPATH=/usr/local/lib/python2.7/site-packages:$PYTHONPATH

(You’ll need to do this every time you open a new terminal unless you permanently add Homebrew’s package folder to your Python path.)

Next, get yourself a copy of glyphIgo. This lovely Python script can convert between TTF and OTF font formats, and subset fonts based on any character set. Alberto Pettarin has a great blog post explaining more about its use.

If you have git installed (brew install git), the following command will download a copy into a glyphIgo folder:

git clone https://github.com/pettarin/glyphIgo.git

Now we need to create the character set: a file containing each of the characters you want to include in your font. I wrote a quick Python script to assist with this, and have included codes several extra typographic symbols that I use often:

from __future__ import print_function

charsets = [
    [0x0020,0x007F],    # BASIC LATIN
    [0x00A1,0x00FF],    # PUNCTUATION, LATIN-1 SUPPLEMENT, COMMON SYMBOLS
    [0xFB00,0xFB04],    # STANDARD ENGLISH LIGATURES fi, fl, ffi, ffl
    [0x0100,0x017F],    # LATIN EXTENDED-A
    [0x0180,0x024F],    # LATIN EXTENDE0D-B
    [0x2010,0x2015],    # HYPHENS AND DASHES
    [0x2018,0x2019],    # LEFT/RIGHT SINGLE QUOTATION MARKS
    [0x201C,0x201D],    # LEFT/RIGHT DOUBLE QUOTATION MARKS
    [0x2026,0x2026],    # ELLIPSES
    [0x221E,0x221E],    # INFINITY SYMBOL
    [0x2190,0x2193],    # ARROWS
    [0x21A9,0x21A9],    # LEFTWARDS ARROW WITH HOOK
    [0x2761,0x2761],    # CURVED STEM PARAGRAPH SIGN ORNAMENT
    [0x2766,0x2767]     # FLORAL HEART, ROTATED FLORAL HEART
]

for charset in charsets:
    for x in range(charset[0],charset[1]+1):
        print(unichr(x).encode('utf-8'),end='')

Some notes on customizing this script: If you want to include any additional character blocks in your font, simply add the hex ranges to the charsets list (see the complete list of Unicode blocks). Single characters can be added by making the first and second numbers of the “range” identical.

Including the ligatures (if the font supports them) makes for a better result on some platforms. On Mac, for example, Safari will make use of the ligatures but Chrome doesn’t use them at all.

Save the above script as makeset.py and create your character set file like so:

python makeset.py > latin.set

Armed with our character set, you can now subset your font like so:

python glyphIgo.py subset -f AlegreyaSans-Regular.otf -p latin.set -o AS-R.otf

Now encode the new “minimized” font using the script we created above:

./webfont-encode AS-R.otf alegreyasans-1 >> fonts.css

Results

To get an idea of the size reduction, I used these methods to produce a single CSS file containing regular, italic, bold, and bold italic versions of two typefaces (a total of eight @font-faces).

Without subsetting the fonts, the resulting CSS file was 2.1 MB in size. When I subset the fonts before encoding them, the result was 611 KB in size, a 70% reduction.

For comparison, Typekit reports a size of 339K for a kit containing the same two typefaces, using the “Default” character set and without including OpenType features. However, I strongly suspect that this the compressed size of their kit. You can achieve the same result by enabling gzip compression on your web server. On my own server, according to checkgzipcompression.com, the 611 KB CSS file gets packed down to a 345 KB download—almost identical to the Typekit version.

I could probably save even more space by omitting the Latin Extended-A and Extended-B blocks in my character set.

Speeding it up even more

Once you have your fonts set the way you like them, you should do yourself a further favour and check out Adam Beres-Deak’s post Loading webfonts with high performance on responsive websites. Using the simple Javascript in his post, you can make your fonts load and perform much faster than they would if you were using Typekit or Google Fonts.

Most phone systems don’t let you use plain-old MP3 files, but you can convert any song to the necessary format.

First, get yourself suitable music. Something instrumental, without any exotic highs and lows. Try this instrumental version of Save the Last Dance For Me, for example.

Next, get ffmpeg, the classic command-line utility for converting audio files to other formats.

For simplicity’s sake, put your MP3 file of choice in the same folder as your extracted ffmpeg executable file, and make sure the filename doesn’t contain any spaces. Then, open a command line/terminal and run this command:

ffmpeg -i YOURFILE.mp3 -ar 8000 -ac 1 -ab 64 YOURFILE.wav -ar 8000 -ac 1 -ab 64 -f mulaw YOURFILE.pcm -map 0:0 -map 0:0

This will create two files, a .wav file and a .pcm file. Try using the .wav file first, if not, the other one should do the job.

Final note: all music sounds like ass over a phone line.

But the Yeti is fine for most podcasters too. Just keep in mind that it picks up a lot of background noise no matter what pattern you set.

I use/used a Yeti on my podcast for a few years now. Many others do too (including Jason Snell for what that’s worth)—it’s long been known as the sweet spot of bang-for-the-buck for intermediate-level podcasting. Marco’s probably right that it’s not ideal in some ways, but let me tell you how I eliminate background noise.

In my experience, you can get a very clean signal with very little background noise from just about any mic if you use the Right Technique. That technique is:

1. Use a pop filter
2. Turn gain on the mic way down
3. Speak super close to the mic

Yes, the pop filter (the $10 Nady MPF-6) is simply held in place with a heavy object. I own no booms or shock-mounts. Not to say I wouldn’t love to have them, but I’m just not about to buy them for now (see further notes below).

Using the above placement, I set the gain knob on my Yeti at 40-45%, and set the pattern to Cardioid (heart-shaped). Then I set Audacity’s input level for the mic to 50%. I speak at a normal volume with my mouth almost touching the pop filter.

Additionally, I run Chris’s Dynamic Compressor plugin on voice tracks after all other editing has been done:

• Compress Ratio: 0.7
• Compression Hardness: 0.7
• Floor: -14.0
• Noise gate falloff: 6.0
• Maximum amplitude: 0.95

I may normalize the track to -2db before or after running the compressor, or both.

You can hear the results on any of the later episodes of my podcast (which I’ve currently not been keeping up with). Which brings me to standard disclaimers: my podcasting is of a different style than most podcasts. My episodes are relatively short (5-15 min), and almost everything I say is pre-written and edited, and I’m the only voice. All of which makes my primitive Yeti/pop filter setup that much more bearable. If I were co-hosting with anyone or doing longer episodes I can see where it would get kind of unworkable, but for what I do I don’t mind it at all.

There are a lot of guides for moving from Blogger to Wordpress, but nothing about moving to any other type of blog. Nearly all of those guides are incomplete, but by adapting and adding to them I was able to achieve all my goals for the move:

• Automatically migrate posts with their metadata into Kirby’s text format
• Make copies of all images in blog posts so they are included in the move
• Retain each blog post’s comments
• Automatically redirect posts at the old blog to the new one without loosing Google juice

1. Migrating Posts, Comments and Images

First of all, download a copy of your Blogger blog: once logged in to Blogger, go to the dashboard for your blog, then click Settings → Other. There will be a link at the top to export your blog–this will allow you to download a .xml file containing your entire blog, including your template, all configuration settings, posts and comments.

The bulk of my work in this projects was in writing a script to get the data I wanted out of that big hairy file.

The blogger2kirby script is on Github. To use it you will need Python3 and a number of libraries installed–there are simple instructions for this in the Readme file at Github.

Place the .xml file exported from Blogger in the same folder as the script, then open Terminal and run the script with the command python3 blogger2kirby.py.

The script will create a folder called out containing subfolders for each post. These subfolders are named using a straightforward pattern:

• Old Blogger URL: myblog.blogspot.com/2010/03/my-trip-to-philly.html
• blogger2kirby output folder: 20100317-my-trip-to-philly
• Resulting New Kirby URL: mysite.com/blog/my-trip-to-philly

Upload all these folders to the relevant content folder on your Kirby site and they will be available immediately.

The folders include copies of any images referenced in the post, and all image links in each post are converted to Kirby’s own format.

2. Redirecting From the Old Blog

Create a folder blogger on the server for your new website, accessible at the URL mysite.com/blogger. Make a file in that folder called index.php and paste in this code:

<?php
/* Make sure to replace mysite.com/blog below
   with your own blog address. /*

    $old_url = $_GET['q'];
    if ($old_url != "") {
        $tld_fix = preg_replace("/blogspot.[a-zA-Z0-9]+/", "blogspot.com", $old_url);
        $permalink = explode("blogspot.com", $tld_fix);

        $new_url = preg_replace('/.+?([^\/]+)\.html/', '$1', $permalink[1]);
        header ("HTTP/1.1 301 Moved Permanently");
        header("Location: http://mysite.com/blog/$new_url");
    } else {
        echo "<!DOCTYPE html><html><head><title>BOO</title></head><body><h1>BOO!</h1></body></html>";
    }
?>

This creates a handler on your new blog that will take incoming requests from your old blog and point them to the correct location on the new blog:

Incoming request: mysite.com/blogger/?q=http://myblog.blogspot.com/2010/03/my-trip-to-philly.html
Redirected to: mysite.com/blog/my-trip-to-philly

Now that your new blog is ready to receive incoming hits, we’ll start redirecting your old blog.

You will need to revert to “Classic templates” on your old blogspot site.

Edit the template and past in the following code just before the </head> tag:

<script>
<MainOrArchivePage>
    window.location.href='http://mysite.org/'
 </MainOrArchivePage>
<Blogger><ItemPage>
    window.location.href='http://mysite.com/blogger/?q=<$BlogItemPermalinkURL$>'
</ItemPage></Blogger>
</script>
<MainPage>
    <link rel="canonical" href="http://mysite.com/" />
</MainPage>
<Blogger><ItemPage>
    <link rel="canonical" href="http://mysite.com/blogger/?q=<$BlogItemPermalinkURL$>" />
</ItemPage></Blogger>

This does two things.

1. It sets a link rel="canonical" tag for each page on your blog listing the new URL for that page on your new site. Several search engines (including Google) use this tag to update their search results with the new URL instead of the old one. This ensures you continue to get traffic from search engines at the new blog instead of the old one.
2. It uses javascript to instantly redirect visitors to a page at your new blog.

Once you’ve saved this template, any hit to any page on your old blog should magically land you at the new one.

I’d advise leaving the old blog in place for as long as possible (at least a year).

• Get a Doxie One scanner. For (optional) convenience, get an Eye-Fi SD card for $35, which will send documents from the scanner to your computer wirelessly and automatically.

  Update: If you want to cut your scanning time by more than half, spend a few bucks more and get the Canon P-215 scanner (as recommended by The Wirecutter). It scans twice as fast, it scans both sides of the page at the same time, it has a document feeder, and it has built-in OCR.

• Scan your documents to your hard drive. Put them all in one big folder. If you want, use the OCR option in Doxie’s software to make your PDFs searchable.
• Date and tag the documents: use this format for filenames: [year]-[month] name of document #tag1 #tag2 #tag3.pdf
• Get an expanding file jacket. Put all your important papers in there and out of the way, and scan them all once every quarter or so (I usually do my scans once a year just before I do my taxes).
• Shred the original documents.
• Keep backups.

When you want to run a search, open your archive folder and run a search. Need all tax-related documents for last year? Search for 2012 #taxes.

No subscriptions. No extra software. Guaranteed to be stay portable and useful for the next 20 years.

Why the hashtags? What about folders?

Using #tags #like #this in the filename is a universal tagging mechanism. It works on Mac OS and on Windows, and the searches on those systems will have no problem finding your files.

Sticking files in a folder hierarchy is a poor way of filing that is on its way out. For example, what do you do if a document is both medical and tax-related in nature? Do you create a Taxes → Medical folder structure, or Medical → Taxes?

Tags allow a document to live in more than one box at a time, are easy to add, and are easy to search for.

Why Not Evernote? Reasons, that’s why.

There have been a couple of great posts by others lately about going paperless, and they’re definitely worth reading. But they all assume you need some kind of fancy software setup, including (most commonly) a subscription plan to Evernote.

I agree it must be nice to have someone else run OCR on my documents and host them for me. But let’s look at the drawbacks:

• I have to pay someone else $60 a year in case I need to perform occasional full-text searches on my own documents.
• Long-term uncertainty. Will Evernote be around in 10 years? 20 years? How do I know I’ll be able to get my massive archive back out again when they go out of business?
• Handing off responsibility for your sensitive documents to someone else’s computers—this is just asking for trouble. Data corruption, security breaches, warrantless searches. Over the next 10 years, it’s almost a given that your hosted service of choice will be hit by at least one of them.

If you have a Mac, you can just follow these excellent instructions by Brad Gessler.

If you’re a Windows user, follow the instructions below, which I’ve adapted from Brad’s post after a good bit of tinkering. I’m also including some details that he left out.

1. Brad writesFull disclosure: I’ve copied the Linode signup link from Brad’s original post, which means it still includes Brad’s referral code. I thought this was fair since he was the one who first posted the basic solution. In his post he expresses a wish to find some way to use his referral code to donate to the EFF; I’ll keep an eye out, and if he finds a way to do that I’ll update this post’s link as well.: “Signup up for a Linode account. After you enter your credit card information and select a Linode server, you’ll be asked where you’d like to boot the server. It’s important that you select London, UK during this step so that you get an IP address from inside of London.” Note that the $20 (least-expensive) server option should be plenty for your needs.
2. When Linode asks which distribution you’d like to use, leave it at the default (Debian). You can also follow all the defaults for the other setup settings (disk space, swap, etc.). After configuration and setup are complete, follow the steps on the web interface to boot your server up.
3. Download PuTTY (just download the putty.exe file listed first). This is the program you will use to connect to your Linode server in London.

4. Configure PuTTY:

   • Main PuTTY screen: Under Host Name enter the IP address of your server, leave Connection type as SSH.
   • In the tree view at left, click Connection → Data. In the auto-login username field, enter the text root
   • In the tree view at left, click Connection → SSH. Make sure enable compression is checked.
   • In the tree view at left, click Connection → SSH → Tunnels. Under Source port, type 8080. Select the Dynamic option and leave the other settings as default, then click Add.
   • Return to the main PuTTY screen by clicking Session in the tree view at left. Type a name under Saved Sessions and click Save (so you won’t have to go through this whole rigamarole every time).

5. Set up your proxy.

   • If you use IE or Chrome, configure this by going to Network and Sharing Center, and clicking Internet Options. Go to Connections tab, click LAN Settings button. Make sure Use a proxy server for your LAN is checked, and click the “Advanced” button. Enter 127.0.0.1 next to the “Socks” field, and enter 8080 for the port. Leave the other fields blank as shown (HTTP, Secure, and FTP).

     

   • If you use Firefox, go to “Connection Settings”, select “Manual proxy configuration” and follow the same procedure, entering 127.0.0.1 next to the “Socks host” field, and 8080 for the port, and ensure the other fields are blank.

Now every thing is set up.

Whenever you want to watch Olympics on BBC:

1. Make sure the proxy is turned on as in step 5 above—these settings will be saved from last time, all you have to do is turn it on again.
2. Open PuTTY, double-click on your saved session, and enter your password when prompted. You can minimize the terminal window once you’re sure you’ve logged in.
3. Browse to http://www.bbc.co.uk/iplayer/tv/bbc_one_london/watchlive to watch the Olympics live, or go to http://www.bbc.co.uk/sport/olympics/2012/live-video to pick and watch specific events.

When you’re done: Tunneling all your web traffic through a London server will make the rest of your browsing slower (and waste your Linode account’s bandwidth) so you should close PuTTY and turn off the proxy server setting from step 5 above when you’re not watching the Olympics.

Thanks to @mja for the original tip about Brad’s post, and the one about where to go directly to watch specific events.

Other approaches

I did attempt to use a VPN service to do essentially the same thing, but it was far too slow.

Keep in mind, it’s not uncommon for Verizon to alter the options they offer. If this article hasn’t been updated in more than 6 months, things may have changed; in that case, look around further online or call customer service and ask them how best to handle it.

Be sure to leave a comment with your findings!

The penny-pincher method (for trips of less than three weeks)

My wife is from Canada and we do this regularly during our visits to family there.

The way Verizon charges for data outside the U.S. is (currently) very simple: They charge for global data in chunks: $25 gets you a somewhat-measly 100MB. You can’t pay in any smaller increments.

Here’s what to do. Call customer service ahead of time⊕From your Verizon phone, dial 611, or dial (800) 922-0204. Press 0 at the menu to just get right to a live person. You’ll be asked to state your reason for calling and told about higher-than-normal wait times, but this is just to deter you into trying the website instead; the wait usually isn’t very long., and ask them to add one 100mb block of Global Data, but only for the days you’ll be outside the US. Give them the days you want it to go on and off your account (i.e., the days that you’ll be crossing the border). This will pro-rate the cost by the number of days you are on the plan, but it will also pro-rate the amount of data you get.

For example, supposing you’ll be out of the country for 11 days. Here’s how the costs for this method would work out (for each line, remember):

• Cost: ($25 / 31) x 11 = $8.87
• Data: (100MB / 31) x 11 = 35MB (round down to nearest MB)

Now (in this example) you’re only paying $9 extra per phone instead of $25. On a two-phone account, that would be a savings of $31.

The trick is staying under that low data ceiling (35MB in this example). If you use more than the chunk of prorated data you’ve already paid for, you’ll automatically get an additional 100MB—and charged the additional $25 as well, meaning you’ll probably pay more than you needed to.⊕Supposing you did use up your “small” chunk and got hit with an additional 100MB chunk, but your total roaming data for the month was still under 100MB, you should be able to call customer service and at least get credited for the “small” chunk. I’ve had to do this once, with no problems.

If you’re going to be out of the country for more than 20 days, the savings from this method become too small to be worth the hassle; you might as well just get the 100MB.

Either way, here’s how to make sure you don’t use up your “cheap” data:

• Save your data usage for when you’re at a wifi hotspot (any data you use over wifi doesn’t count against you). This includes websites, email, Instagram, Facebook, etc.—pretty much app that communicates in any way. Some games don’t use data, but many do. Light usage of these things is ok, but the more you can save for wifi, the more likely you won’t break your data cap.
• Don’t watch videos when not on wifi (Netflix, YouTube, Vimeo, etc.)
• Don’t stream any music when not on wifi (Spotify, Pandora, iCloud, Amazon, etc.)
• If you’ll need maps during the day, look them up ahead of time while on wifi, making sure to zoom in and out to download the tiles at various zoom levels
• (For iPhone users) Turn off Push for email—instead set it to Fetch Hourly (or Fetch Manually). Go to Settings—Mail, Contacts, Calendars—Fetch New Data, turn off the Push option and set the frequency to Hourly or Manually.

What about the inconvenient and totally free method?

Depending on your phone, it’s possible that you may be able to avoid any extra overseas data charges altogether by turning off cellular data.

When your phone is connected to a network of any kind, it is constantly “sipping” data. True, it’s a miniscule amount, but as soon as it sips even one kilobyte while you’re out of the country, you get that $25 charge for a block of 100MB of roaming data.

On an iPhone, you need to turn off cellular data under Settings → General → Network. (Turning off “Data Roaming” will not work—it’s notoriously unreliable.) Another option, if you want to avoid voice roaming charges as well, is to turn on Airplane Mode and then re-enable WiFi. Remember you can’t place or take any cellular calls in Airplane Mode, but you could use Skype or FaceTime to make calls while connected to WiFi.

The catch with this method is that it can never actually eliminate your risk. Unforeseen circumstances can very easily require you to grab an email or place a call when you’re not near wifi, and even if it’s technically possible to change your phone’s settings back and forth in just the right ways, you always risk slipping up even for a second and incurring that $25 charge. Personally I’d much rather be realistic and plan ahead so I can be flexible without breaking the bank. For short trips especially, I really don’t believe it’s worth the mental hassle, unless you want to take the challenge as sort of a game with yourself.

What if I’ll be out of the country for more than three weeks?

Then you really need to read this article: World travel with the unlocked US Verizon iPhone 4S—check out the comments as well.

I found three possible solutions to the problem.

The first (which I used) was to create or modify the following registry key using regedit:

[HKEY_CURRENT_USER\Software\Microsoft\Office\11.0\Excel\Security\FileValidation]
"EnableOnLoad"=dword:00000000

The second option is to uninstall the Microsoft Office File Validation Add-in from the Control Panel.

The third is to upgrade to Excel 2007 or later.

It’s been known for some time now that this is often an iOS 5 bug caused by a contact sync process that gets out of handNo one seems to be sure why, however. The most extensive troubleshooting that has been made public seems to leave a lot of unanswered questions.. In the process of fixing this problem for myself, I discovered an alternative to the commonly-used practice of using an extra Exchange account for syncing Gmail contacts. This new setup has dramatically increased my battery life even beyond what it was before I started having the battery drain issue.

Note: I use Gmail, and I like all my contacts to be available from there. These instructions are thus somewhat Gmail-centric, but you should be able to improve your battery life by following the general principles shown. If you have tips for other email/contact setups, please let us all know in the comments.

First, solve the battery drain issue. The following steps solved the problem for meI based this off of this thread at Apple support—they seem to work even though they were posted as a solution to a similar problem that was before iOS 5:

1. Remove all the messaging accounts on your phone, including iCloud. Remove all Calendars, Contacts, Notes and Bookmarks from the phone (so you don’t have duplicates when you re-add the accounts later).
2. Power down your phone (the normal way, by holding down the power button and sliding to power off).
3. Let it cool off, and start it up again.

You now have a blank slate: no email, calendars, or contacts. A blank slate means a chance to clean up and streamline.

1. Re-add your iCloud account. Wait long enough for contacts and calendars to sync, check to make sure.
2. Re-add your Gmail account as a Gmail account. This means it will only pull in mail (and calendar), not contacts.
3. Clean up your Gmail contacts by opening your contacts in Gmail (i.e., open the website on your computer), clicking the More button at the top, and clicking Find and merge duplicates...
4. Purchase the Contacts Sync For Google GMail app. Yes it’s $4.99. It’s worth it.
5. Run the app, making sure to read the User Guide to make sure it will be syncing contacts the way you want it to. (I used 2-way, so all my contacts live in both my iCloud and my Gmail accounts.)
6. Finally, go to the Settings app, and go to the Mail, Contacts, Calendars section. Click on Fetch New Data. Make sure Push is turned off, and select the Hourly fetch schedule.

Now you have all your contacts synced by an app that knows how to do its job better than iOS does (seriously, check out the reviews), and you have an email connection that is lightweight and uses minimal battery life.

For what it’s worth, I also have an Exchange account for work that syncs mail, contacts, calendars and reminders—also on the hourly fetch schedule.

Wait, won’t there be a big delay for receiving emails this way? No, not really. The fact is that whenever you open an email inbox in the Mail app, your iPhone instantly re-checks the account for new mail anyway. The Fetch setting only limits the background checking that the phone does when you’re not looking, so setting it to hourly just means the red “new email” number on the Mail icon won’t update itself more than once an hourSeriously, how often do you really need to check your email? More than once an hour and I’d say you have serious productivity issues.. You can always get an up-to-the-minute check by just opening the Mail app.

Typographically, the example books I linked to above are more the exception than the rule: the vast majority of LaTeX documents use the same boring default font, Computer Modern, that was originally packaged with the software in the 1980s. Using Computer Modern in a self-published book would be almost as bad as using Times New Roman or Arial.

If you try to figure out whether and how you might be able to use your computer’s normal fonts with LaTeX, you will soon come across a lot of extremely complicated and incomplete documentation about how to convert TrueType or OpenType fonts into a format LaTeX can use.

The happy truth is that these instructions are now obsolete: you now have easy access to OpenType fonts on Windows and Mac platforms, thanks to a new version of LaTeX called XeTeX. XeTeX includes a package called fontspec that gives full access to all system fonts, as well as advanced features for OpenType fonts, such as ligatures and small caps. XeTeX is available for Mac, but what most people don’t say is that this font-accessing goodness can also be used on Windows since XeTeX is included with Windows distributions such as TeX Live and MikTeX.

That being understood, here’s how to use your system fonts in your TeX documents (source):

1. Use the xelatex command in place of pdflatex
2. Add \usepackage{xltxtra} at the beginning of your preamble (enables some XeTeX goodies, in particular it also loads fontspec, which is needed for font selection).
3. Add \setmainfont{Name of OTF font} in the preamble.
4. No step 4.

Note: If you are using the aforementioned pandoc to generate your TeX documents, you do not need to do step 2—pandoc already includes the fontspec package in its default template. Also, you can set the main font by adding the option --variable=mainfont:"font name" when calling the pandoc command.

The idea is to write documentation as a collection of plain-text files in Markdown format and have a no-fuss way to publish them as HTML, re-publishing changes as necessary.

In order for this script to work, you need to be on Windows, and you need to install a program called pandoc.

How to use it:

1. Save a copy of this script file in any folder containing a bunch of Markdown-formatted text files. Include a stylesheet.css file in this folder as well if you want the HTML files to have CSS styling.
2. Run the script (double-click it)—it will silently create updated HTML files for every text file in the folder. Only text files whose HTML counterparts are out of date or nonexistent will be processed.

You can either copy and paste the code below into Notepad and save it as a .vbs file, or you can download the latest version in a zip file. The code in the download will be more extensively commented, and may also contain enhancements developed since this post was written.

Here’s the basic code (provided under the terms of the Artistic License 2.0—http://www.perlfoundation.org/artistic_license_2_0):

Set objShell = CreateObject("WScript.Shell")
Set objFSO = CreateObject("Scripting.FileSystemObject")

strThisFolder = objFSO.GetParentFolderName(Wscript.ScriptFullName)
Set objStartFolder = objFSO.GetFolder(strThisFolder)
strConverterCommand = "pandoc -f markdown -t html -c stylesheet.css -o "

Set objFilesToUpdate = CreateObject("Scripting.Dictionary")

Set colFiles = objStartFolder.Files
For Each objFile in colFiles
    If objFSO.GetExtensionName(objFile.Name) = "txt" Then

        ' Check if HTML version of this text file exists in this folder
        strHTMLName = strThisFolder & "\" & Replace(objFile.Name, ".txt", ".html")
        If objFSO.FileExists(strHTMLName) Then

            ' If it exists, compare the timestamps
            Set objHTMLFile = objFSO.GetFile(strHTMLName)
            If objFile.DateLastModified > objHTMLFile.DateLastModified Then
                'If the text file is newer, add this text file to the list
                objFilesToUpdate.Add objFile.Name, strHTMLName
            End if

        Else
            ' If the file does not exist yet, add this text file to the list
            objFilesToUpdate.Add objFile.Name, strHTMLName
        End if
    End if
Next

' Update all the text files in the list.
colFilesToUpdate = objFilesToUpdate.Keys
For Each strSourceFile in colFilesToUpdate

    objShell.Run strConverterCommand & objFilesToUpdate.Item(strSourceFile) & " " & strSourceFile, 3, True
Next

Possible Future Improvements:

• The script isn’t very helpful about telling you how long the process is going to take. I looked at several options for providing a progress bar or some kind of status output, but ultimately VBScript is just really sucky at this.
• Pandoc is a very powerful converter. One could easily tweak the script to add options for producing LaTeX or even PDF files.

It starts with your page size. If you are self-publishing with a service like Lulu or CreateSpace, you select the size of your book, and this will give you a set of constraints (margins, etc.) to start with. Your page size and maximum margins will generally determine roughly how wide your text block can be.

Next, you want to find a matching set of values for your final font size, line height, and line width. The method I’m going to give you here is based on one possible set of proportions between font size, line height, and line width. See this article about golden ratio typography for more information.

1. Take the width of your text block in inches and multiply by 72. This tells you how many “points” there are in one line of text.
2. Take the square root of this number and divide by 1.618 (the golden ratio). This gives you an optimal font size, in points, for your main text.
3. After rounding this font size to within half a point, multiply it by 1.618 again. This will give you your optimal line height in points.

You may need to reiterate a few times until you get a matching set of numbers that fit well on your page and do not need too much rounding.

Configure Word’s typesetting

A couple of points about paragraph formatting:

• Make sure your main text is set to “justified”, and not “flush left.” While it is currently better to set text flush-left on the web, books look better justified and are nearly always set that way.
• Don’t have spaces between paragraphs in your main body text.
• Paragraphs should have a first-line indent of the width of about 2 or 3 characters, but only where two or more paragraphs are joined together: the first paragraph of any group of paragraphs should have no first-line indent. (This could be a pain to manage; I tend to handle it by making all paragraphs indented by default, then going back and manually removing the indent from first paragraphs at some later stage in the editing.)

Make sure the following settings are enabled under the “Compatibility” options. To get to these options, click on the circular “Office Button” in the upper left corner, and then click Word Options at the very bottom of the menu. Then click Advanced, scroll down to the bottom of that section, and click the + next to Layout Options. On older versions, click the Tools menu, then Options (or Edit → Preferences on a Mac) then click the Compatibility tab.

• Put a check next to “Do full justification like WordPerfect 6.x for Windows.” This allows justified text to contract as well as expand, making the automatic adjustments look a lot better.
• “Don’t add extra space for raised/lowered characters.”
• “Don’t expand character spaces on the line ending SHIFT+RETURN.” This ensures that lines you end with a soft return will still be properly justified.
• “Suppress ‘Space Before’ after a hard page or column break.”

Configure Word’s hyphenation settings. On the toolbar, click the Page Layout tab, then Hyphenation drop-down button → Hyphenation Options. (On older versions, click Tools menu → Language → Hyphenation.)

• Put a check next to “Automatically hyphenate document.”
• Set “Hyphenation zone” to about half an inch.
• Set “Limit consecutive hyphens” to 3.

Finally, enable ligatures. If your font is of good quality and has alternates for character combinations like fi and ffi, this will tell Word to use them automatically. This can only be done in MS Word 2010 or later.

• Open the Font settings window. You can do this by selecting some text, right-clicking and selecting Font from the menu, but I recommend setting this up in whatever “style” you use for your body text (e.g., “Normal”): Home tab, right click the style, select Modifiy, then Format button → Font.
• Click the Advanced tab, then next to the Ligatures option, select Standard Only.

Sources

These tips are compiled from many sources, and in many cases updated for clarity or accuracy with newer versions of Word.

• How to Enable OpenType ligatures in Word 2010
• Typesetting in Microsoft Word by Jack Lyon
• Golden Ratio typography by Chris Pearson

WriteMonkey is extremely Markdown-friendly—useful if, for example, like me you write all your blog posts in Markdown format.

Not all of WriteMonkey’s features are well-explained or documented, so I’m writing them up here.

Configure Markdown features

• Markdown highlighting will not work unless you have Markdown set as your “Markup Standard”—set this in the Print & Export section of your Preferences screen.
• Set the font size/weight/style used on headers: in the Preferences screen’s Colors & Fonts tab, click the button labeled ... in the upper right section (why they didn’t label it more clearly is beyond my understanding).

• Make your exports look great. Download the template in this zip file and place it in WriteMonkey’s templates folder. It’s a version of this Markdown stylesheet with the following changes:

  • Removed padding: 0; margin: 0 rule for the ul and ol elements - this preserves indentation in multi-level lists.
  • The max-width was widened to look better on bigger screens.

Some undocumented features I found by accident

• You can toggle whether WM will use normal quotes or “smart quotes” with CTRL+SHIFT+' (apostrophe).
• Out of the box: type /now to insert the timestamp. You can format this timestamp in the Preferences screen.

Use WriteMonkey to write your book

WriteMonkey has a number of great features for writers:

• It lets you set and monitor progress goals for your writing based on either word count or time or both.
• Hit F5 to toggle between your main text and the “repository,” which works as kind of a scratch pad for the current file.
• You can use the Jump screen to set navigate around your text’s headings, bookmarks, and todo items.

The upcoming version (2.3.5.0 as of this writing), however, will have some great project management functionality. (See here for more info)

• Folders will be treated as projects, and all the files within it will be part of the project. You’ll be able to switch quickly between text files in the same folder using a new Files view in the Jumps window.
• You’ll be able to quickly merge all of a project’s files into a single text file.
• You’ll be able to mark a file with “tags” using a comment line (starting with \\) at the top of the file, and filter the project file list by tags.

• Special tags affect how the file is treated in the project window

  • Tagging a file with a color name will cause that file to show up with a colored star in the jump screen. Multple colors mean multiples stars, e.g. // red red red will add three red stars.
  • Adding the “draft” tag will move the file to the “repository section”—the file will be presented with lighter color and excluded from total word count.
  • Tag with a percentage, e.g. // 50% to add a grey progress bar
  • Tag with a date in order to add a deadline; the border of the file will turn red when it becomes past-due

Let us know of any additional tips in the comments!

I’ve had an iPhone 4S since November 2011, and I would describe Siri as gimmicky, flaky, and useful only within a narrow subset of the things it was promised for.

The biggest killers of my enthusiasm for using Siri are laggy interaction and flaky availability. Interaction misses plus plain old network lag combine to make Siri slow, slow, slow.

There are five possible outcomes to each Siri interaction:

1. Siri misunderstands what you said due to you speaking incorrectly, or
2. Siri misunderstands what you said because of a voice recognition error, or
3. Siri understands what you said but misunderstands what you meant, or
4. Siri is unable to connect to its servers, or
5. Siri connects and responds correctly

Four out of these five outcomes result in a failed interaction. While you can get better at speaking correctly, there are few to no workarounds for the other three error conditions.

Since Siri goes out over the internet in order to analyze each spoken interaction, it can often take a good 5–10 seconds to offer a response to what you’ve just saidConnection failures are especially common when you are on the outer edge of a known wifi network, such as when in the driveway or parking lot, or walking to/from your house. The iPhone seems to think it is connected via wifi for some time after you have left range, causing Siri to attempt using a nearly non-existent connection.. In addition, at least every other day Siri’s servers seem to go dark for a period of time, resulting in “really sorry, but I can’t take any requests right now, please try again in a little while.”

Add this delay, and a random but sizeable chance of connection failure, in between each incorrect response, and you soon get used to doing most things the old way rather than gamble on an unreliable Siri.

Someone’s bound to respond that Siri is still officially beta software. I am aware of that, and don’t expect it to be perfectAlthough I do expect beta software to be at least feature-complete, which I don’t believe Siri is..

But it’s also worth noting that Apple, like most software companies, has introduced many apps and features that they then failed to improve upon or even abandonedSee the Calendar, Weather, Music and Stock apps, iTunes Genius, Ping, and of course Mobile Me.. My gut feeling is that Siri is in danger of ending up as the next Mobile Me, especially given that it has received almost no improvement or attention since its release so far.

⊕If you happen to be using the same Apple ID/iCloud account on two phones, I would assume you don’t need this article since everything is already syncing across all devices within your single account. These instructions assume that each iPhone user has their own, separate Apple ID and iCloud.

1. Use iCloud for Your Calendar Account

I’m not saying you have to use iCloud. I’m saying it’s by far the simplest and easiest way.

Make sure each user has iCloud set up on his or her device. If you have iOS 5 or newer on your phone or iPad, you likely have signed up for iCloud: to make sure, grab your device and go to Settings → iCloud and check that it shows something next to Account. Also check that Calendars is set to On.

If iCloud is not set up on your device, read these simple iCloud setup instrctions from Apple.

Other Calendar Accounts

Gmail accounts come with a pretty useable calendar system, so a lot of people use those; but I found the instructions and process for syncing GMail calendars between multiple Google accounts/iPhones very clumsy, complicated, and unintuitive, even for a geek like myself. If you have tips on that, let us know in the comments.

Exchange accounts also include calendar functionality. I have one of these at my job, and it syncs to my phone also, but I don’t really need to share it with my wife so I haven’t tried. I expect the only way to do this would be to add my exchange account to her phone with my own password, and turn off the mail part of the account in the iPhone’s settings. Again, let us know in the comments if you’ve experimented with this.

2. Share Your iCloud Calendar(s)

This is an easy process, but not entirely obvious because you have to use a laptop/desktop computer, and not your iOS device, to start the process.

1. First of all, pick which iCloud account is going to “own” the shared calendar(s). It really makes no difference because both parties will have full access.
2. Open your web browser on your desktop or laptop computer and go to icloud.com.
3. Sign in using the account of the “owner” and click on Calendar.

4. Click on the small circle to the right of the calendar you wish to share. Under Private Calendar, enter the email address for the user of the “other” iPhone/iPad. It can be any email address for that person (it doesn’t have to be the one they use to sign in to iCloud) but it should be one that they have set up on their iPhone/iPad.

   

5. After entering the email address, click Share.

Now the other user can grab his or her device, open the email, and click the “Join Calendar” button.

Voila, you now have a calendar shared between two devices. Any events or appointments you create or change on the shared calendar on one device will automatically show up on the other device pretty quickly, and without any additional steps.

Some additional notes:

• You can of course share multiple calendars with this process, and you can even share them with different multiple people. My wife and I share three calendars, because this allows us to easily colour-code different kinds of events simply by putting them on different calendars. (There are some calendar apps that let you colour-cde different events within the same calendar, but not the one we happen to use.)

• When creating/changing an event that you want shared, you do have to make sure it is in fact created on one of the shared calendars. That should seem obvious, but it can be an easy step to miss. You can make it easier for yourself by setting your default calendar on your iOS device to the shared calendar you use most often: click Settings, then Mail, Contacts, Calendars, and then scroll down to the Calendars section and click on the Default Calendars setting to change it. Otherwise (if you’d rather not default to sharing all your events) just be aware that your iOS device does have multiple calendars and remember to pick the right one when setting up an appointment.

  • If you use Calvetica Classic as your calendar app, you can have it ask you which calendar to use every time you set up an event, which is nice.

3. Get a Better Calendar App

The calendar app that comes with iOS is plain, and has many shortcomings: the interface for creating new appointments is clumsy, the colour-coding is not visible in month view, and there’s no week view at all, to name a few. For notes and recommendations on iOS calendar apps, read my post on iOS Calendar App Recommendations.

Here are some notes on popular calendar apps I’ve tried and can (mostly) recommend.

• Calvetica Classic is what I currently use and recommend for iPhone. As far as I can tell, it’s identical to Tempus (made by the same developer) but for some reason costs less. (Tempus may be the one that gets more maintenance attention from the developers in the future, however). Calvetica Classic’s interface is designed to be quick and easy to use, and to look attractive. It also happens to be reasonably prompt about automatic syncing—which, surprisingly, not all apps are (see below).

  The reason for the “Classic” version is that the makers of Calvetica made a New-Coke-style error when they redesigned and rewrote the app for the new version 4.0. The regressions in the interface and buggy experience of the new version apparently left a lot of users clamouring for the old version, and from what I can tell, the developers responded by offering both Calvetica Classic and Tempus. I haven’t used the new version, but the reviews on the App Store currently show that it still needs a good bit of bug fixing, especially on the iPad.

• The other really good option out there is Week Calendar. I haven’t tried it personally, but this one has been recommended by Lifehacker, and has hundreds of great reviews (many more than any version of Calvetica), so it must work well. The only reason I didn’t go for it was that Calvetica is faster for adding events⊕Note that if you have an iPhone 4S, you can set up new events very easily on your default calendar with Siri, no matter what app you use., and Calvetica just looks more cool and elegant.
• Agenda was recommended recently on Daring Fireball and was actually the first calendar app I used after getting our phones’ sync configured. It’s not as quick to use as Calvetica, but it looks gorgeous, and swiping between month/week/day view is almost too good to give up. The app otherwise great except for one major thing: it’s terrible at automatic calendar syncing, especially when an event on a shared calendar is being deleted. In my experiments Agenda would not automatically sync until I had either shut down the app and restarted it, or until I had opened the default Calendar app (which triggers its own sync). You can also use the “shake phone to sync” feature of Agenda, but honestly, all three of these things are ridiculous.

YNAB feels refreshingly like a “Quicken Rebooted” would feel. After a couple of years trying “finances in the cloud” a-la-Mint, returning to using a traditional program that just runs on your own computer feels like the right thing to do. I once again have control of my own financial data, and will never have to worry about potential security breaches at unregulated third-party services like Mint.

YNAB insists that you manage your transactions the Old Way: by entering them yourself. The fact that this feels very right was/is quite a surprise to me, but when it “clicked,” it felt like it had been a long time coming. When I signed up for Mint, the automatic behind-the-scenes importing of all my transactions seemed like a brilliant way to streamline things, but it turned out to have some fatal downsides. Mint’s connection with my bank was always spotty, and their automatic categorization of my spending was never more than about 60-70% accurate. This meant I had to go in and regularly sift through all my spending, making sure each transaction was properly categorized—a process even more unpleasant and tedious than just entering them myself. It wasn’t long before I stopped using it altogether. So when I read this on YNAB’s website, it jived a lot:

We do not directly connect with your bank, log in with your username and password, and download transactions for you. That kills awareness and promotes a “set it and forget it” mentality that lets you not revisit your budget for months, leaving you right back where you started. We’ll import downloaded transactions (OFX, QFX, QIF) to make sure you’ve captured every transaction, but bank importation should not be the primary means of entering data into YNAB. (Use your phone and record it as the transaction happens, or make entering receipts a 5-minute daily ritual. Your money will thank you for it. Promise.)

But the biggest difference between YNAB and the Mint approach is that while Mint is geared towards passive capture of past spending, YNAB’s workflow puts planning future spending at the center. I won’t dive into that here, but you should know that this approach is what will make even using finance software worth your while. If you are familiar with the increasingly-popular envelope system of budgeting, or with financial planning evangelists like Dave Ramsey, YNAB will fit right in with those paradigms and help you implement them.

Coming down from the cloud

YNAB’s non-cloud approach means you won’t have completely seamless access to your main financial data store from any browser or from your iPhone. When you think about it, that actually might not be a problem. Do you really need that kind of access? Financial planning isn’t one of those things that inherently benefits from being decentralized.

YNAB tries to strike a middle course by supplying iPhone and Android apps that let you record transactions on the go for easy syncing later. I haven’t yet tried these apps out; I’m not yet sure whether it’s even worth the added complexity for me personally. I can just as easily keep receipts or type transactions into a note app on my phone.

Ideally, a YNAB mobile app would allow automatic background syncing between two phones, so that my wife and I would have quick, seamless access to where our budgets are at, but YNAB’s app isn’t there yet. But in my view, it all goes back to a focus on planning rather than capture. If my wife and I actually have a plan in place for our monthly spending, we pretty much know going into the day where our money is going to go, and up-to-the-minute syncing becomes much less important. Again, I wonder if this is one of those situations where automatic syncing—an inherent “feature” of the cloud approach—would actually be counterproductive in this field, by allowing you to take the easy road and react to spending events, rather than relying on proactive planning.

NB: I’m not an affiliate of YNAB in any way, nor am I being compensated in any way for this overview.

1. DropBox has had security issues that left users’ information exposed to hackers for hours at a time. Could it happen again? Certainly.
2. DropBox staff have the ability to access your files without your knowledge. They have acknowledged that essentially the only thing between their staff and your data are internal company policies. This is much weaker than zero-knowledge systems like SpiderOak, where it is not even technically possible for staff to access users’ files without the user’s key.

Even knowing these weaknesses, I use DropBox anyway. Having access to some (not all, obviously) potentially sensitive files on multiple computers/phones is helpful enough for me to find some way to mitigate the security risks.

It’s important to note that if you’re putting sensitive files on DropBox purely as a backup solution, you should just stop. Find some other way to back those files up. But if, like me, you find it extremely helpful to have access to certain moderately sensitive files from multiple devices, you should find a way to add a layer or two of security to those files before storing them on a cloud service like DropBox.

There are two good ways that I have found to do this. Both are free, and neither involve sending any of your data or keys to an additional third party—all the magic happens on your computer or device. However, there are trade-offs associated with each.

The TrueCrypt Option

The most commonly offered solution is to place your sensitive files in a TrueCrypt volume and save that volume file into your DropBox.

Pros:

• TrueCrypt is open source, making it the most trustworthy and future-proof option
• For extremely sensitive info, TrueCrypt allows you to maintain plausible deniability.

Cons:

• There is currently no way to use or access TrueCrypt volumes on your phone. This is true both for iPhones and Android phones.
• TrueCrypt volumes need to be given a fixed size at the time of creation, forcing you to guess how big it’ll need to be in the future and usually resulting in wasted space.
• You need to be careful not to have the volume “mounted” on more than one computer at a time to avoid corrupting it. Because there’s nothing to prevent you from doing this, you can easily end up corrupting the volume or creating a lot of large “conflict copies” of the volume by accident if you forget this.
• Because DropBox can’t back up changes to any of your encrypted files until you actually unmount the whole volume, you have to remember to unmount it periodically, which can be cumbersome.

The BoxCryptor option

BoxCryptor is a newer solution that works by encrypting individual files on your computer, before they are sent to DropBox. Like TrueCrypt, the software runs on both Windows and Mac OS.

Pros:

• BoxCryptor has an Android and an iPhone version of their software, making it possible to access encrypted DropBox files from your phone.
• The software has limited compatibility with the open-source EncFS encrypted file system, making it at least somewhat future-proof
• File-level encryption makes it much less clumsy to use, and allows DropBox to sync encrypted files just as seamlessly as normal files, and without additional likelihood of conflicts where multiple computers are involved.

Cons:

• The iPhone app is $8 for non-commercial use. This seems stupidly high, considering the Windows and Mac versions are free and they have no back-end infrastructure to maintain.
• No form of plausible deniability is available in either the desktop or mobile versions of the software.
• BoxCryptor is not open-source, so ultimately your trust in the software comes down to your faith in Robert Freudenreich’s ability to correctly implement the security algorithms, to keep maintaining the software, and not to spy on his users. I’m not saying he’s untrustworthy, just that non-open software comes with risks and weaknesses. The security community at large does not have a way of thoroughly and independently evaluating the software, and that represents a security weakness, for one. Furthermore, if Robert or his company lose interest in the software (which can happen for any of a dozen reasons) you will need to take notice and migrate to another solution before you lose all ability to support the now-defunct software.

Creating these reports will involve coming up with your own solutions to an interesting set of problems: how to capture all that data, how to store it in an analytics-friendly format, how to actually analyze it, and how to design the information displays. In this post I’m dealing mainly with the first two parts of that list: capturing data and storing it, with some hints about analytics afterwards.

In data collection, your smartphone is your friend. You want to make sure collecting data is easy and frictionless, so that you get it all. Your phone is always with you, so you can jot things down and not worry about having to get it later. And as much as I love pen and paper, if you go that route you’re going to end up collecting the same info down twice when it comes time to get it into your computer for analytics.

There are a lot of apps out there for collecting and reporting various kinds of data—running times/length, weight loss/gain, sex, sleep and eating habits—and these can be great if you’re only interested in tracking one or two aspects of your life. But as soon as you begin to raise your sights a little and think about comprehensive Felton-scale data collection, you realize what a pain it’s going to be to have a herd of seventeen apps to manage. Another problem with most of these apps is that they don’t provide any access to the actual data.

Daytum

For awhile, Felton was working on a project called Daytum that would help people create their personal reports similar to his. Daytum has always had a lot of promise, but there are a few major problems with it that need to change before it can be really useful:

1. Felton was hired by Facebook recently, and doesn’t seem to be actively maintaining the service anymore
2. The web interface is clumsy for entering anything more than simple quantities
3. The iPhone app—which would ordinarily be the ideal channel for collecting data—is buggy, infrequently updated, and (worst of all) has been known to randomly erase data

The Format is Text

I found what I was looking for in Ben Lipkowitz’s lifelog project. He developed a simple text format that allows you to quickly capture personal events and data as they happen. A self-explanatory sample is below:

date 2011 01 08
0000 0851 sleep
0851 0902 domestics
0902 0904 walking langton-labs
0904 0906 setup kitty
0906 0907 science guinea-pig
0908 0920 food cookie-cereal 2c soy-milk 0.6c peanut-butter-ice-cream 1c
0920 1000 net thermal-clothing, food donut-hole 2pc oatmeal-cookie-dough 3pc
1000 1052 net thermal-clothing
1052 1100 riding kaplans
1100 1145 shoppin, act tour-kaplans
1145 1155 riding langton-labs
1155 1200 chat rachel-?
1200 1210 riding rei
1210 1445 shoppin, domestics test-clothes
1445 1451 stupid rei-membership-form

The syntax is pretty self-explanatory. Each interval is given an activity (e.g., net or drive) followed by any number of tags that add detail (e.g. drive commute-home). Multiple activities and their tags are separated by commas.

The advantages of capturing data in this way are obvious:

• Both the time length and frequency of activities is captured
• It’s easy to add custom data to different kinds of activities (such as the quantities given in the food activity above)
• You can easily enter and read the data without any special software
• The data will still be easy to read ten or fifty years from now

How to actually use the data: Creating any visual displays of all this data is going to involve brushing off your script-writing chops. The good news is if you have any programming ability whatsoever, you should be able to cobble something together quite easily for whatever you want to do. Check out the lifelog project for examples of scripts for parsing and displaying the data. Ben currently produces graphs showing time intervals colored by activity, but you could just as easily build a script in your favourite language to build reports for things like average commute times, top five conversation topics, or total times you had to look for things and how many of those times you found them, etc. If you have your script output the results in a CSV format, you can open those reports directly in Excel and create charts from there.

This format doesn’t work well for capturing broader categories of events that span over multiple time intervals. For example, there’s no clear way to record that everything you did this afternoon was part of Brother Mike’s Wedding, for example. There are a couple of ways to extend this, such as adding mark, start or end keywords to mark the beginning and ending of these types of things, or simply recording that info elsewhere.

I don’t recommend trying to record your moment-to-moment moods for any reason whatsoever. That way lies self-referential madness.

The App is Nebulous Notes

Nebulous Notes has a couple of great features that make it great for this kind of data collection:

• Shortcut keys: You can set up shortcut keys to quickly insert date and timestamps in right format, as well as skip forward and backwards by word or character (see screenshots above)
• Dropbox support: Store your text file on your Dropbox account and it will be auto-saved to the cloud every time you edit it, and you can easily pull it into your laptop for analytics.

I recently switched to the iPhone, so if you have an Android or Blackberry you’ll need to find your own favorite app for that platform. (Personally I can’t imagine attempting anything like this on my laggy old Blackberry.) Let me know in the comments if you find anything!

The links given in this list are to Kindle editions of the books, free wherever possible, unless there have been severe quality complaints with the ebook versions. If you want to see book covers and a summary of comments by those who have read them, see this summary of the reddit thread by John Forsythe.

1. Dune by Frank Herbert—1965
2. The Hitchhiker’s Guide To The Galaxy by Douglas Adams—1979 Good light bathroom reading. Perhaps the schtick will wear off as quickly for you as it did for me, but lots of people never tire of it.
3. Ender’s Game by Orson Scott Card—1985 My personal favourite of the ones on this list that I have read.
4. Foundation Trilogy by Isaac Asimov—1942 More of a saga broken up into smaller novels with one majestic overarching connection. I really enjoyed this one.
5. Hyperion by Dan Simmons—1989 “On the eve of Armageddon, with the entire galaxy at war, seven pilgrims set forth on a final voyage to Hyperion seeking the answers to the unsolved riddles of their lives.”
6. Neuromancer by William Gibson—1984 “Case was the hottest computer cowboy cruising the information superhighway—jacking his consciousness into cyberspace, soaring through tactile lattices of data and logic, rustling encoded secrets for anyone with the money to buy his skills. Then he double-crossed the wrong people, who caught up with him in a big way—and burned the talent out of his brain, micron by micron. Banished from cyberspace, trapped in the meat of his physical body, Case courted death in the high-tech underworld. Until a shadowy conspiracy offered him a second chance—and a cure—for a price…”
7. Snow Crash by Neil Stephenson—1992 “In California of the near future, when the U.S. is only a ‘Burbclave’ (city-state), the Mafia is just another franchise chain, and there are no laws to speak of, Hiro Protagonist follows clues from the Bible, ancient Sumer and high technology to help thwart an attempt to take control of civilization—such as it is.”
8. Childhood’s End by Arthur C. Clark—1953 “The Overlords appeared suddenly over every city—intellectually, technologically, and militarily superior to humankind. Benevolent, they made few demands: unify earth, eliminate poverty, and end war. With little rebellion, humankind agreed, and a golden age began. But at what cost? With the advent of peace, man ceases to strive for creative greatness, and a malaise settles over the human race. To those who resist, it becomes evident that the Overlords have an agenda of their own.”
9. The Forever War by Joe Haldeman—1974 “Short, but fantastically well executed. It might be so good, in part, because it’s short.”—“Humans first bumped heads with the Taurans when we began using collapsars to travel the stars. Although the collapsars provide nearly instantaneous travel across vast distances, the relativistic speeds associated with the process means that time passes slower for those aboard ship. For William Mandella, a physics student drafted as a soldier, that means more than 27 years will have passed between his first encounter with the Taurans and his homecoming, though he himself will have aged only a year. When Mandella finds that he can’t adjust to Earth after being gone so long from home, he reenlists, only to find himself shuttled endlessly from battle to battle as the centuries pass.”
10. Ringworld by Larry Niven—1970
11. Do Androids Dream of Electric Sheep? by Philip K. Dick—1968 This is the novel on which the movie Blade Runner was based. “By 2021, the World War had killed millions, driving entire species into extinction and sending mankind off-planet. Those who remained coveted any living creature, and for people who couldn’t afford one, companies built incredibly realistic simulacrae: horses, birds, cats, sheep…they even built humans. Emigrées to Mars received androids so sophisticated it was impossible to tell them from true men or women. Fearful of the havoc these artificial humans could wreak, the government banned them from Earth. But when androids didn’t want to be identified, they just blended in.”
12. A Stranger in a Strange Land by Robert A. Heinlein—1961 “The story of Valentine Michael Smith, born during, and the only survivor of, the first manned mission to Mars. Michael is raised by Martians, and he arrives on Earth as a true innocent: he has never seen a woman and has no knowledge of Earth’s cultures or religions. But he brings turmoil with him, as he is the legal heir to an enormous financial empire, not to mention de facto owner of the planet Mars. With the irascible popular author Jubal Harshaw to protect him, Michael explores human morality and the meanings of love.”
13. Starship Troopers by Robert A. Heinlein—1987 “Juan Rico signed up with the Federal Service on a lark, but despite the hardships and rigorous training, he finds himself determined to make it as a cap trooper. In boot camp he will learn how to become a soldier, but when he graduates and war comes (as it always does for soldiers), he will learn why he is a soldier.”
14. The Culture Series by Iain M. Banks—1987: Consider Phlebas, Surface Detail, Use of Weapons, Matter and others
15. A Canticle For Leibowitz by Walter M. Miller, Jr.—1960 (Not currently available for Kindle) Strangely arresting and thought-provoking look through the lens of a post-apocalyptic world.
16. Rendezvous With Rama by Arthur C. Clarke—1973
17. Pandora’s Star by Peter F. Hamilton—2004 “Hamilton creates a dense, thoroughly defined twenty-fourth-century world, in which humanity has colonized the stars, thanks to the discovery of wormhole travel, and established a successful commonwealth. The species has even encountered aliens and space-faring artifacts. One remaining mystery is the barrier around stars known as the Dyson Pair. Human curiosity still being what it is, a spaceship capable of faster-than-light travel (thanks to those wormholes again) goes to investigate. When what’s behind the barrier is discovered, the thrill-ride really starts. Aliens formerly trapped inside it, fighting over limited resources, are freed to invade human space.”
18. The Mote In God’s Eye by Larry Niven and Jerry Pournelle—1974 “In the year 3016, the Second Empire of Man spans hundreds of star systems, thanks to the faster-than-light Alderson Drive. No other intelligent beings have ever been encountered, not until a light sail probe enters a human system carrying a dead alien. The probe is traced to the Mote, an isolated star in a thick dust cloud, and an expedition is dispatched. In the Mote the humans find an ancient civilization—at least one million years old—that has always been bottled up in their cloistered solar system for lack of a star drive. The Moties are welcoming and kind, yet rather evasive about certain aspects of their society. It seems the Moties have a dark problem, one they’ve been unable to solve in over a million years.”
19. The Stars My Destination by Alfred Bester—1956 “Marooned in outer space after an attack on his ship, Nomad, Gulliver Foyle lives to obsessively pursue the crew of a rescue vessel that had intended to leave him to die.”
20. Altered Carbon by Richard K. Morgan—2002 “In the 25th century, it’s difficult to die a final death. Humans are issued a cortical stack, implanted into their bodies, into which consciousness is “digitized” and from which—unless the stack is hopelessly damaged—their consciousness can be downloaded (“resleeved”) with its memory intact, into a new body. While the Vatican is trying to make resleeving (at least of Catholics) illegal, centuries-old aristocrat Laurens Bancroft brings Takeshi Kovacs (an Envoy, a specially trained soldier used to being resleeved and trained to soak up clues from new environments) to Earth, where Kovacs is resleeved into a cop’s body to investigate Bancroft’s first mysterious, stack-damaging death.”
21. Red Mars by Kim Stanley Robinson—1993 The first in a trilogy. “An action-packed and thoughtful tale of the exploration and settlement of Mars—riven by both personal and ideological conflicts—in the early 21st century.”
22. 2001: A Space Odyssey by Arthur C. Clarke—1968 “When an enigmatic monolith is found buried on the moon, scientists are amazed to discover that it’s at least 3 million years old. Even more amazing, after it’s unearthed the artifact releases a powerful signal aimed at Saturn. What sort of alarm has been triggered? To find out, a manned spacecraft, the Discovery, is sent to investigate. Its crew is highly trained—the best—and they are assisted by a self-aware computer, the ultra-capable HAL 9000. But HAL’s programming has been patterned after the human mind a little too well. He is capable of guilt, neurosis, even murder, and he controls every single one of Discovery’s components. The crew must overthrow this digital psychotic if they hope to make their rendezvous with the entities that are responsible not just for the monolith, but maybe even for human civilization.”
23. Contact by Carl Sagan—1985 (Not currently available for Kindle) “After years of scanning the galaxy for signs of somebody or something else, this team believes they’ve found a message from an intelligent source—and they travel deep into space to meet it.”
24. The Sirens Of Titan by Kurt Vonnegut, Jr.—1959 “Plain and simple, there would probably be no Hitchhiker’s Guide to the Galaxy as we know it without The Sirens of Titan.”
25. I, Robot by Isaac Asimov—1950 “In I, Robot, Asimov chronicles the development of the robot through a series of interlinked stories: from its primitive origins in the present to its ultimate perfection in the not-so-distant future—a future in which humanity itself may be rendered obsolete.”
26. The Left Hand Of Darkness by Ursula K. Le Guin—1969 “Genly Ai is an emissary from the human galaxy to Winter, a lost, stray world. His mission is to bring the planet back into the fold of an evolving galactic civilization, but to do so he must bridge the gulf between his own culture and prejudices and those that he encounters. On a planet where people are of no gender—or both—this is a broad gulf indeed.”
27. Revelation Space by Alastair Reynolds—2000 “Sylveste is the only man ever to return alive and sane from a Shroud, an enclave in space protected by awesome gravity-warping defenses. Now an intuition he doesn’t understand makes him explore the dead world Resurgam, whose birdlike natives long ago tripped some booby trap that made their own sun erupt in a deadly flare. Meanwhile, the vast, decaying lightship Nostalgia for Infinity is coming for Sylveste, whose dead father (in AI simulation) could perhaps help the Captain, frozen near absolute zero yet still suffering monstrous transformation by nanotech plague. Most of Infinity’s tiny crew have hidden agendas—Khouri the reluctant contract assassin believes she must kill Sylveste to save humanity—and there are two bodiless stowaways, one no longer human and one never human. Shocking truths emerge from bluff, betrayal, and ingenious lies.”
28. Old Man’s War by John Scalzi—2005 “With his wife dead and buried, and life nearly over at 75, John Perry takes the only logical course of action left him: he joins the army. Now better known as the Colonial Defense Force (CDF), Perry’s service-of-choice has extended its reach into interstellar space to pave the way for human colonization of other planets while fending off marauding aliens. The CDF has a trick up its sleeve that makes enlistment especially enticing for seniors: the promise of restoring youth.”
29. Anathem by Neal Stephenson—2008 “Fraa Erasmas is a young avout living in the Concent of Saunt Edhar, a sanctuary for mathematicians, scientists, and philosophers, protected from the corrupting influences of the outside ‘saecular’ world by ancient stone, honored traditions, and complex rituals. Over the centuries, cities and governments have risen and fallen beyond the concent’s walls. Now, in celebration of the week-long, once-in-a-decade rite of Apert, the fraas and suurs prepare to venture beyond the concent’s gates—at the same time opening them wide to welcome the curious ‘extras’ in. During his first Apert as a fraa, Erasmas eagerly anticipates reconnecting with the landmarks and family he hasn’t seen since he was ‘collected.’ But before the week is out, both the existence he abandoned and the one he embraced will stand poised on the brink of cataclysmic change.”
30. Armor by John Steakley—1984 “Felix is an Earth soldier, encased in special body armor designed to withstand Earth’s most implacable enemy-a bioengineered, insectoid alien horde. But Felix is also equipped with internal mechanisms that enable him, and his fellow soldiers, to survive battle situations that would destroy a man’s mind.”
31. Oryx And Crake by Margaret Atwood—2003 “Snowman (a man once known as Jimmy) sleeps in a tree and just might be the only human left on our devastated planet. He is not entirely alone, however, as he considers himself the shepherd of a group of experimental, human-like creatures called the Children of Crake. As he scavenges and tends to his insect bites, Snowman recalls in flashbacks how the world fell apart.”
32. Fahrenheit 451 by Ray Bradbury—1953 “In Fahrenheit Ray Bradbury’s classic, frightening vision of the future, firemen don’t put out fires—they start them in order to burn books. Bradbury’s vividly painted society holds up the appearance of happiness as the highest goal—a place where trivial information is good, and knowledge and ideas are bad. Guy Montag is a book-burning fireman undergoing a crisis of faith. His wife spends all day with her television “family,” imploring Montag to work harder so that they can afford a fourth TV wall. Their dull, empty life sharply contrasts with that of his next-door neighbor Clarisse, a young girl thrilled by the ideas in books, and more interested in what she can see in the world around her than in the mindless chatter of the tube. When Clarisse disappears mysteriously, Montag is moved to make some changes, and starts hiding books in his home. Eventually, his wife turns him in, and he must answer the call to burn his secret cache of books. After fleeing to avoid arrest, Montag winds up joining an outlaw band of scholars who keep the contents of books in their heads, waiting for the time society will once again need the wisdom of literature.”
33. A Fire Upon The Deep by Vernor Vinge—1992 “Vinge presents a galaxy divided into Zones—regions where different physical constraints allow very different technological and mental possibilities. Earth remains in the ‘Slowness’ zone, where nothing can travel faster than light and minds are fairly limited. The action of the book is in the ‘Beyond,’ where translight travel and other marvels exist, and humans are one of many intelligent species. One human colony has been experimenting with ancient technology in order to find a path to the ‘Transcend,’ where intelligence and power are so great as to seem godlike. Instead they release the Blight, an evil power, from a billion-year captivity. As the Blight begins to spread, a few humans flee with a secret that might destroy it, but they are stranded in a primitive low-tech world barely in the Beyond. While the Blight destroys whole races and star systems, a team of two humans and two aliens races to rescue the others, pursued by the Blight’s agents and other enemies.”

When I use an audio post to publish my latest podcast episode as .mp3 (since I want my listeners to get the Flash audio player on Tumblr) and put the link to the .mp3 file in the description of that audio post it also shows up in the iTunes description of the episode when I use FeedBurner to get my podcast on iTunes. In order to get ‘cleaner’ show notes, I’d like to exclude the link from the iTunes info field. Looks a bit weird if there’s stuff like (‘Download MP3 file’) in the show notes.

I noticed the same thing on my tumblr-based podcast. This titling originates with how Tumblr serves up its feeds to FeedBurner. Tumblr has no descreet “Title” field for audio posts; instead Tumblr takes, from the description field, the first however-many complete words there are before the 63-character mark (or thereabouts, including spaces and punctuation), slaps an ellipses (…) on the end, and uses that as the title. This title is the one that gets passed to Feedburner and the one that your listeners eventually see in iTunes. This is what causes ugly things like seeing “Download Mp3 file” as the episode’s title in iTunes.

Fortunately there’s a simple workaround. The MP3 download link doesn’t need to be at the very beginning of your description, it just needs to be the first link in the description. So, just make sure it occurs after the first several words (or after the 63-character mark, to be precise).

In my posts, I’ve been using variations on the following template in my description:

Episode 1234: Blue-Collar Reading Habits, recorded on Aug 23, 2011, is now available for download etc etc

You can download the mp3 audio [mp3 link] (1:26:46, 59.8 MB) or subscribe to the podcast [feedburner link].

This ensures that the episode’s actual title is the first thing in the title that ends up in iTunes. The “overflow,” if there is any, contains relevant info like the record date, etc.

In the above example, the title would show up in iTunes as “Episode 1234: Blue-Collar Reading Habits, recorded on Aug 23…”.

Update, Lars responded:

By the time I got your e-mail I also figured that iTunes takes the first 63 character to create the episode’s title and the rest flows into the description field. However, I’m still wondering if there’s a way to have a shorter title (without having to put lots of spaces in there…) and the body of the audio post (without the actual MP3 link as description in iTunes). I might be a bit perfectionist in this case, but I’d really like to find a solution to that without having to manually edit the XML feed every time I update my Tumblr blog with a new episode. Maybe there’s a way to “tweak” FeedBurner to take the “Title” field you can specify for an MP3 file you link on Tumblr.

I currently don’t know of any tweaks that are possible; neither Tumblr nor Feedburner seem to expose the kind of functionality that would allow for this tweaking. Any suggestions are welcome!

Just enter your search using the form intitle:index.of Moby Dick epub mobi—replace Moby Dick with your desired title or keyword. This search will turn up file listings with direct downloads for (hopefully) ebooks. You may, in fact, get many more books than just the one you were searching for.

If clicking on a search result gives you some kind of “access denied” message, just go back to the Google search result and click where it says Cached to access the copy Google cached before the file listing was made private. Usually the download links from these cached listings still work.

Kindles don’t support the ePub format, so if that’s all you can find, you’ll need to convert it to .mobi format using Calibre.

1. Write your posts in a text editing program on your computer and save them on your computer. (I use a yyyy-mm-dd post title.txt format)
2. Then copy and paste the text into the online Markdown processor and click Convert to generate HTML. (Set “Filter” to “both” for extra typographic goodness.)
3. Finally, copy and paste the HTML into a new post in Blogspot.

This has two advantages. First, it future-proofs your blog. No matter what happens, if Blogger ever gets shut down or becomes undesirable to use for any reason, in ten years you’ll still have a very useable copy of all your writing. Second, a text-editing program is much less likely to crash than your browser. This approach eliminates the risk of a browser crash causing you to lose large amounts of work.

Getting Blogspot to play nice with your Markdown-generated HTML

This is the area people seem to have trouble with, but it’s really quite simple.

1. In Blogspot, go to Settings tab, then the Formatting section. Set “Convert Line Breaks” to No.

2. In your New Posts,

   • Make sure you are using the “Edit HTML” tab

   • Under “Post Options” (at the bottom) make sure

     • “Edit HTML Line Breaks” is set to Use <br /> tags
     • “Compose Settings” is set to Interpret typed HTML

It’s that simple really. Now you can paste in your Markdown-generated HTML without getting extra linebreaks or other wierdnesses.

My Windows 7 laptop began displaying a notification/error every time I logged in:

Windows created a temporary paging file on your computer because of a problem that occured with your paging file configuration when you started your computer. The total paging file size for all disk drives may be somewhat larger than the size you specified

After clicking OK, it would open the virtual memory settings without any explanation of what you were supposed to check or do there.

This evidently happens because pagefile.sys, the file that Windows uses for virtual memory, has become corrupted in some way.

This Microsoft Answers article recommends running a system file check. Here’s how to run an SFC. This did not solve the problem for me, but it is something you should try first.

Here’s how I cleared it up:

1. Log in under a local Administrator account. (Do this after each restart in these instructions as well.)
2. If it’s not already open, open the virtual memory settings by rich-clicking on Computer, → Properties → Advanced System Settings → click the Advanced tab → Under Performance, click Settings, go to Advanced tab, finally under Virtual Memory section click the Change button.
3. Uncheck the Autmatically manage paging file size for all drives checkbox.
4. Set a “Custom size” for the paging file on the C drive: 0MB initial, 0MB maximum.
5. Click OK, close all dialog boxes, and restart your computer.

6. After logging in again, delete the file C:\pagefile.sys

   1. To do this, you may need to change your folder settings so you can see it first. Open a window of your C: drive and click Organize at the top, then Folder and Search Options
   2. Click the View tab, and make sure Show hidden files, folders and drives is turned on, and that Hide protected system files is not checked.
   3. Click OK and go back to your C: drive, find pagefile.sys and delete it.
7. Now go back to the virtual memory settings (see step 2 above) and set the paging file for the C: drive to System managed size, and then make sure the Automatically manage paging file size for all drives checkbox is checked.
8. Click OK, close all dialog boxes, and restart your computer.

A summary of what this does: By temporarily turning off virtual memory, you allow yourself to delete the (now-corrupt) paging file. Then when you re-enable virtual memory, Windows automatically builds a new paging file from scratch, and voilà, problem solved.

I was helped by this thread at geekstogo.com although I did not find it necessary to do any editing of the Registry or any of that jazz. Try the simplest solution first, I always say.

I have not read either yet, but I have downloaded the free ebook and will be reading it as soon as I can! I’m always on the lookout for new reading material and thought I’d pass this on.

J. Mark Bertrand is also known as the writer of Bible Design Blog, which centers around reviews and features of very high-quality Bibles and book-making in general. It’s actually a rather interesting subject even if you are not religious. See his announcement about his novels here.

I publish a couple of podcasts: Howell Creek Radio uses Textpattern, and Anything Good uses Tumblr. So in some of the steps I have given some examples that are specific to those CMSs, in order to help you along; but the important thing is that these steps can be easily adapted to any CMS such as Blogger, WordPress, etc.

Create a separate tag or category for your podcast posts on your blog.

This is optional; I recommend it because it allows the website for your podcast to be more flexible. For example, if you use Tumblr, you can create a podcast tag, and then continue posting a mix of videos, photos, quotes, etc. alongside your podcast episodes. This way your podcast subscribers will get a clean feed containing only audio downloads, while your website readers will be able to see all your other posts as well.

Even if your website is pretty much exclusively a vehicle for your podcast, you may want to publish other kinds of things posts now and then for administrative purposes, and this will give you the freedom to keep those posts separate.

Make sure you have cover art where you need it

You need to create and use cover art in two places: first you create cover art for your podcast as a whole, and then you also embed cover art in every individual podcast recording. If you use nothing else from this article, please: add cover art to your mp3 files. Without it, your episodes show up with blank covers in iPods and most mp3 players! Your podcast episodes will look dorky without it! It’s not enough to add cover art to your itunes feed, you need to embed the cover art in every finished mp3 file. This is easy to do, yet many beginners forget to do it.

Set up your podcast feed with cover art: Create a 600×600px cover art image for your podcast and upload it to your site, or somewhere publicly accessible. (In some places Apple says 300px is OK but their technical spec says 600.) I recommend using JPEG<, not PNG—the latter is allowed but will look blocky when viewed at reduced sizes in iTunes.

1. Get a FeedBurner account and set up your podcast feed:

   1. Tumblr: Set the “original feed” on FeedBurner to the RSS feed for the specific tag you created for your podcast. To get this feed, add tagged/YOURTAG/rss to your tumblr’s address. (Example: http://mytumblr.tumblr.comn/tagged/podcast/rss)
   2. Textpattern: Set the “original feed” on FeedBurner to Textpattern’s atom feed for that category (e.g., http://foopaux.com/atom/?category=podcast).
   3. Blogger: Set the “original feed” on FeedBurner to http://www.YOURBLOG.blogspot.com/feeds/posts/default/-/PODCASTTAG (per these instructions from Google).
2. Under FeedBurner’s Optimize tab, add the SmartCast service to make your feed podcast-friendly. Set the cover art to the URL of your covert art image and add as much description, keywords and categories as you can muster.

Embed cover art for individual episodes: You’ll find that iTunes does not automatically use your cover art for downloaded episodes when they are playing in your iPod. The cover art you created in the steps above is only used in the iTunes store listing for your podcast (if you get one). In order for your cover art to actually display in people’s iPods when your episodes are playing, you need to embed the cover art into each episode’s MP3 file. Luckily, this is easy to do using only the iTunes (the simplest way I know how):

1. Prior to uploading, open add the episode’s MP3 to your iTunes library.
2. Right-click the episode in iTunes, click Get Info.
3. Go to the Artwork tab, manually add your cover art to the file, and click OK. (Tip: in Windows you can actually copy/paste the artwork JPG file from Explorer directly into this tab.)
4. The cover art is now embedded, you can now upload your MP3 file.

Create a “subscribe” link on your website.

Lots of folks use iTunes, so it’s nice to provide an iTunes instant-subscribe link for them and a standard RSS link for everyone else. To create an iTunes link, just prefix the URL of your FeedBurner feed with itpc:// instead of http://. So, for example, you could place this prominently on your website:

Subscribe in <a href="itpc://feeds.feedburner.com/MyPodcast">iTunes</a> or <a href="http://feeds.feedburner.com/MyPodcast">RSS</a>

Record and upload your podcast episodes

I use Audacity to record, then upload the MP3 to my website using FTP. If you don’t have any hosted space, you can use a free Dropbox account and host your files in a public folder. The bonus with this approach is that uploading is automatic.

Format your podcast posts properly

A properly-formatted post ensures that your subscribers will get their episodes automatically with no hiccups.

1. Don’t forget to set the post’s category (or tag) to the podcast category you created earlier.
2. Each podcast post should contain a manual, direct download link to the MP3 file for that episode. This is non-optional, and it should be the first link in the post. This will allow FeedBurner to correctly detect and include your audio in the podcast feed. For the text of the link, I recommend something like “Download MP3 audio (14.76 mb, 19:32)” (Update, Sep 13, 2011: this link doesn’t have to be at the very front of your post, it just has to be the first link in the post. Also, when using Tumblr, to ensure cleaner descriptions see this follow-up post.)

3. One nice thing to do if you will be syndicating onto another service, such as Facebook notes etc., is to create a special CSS class called for-syndicate and set it to display: none. Then add a little “helper” boilerplate on the bottom of each post, in a paragraph set to that class:

   <p class="for-syndicate">This is a podcast post: <a href="http://site.com/episode.mp3">click here</a> to download the MP3 audio, or visit <a href="http://site.com/podcast">site.com</a> to listen online and subscribe in iTunes.</p>

   The for-syndicate class will render the paragraph invisible on your website, but it will be visible when imported into Facebook or when the feed is viewed in a newsreader, since these other sites do not import your CSS styles. (If you like, this quasi-hidden paragraph can also serve as the required MP3 link.)

Letting people listen from your website

People will listen to your podcast in one of two ways: by subscribing in iTunes or some similar program (which we’ve already covered) or by going to your web page and listening on their computer. Although they can click to listen to the MP3 file using the link you provided, it’s nice to embed some kind of player that will stream the audio and let them listen right there.

There are lots of ways to do this:

1. In Textpattern, install the jnm:audio textpattern plugin and include a <txp:jnm_audio> tag in each podcast post.
2. In Tumblr, create your podcast post as an “audio post” and Tumblr will automatically embed an audio player. (Don’t forget to also include the download link in the text portion of the post though.)
3. Other platforms (WordPress, etc): Let me know how you do it in the comments!

These methods use Flash programs for the audio players, which don’t run on iPhone or iPad browsers. I’ve been tinkering with ways to use HTML5 audio players when the browser supports them, but HTML5 audio support is still flaky for the time being. Check back again in a year or so and maybe I’ll have something for you.

Get listed in the iTunes Store

After you’ve gotten your production groove down and can demonstrate that your episodes come out at least somewhat regularly, it’s worth trying to get your podcast added into the iTunes store. Read Apple’s FAQ for Podcast Makers.

Unfortunately, in typical traditional-media fashion, they neglected to add any links to any of the books mentioned, losing an obvious opportunity to use the web to both their readers’ and their own advantage. So I have gone through the list and added links to the Kindle editions of every book for which one is available.

I linked to a free edition wherever possible. If a book was not available on the Kindle store, I marked it with an * asterisk. If you know of a Kindle version of a book I could not find, or of a free or better-formatted edition than the one I have linked, let me know via email or comments!

Philip Pullman

• Through the Looking Glass by Lewis Carroll. Indispensable. The great classic beginning of English children’s literature.
• Pinocchio (free) by Carlo Collodi. What effortless invention looks like.
• Emil and the Detectives by Erich Kastner. A great political story: democracy in action.
• Swallows and Amazons by Arthur Ransome. As clear and pure as Mozart.
• Black Hearts in Battersea by Joan Aiken. If Ransome was Mozart, Aiken was Rossini. Unforced effervescence.
• The Owl Service by Alan Garner. Showed how children’s literature could sound dark and troubling chords.
• The Phantom Tollbooth by Norton Juster. Superb wit and vigorous invention.
• Moominsummer Madness by Tove Jansson. Any of the Moomin books would supply the same strange light Nordic magic.
• A Hundred Million Francs* by Paul Berna. A particular favourite of mine, as much for Richard Kennedy’s delicate illustrations (in the English edition) as for the story.
• The Castafiore Emerald* by Hergé. Three generations of this family have loved Tintin. Perfect timing, perfect narrative tact and command, blissfully funny.

Michael Morpurgo

• The Star of Kazan by Eva Ibbotson. The heroine is blessed with such wonderful friends who help her through the twists and turns of this incredible journey.
• A Christmas Carol (free) by Charles Dickens. The first few pages were so engaging, Marley’s ghostly face on the knocker of Scrooge’s door still gives me the shivers.
• Just William books by Richmal Crompton. These are a must for every child.
• The Happy Prince (free) by Oscar Wilde. This was the first story, I think, that ever made me cry and it still has the power to make me cry.
• The Just So Stories by Rudyard Kipling. The story my mother used to read me most often, because I asked for it again and again. I loved the sheer fun of it, the music and the rhythm of the words. It was subversive too. Still my favourite story.
• Treasure Island (free) by R.L. Stevenson This was the first real book I read for myself. I lived this book as I read it.
• The Old Man and the Sea by Ernest Hemingway. A classic tale of man versus nature. I wish I’d written this.
• The Man Who Planted Trees by Jean Giono. A book for children from 8 to 80. I love the humanity of this story and how one man’s efforts can change the future for so many.
• The Singing Tree* by Kate Seredy. The story of two children who go to find their father who has been listed missing in the trenches of the First World War.
• The Secret Garden (free) by Frances Hodgson-Burnett. I love this story of a girl’s life being changed by nature.

Katy Guest, literary editor for The Independent on Sunday

• Refugee Boy by Benjamin Zephaniah. Story of a young Ethiopian boy, whose parents abandon him in London to save his life.
• Finn Family Moomintroll (and the other Moomin books) by Tove Jansson. A fantasy series for small children that introduces bigger ones to ideas of adventure, dealing with fear, understanding character and tolerating difference.
• Diary of a Wimpy Kid by Jeff Kinney. It’s rude, it’s funny and it will chime with every 11-year-old who’s ever started a new school.
• I Capture the Castle by Dodie Smith. Written for a teenage audience but fun at any age.
• The Lord of the Rings by J.R.R. Tolkein. Be warned, these tales of hobbits, elves and Middle Earth are dangerously addictive.
• The Tygrine Cat* (and The Tygrine Cat on the Run) by Inbali Iserles. If your parents keep going on at you to read Tarka the Otter, The Sheep-Pig and other animal fantasies, do—they’re great books—also try Iserles’ stories about a cat seeking his destiny.
• Carry On, Jeeves by P.G. Wodehouse. A grown-up book ? but not that grown-up.
• When Hitler Stole Pink Rabbit by Judith Kerr. Judith Kerr’s semi-autobiographical story of a family fleeing the Nazis in 1933.
• Moving Pictures by Terry Pratchett. Elaborate mythological imagery and a background based in real science. If you like this, the Discworld series offers plenty more.
• The Story of Tracy Beaker by Jacqueline Wilson. The pinnacle of the wonderful Jacqueline Wilson’s brilliant and enormous output.

John Walsh, author and Independent columnist

• The Adventures of Sherlock Holmes (free) by Sir Arthur Conan Doyle. Irresistible puzzle-solving tales of the chilly Victorian master-sleuth and his dim medical sidekick.
• The Curious Incident of the Dog in the Night-Time by Mark Haddon. Age-transcending tale, both funny and sad.
• Mistress Masham’s Repose by T.H. White. Magical story of 10-year-old Maria, living in a derelict stately home, shy, lonely and under threat from both her governess and her rascally guardian.
• Little Women (free) by Louisa May Alcott. Inexplicably evergreen, trend and taste-defying 1868 classic.
• How to be Topp* by Geoffrey Willams and Ronald Searle. Side-splitting satire on skool, oiks, teechers, fules, bulies, swots.
• Stormbreaker by Anthony Horowitz. First of the action-packed adventures with 14-year-old Alex Rider.
• Private Peaceful by Michael Morpurgo. “Dulce et Decorum Est” for pre-teens.
• Artemis Fowl by Eoin Colfer. Lively, amoral, wildly imaginative debut (six more followed) about the money-grabbing master-criminal Artemis, 12. The author called it “Die Hard with fairies.”
• The Silver Sword* by Ian Serraillier. Inspiring wartime story of the Balicki family in Warsaw.
• Animal Farm (free) by George Orwell. Smart 11-year-olds won’t need any pre-knowledge of Marx, Lenin, Trotsky and 1917 to appreciate this brilliantly-told fable.

Michael Rosen

• Skellig by David Almond. Brings magical realism to working-class North-east England.
• Red Cherry Red* by Jackie Kay. A book of poems that reaches deep into our hidden thoughts but also talks in a joyous voice exploring the everyday.
• Talking Turkeys by Benjamin Zephaniah. A book of poems that demands to be read aloud, performed and thought about.
• Greek myths* by Geraldine McCaughrean. Superheroes battle with demons, gods intervene in our pleasures and fears—a bit like the spectres in our minds going through daily life, really—beautifully retold here.
• People Might Hear You (Viking Kestrel picture books) * by Robin Klein. A profound, suspenseful story about sects, freedom and the rights of all young people—especially girls.
• Noughts and Crosses (free) by Malorie Blackman. A book that dared to go where no one thought you could with young audiences because it raises tough stuff to do with race.
• Einstein’s Underpants and How They Saved the World by Anthony McGowan. A crazy adventure set amongst the kids you don’t want to know but who this book makes you really, really care about.
• After the First Death by Robert Cormier. Cormier is never afraid of handling how the personal meets the political all within the framework of a thriller.
• The London Eye Mystery by Siobhan Dowd. A book that allows difference to be part of the plot and not a point in itself.
• Beano Annual. A cornucopia of nutty, bad, silly ideas, tricks, situations and plots

*—not known to be available as an ebook.

Ask it to do less. With its apps and its web browser, the Kindle is technically capable of many things, but great for only one thing: reading. Reading, you may recall, is a wonderful pleasure that may have gotten pushed out of your life awhile back. Use your Kindle for reading more. Resist the temptation to use it for things that will tend to marginalize reading again: games, email, and so forth.

Use the magic wirelessness to your advantage. There is really no good reason to be in the habit of plugging your Kindle into anything (other than to charge it up once or twice a month).

Here’s how I manage my ebook collection wirelessly:

1. To put an ebook on my Kindle, I email it to my free.kindle.com address (a snap since Gmail accepts drag-and-drop attachments). Presto, book appears on my Kindle.
2. When I’m done with a book, I either delete it from my Kindle or put it in a “Finished” folder in my Kindle.
3. Gmail keeps a copy of the file in the email attachment in case I ever need it. (I also stick them in a folder on my computer.)

Using this method, there are no wires, no syncing, and there’s no need for special software like Calibri unless I need to convert an ebook to a Kindle-compatible format.

Make finding new reading material as automatic as possible. Time spent looking for new stuff to read is time you could have spent reading. Find ways to have the world send you new things, rather than digging for them yourself. This one is something I am continually looking for improvements on. Some options:

• Delivereads–This is a new one, and it’s just the kind of thing I’m looking for: free, high-quality stories delivered automatically to your Kindle, roughly once a week. This one is almost a no-brainer.
• Instapaper–Even though Instapaper is having some problems with automatic deliveries at the moment (which will probably be fixed before too long), if you do any browsing on the Internet in the course of a normal day, Instapaper makes a great way to collect long articles for later reading. Just try and use it as a stash for things you already run across; don’t start crawling the web just to look for Kindle material–you’re trying to get away from that, remember?
• Newspaper subscriptions: Try a subscription to the New York Times or the Wall Street Journal. Currently the reviews are very mixed; as of today you can see that not everyone finds these subscriptions worth the cost compared to the print editions. It will depend on the publication and whether you have the time to read all the issues.

Treat Twitter like a newspaper. One good use I have found for the web browser is to use it to log into m.twitter.com. This is an excellent way to catch up on Twitter. You can now check it once or twice a day at home as part of your morning or evening routine, and forget about it for the rest of the day. (Unless you happen to be stuck in a queue or waiting room with nothing but your smartphone.)

Start or join a book club. The ideal book club will center around a specific kind of book, and send you a new book every month automatically. This is just an idea of mine–I haven’t yet run across a book club like this–but it makes so much sense it’s hard to believe they don’t already exist.

Here’s the scenario:

1. There are new unread articles in my Instapaper account that are more than a day old.
2. My Instapaper account is configured to email new articles to my Kindle every day (see above). I have a Kindle 3 wifi-only.
3. I never receive any emails from Instapaper unless I click the Send Now button. Then, the new Instapaper issue is sent and arrives on my Kindle exactly as expected.

The manual sends arrive just fine; ergo: the Kindle email address is properly configured, and the Kindle account is properly set up to receive the emails.

The status just above the Send Now button commonly reads “Your last compilation was sent 4 days ago” even when there are new unread articles sitting in the account.

I conclude that Instapaper simply is not sending the emails for some reason. Any guesses as to why?

If you’re still having problems, let us know in the comments!

The update history showed they mostly failed with error 80071A90. The help file on that error recommended running Windows Update manually after starting Windows in safe mode with networking, but the Windows Update service will not run in safe mode.

I found the solution in this Microsoft Answers article:

Assuming the updates-in-question include KB2515325, KB2492386, KB2506928, KB2512715 and/or KB982018, and all is well with your computer otherwise:

1. Run a manual check for updates per http://windows.microsoft.com/en-us/windows7/How-can-I-tell-if-my-computer-is-up-to-date
2. Select (check) only KB2515325, KB2492386, KB2506928 and/or KB2512715, and install them; follow all prompts.
3. Now run another manual check for updates, if necessary, and install KB982018 by itself; again, follow all prompts.

I tried manually opening the URL in the script tag, which refers to a feeds.www.delicious.com address, and the browser told me it couldn’t find the site!

On a whim I tried removing the “www” from the address, and voila. The script worked. So when you add the code to your site, change feeds.www.delicious.com to feeds.delicious.com.

I have sent a support request to Delicious about this and will update the post when I hear back from them.

Thankfully, there is a solution provided by Martin Backschat:

To modify this annoyance you can directly modify the PDF document in your Text editor.

With UltraEdit, for example, I load the PDF document and open the “Search and Replace” box, enable “Regular Expressions” and replace all occurrences of R/XYZ*] with R/XYZ], and then also all occurrences of R/Fit*] with R/XYZ]. Now save the document.

With the Perl scripting language, this hack is applied with

perl -pe 's#R/(XYZ.*?|Fit.*?)\]#R/XYZ\]#g#' in.pdf >out.pdf

The next time you open the modified document with Acrobat you will get a message that the document is being repaired. Just safe it again with Acrobat and everything is fine.

I don’t have UltraEdit but I was able to make this work using Notepad++. The exact search/replace text was slightly different for my PDF files (note the added space) but the principle is the same:

1. In Notepad++, click the TextFX menu, then TextFX Quick → Find/Replace (the standard find/replace tool will not help you here). Make sure you check the “Regular Expr” check box on the right.
2. Use R/XYZ(.*)] as your search string and R/XYZ] as your replace string and replace all instances.
3. Do it again using R/Fit(.*)] as your search string and the same replace string as above.

This information is surprisingly hard to find, but the short answer is: you can’t yet.

How can I use Wikipedia’s new skin (Vector) on my wiki?

Vector is not available in MediaWiki versions prior to 1.16, and will be made default skin in 1.17.

—buried in the MediaWiki FAQ

As of the time of this writing (June 2010), 1.16 is still in beta, and 1.17 has no planned release date. Check the MediaWiki version lifecycle for current information.

I found the solution here after some searching, but even that page only explains how to learn where this temporary folder is located; it does not make it clear how to actually open the file. I found how to do it though.

Open Registry Editor (Click Start → Run, type regedit and hit Enter). Browse to the following location in the registry structure, depending on the version of Outlook you use:

Double click the OutlookSecureTempFolder value, and copy that value to the clipboard (i.e., select all the text, right-click and hit Copy on the popup menu).

Then go to Start → Run and paste the value in, and hit enter. An Explorer window will open showing the folder, containing probably every attachment you’ve ever opened.

You can download the VBScript here: bbmcleaner-1.1.zip. This code is released to the public domain.

Once you have the BBM log file on your computer (email it there from your phone, again, see the last post on this subject), just drag and drop it onto this .vbs file, and a “clean” version will be produced as a separate file in the same directory. The new file will have human-readable dates and the message will be properly escaped–in short, it will be something you can just open and use in Excel (e.g.).

Change Log

Version 1.1 (Feb 20, 2010)

• Added GMTOffset constant to allow timestamps to be properly adjusted for time zones.