You know that sequence in The Matrix where Neo plugs a cable straight into his brain for the purpose of learning some mad skillz... And it only takes a few seconds. Whoah! I love that, but I wouldn't trade my world of illusion for the speed of learning kung fu that way (because of the killer robots, among other reasons).

In so-called "real life," we have to learn things "the hard way," which takes a "little longer..." but what if I said it was possible to read papers much faster than you're used to? As in, 3 or 4 times faster? As in, 350 words per minute? Sounds pretty far-fetched, but here's where I offer you the blue pill. Eat it. Eat it!

the voice in your head that reads books to you

I've been interested in the idea of speed reading for some time now, and there have been a variety of interesting solutions over the years. The take-home message from speed reading books (at least the ones I've read) is that you need to pace yourself, and that you waste time "vocalizing" the words silently inside your head. Such books claim that if you can learn how to recognize words without speaking them to yourself, then you'll be faster.

Well, maybe so! I haven't been able to figure out that trick, but it sounds about right. What if I told you to perform some mental arithmetic while you read a passage in a book? As in: count backwards from 103, subtracting by 7 each time. Now see if you read faster or slower than normal... This sort of cognitive load argument suggests to me that you would, in fact, read slower if you were pronouncing the words versus not.

Or, consider the situation where you are reading a book and you "space out," causing you to read a whole paragraph without actually remembering anything you just read. What this suggests to me is that the process of your inner voice reciting the words can become so automatic that you are able to do it without investing any attention in the process. On that basis, I do think I could train myself to read without pronouncing the words - it just needs to become automatic.

blink and you'll miss it

Another interesting approach is rapid serial visual presentation (RSVP), in which a computer presents individual words on the screen, several hundred per-minute. I've tried this, and it's a great solution for keeping the pace, but it has drawbacks.

The biggest point to detract from RSVP is the significant investment it takes to convert a document to an RSVP-formatable representation. What do you do with images? equations? tables? These don't map onto RSVP in any easy manner, making this a non-starter for academic reading.

co-reading: the better approach

co-read (verb): to visually scan a document while that document's words are raidly spoken to you using text-to-speech (TTS) software.

For all I know, my wife actually invented this technique some time around 2005. I've never heard about it elsewhere, either before or since. In its simplest version, you take advantage of your operating system's speech facilities, which are used by the visually impaired for screen-reading. If you don't have trouble seeing your computer display, then maybe this never occurred to you, but the general idea is that even blind people can use computers... they just use software to speak all of the text to them.

I can't really say much about the Microsoft speech facilities, but as far as TTS is concerned, OS X has taken huge strides in the last half-decade. The new voices that shipped with OS X Lion are just fantastic, and you can get started co-reading almost immediately. Like, within 60 seconds.

First, set up a hotkey to begin speaking any words you've selected. Open System Preferences and click on Speech:

Then, click "Speak selected text when the key is pressed". Make this into a key combination you like; I've chosen Option+Control+S

Then, open a PDF, select a page at a time, and press the key combo you just chose in order to listen to the words while you follow with your eyes. Once you're comfortable with that, go back to the Speech preferences and crank up the Speaking Rate of the text-to-speech engine. This is the horizontal slider in the Speech preferences pane that goes from slow to Normal to Fast. Suddenly you're co-reading faster than you thought possible.

taking it to the next level

For starters, it can be cumbersome to select the words on each page as you read through a document, so we'll just render the whole document to mp3 - all at once. This is advantageous in several ways:

• an mp3 can be paused and resumed at will
• by looking at the length of the mp3, you can see exactly how long it will take to read the document

Don't underestimate this second point. The ability to plan out reading, in pre-determined chunks of time, is a huge advantage.

Next, we'll automate this process, and add on some optimizations that skip over the parts of the documents that interrupt the flow of the text (like page headers and citations).

extracting all of the text from a PDF

The general process for rendering a PDF to an audio file begins when we extract all of the words from the .PDF, and save them as a .TXT file. This is easily accomplished with pdftotext, which can be downloaded from this link, or compiled using homebrew. (highly recommended!) The official Xpdf site is here, which includes Windows binaries.

