Category Archives: Tech Tips

Tracking packages installed

To help with restores or migration to another piece of hardware I find it useful to keep track of which packages are installed on my Linux systems. This isn’t very difficult, but it has taken a bit of experimenting to come up with with something that works fairly well and is automated.

Create in /etc/systemd/system/status-email-root@.service. This is a helper service for sending emails on service failures.

Description=status email for %i to Jon

ExecStart=/usr/local/sbin/ root %i

/usr/local/sbin/ looks like this


debug() { ! "${log_debug-false}" || log "DEBUG: $*" >&2; }
log() { printf '%s\n' "$*"; }
warn() { log "WARNING: $*" >&2; }
error() { log "ERROR: $*" >&2; }
fatal() { error "$*"; exit 1; }
try() { "$@" || fatal "'$@' failed"; }

mydir=$(cd "$(dirname "$0")" && pwd -L) || fatal "Unable to determine script directory"

/usr/sbin/sendmail -t <<ERRMAIL
To: $1
From: systemd <root@$HOSTNAME>
Subject: $2
Content-Transfer-Encoding: 8bit
Content-Type: text/plain; charset=UTF-8

$(systemctl status --full "$2")

Create in /etc/systemd/system/track-installed-packages.service with the content. Note the “showmanual” argument to “apt-mark”. This makes sure to only output the packages that were manually installed and not include those that were installed as dependencies. This keeps the list short and if dependencies change later keeps from installed unneeded packages later.

Description=track installed packages

ExecStart=/usr/bin/apt-mark showmanual

Now create /etc/systemd/system/track-installed-packages.timer

Description=track installed packages daily



Now enable the timer with

systemctl daemon-reload
systemctl enable track-installed-packages.timer
systemctl start track-installed-packages.timer

Now if you backup /home, you’ll always have the most recent list of installed packages.

I have a similar pair of systemd files for snaps that calls “snap list” and outputs to “/home/snap-packages.txt”. Snap doesn’t appear to have an option to specify only manually installed snaps. This may also error out if there are no snaps installed.

Configure Linux Jenkins node

I have been setting up a few Jenkins nodes lately and decided that I should write up the configuration that I’m using to share with others.

Create the node in Jenkins

The first thing to do is to create the node in Jenkins. Start by logging into your Jenkins host, then visit the “Manage Jenkins” link. Once there, visit “Manage Nodes” and then click “New Node” on the left.

Give your node a name. It’s a good idea to avoid spaces and special characters. I use letters, numbers, underscores and hyphens. Select “Permanent Agent” and then “OK”.

Here you need to specify the working directory, labels and the usage. I usually set the usage to only build jobs with a matching label expression. This is useful when setting up nodes per job to make sure that the node doesn’t get used for other random jobs. You may also want to specify an email address to notify when the node goes online and/or offline.

Once you have saved the configuration you will see a page specifying that the agent is offline and how to launch it. The important piece of information here is the secret. This will be a very long string of letters and numbers.

Linux Setup

First create a user in Linux that the node will run as. This user should not have any special privileges.


Replace “JENKINS_BUILD_USER” with the username that you are using. By default this user has a locked password so no one can login as this user.

In “/home/JENKINS_BUILD_USER” create the file “” to start the node


debug() { ! "${log_debug-false}" || log "DEBUG: $*" >&2; }
log() { printf '%s\n' "$*"; }
warn() { log "WARNING: $*" >&2; }
error() { log "ERROR: $*" >&2; }
fatal() { error "$*"; exit 1; }
try() { "$@" || fatal "'$@' failed"; }

mydir=$(cd "$(dirname "$0")" && pwd -L) || fatal "Unable to determine script directory"


cd "${mydir}"
# --no-check-certificate is needed if the certificate store does not recognize the jenkins host certificate
try wget https://${jenkins_host}/jnlpJars/agent.jar -O agent.jar

# -noCertificateCheck is needed if the certificate isn't recognized
nohup java -jar agent.jar -jnlpUrl https://${jenkins_host}/computer/${jenkins_node_name}/slave-agent.jnlp -secret ${jenkins_node_secret} -workDir "${HOME}" > "${HOME}"/jenkins-node.log 2>&1

Replace JENKINS_HOST with the hostname that Jenkins is running on. This script assumes that Jenkins is running at hte root of your server. If that’s not the case you’ll want to append the base path to the end of JENKINS_HOST. Replace NODE_NAME with the name of the node and SECRET with the secret from the node configuration on the Jenkins host.

