log.brandonthomson.com

Blogger: Having posts skip the RSS feed

2011-07-08T09:45:00.002-04:00

Turns out you can make new posts not show up in the RSS feed in Blogger, but the only way to to do it is to backdate them far enough that, chronologically, they are more than 8 entries ago.

Oi, working around the limitations of closed platforms is always frustrating.

Spotlight on Open Source: youtube-dl

2011-06-29T11:41:00.002-04:00

youtube-dl by Ricardo Garcia Gonzalez (Public Domain)

One of the things I really enjoy watching on Youtube are "Let's Play's": regular people recording their play-throughs of (typically classic) video games in an episodic format. I have a lot of childhood memories associated with various 8- and 16-bit titles, so it's always a fun trip down memory lane.

Unfortunately Youtube's playlist interface can be summarily described as "awful" and the interface still does not support altering playback speed for most videos. Worse, Adobe Flash just sucks and doesn't belong anywhere near Linux.

I used to use an extension for my web browser to download individual videos, but youtube-dl makes life much easier by letting you download an entire playlist into a directory. You can even resume downloading where you left off so it's easy to get partial playlists or keep your local archive up to date as new videos are added.

Is it worth it to waste disk space storing videos you can download for free whenever you want? Of course! For one thing, it's nice if you have a monthly download quota like I do since playlists with HD videos can often exceed 20GB: you can download some content in advance to watch later when you might be near the quota.

For another, mplayer is far superior to Youtube's player. You can set a default (faster) playback speed and apply video filters like unsharp mask and add noise which really improve perceived video quality, or use vdpau to get hardware acceleration for 1080p movies.

Finally, you can move each file into a "watched" subfolder as you finish watching it, which I find to be far more intuitive than any of Youtube's playlist-type features.

The only thing I thought youtube-dl was missing was support for parallel downloads of all files in a playlist: Youtube limits standard defintion video downloads to about 100k/s, so if you want to max out your connection, parallel downloads are necessary. I tend to run it in GNU screen on a server, though, so it doesn't bother me if it takes a while to finish.

Overall, youtube-dl is a fantastic script. Thanks, Ricardo!

Spotlight on Open Source is a periodic feature where I highlight a piece of open-source software that is making my life better. If you liked this entry, why not view the previous features? Open-source projects usually benefit from publicity, so I encourage you to spread the word as well!

A quote: Concise, to-the-purpose solutions

2011-06-23T11:54:00.002-04:00

I'm glad I can program, because personal programming in the small is fertile ground and tremendously useful. [...] Writing concise to-the-purpose solutions is a primary reason for programming in the twenty-first century.

— James Hague

Indeed. One of the best parts of taking the effort to learn about software is that you get to customize your tools to behave exactly how you want them to instead of being stuck with a few options someone thought were most likely to appeal to the unwashed masses.

Working is a lot more enjoyable when your tools do exactly what you want.

Don't get me wrong; I like the trend towards app stores, too. It's just that, for most of what I want to do, There's No App For That™.

Hyphenator on Blogger

2011-06-15T02:37:00.005-04:00

It feels a little kludgy, but I managed to get Hyphenator installed on this blog so the text can be justified.

I'm not sure if editing your template to add the hyphenate class to the post-body entry-content div is the only way to do it, but it worked for me. For some reason I already had my template under version control so it's pretty easy for me to add stuff to it even though I run into bugs in Blogger every time I try to update the template.

But I'll spare you the boring details of my complaints about Blogger.

Air conditioning affects line voltage

2011-06-14T16:01:00.000-04:00

This is kinda neat. As May has turned into June and more people are using air conditioning, the line voltage detected by my UPS has started to dip during the day. It's the orange line at the top in this image:

The minimum line voltage corresponds to about 4PM.

Terrible, then merely bad

2011-06-12T13:22:00.005-04:00

Over on the post where Google announced they were going to shut down the Translate API, I found this (abridged) comment:

Google is like NASA of the internet - they have the best and brightest on their payroll - and I'm not just talking about their developers. If there was truly an abuse to the API they would have developed a way to handle it without shutting it down. So, in this case, the abuse is nothing more than a smoke screen.

If you woke up one morning and found out that Google is going to charge for their API you would start bashing Google left and right for charging for something that used to be free and their PR would flat line - essentially - they would look like the monster taking candy from a child.

I don't know whether he's right and it was an intentional move, but he is right that the PR tends to work better if you announce something terrible and then recant and announce something merely bad which looks good in comparison to your original announcement.

Recently Google's App Engine team also announced major pricing changes which looked like a disaster for many of us, and then changed their mind about some of the details to make them more favorable. I think the overall sentiment in the community is now actually better than it would have been if they had simply announced the latest (better) details in the first place and then not made any changes.

Doing this sort of thing intentionally is probably a bit unethical, but I don't doubt that it works.

Comcast Bandwidth Usage Python Script

2011-05-21T02:29:00.006-04:00

It's not exactly easy to find through Google, but Jared Hobbs has written a Python script which can log in to Comcast's website and write your current bandwidth usage to stdout. A really handy thing to have tied into your status bar if you are a heavy user! Get it here: http://thehobbsfamily.net/archive2011/comcappy-comcast-internet-usage-script/

Closure Compiler: Removing console log statements

2011-04-27T06:50:00.000-04:00

This thread has a great solution for stripping console.log() calls using the closure compiler:

var
  /** @define {boolean} */ DEBUG = true,

console_log = function(var_args) {
  if (DEBUG) {
    console.log.apply(console, arguments);
  }
};

(Now you must use console_log calls instead of console.log.)

I tested it and it works great. There are some other ideas on stackoverflow but many of them don't work. I think this is the best way.

Incidentally @define will allow you to pass a flag to the compiler to enable/disable the log statements but I prefer to just change the constant in the JavaScript file since make will then automatically detect the change and rebuild without needing any changes to the Makefile.

The Future of Firefox

2011-04-26T16:05:00.000-04:00

Recently I tried to create my first Firefox addon. It was not a pleasant experience. Chromium's API makes such things as adding an item to the browser context menu simpler and the debugging process is easier to understand.

This is not to knock on the fine folks working at Mozilla; I read somewhere that Firefox's codebase has been touched by so many people that it is truly a cruel and unusual form of torture trying to understand and modify it. I believe it.

Still, it makes me sad. I like the idea of contributing to the software ecosystem around a browser made by a non-profit organization. I am just finding it hard to justify it on practical grounds.

If I am having these doubts, maybe other people are too.

CLRS bibtex entry (3rd edition)

2011-04-21T02:11:00.000-04:00

Following on the work of Timmie Smith, here is some bibtex for the 3rd edition of CLRS.

@book{clrs,
  author = "T.~H. Cormen and C.~E. Leiserson and R.~L. Rivest and C.~Stein",
  edition = "3rd",
  publisher = "The MIT Press",
  title = "Introduction to Algorithms",
  year = "2009",
  isbn = "978-0-262-03384-8"
}

Changing Ubuntu Lucid's Boot Drive with Grub 2

2011-04-12T14:39:00.000-04:00

I recently bought an SSD for my workstation and wanted to boot from the SSD instead of spinning disk. It used to be you could do this simply by copying all the files from your current / partition over to the new partiton, mucking about in /etc/fstab a bit, (optionally) installing grub in the MBR of the new disk, and then changing the boot order in the BIOS to put the disk with your new partition at the top of the list. This would cause grub to see your new disk as hd0 and maybe you didn't even need to change /etc/fstab either if the number of the new partition was the same as the old one.

It turns out that with Grub 2, changing the boot order of disks in the BIOS is no longer sufficient because Grub 2 uses UUIDs for all entries! So even after you change the boot order it will still find the old disk.