So let's say you have a .PDF called Important Paper.pdf that you want to co-read. For the sake of this example, Important Paper.pdf is on your Desktop. First, open the terminal (in Applications/Utilities), change directories to your Desktop, and extract the text. To accomplish all that, just type the following commands into the terminal command prompt:

cd ~/Desktop
pdftotext "Important Paper.pdf"

Anyway, this creates a text file called Important Paper.txt. The quotation marks are important, because this filename has a space in it. Otherwise, the computer thinks you're dealing with two files (one called Important and the other called Paper.pdf), because that's what spaces mean on the command line.

Also, this last iconv step might be important, just in case the character encoding on the text file ends up being a little funky. First, try skipping this step, but if the audio steps give you an error, then come back and try this:

iconv -f ISO-8859-1 -t utf8 "Important Paper.txt" > tmpfile
mv tmpfile "Important Paper.txt"

rendering an entire TXT document to audio

Next, use the OS X speech engine to convert the .txt file into a sound file:

say -v Samantha -r 220 --data-format=alac -o "Important Paper.m4a" -f "Important Paper.txt"

I like to use the Samantha voice, which is one of the new voices that ships with OS X Lion. Alex is another good choice. The important part here is the number 220, which is the number of words per minute to speak. 100 is slow, 200 is medium, 300 is fast, and 400 is right on the brink of what I (personally) can meaningfully interpret.

Finally, convert this file to an .mp3, which is likely to be smaller and might be more portable.

ffmpeg -i "Important Paper.m4a" "Important Paper.mp3"

Of course, you can skip this step if you want; iTunes imports m4a files without complaining. You can compile ffmpeg using homebrew, or look at a point-and-click alternative like Audacity.

Now, the time has come to do this thing. Load the .PDF in one window, load the .MP3 in another window, press play on the .MP3, and learn kung fu!

removing citations

What!? Remove citations!? Yes. Well, sortof. See, citations are filled with punctuation, including commas, semicolons, and parenthesis. Usually, text-to-speech software treats these as pauses, and it can really break up the flow. Also, citations frequently appear in the middle of a sentence, and it's just not conducive to grokking a sentence when it is interrupted. That's why I wrote this regular expression (regexp), which removes anything inside parenthesis containing letters and something that looks like a year:

\([^\)]+?\d{4}?[^\)]*?\)

At the moment, I choose to do this as a manual step, because each document is a little different. I recommend loading the .TXT file in a text editor that supports regexp find-and-replace (emacs, TextMate, Sublime Text, others), and just replace everything with nothingness. If you're bold and reckless, then go ahead... do it without looking:

perl -pe 's/\([^\)]+?\d{4}?[^\)]*?\)//g' "Important Paper.txt" > tmpfile
mv tmpfile "Important Paper.txt"

After you've done this, then go back and render the .TXT file to an mp3. Now, you can look at the citations (you'll recognize familiar author names visually), but you won't get tripped up when sentences are split in half by references.

Here is another good one: removing hyphenation.

perl -pe 's/-[\s\n]+//g' "Important Paper.txt" > tmpfile
mv tmpfile "Important Paper.txt"

In fact, you can edit this text file to your heart's content. Don't want the bibliography? Just delete it, because you're not going to want to listen to it. Get rid of page numbers, page headings and footers, and anything else that isn't the actual content of the paper. If you don't want to hear it, delete it.

automating the whole process

Save the following as co-read.sh, or download it from github.

    #!/bin/bash

    WPM=300
    INFILE=$1
    BASENAME=`basename -s .pdf $INFILE`
    TXTFILE=/tmp/tmp.txt
    SNDFILE=/tmp/tmp.m4a
    MP3FILE=$BASENAME.mp3
    TMPFILE=/tmp/tmpfile

    echo "extracting text from $INFILE"

    pdftotext "$INFILE" "$TXTFILE"
    iconv -f ISO-8859-1 -t utf8 "$TXTFILE" > $TMPFILE

    say -v Samantha -r $WPM --data-format=alac -o "$SNDFILE" -f $TMPFILE
    ffmpeg -i "$SNDFILE" "$MP3FILE"

    echo "wrote to $MP3FILE"