Mark the file executable.

chmod +x /home/JENKINS_BUILD_USER/

Create “/etc/systemd/system/jenkins_node.service”




Replace JENKINS_BUILD_USER with the user that you created. Then you can enable and start the service with

sudo systemctl daemon-reload
sudo systemctl enable jenkins_node
sudo systemctl start jenkins_node

At this point you should see your node online in Jenkins and you are ready to use it for jobs.

IPv6 on Comcast Residential

Comcast has now opened up their IPv6 service to residential customers. If you have a supported modem from Comcast and a device connected to it that understands IPv6 you can connect. You might ask why would I want to setup IPv6? And that is a good question. One reason is to stay up to date with current networking technology. Another reason is that we’re running out of IPv4 addresses and we will eventually need to switch to IPv6. Currently many sites on the Internet are supporting IPv4 and IPv6 to help with the adoption of IPv6. Another reason for IPv6 support is that this setup can give you a subnet of public IPv6 addresses to use in your house. Meaning that you can allow computers on your internal network to be accessible from the outside world. Of course this also means that you could potentially open up your computers to the outside world, so you need to be careful and setup your firewall to keep your internal computers secure unless you want them accessible. This also removes any issues with NAT as IPv6 doesn’t have any NAT support.

For my setup I have a compatible modem from Comcast and a Linux computer as my router. My Linux computer is running Ubuntu. These instructions are specific to my setup, but should be able to be used by others running most any Linux distribution.

The first thing you should do is secure your network from IPv6 so that something doesn’t get in while you’re setting things up. Here is my IPv6 firewall setup, it’s very similar to my IPv4 setup, except the port numbers for DHCP are different. Outbound traffic is allowed and inbound traffic is denied. I’ve also disabled forwarding of traffic, this prevents inbound traffic directly to the internet work. This script needs to be located at “/usr/local/sbin/firewall-ipv6-start” for the radvd script at the end of this post to work properly.




# accept everything by default

 -m state --state RELATED,ESTABLISHED \
 -m comment --comment "allow inbound traffic for established and related connections" \
 -i ${LAN_IFACE} -o ${INET_IFACE} \
 -m comment --comment "allow all Internet bound traffic from the internal network" \
${IPTABLES} -A FORWARD -p ipv6-icmp \
 -m comment --comment "forward any ICMP traffic" \

 -m state --state RELATED,ESTABLISHED \
 -m comment --comment "allow inbound traffic for established and related connections" \

 -i ${LO_IFACE} \
 -m comment --comment "allow any local-only traffic" \

 -p ipv6-icmp \
 -m comment --comment "allow ICMP traffic from anywhere" \

 -p udp -m udp --dport 546 \
 -m comment --comment "Accept DHCP traffic" \

 -p udp -m udp --dport 547 \
 -m comment --comment "Accept DHCP traffic" \

The remainder of this post is based upon this post on using DHCPv6 with prefix delegation.

The next thing we need to do is get an address from Comcast along with a prefix (subnet) to hand out to the computers on the internal network. Comcast doesn’t appear to be using router advertisements for IPv6, so we’ll need to use DHCP over IPv6. For this I could use the ISC DHCP server that I’m using for IPv4, but it doesn’t support prefix delegation which I need to give the other computers in my house IPv6 addresses. For this I installed wide dhcp client. Ubuntu includes this in the package wide-dhcpv6-client. A side advantage to using a different DHCP client for IPv6 is that you can turn it off to disable IPv6 support without messing with your IPv4 network. Once you install the client edit /etc/wide-dhcpv6/dhcp6c.conf to look like this. You will need to modify the interface used and possibly the sla-len. I found the sla-len by trial and error. You won’t get a prefix if the value is incorrect.

interface eth0 { # external facing interface (WAN)
 send ia-na 1;
 send ia-pd 1;

 request domain-name-servers;
 request domain-name;