The good news is that you can easily solve this by search/replace of the UUIDs in the /boot/grub/grub.cfg file you are not supposed to edit. After changing the UUIDs you will boot into the new partition, and from then on update-grub seems to detect the correct UUID since it probably just finds the UUID of the partition mounted as /.

I haven't seen this procedure written about anywhere; I just guessed that it would work and it did. Your mileage may vary!

The SSD reduced boot time a bit, but not as much as I was expecting. Down from about 15 seconds (post-bios) to about 9. (Ubuntu did a lot of work reducing boot times on spinning disks in the 9.x series, I think.) My bios really sucks and takes like 20 seconds just to get to grub, so the reduction is not really noticeable.

Boot time was a wash, but the real win is that package management operations are much faster: running updates and starting Synaptic is no longer unbearably slow.

Overall, using a UUID to reference disks in GRUB is a win even if it does make the procedure for rare changes like this more confusing. My old motherboard has 2 different SATA chipsets and doesn't like some devices on some ports, so it's nice not to have to worry about screwing up your boot procedure when rearranging devices.

Cloud Storage: Expensive

2011-03-29T22:19:00.002-04:00

Amazon's recently-announced Cloud Drive service shows why Internet storage still doesn't make economic sense unless you don't have much data.

The biggest storage tier, 1000 GB (1TB), is $1000/year. My cheapo FreeBSD server cost about $550 (plus my time) to build and stores 6000 GB in a reasonably redundant manner. It uses about 1kWh/day of electricity and thus costs about $26/year to operate.

Storing your own data is more risky. Probably. If the house catches fire my data will be destroyed. If I kick the box over while it is running, more than 2 drives will probably crash and the data will be destroyed. Then again, if you read the terms of service for Cloud Drive, Amazon is not going to compensate you for data loss if they screw up and delete your data, either. Maybe they make tape backups like Google does, maybe not. You don't really know.

Convenience is probably better (for some folks) with a service like Cloud Drive: you can use it with your phone or whatever though a nice interface. Me, I have to setup ssh and deal with people trying to break in. (Then again, I can also use my server to run IRC and host a website and do other useful work.)

Even if you have FiOS or some ridiculous Internet connection, transfer to local storage is probably going to be faster. I can transfer data to and from my NAS box at gigabit speeds which makes it trivial to back up my workstation every hour. I suspect that would be painful with a service like Cloud Drive.

I know they are targeting mostly non-technical folks with this service. Still, it is interesting to observe the costs from a power user's perspective.

Fawn Running Beside Car [Video]

2011-03-22T17:04:00.000-04:00

Took this a couple years ago...

gmail smart labels

2011-03-11T02:15:00.000-05:00

Gmail's new smart labels are pretty useful. In particular the idea of having a separate box for all bulk mail. I subscribe to a lot of mailing lists so I already had a lot of filters which removed stuff from the inbox, but for some reason it had never occurred to me to detect bulk mailings and move those out of the inbox as well.

With fewer things showing up in the inbox it becomes way more practical to use new mail notification.

Yet another HTML5 canvas demo

2011-03-03T22:48:00.000-05:00

I made a canvas demo that takes advantage of the new GPU acceleration in the beta Chrome builds. It sorta works in Firefox, too, but good god it's slow. I get 60fps at 1680x1050 in Chrome.

Python: Remove Duplicate Spaces

2011-01-21T23:58:00.000-05:00

>>> from functools import partial
>>> import re
>>> undup_spaces = partial(re.compile(r' +').sub, ' ')
>>> undup_spaces('  foo bar  foobar    foo bar    bar fu   ')
' foo bar foobar foo bar bar fu '

Python itertools grouper with truncation

2011-01-17T18:26:00.001-05:00

I wanted something like a "grouper" (see docs for itertools) that truncated the final list instead of filling with a fillvalue. This solution is not very efficient since the loop is in Python code and the intermediate lists must fit into memory, but it does work:

def grouper(n, iterable):
  "grouper(3, 'ABCDEFG') --> ABC DEF G"
  buf = []
  for i, c in enumerate(iterable):
    buf.append(c)
    if (i+1) % n == 0:
      yield buf
      buf = []
  if buf:
    yield buf

Is there a faster way to do this using the itertools primitives?

Python console prompt yes/no

2011-01-15T15:06:00.000-05:00

I've been using the prompt recipe on Activestate for a while because I know it works, but I actually looked at it today and realized it could be improved a bit so here you go:

>>> confirm()
Confirm n|y: 
Please enter y or n.
Confirm n|y: y
True

>>> confirm("Detonate explosives?", allow_empty=True, default=True)
Detonate explosives? [y]|n: 
True

>>> confirm("Invent cure for cancer?", allow_empty=True)
Invent cure for cancer? [n]|y: 
False

def confirm(prompt_str="Confirm", allow_empty=False, default=False):
  fmt = (prompt_str, 'y', 'n') if default else (prompt_str, 'n', 'y')
  if allow_empty:
    prompt = '%s [%s]|%s: ' % fmt
  else:
    prompt = '%s %s|%s: ' % fmt

  while True:
    ans = raw_input(prompt).lower()

    if ans == '' and allow_empty:
      return default
    elif ans == 'y':
      return True
    elif ans == 'n':
      return False
    else:
      print 'Please enter y or n.'

Sandy Bridge on Linux? Nah, not yet...

2011-01-14T10:18:00.001-05:00

I was looking at the new Sandy Bridge hardware yesterday. For $450 or so I can get a CPU that's about twice as fast as my Q8200, 8G RAM, and a board with USB 3 and all the new goodies. Intel's new P67 boards (like the BOXDP67DE) also support 32G RAM total so there's a nice upgrade path with 2x8GB DIMMs in the future.

Sadly they are not really ready on linux yet unless you like compiling your own kernel.

Intel's comments are encouraging, though. Oh well, maybe in a few months.

Quick Python zlib vs bz2 benchmark

2011-01-11T17:39:00.001-05:00

I use the zlib module a lot on Google App Engine; often the tiny CPU time for decompression is a good tradeoff to save disk space. I was curious how bz2 compares so I ran this short benchmark.

The test file was this plaintext book, a highly-compressible source. Columns are: level, time, bytes uncompressed, bytes compressed, ratio.

% ./bench.zsh

zlib compress
0   6.98ms 640599 640700 1.000
1  21.22ms 640599 274195 2.336
2  25.08ms 640599 261638 2.448
3  34.24ms 640599 249649 2.566
4  36.41ms 640599 241500 2.653
5  54.24ms 640599 232545 2.755
6  77.22ms 640599 228621 2.802
7  87.94ms 640599 228032 2.809
8 112.49ms 640599 227622 2.814
9 113.03ms 640599 227622 2.814

zlib decompress
0   1.54ms
1   6.39ms
2   6.13ms
3   6.02ms
4   6.22ms
5   5.96ms
6   5.94ms
7   5.90ms
8   5.89ms
9   5.94ms

bz2 compress
1 105.30ms 640599 196752 3.256
2 103.42ms 640599 186082 3.443
3 105.40ms 640599 180905 3.541
4 104.95ms 640599 177642 3.606
5 113.12ms 640599 176232 3.635
6 110.45ms 640599 173153 3.700
7 113.06ms 640599 169634 3.776
8 110.27ms 640599 169634 3.776
9 111.43ms 640599 169634 3.776

bz2 decompress
1  36.40ms
2  35.79ms
3  36.35ms
4  36.81ms
5  41.18ms
6  44.86ms
7  48.96ms
8  48.45ms
9  47.95ms

Conclusion: probably not worth it. bz2 at level=4 takes about 7 times longer to decompress than gzip at level=9 for only a modest improvement in the compression ratio from 2.8 to 3.6.