Then, make it executable and test it out with your Important Paper:

./co-read.sh "Important Paper.pdf"

That's it. This chugs along, producing an audio file (the mp3) that goes at 300 words per minute. If you want it to go slower, then change $WPM to 250 or something. You have the mp3 now, so get cracking!

how fast is it?

How fast does this whole process go? Fast! I can responsibly get through 25 dense pages in about 80 minutes. The rendering process takes less than 10 minutes. Like I said, since you can look at the length of the MP3 to determine how long the document will take, I can also budget my time better... and that contributes to further time savings because I only do this when I'm in the right state of mind. (which is to say: after chugging a pot of green tea)

a caveat, and an appeal

This process is written for OS X, but it will wwork almost as well on Linux using Festival/Festivox TTS. If someone would adapt the process to Windows and post a comment about it, I'm sure others will appreciate that.

(an aside: when the PDF doesn't "highlight")

There's something you need to understand about PDFs. Much of the time, they are basically just pictures, which have been scanned from sheets of paper, and which are stored in the PDF as a collection of pictures. This makes as much sense to TTS software as reading a picture of a sunset or a kitten (which is to say it doesn't make any sense at all).

In order to make this PDF "readable", it must be passed through an Optical Character Recognition (OCR) processor. If you purchased a scanner, you might have some OCR software lurking on your computer. Adobe Acrobat X Pro does a pretty good job - I'd go so far as to recommend it.

OCR software will look at pictures, then try to notice anything in the picture that looks like a letter. If it finds letters, then it annotates the PDF by putting an invisible, selectable letter on top of the picture of that letter. Later on, you can use your mouse to highlight these invisible letters, but it will look just about right because the pictures of the real letters are right underneath.

When you paste the clipboard, it's probably going to contain the text you just highlighted... This specific detail comes down to the quality of the OCR software used, as well as the quality of the scanned image.

the tools for unbinding

It starts with the tools. I use a box cutter and a guillotine-style paper cutter to unbind the textbook.

Then, to bulk-scan everything, I use the amazing Fujitsu ScanSnap. It's probably not worth the time to do this job with a flat-bed scanner. Yes, these scanners are $400-$500, but I'll argue that it's worth it, if only for the home-office angle. Get one, or use the one you might have access to at work.

The general idea is to split the textbook into individual pages, then stream all of those pages through a form-feed scanner. A book is created when separate pages are glued together at the spine, so to un-create said book (returning it to its elemental pages), simply destroy the spine. I've heard of people using a table saw for the job, but my method is a little more apartment-friendly. We're simply trying to separate the pages from the glue, and a blade is fine for the job.

cut the book into segments

Start by extending the blade about an inch or so. This isn't a half-hearted thing. We want to cut straight-through the glue, all the way.

Then, grab about 10 or 15 sheets.

Fold the spine so it's flush against the ground...

...and cut straight through the glue of the spine. Take note that we're not cutting through the paper. That was my first strategy, but it's way too much work.

You will be slicing between the pages, right through the binding.

After the first cut, you will have a packet of 15 pages, still glued together. It is like a little pamphlet now.

After the book has been segmented

Keep cutting through the spine, 10 or 15 pages at a time. When you're done, you will have lots of pamphlets that are largely intact. If you're doing it right, you will have created a minimal amount of scraps/waste.

The reason I suggest doing 10 or 15 pages at a time is that the guillotine-style paper cutter needs to be able to slice through those pages, because this is how you actually remove the glue from the spine. In the picture below, the spine is hanging over the edge of the paper cutter by about half a centimeter.

It's important to cut off enough of the spine that you remove all of the glue. If you don't, then some of the pages will still be stuck together, and they won't go through the form-feed scanner properly. This is the biggest source of jams I've encountered so far.

On the other hand, you don't want to cut off so much of the page that you lose any of the text. It also looks nicer when the text isn't flush against the edge of the page. Once you've found the right amount to cut off, set the guide on your paper cutter (if it has one) to ensure that all of the 15-page packets end up being cut at the same point.