 script "/etc/wide-dhcpv6/dhcp6c-script";

id-assoc pd 1 {
 prefix-interface eth1 { #internal facing interface (LAN)
 sla-id 0; # subnet. Combined with ia-pd to configure the subnet for this interface.
 ifid 1; # IP address "postfix". if not set it will use EUI-64 address of the 
         # interface. Combined with SLA-ID'd prefix to create full IP address of interface.
 sla-len 0; # prefix bits assigned. Take the prefix size you're assigned
            # (something like /48 or /56) and subtract it from 64. 
            # In my case I was assigned a /64, thus the value is 0

id-assoc na 1 {
 # id-assoc for external interface

When you start the wide DHCP client and all is happy you will find that your external interface has an address. In my case it starts with 2001:558:6014. See the output of “ip addr show dev eth0” changing the interface as appropriate. Below is the output for my system with the IP addresses masked out.

2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP group default qlen 1000
 link/ether 00:d0:b7:3f:4d:18 brd ff:ff:ff:ff:ff:ff
 inet XXX.XXX.XXX.XXX/22 brd scope global eth0
 valid_lft forever preferred_lft forever
 inet6 2001:558:6014:XXXX:XXXX:XXXX:XXXX:XXXX/128 scope global 
 valid_lft forever preferred_lft forever
 inet6 fe80::XXXX:XXXX:XXXX:XXXX/64 scope link 
 valid_lft forever preferred_lft forever

Once this is setup you can ping IPv6 addresses from your router. You can test this with “ping6”.

Now to allow your local network talk to the Internet via IPv6 you’ll need to allow forwarding and then assign them IPv6 addresses.

First we’ll tell the kernel to allow forwarding by modifying adding the file 70-ipv6-routing.conf to /etc/sysctl.d. Note that net.ipv6.conf.all.accept_ra is set to 2. Any other value will not work due to how the router advertisements are handled.

# only set this on the external interface, otherwise we don't get a
# default route for IPv6



Once you change these values you will need to reboot or use the sysctl utility to set them immediately.

Now to hand out IPv6 addresses to the rest of the network. This will be done by setting up radvd. The package ‘radvd’ on Unbuntu contains this daemon. Once installed you can setup /etc/radvd.conf for the prefix that Comcast gave you. However when your IP address changes you’ll need to update the file. So instead I have created a script that can be run from wide dhcp client. Put the following in “/usr/local/sbin/” and add a call to this script from the end of /etc/wide-dhcpv6/dhcp6c-script. You’ll need to change the interface in this script to be your internal interface.


debug() { ! "${log_debug-false}" || log "DEBUG: $*" >&2; }
log() { printf '%s\n' "$*"; }
warn() { log "WARNING: $*" >&2; }
error() { log "ERROR: $*" >&2; }
fatal() { error "$*"; exit 1; }
try() { "$@" || fatal "'$@' failed"; }

mydir=$(cd "$(dirname "$0")" && pwd -L) || fatal "Unable to determine script dir

prefix=$(ip -6 addr show dev eth1 scope global \
 | grep inet6 \
 | awk '{print $2}') \
 || fatal "Unable to get prefix"

cat > /etc/ <<EOF

interface eth1
 AdvSendAdvert on;
 AdvIntervalOpt on;
 MinRtrAdvInterval 60;
 MaxRtrAdvInterval 300;
 AdvLinkMTU 1280;
 AdvOtherConfigFlag on;
 AdvHomeAgentFlag off;
 prefix ${prefix}
 AdvOnLink on;
 AdvAutonomous on;
 AdvRouterAddr on;


diff /etc/ /etc/radvd.conf > /dev/null
if [ $? -ne 0]; then 
 # only move if there are differences
  try mv -f /etc/ /etc/radvd.conf
  try service radvd restart
try /usr/local/sbin/firewall-ipv6-start

Now you have IPv6 setup on your router and your home network. I found that Linux, Windows and Mac automatically recognize the IPv6 router advertisements and grab addresses and setup routes appropriately.



Skitch for easy sharing of drawings

I use a Mac at work and was recently introduced to Skitch in a training class. This application is really handy if you need to share images or screen shots with others. Skitch allows you to easily take a screen shot of what you’re doing and then annotate it to state what is important in the image. You can also easily do simple drawings and then share them. Once you have an image that you like you can just drag it to your email program, or if you sign up for an account with Skitch you can have the image uploaded there and accessible from their website.

Backing up cloud data

This year I replaced my Palm Treo with an iPod Touch. To make sure that I could access all of my data on my iPod as well as on my Linux desktop (and anywhere else for that matter) I moved all of my data to the cloud. This is great for accessibility, however I still want backups in case something happens to the cloud provider. Remember that all data needs to be backed up or you run the risk of losing it.

The 3 cloud providers that I am currently using and want backups for are Google Contacts, Google Calendar and Toodledo. My backups are done from my Linux desktop, so I’m using unix tools to do the work. I’m sure people can find replacements under Windows as well.

I wrote a script for each job (based upon various solutions that I found on the net). The data for each cloud service is backed up into a directory named by the date and I choose to keep 30 days worth of backups, so that I can go back and pull information that I may have accidentally changed or deleted.

First up is Google Calendar.

#!/bin/bash -e
date_dir=`date +%Y%m%d`
mkdir -p ${base}
find ${root} -maxdepth 1 -type d -mtime +30 -exec rm -rf \{\} \;
CURL="curl -s -S"
${CURL} -o ${base}/cal.xml "PRIVATE_URL_FROM_GOOGLE"

Here I setup some variables to determine the name of the directory based upon date. I then delete anything older than 30 days. The real key here is the last line. This tells curl to download the calendar and save it locally as “cal.xml”. The PRIVATE_URL_FROM_GOOGLE is found by going to calendar settings for the calendar in Google. At the bottom is the private address with 3 links for XML, ICAL, and HTML. I choose to download the XML version, but you can pick any that you want to work with. Since this script has your private calendar URL, you should protect it from others as they can change your calendar with this URL.

Backing up Google Contacts is a little harder because you have to login to get the contacts. I found a script to do this searching Google. I found a script written in python that dumps the contacts in Google’s XML format. I don’t know the best way to load back from this format, but I’m sure I could figure it out if needed.

#!/usr/bin/env python

import gdata.contacts.service

gd_client = gdata.contacts.service.ContactsService()
gd_client.ClientLogin('', 'password')

query = gdata.contacts.service.ContactsQuery()
query.max_results = 1000 # change for max contacts returned

feed = gd_client.GetContactsFeed(query.ToUri())
print feed

Then I wrote a wrapper script like the one for Google Calendar that puts the data where I want it.

#!/bin/bash -e
date_dir=`date +%Y%m%d`
mkdir -p ${base}
find ${root} -maxdepth 1 -type d -mtime +30 -exec rm -rf \{\} \;
export base
${HOME}/bin/ > ${base}/contacts.xml

I’m sure I could have done this in python too, but I wanted to keep all of my scripts as much the same as possible.

The last cloud service I needed a backup of was Toodledo. This one uses curl like the one for Google Calendar. Except that it does the login too. This script has curl post to the login page, save the cookies, then visit the XML export page. Since the cookie is saved, we don’t get prompted for a login again. I tried to do this trick on the Google Contacts page as well, but it doesn’t work because Google embeds a random hash in the login page as a hidden form field that needs to be passed on for the login to work. Anyway here’s my Toodledo backup script:

#!/bin/bash -e
root=${HOME}/backup/pim/tododate_dir=`date +%Y%m%d`base=${root}/${date_dir}mkdir -p ${base}
cd ${base}
curl \  
  --output /dev/null  \ 
  --form 'email=YOUR_EMAIL' \
  --form 'pass=YOUR_PASSWORD' \ 
  --form 'remember=1' \ 
  --cookie-jar ${root}/cookies.txt \ \ 
  --output toodledo.xml \

Note that this script has your username and password in it, so you’ll want to set the permissions on the script to keep others out.

To backup my email from gmail, I’ve found offlineimap to be a great application and easy to setup.

Passwords on the iPod Touch

On my Palm I used Keyring to keep track of my passwords. This has a nice interface in jpilot to access it on my desktop. When it came to my iPod Touch I needed to find something else to use. I did some searching and found that there was an open source password program called KeePass that had applications for many platforms (including Windows, Linux, Mac and IOS).  It turns out that there is an old version of the database (1.x) and a new version (2.x). There isn’t an application for the new format on Linux yet, so I choose to use the old database format and the desktop application KeePassX. There are two applications for IOS listed on the KeePass website: MyKeePass and iKeepass. I chose  MyKeePass because it supports both the old and new formats and seems to have been updated more recently.

MyKeePass can store multiple databases and those databases can be loaded from a public website, or from it’s own web server. You can tell the application you want to import a database file and it starts up a mini web server that just has an upload page and tells you the URL to visit. If your computer is on the same network you can visit this URL and then upload the database and it’s on your device. This is pretty nice. It would even better if MyKeePass could read the database file from Dropbox, but that functionality doesn’t exist yet. You can have MyKeePass reference a public URL and that could be a public file in Dropbox, but that seems a little to open for me. I’d prefer it to be a private folder on Dropbox that I store my database in.

I found an XSLT to convert the output of the keyring XML exporter to the 2.x format of KeePass, but not to the 1.x format. So I hacked on the 2.x XSLT some and created my version for 1.x. This is a fork of the original that I hope will get pulled into the main.


Offline web pages on iPod Touch

One of the things that I really liked about my Palm was using Plucker to view web pages when I’m not connected to the Internet. I’ve found a few apps for the iPod Touch that do this and here are the ones I’ve tried and what I think about them.

I read all of my news using Google Reader and so I wanted an app that would sync with it and keep the articles offline so that I could read them later. I tried Byline and MobileRSS. Both are good RSS readers, however I’ve found that I prefer MobileRSS. The syncing of all messages and ability to scan through all messages easily is great. Also MobileRSS allows one to send web pages to multiple other services, twitter, email, safari, Instapaper, Read It Later, etc. I’m currently using the free version and it works nicely. I’ll probably upgrade to the pro version to get rid of the ads eventually.

For generic web pages I started out using iWebSaver favelet. This favelet takes a given web page and sends it through the iWebSaver favelet site and produces a data page that can be stored on your IOS device. This data page is then opened in Safari when you want to view it. The advantage to this is that you have the whole page as is downloaded onto your device. The problem is that it takes a long time to load and doesn’t remember where you are in the page.

Next I tried Instapaper. This has worked very well for most pages. I’ve been very happy with the scaled down version of web pages. However I found that my Bible study had a problem with rendering. I couldn’t see the days. I’m guessing this is some CSS magic that gets stripped out by Instapaper as extra visuals.

I then gave Read It Later a try. At first I thought that it wasn’t going to help because the stripped down page looked the same as Instapaper and my Bible study still didn’t work. However then I noticed a button at the bottom of the page with a ‘T’ on it. It turns out that this toggles the page from the stripped down text version to the full page. With a little reading through the options I found that if I disable auto picking of the “right” format to download I can have Read It Later always download both the text and full versions of the page. Then when I’m offline I can toggle between the two. This allows me to view most pages in text and then pages like my Bible study as the full page.

Palm Contacts to Google

I have already been using Google to store some of my contacts for syncing using Zindus. So it seemed pretty natural to use Google to store all of my contacts.  Using Google means that my information is available on any platform. Google provides a nice sync interface for the iPod touch that works well in an offline mode, so I was happy with it.

Originally I started writing an application in python to convert my Palm contacts to Google. As I got close to having this done I discovered that the Birthday and Anniversary fields couldn’t get populated via the python API from Google (it may work now, but didn’t work then). So I started looking for other options.

It turns out that Google allows you to export your contacts in a CSV format and can import in that CSV format as well. So I entered a few contacts with all of the fields that I wanted and then did an export to see what I got. The CSV file was pretty standard, but had lots of extra columns. So I tried trimming it down and discovered that I actually need to have most of the columns, even if they’re blank, otherwise Google wouldn’t recognize some of the other non-blank columns. This seems kind of odd, but my guess is that Google is looking for some set of column names to determine if it’s a CSV file from Outlook or one from Google.

So now I needed to get my contacts into the Google CSV format. I started by exporting from jpilot and then trying to reorganize the data. This got old real fast. So I wrote another application in C++ using the pilot link library that would output my CSV files. I’ve put this application up on github so that anyone else can use it as well.

After running this application I had a nice CSV file that I was able to import into Google and all of my contacts were now available to my iTouch. I did end up hacking the IM conversion as I didn’t have many contacts with IM information in my Palm. Otherwise the conversion went pretty well.

Convert Palm Calendar to Google

I chose to use Google for my calendar. I already use Google for some of my mail and I sync contacts with Thunderbird using Zindus. Using Google means that my information is available on any platform. Google provides a nice sync interface for the iPod touch.

One annoying thing about the Google calendar integration with the iPod Touch is the lack of the ability to choose the color of the calendar. You need to choose to sync one calendar, then if the calendar color isn’t what you want, tell google to not sync the calendar, wait 10 minutes, then tell it to sync again. Repeat until you get the color you want.

I started writing a python program to do the calendar conversion as jppy gave me acces to the Palm database and Google has a python version of their API. However I found the python API to be lagging behind the Java API in features supported, such as birthday and anniversary information. So I decided to use Java to interact with Google. In initial testing this worked well, however I needed a way to access my Palm database from Java.

Instead of direct access I choose to write a C++ program that read the Palm database using the pilot link library and then output using Google protocol buffers. This kept me from having to rewrite the code to parse the palm database and give me a format that I could read in most any language. The C++ program is available on github as palm-export. The Java program for importing into Google calendar is also on github as calendar-import.

As of this writing I can import all calendar information except recurrence exceptions. This is when you have a repeating event and have chosen to cancel some of the events in the series. Google supports this concept and I have even gotten it to work for some events. However since I haven’t gotten it to work for all and I can’t tell when it’s not working, I came up with a workaround. Instead of creating the exception I create a new single event for the exception with “EXCEPTION:” prepended to the event name. This way I can recognize when one is canceled and I can just cancel the single event in Google, which works fine.

After the import I found a few of my appointments off by an hour. I suspect some timezones on recurring events didn’t get in correctly, so you’ll want to check appointments that are created with timezones in your Palm.

A couple of things to note. The iTouch doesn’t support all repeat types nor all alarm durations that the Palm does, however Google does. What this means is that these will show up as “Custom” in the iTouch and cannot be entered directly. So when you want to use an alarm or repeat type that the iTouch doesn’t support you’ll need to use the Google web interface to the calendar and then wait for the data to sync, which is pretty fast.

Recently (2/17/2011) I’ve noted that Google sometimes has trouble loading all of my calendars so they will disappear from the iTouch and then come back later. I’m hoping this is just a temporary situation and will be corrected in the future.

Replacing my Palm

I have been using a Palm as my PDA for a number of years. With the decline of the Palm platform I have been looking for a replacement PDA. The smartphones aren’t an answer for me as I really don’t want to pay for a data plan. I was looking at the Archos 43, however I haven’t been able to get my hands on one to see how well it works. In particular if the resistive touchscreen is reasonable. Furthermore Best Buy removed the Archos 43 from their website after listing it for 2 months. So I broke down and bought and iPod Touch.

I run Linux at home, so a major concern is how to sync data. In this post and following posts I will describe the tools that I’ve chosen to use and why; as well as how I imported my old data. Hopefully this will help others that are considering making such a change or looking to convert from one PDA to another or just want to know what tools others are using.

I also wanted to make sure that all of my information is available offline as well like my Palm. So I have mapped each of my Palm apps to the apps on my iTouch and then either web applications or a desktop application to view the data on my Linux computer.

  • Todo: Appigo todo backed in Toodledo to have an online backup. This is also a handy way to edit a bunch of todo items. Note that the free account doesn’t support the hierarchies of the Appigo application, but at least the data is there. To import data here I just manually entered the todo items.
  • Memo: Appigo notebook backed in Toodledo. I tried Evernote, but it was overkill for my needs and I wasn’t able to easily import my information from my Palm. To import data I just copied and pasted from jPilot into Toodledo. 3/20 update: I’ve switched to PlainText for my memos app. It’s really nice because it stores each memo as a text file in Dropbox and then it can be easily edited on my desktop.
  • pFuel: Gas Cubby is a nice application for keeping track of gas mileage and maintenance reminders. It also integrates very well with Appigo’s todo application so that maintenance reminders can be turned into todo items. Importing data here was just a matter of exporting from pFuel through the palm memos application and then massaging the CSV file to match what Gas Cubby wants for their input format.
  • plucker (offline web pages): See this post for details.
  • MyBible: Laridian has made MyBible for the Palm and PocketBible for the iPod Touch (and other IOS devices). I was able to transfer all of my Bibles easily. This worked out very well.
  • Keyring: MyKeePassmore information on this in a future post
  • Titrax: HoursTracker is a nice application for keeping track of time on projects.
  • Dropbox: I didn’t have this on my Palm, but it’s pretty handy for keeping photos as the photo album application won’t let me create albums.
  • Podcasts: Podcaster. I tried iTunes, but you can’t subscribe to a podcast on the device. Podcaster allows me to do this and has a nice refresh feature to grab all of my latest podcasts.
  • Calendar: Google Calendarmore details in a later post
  • Contacts: Google Contactsmore details in a later post