Interestingly for write-heavy workloads bz2 may actually be the better choice since compression time is not much worse than gzip at level=9.

I think it's better not to use the timeit module for this kind of benchmark since in typical usage you will just be compressing/decompressing some given data once. If the operations speed up in repeat runs due to caching (and they do), that doesn't reflect typical usage. Starting a new python process for each test seems to reduce cache effects.

Anyway, here is the code.

import zlib
import bz2
import time
import sys

level = int(sys.argv[1])
mod = zlib if int(sys.argv[2]) else bz2
is_decompress = int(sys.argv[3])

with open("pg4238.txt") as f:
  data = f.read()

if is_decompress:
  c_data = mod.compress(data, level)

t = time.time()
if is_decompress:
  data = mod.decompress(c_data)
else:
  c_data = mod.compress(data, level)

print level, "%6.02fms" % (1000*(time.time() - t)),
if not is_decompress:
  print len(data), len(c_data), "%.03f" % (float(len(data))/len(c_data))

#!/usr/bin/zsh
echo 'zlib compress'
for level in {0..9}; do python bench.py $level 1 0; done
echo '\nzlib decompress'
for level in {0..9}; do python bench.py $level 1 1; done
echo '\nbz2 compress'
for level in {1..9}; do python bench.py $level 0 0; done
echo '\nbz2 decompress'
for level in {1..9}; do python bench.py $level 0 1; done

GVIM: Remove Bold Font

2011-01-06T02:38:00.002-05:00

Found a neat function for gvim which automatically strips out bold font directives from syntax files since there's no way to globally disable bold. Bold really stinks on most small bitmap fonts; it is much better to use different colors for emphasis. Add this to .gvimrc:

function! Highlight_remove_attr(attr)
        " save selection registers
        new
        silent! put

        " get current highlight configuration
        redir @x
        silent! highlight
        redir END
        " open temp buffer
        new
        " paste in
        silent! put x

        " convert to vim syntax (from Mkcolorscheme.vim,
        "   http://vim.sourceforge.net/scripts/script.php?script_id=85)
        " delete empty,"links" and "cleared" lines
        silent! g/^$\| links \| cleared/d
        " join any lines wrapped by the highlight command output
        silent! %s/\n \+/ /
        " remove the xxx's
        silent! %s/ xxx / /
        " add highlight commands
        silent! %s/^/highlight /
        " protect spaces in some font names
        silent! %s/font=\(.*\)/font='\1'/

        " substitute bold with "NONE"
        execute 'silent! %s/' . a:attr . '\([\w,]*\)/NONE\1/geI'
        " yank entire buffer
        normal ggVG
        " copy
        silent! normal "xy
        " run
        execute @x

        " remove temp buffer
        bwipeout!

        " restore selection registers
        silent! normal ggVGy
        bwipeout!
    endfunction
    autocmd BufNewFile,BufRead * call Highlight_remove_attr("bold")

Found here. Written by Steve Hall.

Python Kakuro Solver Now Pretty Fast

2010-12-30T16:50:00.001-05:00

Ahh, winter holidays. Finally got around to working on my Python Kakuro Tools again. I've had the top spot for "python kakuro" in Google for a while, but the code was embarrassingly bad and slow. Now it is solving the fairly complex puzzle below in less than 200ms. Not bad for an interpreted language.

Still a lot of work to do before it's ready for a 1.0 release, but at least the solving engine is pretty much done. I wonder how much slower this code is rather than something written in a constraint programming language (like the process described in this paper) or a native C implementation. C implementations can get away with using a platform word to store the possible values for each cell which enables fast bitwise operations; I'm sure that helps a lot. I used Python's sets which are a more generic solution since they're not limited to 32 or 64 cell values (depending on the platform), but also much slower.

  0  | 0,24| 0,28|  0  | 0,14| 0,33| 0,13| 0,8 | 0,39|  0  | 0,27| 0,45| 0,16| 0,8 |  0  | 0,20| 0,32| 0,21|