Even though my paper cutter has a handle, I've found that this is not always the most effective way to cut. The handle implies that you should use it to apply all of the force, but this is just a suggestion. In the picture above, I'm pressing on the middle of the blade, but I would be remiss if I didn't mention the risk of slicing all the fingers off your hand.

Once that's done, you will have a stack of paper consisting of all the pages of the textbook, and a pile of spine left over. Now feed the stack through the scanner, using the OCR software that probably came with it. I assume you've done this part before, so just do what feels right.

Congratulations! You don't have to lug your textbooks around anymore! If you want, you can now re-bind your textbook, but that's beyond the scope of this article. I've done it before, so maybe I'll write about that some time.

Don't be an asshole

I'll also say something else: now that you have a PDF of your textbook, don't share it with people who haven't bought the book. I know it seems like a rip-off when you pay $150 for a textbook, but it's not like academics become millionaires from their textbooks. Think of these authors as being like small-time artists. If they're lucky, they sell a few thousand copies per year, and they get some fraction of the sale price. Just like with the music industry, the publisher takes most of the money. So let's say some bent-over academic sells 2,000 copies of their book each year for 10 years, and they get $15 for each one. This $30,000 per year won't put them in a different tax bracket, and you, as a student, are not getting personally ripped off by the person who wrote the book.

So: don't be a dick. For the most part, these are good people, and the way things are going, university-level academics tend to live lower-middle-class lives. The media likes to portray academia one way, but like everything else, this is a distortion. I will reiterate: don't steal from these people. If you're rich enough to be in college, then your family may well be richer than your professors, and only an asshole steals from people poorer than themselves.

With the advent of the World Wide Web (Berners-Lee & Cailliau, 1990) came the introduction and growth of web-based forums, such as the notable online community Something Awful (Kyanka, 1999). The Web was used to propagate one of the first widely-reposted animations, Dancing Baby (Girard et al., 1996), and by the year 2000, the Something Awful community mainstreamed one of the first popularly mutated Internet Memes, All Your Base Are Belong To Us (Dibbell, 2008).

The proliferation of broadband Internet and peer to peer file sharing (e.g. Napster, Kazaa) enabled increasingly sophisticated video sharing, setting the stage for online video phenomena such as Star Wars Kid (Raza, 2002). By 2006, the BBC estimated Star Wars Kid had been viewed over 900 million times (“Star Wars Kid is top viral video,” 2006), which was accomplished through such rapid online retransmission that its trajectory resembled that of a viral pandemic. Capitalizing on this trend, YouTube launched (Chen, Hurley, & Karim, 2005) to become a popular online repositories of viral videos.

In 2004, Something Awful community members coined the term image macro, which was named after the mechanism used to insert images into forum posts (“Image Macro,” 2004). Image macros are characterized as a background picture with one or two lines of text captioning overlaid onto the image, usually for ironic or comedic effect (see Figures 1 and 2). In the same year, a Something Awful community member named “moot” founded 4chan (Poole, 2004), which was an image board (modelled after the popular Japanese forum 2ch) that came to be known for its blanket use of the pseudonym Anonymous and as a prolific incubator of memes.

4chan, in turn, helped launch an early class of image macros known as “LOLcats” (Langton, 2007), which are recognizable as pictures of cats with phonetically or grammatically erroneous captions (e.g. “I can has cheezburger”). LOLcat image macros were collected on a popular blog entitled icanhascheezburger.com (Nakagawa & Unebasami, 2007), which became so heavily trafficked that it was sold to investors within the year for $2 million (Grossman, 2008).

In 2009, Time Magazine named 4chan's moot as the year's most influential person, even surpassing politicians, celebrities, and criminals for the title (“The World’s Most Influential Person Is...,” 2009). It was later revealed that the Time poll had been so thoroughly hacked by Anonymous as to manipulate not simply the #1 spot, but also #2-#21, in order to create an acrostic spelling “mARBLECAKE. ALSO, THE GAME” (Schonfeld, 2009), both of which were memes created by 4chan.

As a result of stunts like the Time Magazine hack, the public visibility of memes, and image macros in particular, created demand for simple and user-friendly tools such as quickmeme.com (Wayne, 2010) that enabled novice users with no image-manipulation experience to quickly create image macros. More recently, Cheezburger Inc. raised an additional $30 million from investors to continue the expansion of their commercial image macro/comedy empire (Crunchbase, 2012), while the Canadian magazine Adbusters used a professionally-crafted image macro to launch the Occupy Wall Street movement (Beeston, 2011).

