Lambda the Ultimate

I have one huge directory containing programming language papers, and a few others for other things (math, graphics, psychology, biology, etc.). Inside the huge directory are subdirectories for each topic. Since I haven't bothered to organize them at all, there are way too many and there are probably duplications.

Each one can contain a directory called 'printed', which holds the ones I've printed, in the hopes that I don't print out something I have already printed, and waste paper.

The funny thing is that I almost never go back to this repository, even though I've only read a portion of the papers in it. I think I just collect them obsessively -- you know, in case I'm stranded on a desert island with nothing but a computer and a power outlet.

It's kind of funny to look at the list now and see how haphazard the categorization is.

I wish I had written a short synopsis of each paper I read; it would be a useful web site by now. Hmm -- maybe this is something that LtU should consider having: a collection of summaries.

abstractinterpretation
adaptivity
algebraic
algol
analysis
ancient
arrows
atomicity
binding
biological
boxing
bsp
burstall
categorytheory
classic
combinators
compilation
concurrency
continuations
coroutines
co-stuff
curiosities
cute
datastructures
deforestation
defunctionalization
denotational
dependenttypes
derivative
design
discriminated_union
distributed
domaintheory
dsl
dynamicscoping
dynamictypes
exceptions
extensible
filters
flowanalysis
fold
functional
functionaldependencies
functionalhttp
gadt
garbagecollection
generative
genericity
gofer
graph.reduction
gui
haskell
henrybaker
hindley-milner
imperative
incremental
iterators
johnhughes
lambdacalculus
lazy
lecturenotes
lenses
linearity
listlessness
lockstep
logicprogramming
lowlevel
macros
media
metacircular
modules
monads
multistage
namespaces
objects
optimization
overloading
parallelism
parsing
partial.evaluation
partial.types
patternmatching
persistence
persistent.threads
picalculus
polymorphism
polytypic
primitives
python
records
recursion
reflection
relational
ruby
scheme
shape
shells
simulation
softtyping
strictness
subtyping
supercompilation
systemf
tags
testing
theory
threads
toocloseforcomfort
trampolines
transactions
typeclasses
typeinference
types
undynamicking
unification
userdirectedoptimization
v
variant
virtual.machines
wadler
www
xml
ycombinator

I print them, annotate them, and file them.

Anyway, does anybody out there have a tool (or just an organizational discipline) that they're happy with?

I wrote a simple document storage and cataloguing application for a completely different purpose a few years ago, and I use that to store my papers.

Unfortunately, I download them much faster than I read them or catalogue them, so this approach doesn't work as well as I would like. ;-)

Still, it beats sifting through hundreds of crypticly named pdf/ps files looking for that Wadler paper I wanted to reread.

One of the most liberating experiences of my life was deleting all the papers from my hard drive. That said, I haven't used CiteULike long enough to see how it fares in the long haul. But analogous experiences (e.g., Google vs. bookmarks) bodes well for the "labels" approach.

After I download a paper, I rename the file to something like "wadler98prettier", where the first is the author's last name, the second the year of publication, and the last an abstraction of the title. I store all my papers in one big directory Papers; or rather, I move them there after I've read them.

Concerning the filename: if there are multiple authors, I pick the one I read the most, or the most well-known: basically, I choose the one I know I will tend to associate most closely with the paper if I have to search for it. If it's a preprint or unpublished or has an unknown (to me) pubdate, I use a dash instead of the year. For the title, I choose some memory-jogging key words from the title. Again, the idea is that it reminds me of the paper; it needn't be accurate or mnemonic for someone else.

Also, I try to keep it short enough to double as a BibTeX key, and long enough to avoid collisions.

I also have a BibTeX file in my Papers directory, managed using BibDesk, which at some point I hope to update so it indexes all the papers there, but frankly I don't think that will ever happen.

I don't use a by-subject classification scheme. One reason is that I never go browsing through the papers by subject; instead, I remember a paper I need to check, and then maybe a couple other papers that it references, so the author-year-title scheme works better. Another reason is that any directory-based (i.e., hierarchical) classification scheme is going to be inadequate anyway, and of little use to me.

Oh, and I gzip all the PS files, since GhostView can read them that way, but not the DVI files, since Xdvi can't, and anyway they're pretty small. PDF's I keep as is, since nowadays they're usually compressed internally.

Now that I have Spotlight on my Mac (desktop search), I've uncategorized all my documents. Everything's in one directory and the filenames are typically the titles, abbreviated. The only reason for subdirectories is to keep related files together (chapters of a book, pages from a website, lecture series, etc)

Also, for every file, I try to have a corresponding .txt file that contains notes I've made about that article. I treat it like a log: never overwritten, always to be appended to. It is instructive to see how one's understanding has changed when you revisit a paper.

This approach frees me from having to give it a structure, in terms of filenames, directory hierarchies or RDF. Free-form notes and good text indexing work really well.

Today I stumbled across another BibTeX/organization tool: JabRef. It can launch PDF and PS viewers, and search CiteSeer. It seems to work a lot like BibDesk, but BibDesk is a Mac (Cocoa) app whereas JabRef is a Java (cross-platform) app.