-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
 12,0|  1  |  1  |16,43|  1  |  1  |  1  |  1  |  1  | 30,0|  1  |  1  |  1  |  1  |11,10|  1  |  1  |  1  |
-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
 43,0|  1  |  1  |  1  |  1  |  1  |  1  |  1  |  1  | 36,6|  1  |  1  |  1  |  1  |  1  |  1  |  1  |  1  |
-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
 32,0|  1  |  1  |  1  |  1  |  1  |22,19|  1  |  1  |  1  |  1  |  1  |  1  |11,11|  1  |  1  |  1  |  1  |
-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
  0  |33,13|  1  |  1  |  1  |  1  |  1  |42,45|  1  |  1  |  1  |  1  |  1  |  1  |  1  |12,40|  1  |  1  |
-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
 15,0|  1  |  1  |  1  | 29,8|  1  |  1  |  1  |  1  |  1  |  1  |  1  |18,30|  1  |  1  |  1  |  1  |  1  |
-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
 11,0|  1  |  1  |  1  |  1  |24,10|  1  |  1  |  1  | 18,0|  1  |  1  |  1  |  1  |22,12|  1  |  1  |  1  |
-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
  0  | 0,24|34,36|  1  |  1  |  1  |  1  |  1  | 0,35|  0  |23,26|  1  |  1  |  1  |  1  |  1  | 0,21| 0,13|
-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
 24,0|  1  |  1  |  1  |19,26|  1  |  1  |  1  |  1  | 6,6 |  1  |  1  |  1  |10,27|  1  |  1  |  1  |  1  |
-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
 20,0|  1  |  1  |  1  |  1  |  1  |42,27|  1  |  1  |  1  |  1  |  1  |  1  |  1  |23,28|  1  |  1  |  1  |
-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
 12,0|  1  |  1  | 33,7|  1  |  1  |  1  |  1  |  1  |  1  |  1  | 33,7|  1  |  1  |  1  |  1  |  1  | 0,22|
-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
 27,0|  1  |  1  |  1  |  1  |23,12|  1  |  1  |  1  |  1  |  1  |  1  |24,12|  1  |  1  |  1  |  1  |  1  |
-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
 37,0|  1  |  1  |  1  |  1  |  1  |  1  |  1  |  1  | 36,0|  1  |  1  |  1  |  1  |  1  |  1  |  1  |  1  |
-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
 7,0 |  1  |  1  |  1  | 10,0|  1  |  1  |  1  |  1  | 16,0|  1  |  1  |  1  |  1  |  1  | 8,0 |  1  |  1  |
-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+

 
  0  | 0,24| 0,28|  0  | 0,14| 0,33| 0,13| 0,8 | 0,39|  0  | 0,27| 0,45| 0,16| 0,8 |  0  | 0,20| 0,32| 0,21|
-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
 12,0|  7  |  5  |16,43|  1  |  3  |  4  |  2  |  6  | 30,0|  8  |  9  |  6  |  7  |11,10|  8  |  1  |  2  |
-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
 43,0|  8  |  4  |  5  |  3  |  6  |  9  |  1  |  7  | 36,6|  5  |  6  |  2  |  1  |  3  |  7  |  8  |  4  |
-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
 32,0|  9  |  8  |  6  |  2  |  7  |22,19|  5  |  4  |  2  |  3  |  7  |  1  |11,11|  2  |  5  |  3  |  1  |
-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
  0  |33,13|  6  |  7  |  8  |  9  |  3  |42,45|  9  |  3  |  6  |  8  |  7  |  5  |  4  |12,40|  9  |  3  |
-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
 15,0|  8  |  3  |  4  | 29,8|  8  |  2  |  6  |  5  |  1  |  4  |  3  |18,30|  2  |  1  |  6  |  4  |  5  |