References

Beeston, L. (2011, October 11). The Ballerina and the Bull. The Link. Retrieved from http://thelinknewspaper.ca/article/1951

Berners-Lee, T., & Cailliau, R. (1990). WorldWideWeb: Proposal for a HyperText Project. CERN. Retrieved from http://www.w3.org/Proposal.html

Chen, S., Hurley, C., & Karim, J. (2005). YouTube. Retrieved from http://www.youtube.com

Crunchbase. (2012). Cheezburger. Retrieved from http://www.crunchbase.com/company/pet-holdings-inc

Daniel, S., Ellis, J., & Truscott, T. (1980). USENET. Retrieved from http://ftp.digital.com/pub/news/a/a.news.tar.Z

Dawkins, R. (1976). The selfish gene. New York: Oxford University Press.

Dibbell, J. (2008, January 18). Mutilated Furries, Flying Phalluses: Put the Blame on Griefers, the Sociopaths of the Virtual World. Wired, 16(2). Retrieved from http://www.wired.com/gaming/virtualworlds/magazine/16-02/mf_goons

Fisher, D. (1994, January 26). Weeks? hah!! alt.folklore.computers. Retrieved from http://groups.google.com/group/alt.folklore.computers/msg/4bd75d223b992e8d

Girard, M., Amkraut, S., Chadwick, J., Bloemink, P., Hutchinson, J., & Felt, A. (1996). Dancing Baby. Character Studio.

Grossman, L. (2008, undefined). The Master Of Memes. Time. Retrieved from http://www.time.com/time/magazine/article/0,9171,1821656,00.html

Image Macro. (2004, February 12).Something Awful. SAclopedia. Retrieved January 8, 2011, from http://forums.somethingawful.com/dictionary.php?act=3&topicid=83

Kyanka, R. (1999). Something Awful. Retrieved from http://www.somethingawful.com

