Just a quick post to underline a Google Reader feature which, though simple, may come in handy: creating a feed for “feed-less” sites. It basically tracks updates on pages by periodically checking the pages you choose.

I need to mention that for table-based pages (or any page with recurring pattern but no feed) there are existing services such as Dapper which will allow you to create a more sophisticated and precise feed by creating a page scrapper on-the-fly.

It’s the kind of feature for which I tend to find more and more uses as time goes on. One significant example I’m thinking of is personal homepages of friends and people who haven’t yet integrated a feed: it’d be nice to be alerted when they change.

(Via this LifeHacker article)

Update the next day: there seems to be plenty other similar services. ChangeDetection.com is an old one, sending updates via email. For others, just Google for “monitor page changes”.

(To be perfectly honest, from a programmer’s point of view, I guess you could do the same by having a list of URLs and setting up a script to periodically check whether significant changes have been made (i.e. using a “diff”). Yet I never took the time to do it, and now that’s it’s easily available…)

For the context: when we launched Clusterify, one of the early projects I proposed was a simple “matching pairs” game. Some almost-complete code I wrote up has been sitting on my computer ever since, just needing a few last fixes, and the addition of actual pictures. So I did those last fixes, adapted stock photos for it, and now here’s the game.

Changelog

• 2010.02.22: as per a commenter’s (Jebadiah’s) suggestion, added a score and a timer. Also, images are now shuffled so the last ones (cats and birds) show up in the smaller grid.

• The recent Google Goggles and Google Shopper. Goggles adds information to objects you take a picture of, or uses GPS to retrieve information about shops you walk by and add it to the picture (most AR apps I’ve seen focus on this). Shopper adds information about the current product.
  • Another feature of Goggles is the instant translation of text in a picture. This could be quite handy when travelling.
• There are augmented reality “browsers” which provide a platform to add features to. For example, Layar lets you select “Layers” of information to add to the scene.
  • There’s also Junaio, a browser which allows the addition of 3D animations to the image, with lots of potential for entertainment apps.
• Wikitude uses augmented reality to add traveller’s guide type information to the scene.
• TAT augmented ID: use the cam to get a good image of someone to identify, and this uses an online face recognition service to provide public information they want to share if they’ve set up their “public ID card” (Twitter profile etc.).

Augmented reality appears a lot in science fiction. For the most part, though, it involves directly augmenting the field of view of a person. If you’ve ever seen Ghost in the shell (the movie, especially the second one), you’ll know what I mean. I remember being quite excited when I read about the possibility of added information through semi-transparent head-mounted displays (this video demonstrates, though in this case it’s not transparent at all, and obviously not something you’d walk with in your everyday life ). Cam-and-screen is more reachable for the moment, I guess, and a lot less cumbersome.

By the way, the following are just simple tips I use. Some will seem obvious maybe, but they lay ground work for (potential) next posts.

Motivation and (*ahem*) philosophical considerations

Since I started graduate studies, I’ve been accumulating a lot of documents, mostly PDFs of research papers (which, btw, I annotate heavily with PDF XChange Viewer, see this post). Yet it’s easy to forget where I’ve put one of them.

Now, for academic documents, there are dedicated solutions for document management, such as Zotero. These obviously offer lots of options for filing, searching (and citing).

Yet I have a tendency to prefer lightweight solutions, based on basic filesystem principles (filenames and directories). This simplifies incremental backups, never becomes obsolete, and will always be cross-platform Also, from a programmer perspective, it’s easy to use such a structure with scripts, too, if the need ever arises (e.g. for backup scripts).

Using plain old filenames with “tags”

My current system is simply a hierarchy of documents in directories (dah, but bear with me). Yet I’m careful in the way I name the documents. A basic problem with hierarchies is that a given document can often be placed in multiple places. In turn, a common solution is to place it somewhere that nevertheless makes sense, even though there might be other classification options, and then use tags (keywords) for those other options. Then you can list by tags (see Virtual folders) and get it in multiple places.

Concretely, I name my documents this way: “title, authors, date, tags .extension”. For example, “Learning representations by back-propagating errors, Rumelhart Hinton Williams, 1986, neural networks, machine learning.pdf”.

Yet hierarchies are also highly intuitive, so most of the time I can locate the document by browsing the filesystem, not searching. So, the final solution is: 1) try hierarchy, if that doesn’t work, 2) search filenames for keywords, authors, dates, etc.

This might seem quite obvious, actually, but it requires planning. Notably, consistency is required for tags. If applicable, I try to use directory names as tags. For example, a document might be relevant to “signal processing” and “machine learning”. So I’d use the tag “digital signal processing” if I filed it under the “machine learning” directory.

Virtual folders