-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
 11,0|  5  |  2  |  3  |  1  |24,10|  7  |  9  |  8  | 18,0|  1  |  5  |  9  |  3  |22,12|  9  |  7  |  6  |
-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
  0  | 0,24|34,36|  9  |  7  |  4  |  6  |  8  | 0,35|  0  |23,26|  2  |  8  |  1  |  9  |  3  | 0,21| 0,13|
-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
 24,0|  7  |  9  |  8  |19,26|  2  |  1  |  7  |  9  | 6,6 |  2  |  1  |  3  |10,27|  3  |  1  |  2  |  4  |
-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
 20,0|  2  |  6  |  1  |  8  |  3  |42,27|  5  |  8  |  3  |  7  |  4  |  6  |  9  |23,28|  8  |  6  |  9  |
-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
 12,0|  5  |  7  | 33,7|  4  |  1  |  9  |  3  |  6  |  2  |  8  | 33,7|  4  |  8  |  9  |  7  |  5  | 0,22|
-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
 27,0|  6  |  8  |  4  |  9  |23,12|  8  |  2  |  3  |  1  |  5  |  4  |24,12|  1  |  8  |  2  |  4  |  9  |
-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
 37,0|  3  |  2  |  1  |  5  |  9  |  6  |  4  |  7  | 36,0|  1  |  2  |  8  |  7  |  5  |  4  |  3  |  6  |
-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
 7,0 |  1  |  4  |  2  | 10,0|  3  |  4  |  1  |  2  | 16,0|  3  |  1  |  4  |  2  |  6  | 8,0 |  1  |  7  |
-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+

Weather Alerts for XMobar

2010-12-29T11:15:00.001-05:00

By default xmobar's weather module only fetches temperature, humidity, and some other basic weather data for your location.

This script fetches weather alerts (like "Winter Storm Warning") for your county in an xmobar-friendly format. Only for US users since it queries the National Weather Service.

I like it for keeping track of winter weather alerts especially.

Backup Strategies: Linux to FreeBSD ZFS

2010-12-23T10:46:00.001-05:00

I use FreeBSD on my home server mainly for the ZFS support, but I run Linux on my workstation and laptop.

I've been trying to figure out the best backup strategy for this environment. If I was running FreeBSD on my client machines and they had local ZFS filesystems, I could use snapshots with ZFS send to propagate changes to the server. This would be really great but is impractical until a fast, stable version of ZFS arrives in Linux (probably never).

For now I've settled on mounting an NFS share from the server on each machine and then using rsync to copy changes from the local volume to the NFS share via cron job. Using NFS is faster than tunneling over rsync over ssh since the server is slow. I run rsync in the mode that propagates deletions to the destination volume and rely on zfs snapshots on the server to recover any accidentally deleted files.

I guess it's not perfect, but probably the best I can do without switching my client machines to FreeBSD.

Ubuntu Slow After Hibernate Resume

2010-12-18T22:38:00.001-05:00

I use hibernate probably more often than I should. It's not totally stable on my hardware and sometimes it crashes on resume, or does weird things like crashes on the first resume attempt but works fine on the second. And God help you if you install some system update and then accidentally hibernate instead of restarting. But even with all the weird idioscyncracies it's still faster than rebooting every morning, so I use it.

I've already had to write a custom hibernate/resume script to unmount/remount my NFS share, lest it hang on resume and make the system unusable by locking up every shell when it tries to read my home directory (still haven't figured out a way out of that pickle). I'm thinking about also adding swapoff -a; swapon -a to the resume script. For whatever reason linux seems to leave everything on the swap disk by default and only page stuff back in as it's accessed, which means the system is slow for a few hours after hibernate resume every time you access some program you haven't accessed yet. I rarely use even half my RAM so it makes more sense to page everything back in right after resume so the system is snappy again.

Isn't that true for most people? I wonder why this isn't done by default.