Langton, J. (2007, September 22). Funny how `stupid’ site is addictive. The Toronto Star. Retrieved from http://www.thestar.com/living/article/257955

Nakagawa, E., & Unebasami, K. (2007). I Can Has Cheezburger. Retrieved from http://www.icanhascheezburger.com

Poole, C. (2004). 4chan.org. Retrieved from http://www.4chan.org

Raza, G. (2002). Star Wars Kid.

Schonfeld, E. (2009, April 21). 4Chan Takes Over The Time 100. The Washington Post. Retrieved from http://www.washingtonpost.com/wp-dyn/content/article/2009/04/21/AR2009042101864.html

Star Wars Kid is top viral video. (2006, November 27).BBC. Retrieved from http://news.bbc.co.uk/2/hi/entertainment/6187554.stm

The World’s Most Influential Person Is... (2009, April 27).Time. Retrieved from http://www.time.com/time/arts/article/0,8599,1894028,00.html

Wayne. (2010). quickmeme. quickmeme LLC. Retrieved from http://www.quickmeme.com

Keyboard Shortcuts to the rescue

OS X provides an interface for mapping any key combination onto any menu item.  In terms of an application like TextMate, when you see a pull-down menu option like "Next File Tab", you can change the keys for that item to any combination you want.

Start by opening the Keyboard control in System Preferences

Then click on the Keyboard Shortcuts tab at the top of the window, then select Application Shortcuts in the left column.

Next, click on the + icon, which will enable you to create a new mapping.

In the screenshot above, it says "tell TextMate to call the Next File Tab option whenever I press a certain keyboard combination."  You can add any application you want by pulling down Application, then finding "other" at the very end of the list:

And that does the trick!  TextMate behaves exactly like I want, even though they changed the key mappings with the latest release.  This principle generalizes to almost any OS X application out there, with certain notable exceptions like X11 programs.

What makes a good key combination?

This is a rather philosophical question, but one framework approaching it is this: the most common commands should be the easiest to type.  This property can be measured in terms of whether you can do the keystroke one-handed (e.g. cmd-s) versus two-handed (cmd-^), or in terms of how far you have to stretch your fingers to reach the keys (cmd-z versus cmd-y).  I am using cmd-alt-arrow keys to control my tabs, which is a two-handed combination.  I might even consider switching to something simpler, but I'm used to this combination by now, and I use the same combination in several different applications...  so it's probably here to stay.

Now that you know how to control any application, you can normalize between applications too.  This process is so simple, and it can relieve so many little headaches.  Enjoy!

Installing watchpaths

First, download watchpaths and place it somewhere in your path. I use ~/bin, so try something like this:

cd ~/bin
wget https://github.com/iandennismiller/watchpaths/raw/master/bin/watchpaths.py
chmod 755 ~/bin/watchpaths.py

Using watchpaths

Let's say I want to monitor a folder containing images, and each time a new image is added I want to sync the folder to a remote computer. Using watchpaths, that will look like:

watchpaths.py "rsync -a ~/my_pictures user@example.com:public_html" ~/my_pictures

To convert that command into English, it would sound like this:

"Watch the my_pictures folder for any changes (new files, deleted files, updated files, etc) and each time a change happens in that folder, synchronize the contents of that folder with my web server."

More Information

The project page, including links for downloads, is here. If there is any interest, I am happy to incorporate feedback.

This worked acceptably well, but I frequently had to ask myself: "which password did I use when I signed up for this service?" In response to having to guess my own passwords, I made two decisions: I would start writing my passwords down, and I would make them all unique and randomly generated. Four years later, I am using a totally different system, and I'll explain all of my reasoning.

To facilitate my random password approach, I started using 3x5 index cards and a card filer. I added A-Z tabs, and I generally filed cards according to the domain name of the service (e.g. paypal.com is filed under P). I wrote a quick perl script to make 10 random passwords at a time, and I would pick one from the list and write it down on the index card. I really liked the concept of a purely non-digital password storage system, because it would be essentially unhackable without physical access. Essentially unhackable - more on this later.

There were several drawbacks to the index card system. For brevity, I'll just list them:

• writing some characters by hand is ambiguous. I confused capital I, lowercase L, and numeral 1 all the time. Capital O and numeral 0 are also a trick.

• it's possible to copy the password incorrectly

• it is extremely difficult to create a backup copy, so catastrophic loss is a possibility

• if someone has physical access to the index cards, they have access to your accounts

• it's tedious to type in a random password every time you log in

• it doesn't scale well after about 400 accounts

The scaling problems were the real killer. For example, did I file sandbox.paypal.com under P for paypal or S for sandbox? I don't remember, so I need to perform a linear search through both letters. Or, since a disproportionate number of words start with S, then it became a more tedious task to flip through all the S cards in order to find an S site, whereas a site that started with Y would be pretty quick to look up since there were fewer. Eventually, it got to the point that I knew it was too much of a chore to look up cards, and on that basis, I became too lazy to log in to my accounts! Total failure.

The solution for me is to use Apple Keychain. If you're a GTD adherent, then you'll understand what I mean when I say this is my trusted system for account information. How did I reconcile a digital password storage with my original goal of keeping my passwords offline in order to make it unhackable? It was when I realized that both offline passwords and the keychain can be successfully attacked with a keystroke logger. If someone went to those lengths to get a password, then it wouldn't matter how it was originally stored; the password could be intercepted regardless.

Why use Apple Keychain? Based on my list of drawbacks for the index cards, here's a list of pro-Keychain points:

• built-in random password generator

• keyword search

• simple cut-and-paste workflow makes it very easy to enter passwords without typing

• keychain itself is password protected

• passwords are Triple DES encrypted (which should be acceptable until the year 2030)

• simple to back up keychain file

• slick integration with many applications, including Mail.app, subversion, and Safari/Chrome.

I'm currently at about 900 accounts (yes - this is deserving of a separate post unto itself) and the system is working great. I think this scales to meet my requirements, and probably beyond. In practical terms, a password that used to take 30 second to retrieve is now instant. I probably save 5 minutes per day by switching away from index cards, and I am avoiding untold frustrations. In all, I recommend Apple Keychain highly.