Now the fun part of being consistent in tags and naming: if you’re using this convention, you can then use the Virtual folder principle to group documents by tags, as if they were in a real directory, which would otherwise be in different directories. That way, in my “signal processing” directory, I can create a saved search which will grab the document I put in the “machine learning” directory automatically.

Basically, instead of typing a query each time, you just save it like a file, and the results now behave like a new directory. This is available on all OSes, see this Wikipedia page.

Searching in the files themselves

I use filename search because it’s fast and very easy, and makes “virtual folders” work real swift. It’s also possible to search inside the files, of course. I won’t say much about this, except mention the essential: for content search to be fast, files need to be indexed in advance.

There are many programs which can do this, and some of them now come integrated with operating systems (Explorer does it on Windows, Spotlight for Mac OS, and there are a variety of options for Linux, notably Beagle). For more advanced functionality and to handle more information sources (e.g. emails, IMs…), Google Desktop must be mentioned.

Musings and relation to other posts

• The “lightweight” principle starts to come back often in my posts. It’s one strength, to me, of Wikidpad: wiki entries are plain text files.
• The hierarchy-and-tags principle is the idea behind might Wikidpad “saved search” extension.

I personally have been using Mnemosyne for a few months (to study a new language — spaced repetition is very well suited for the task). This really does seem to work on this timescale. I have yet to discover if after 5, 10… years the knowledge still sticks (if using only that schedule).

—

Also, following this Lifehacker article, I updated the recent post on Quix.

Two very concrete uses of this I see here is accessing a wider variety of search engines and dictionaries and submitting to social sites. The webmaster tools seem very interesting too, if you’re into that.

By the way, this is similar to the Firefox “bookmark keyword” feature, which, combined with the “Add a keyword for this search…” feature gives a similar functionality (see Lifehacker guide). Yet, Quix has a wide range of integrated commands (just reading the list I made a bunch of fun discoveries) and the replacements are more flexible.

Sure earlier there were “command lines for the Web” such as, notably, YubNub. But Quix is different in that it executes in the context of the current page, allowing it to be a portal to other bookmarklets. YubNub is interesting for the wide variety of commands it already has, by the way (and it could be integrated through Quix easily, I guess).

You can also add custom commands to use in the Quix prompt. To do this, you have to understand its syntax, but it’s very simple. As an example, I added a command to clean up the current page for easier reading with the “Instapaper Text” tool (which is similar to Readability, which I posted about about a year ago). The basic command structure is:

command  "bookmarklet code or url"  "description"

To use your own extension (go there for form), you’ll have to put up a text file somewhere on the Web. I suggest using Pastie, and clicking on the “Raw” link. Here’s the textfile for the above Instapaper command.

Update: as this new Lifehacker guide suggests, you can even get the Quix prompt quicker by setting up a keyword/keybinding in Firefox, or similarly in other browsers. See the guidelines for each browser. Also, Lifehacker points to Merlin Mann’s own extensions.

Via ReadWriteWeb.

I tried it on a few sites I visit frequently and it seems pretty solid for the most part. On the other hand, it failed on this page. Creating an algorithm to find the main content is quite hard, though, which is why I thought previously a program automating the procedure would not surface. Yet I think it’s still a valuable tool: try it on a page; if it works: great, otherwise use something like Aardvark or deal with dancing bananas and ads for ever more efficient diets.

1. out of the normal scope of this blog (it’s about personal _information_ management, not personal _knowledge_ management).
2. mostly for geeks/programmers who will never be fully satisfied by any planning system, ever.

Over the years I’ve tried different ways of handling my ToDo, planning and work logging. This is my Xth iteration. I wonder if anyone but a programmer could use this, but hey, programmers are a non negligible fraction of society (which I happen to be part of)!

I’ve long wanted to create a program which would do precisely what I want in terms of planning, but was always put off by the “*knocks head on wall* the GUI is so long to code!” aspect. Well to hell with the GUI! Let’s deal with raw information, rarrr.

Err, sooo… Plyn (ie. this system) is inspired by the todo.txt scripts of Gina Trapani (LifeHacker author). Basically it allows you to have a very simple yet powerful todo.txt file, and the file is meant to be read directly (in contrast to other programs which use databases only the program can read). The difference is that my version:

1. is written in Python (in contrast to Bash for Gina’s todo.txt)
2. allows for hierarchy, empty lines, comment lines, etc. in the file, so the file can really be structured and read by itself, and a good deal of everyday tasks can be done without ever using the scripts
3. includes a work log aspect, ie. you can record how much time you spent on tasks to keep stats.
4. includes time estimates, but for the moment it’s not very developed.

So I’d say it departs from the need to be simple, to be expandable and support other dimensions of planning&logging.

Google Code link for the project & code: http://plyn.googlecode.com

The todo.txt format is pretty simple. Here’s an example of content:

12 Elephant in refrigerator project ||| Yeah, I shouldn't try myself at humor.
	# Open refrigerator door
	# Put elephant in refrigerator
	# Close refrigerator door

	-- This line is just a comment

A few observations:

• You see a task may be nested in another one (which you can see as a project), simply using tabs.
• Each line begins either with an ID (number) or with #. The # is replaced by a proper ID by cleanchanges.py (more on this later).
• The ID is followed by a title, then |||, which indicates the start of parameters/comments.
• You can have blank lines, and comments lines (starting with –).

After the ‘|||’ characters, you can place different parameters. In more detail, the format of a line is:

(INDENT) ID TITLE ||| {PRIORITY} <MINUTES_DONE/MINUTES_TODO> [START_DATETIME-ENDDATE_TIME] COMMENTS

As you can see, many more options may be specified (see the “format.txt” file for detailed information about each of these parameters), and of course this can be expanded (it all relies on a huge regex). But everything following ||| is optional.

So you can edit the todo.txt file manually, but there are, of course, helper scripts to automate certain tasks. The one you’d use the most is today.py. It gives you a list of all high-priority tasks, late/coming up tasks, and tasks awaiting feedback (“+feedback” tag in title). By editing the script you could add whatever other list you need.

You can also, of course, filter tasks by text using grep. So you could have tags or contexts, for example, if you’re into GTD.

The cleanchanges.py script will replace the # at the beginning of the line by an ID which can then be used to refer to the ToDo item in other scripts. cleanchanges.py will also transform dates, so you can write:

-- Today is 2009/03/14
# Clean refrigerator ||| [-+15]

and the item will be changed into

15 Clean refrigerator ||| [-2009/03/29]

ie. the date can be specified as the number of days in the future, which saves finger mana.

The work log is also simple. To say you’ve just spent the last 3 hours cleaning the refrigerator, you would do:

./log.py 15 180 "Some comment to add to the log"

(where 15 is the task ID and 180 is 3 hours expressed in minutes). This will add a line to the log.txt file, and will change the MINUTES_DONE field of the item in todo.txt.

Scripts are meant to be called from a command line you keep open somewhere in the scripts directory, so you can use autocompletion. Path for todo.txt and other files are configured in cfg.py.

And, of course, the whole thing can be extended as you please. My ultimate goal is to have a script with which I can truly estimate the free time I have, ie. to determine if I can engage in a new task or not.

If anyone ever uses this, be sure to let me know! I’m especially interested in hearing of other must-script-the-procrastination-away coders who expand this thing in whichever direction their urges take them.

• 2009/04/10, added script to open files from file manager.

PDF-XChange Viewer is a Windows freeware (pro version available too) which installed flawlessly under Wine (Windows emulator) in Ubuntu. In fact I had not used Wine up to this point, and I was surprised how indeed flawless the process was: ‘sudo apt-get install wine’, ‘wine installer.exe’. Bam. It just worked. And it loaded a huge PDF without flinching.

All is not so rosy, though, as the annotations and text won’t show up completely under Ubuntu default PDF viewer. But this had happened with annotations I had made with other programs, so I guess it has to do with Ubuntu’s viewer, not PDF-XChange. Indeed things worked a bit better under Xpdf.

The most surprising part in all of this is that the freeware beats other annotation options I had tried under Windows in the old days: it has many different ways of adding text to pages, different shapes to add and different highlighting options. So I guess I’d recommend that you try it even if you run Windows.

And a quick tip: you can add shortcuts for toolbar commands (including highlighting) by clicking right in the toolbar area, clicking “Customize…”, selecting the “Commands” tab, selecting “Highlight” under “Tools” and clicking “Properties”.

(Found via this post, from someone else who grappled with the other options)

Launching with “Open with…” (NEW 2009/04/10)

To open PDF files from the file manager, put the following script somewhere, change its file permissions to “executable” and use it for the “Open with…” command (adapted from here):

#!/bin/bash  

# Then use this script as default to open PDF files

# Adapted from:
# http://sodeve.net/foxit-reader-on-ubuntu-linux-through-wine/

# Purpose: To convert Linux-style filename to Windows-style
# to pass as an argument to wine when starting PDF XChange Viewer
Filename="z:"${1//\//\\}  

#assuming you use the default installation folder for PDF
# XChange Viewer in Wine
App='eval wine "C:\Program Files\Tracker Software\PDF-XChange '
App=$App'Viewer\pdf-viewer\PDFXCview.exe" "'$Filename'"'

$App

Once you’ve read that, you might want to check out this other article, which builds on the first one and shows you how to find the most relevant knowledge the set of results you’ve come up with. In essence, it uses AideRSS’ PostRank to find the best articles in the list of blogs you’ve come up with, and shows you how to use Google Custom Search to build a custom search engine that searches only those top sites you’ve found.