Changing the selected audio output device was just the thing to implement as a workflow. OS X has a nice shortcut for doing this without heading to system preferences. Option clicking the speaker in the menu bar well let you change the input or output device, but I wanted to do it easily from the keyboard.

The ‘Script Filter’ option under the input menu is the magic for this workflow. It allows a script to output a list of items for display and selection in the Alfred GUI. You get Alfred’s great predictive auto complete which makes selecting a device a breeze.

Output via Growl or Notification Center provides feedback of the completed action.

The workflow is pretty simple in Alfred’s workflow editor, it ends up looking like this:

Alfred makes sharing workflows insanely easy by throwing all the necessary files for each workflow in a dedicated directory. Right clicking a workflow in Alfred gives an export workflow option which creates a zip file of this directory with the ‘.alfredworkflow’ extension.

Grab SwitchAudio.alfredworkflow

The heavy lifting is done by switchaudio-osx by deweller on GitHub with a simple perl glue script to pass data back and forth between Alfred and switchaudio-osx.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

#!/usr/bin/env perl

use strict;
use warnings;

use FindBin;

my $action = shift || 'list';
my $direction = shift || 'output';

if ($action eq 'list') {
    my $devices = get_possibilities($direction);
    print qq{<?xml version="1.0"?>\n<items>\n};
    print output_device($_) for @$devices;
    print "</items>\n";
}

if ( $action eq 'set' ) {
    my $device = shift;
    print set_device($direction, $device) . "\n";
}

sub get_possibilities {
    my $direction = shift;
    my @devices;
    open( my $fh, '-|', $FindBin::Bin . '/SwitchAudioSource',
        '-at', $direction );
    while ( my $line = <$fh> ) {
        chomp $line;
        $line =~ s/ \(\Q$direction\E\)$//;
        push @devices, $line;
    }
    close $fh;
    return \@devices;
}

sub set_device {
    my ( $direction, $device ) = @_;
    open( my $fh, '-|', $FindBin::Bin . '/SwitchAudioSource',
        '-t', $direction, '-s', $device );
    my $output = join "\n", <$fh>;
    close $fh;
    return $output;
}

sub output_device {
    my $device = shift;
    ( my $device_no_space = $device ) =~ tr/ /_/;
    return qq{<item arg="$device" uid="$device_no_space"><title>$device</title><subtitle/><icon>icon.png</icon></item>\n};
}

The town currently gets most office supplies from WB Mason. I do not know if this includes coffee but at work we get our coffee from WB Mason so as any Geek would do, I made a spread sheet.

Direct Link to Google Docs Spreadsheet

There are only two fair trade items in this category but they are right in line with prices for non fair trade varieties. If you are already using one of the non fair trade blends from the two companies with a fair trade blend, there is 0 price difference.

This lack of price difference surprised me.

This snippet from a paid nerd adds ‘…’ output during completion that is replaced with the completion or removed once the completion engine is finished.

Here’s the snippet:

1
2
3
4
5
6
7
8

# http://stackoverflow.com/a/844299
expand-or-complete-with-dots() {
  echo -n "\e[31m...\e[0m"
  zle expand-or-complete
  zle redisplay
}
zle -N expand-or-complete-with-dots
bindkey "^I" expand-or-complete-with-dots

Also, get yourself in the habbit of including a comment with a url for stuff like this. I once wanted to write a blog post about something I found somewhere and couldn’t remember where I found it online! I’ll never make that mistake again.

My named directories start with ~ for my home directory so they need to exist for expansion to work properly and not output errors when I log in. When I first implemented syncing I added this check with a very simple test:

1

[[ -d ~/Dropbox/wiki           ]] && wiki=~/Dropbox/wiki

One line like this isn’t too bad but when you have 30, it gets a little silly looking.

I finally took the time to sit down and read the docs on zsh associative arrays and whipped up a much better solution.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

typeset -A NAMED_DIRS

NAMED_DIRS=(
    bin      ~/Dropbox/Documents/bin
    docs     ~/Dropbox/Documents
    lbin     ~/Documents/bin
    wiki     ~/Dropbox/wiki
    dot      ~/Dropbox/Documents/dotfiles
    octo     ~/Dropbox/Documents/octopress
)

for key in ${(k)NAMED_DIRS}
do
    if [[ -d ${NAMED_DIRS[$key]} ]]; then
        export $key=${NAMED_DIRS[$key]}
    else
        unset "NAMED_DIRS[$key]"
    fi
done

The unset isn’t necessary here for the base functionality. I had another problem. With 30 or 40 named dirs, some belonging to projects that I might not have looked at in 6 months and suddenly need to come back to, it’s hard to remember the name I gave for a directory. I added an lsdirs function that lists just the named directories that existing on the machine I’m on.

1
2
3
4
5
6

function lsdirs () {
    for key in ${(k)NAMED_DIRS}
    do
        printf "%-10s %s\n" $key  ${NAMED_DIRS[$key]}
    done
}

This gives me nice easy to read output with both the names and the full path.

This blog post is more future reference for myself but perhaps it may be useful to you.

For those interested, here is the Makefile I use:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

DOTFILES ?= $(shell pwd)
HOSTNAME ?= $(shell hostname)

all: shell code perl web mail

shell:
  ln -fs $(DOTFILES)/zsh/zshrc        ${HOME}/.zshrc
  ln -fns $(DOTFILES)/zsh/zsh.d       ${HOME}/.zsh.d
  ln -fs $(DOTFILES)/gnupg            ${HOME}/.gnupg
  ln -fs $(DOTFILES)/ssh/config       ${HOME}/.ssh/config

    ifeq ($(HOSTNAME),orion)
      ln -fs $(DOTFILES)/screen/screenrc_orion ${HOME}/.screenrc
    else
      ln -fs $(DOTFILES)/screen/screenrc  ${HOME}/.screenrc
    endif

code:
  ln -fs $(DOTFILES)/gitconfig        ${HOME}/.gitconfig
  ln -fs $(DOTFILES)/vimrc            ${HOME}/.vimrc
  ln -fns $(DOTFILES)/vim             ${HOME}/.vim
  ln -fs $(DOTFILES)/.tm_properties  ${HOME}/.tm_properties

perl:
  ln -fs $(DOTFILES)/perltidyrc       ${HOME}/.perltidyrc
  ln -fs $(DOTFILES)/perlcritic       ${HOME}/.perlcriticrc

web:
  ln -fs $(DOTFILES)/vimperatorrc   ${HOME}/.vimperatorrc

mail:
  ln -fs $(DOTFILES)/muttrc           ${HOME}/.muttrc

Through a Freedom of Information Act request their Analyst’s Desktop Binder (4.4 MB PDF) was made publicly available. This is essentially the employee manual for MMC analysts, describing how to preform their job. There are quite a few very interesting tid bits in it such as the list of keywords and search terms used when searching social media sites.

Section 2.6 beginning on page 14 lists credible sources broken out into various tiers. Local affiliates of the major networks are considered first tier sources and don’t require any additional corroboration prior to release. Meanwhile, all blogs “even if they are of a serious, political nature,” are considered third tier sources and must be corroborated by a first tier source.

Also of interest were screen shots of various interfaces they use such as the Item Of Interest (IOI) report screen used to log an article and useful metadata.

The real problem with this document is the peak inside Homeland Security at how they do things.

Near the end, in section 8 ‘Usernames, Passwords & Contact Information,’ we see that a common username and password are shared amongst analysts to log in to computers, shared drives, DHS email, and more.

I am interested in the twitter information in this section. @DHSNOCMMC1 is a protected twitter account with no tweets and following 339 users. I’d love to see the followers list but I’m sure it is filled with just a lot of boring traditional news organizations.

Jumping back a bit, to section 7, we find something even worse. This section is called “HSIN REDACTED Connection Instructions.” Here we see that REDACTED is a system that is so vital to our security that even it’s name must not be known.

See?!? It’s obvious even to my seven year old that this is a system so vital to keep secret that even the name must be secret.

If one continues reading this section you come across this very surprising passage:

For those using screen readers due to blindness or those not trusting their eyes, this is the sentence in that image:

After clicking on next, the following screen will appear and you must select “Accept for all sessions”

This is followed by an image of an invalid SSL certificate warning dialog. All along experts have worried about teaching everyone’s mother not to blindly accept invalid certificate warnings. If Homeland Security is instructing their analysts to blindly accept invalid SSL certificate warnings then not only have we lost the war, the enemy is dancing on our grave as the baby jesus cries dark tears in the corner.

I ended up having to modify the library slightly to get it to pass the yaxes option on to flot. My source is over on github.

You can see the real time data over here.

I recently replaced the thermostat in our new house with a Filtrete 3M-50. This thermostat has a wifi module and is available at your local Home Depot for $99. I’d been aware of it for a while but had planned on purchasing the $250 nest. The turning point for me came one even as I was going to bed. I was hot, the heat was running and I chose to turn the fan on instead of going downstairs and adjusting the thermostat. In my defense, I knew the thermostat would switch to night mode in another 45 minutes and reduce the set point but I was still wasting energy.

Comparing the Filtrete to the nest the main features you are missing out on are:

• automatic occupancy detection
• humidity detection
• automatic schedule learning

Automatic scheduling is a big win for the average person but our schedule isn’t static enough for this to be much benifit to us. The location of our thermostat is about the best place for a thermostat, but not for occupancy detection so this feature isn’t missed. I’m a bit sad with the loss of humidity detection, the next model up Filtrete has it for $200 but it’s not a deal breaker.

The real win for geeks with a WIFI thermostat isn’t the iPhone or Android Apps, it’s the ability to interface with it and do geeky things. The Filtrete 3M-50 is a rebadged Radio Thermostat Company of America CT30. Radio Thermostat has the API documentation hidden on their website in the latest news section. Scroll to the bottom of the page and click the ‘I Accept’ checkbox. There is also a 3rd party wiki with API documentation and sample code.

I started with the poller.pl script available on the wiki to go from nothing to something quickly. There’s a lack of error checking in it and the non CPANed Radio::Thermostat module available on that page but it gets you up and running quickly.

After this, I wrote a simple script to tweet daily thermostat information.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

#!/usr/bin/perl 

use 5.010;
use strict;
use warnings;

use RRDs;
use DateTime;
use Net::Twitter;
use Mojo::UserAgent;
use List::Util 'sum';

my $runtime  = get_runtime_string();
my $averages = get_averages_string();

die unless $runtime && $averages;

my $tweet = "Yesterday $averages with $runtime.";
say $tweet;

my $consumer_key    = '';
my $consumer_secret = '';
my $token           = '';
my $token_secret    = '';

my $thermostat_url  = 'http://10.8.8.98/tstat/datalog';
my $rrd_path        = '/home/michael/srv/therm/poller/data/temperature.rrd';

my $nt = Net::Twitter->new(
    traits   => [qw/OAuth API::REST/],
    consumer_key        => $consumer_key,
    consumer_secret     => $consumer_secret,
    access_token        => $token,
    access_token_secret => $token_secret,
);

$nt->update($tweet);


sub get_runtime_string {
    my $ua = Mojo::UserAgent->new;
    my $res = $ua->get($thermostat_url)->res;

    die "Didn't get runtimes for yesterday" unless $res;

    my $data = $res->json;
    return build_runtime_string('heat', $data->{ yesterday } )
        || build_runtime_string('cool', $data->{ yesterday } )
        || "no heat or A/C used";
}

sub build_runtime_string {
    my ($mode, $data)  = @_;
    my $times = $data->{ $mode . '_runtime' };
    return unless $times->{ hour } || $times->{ minute };
    return sprintf '%sing runtime of %i:%02i',
        $mode, $times->{ hour }, $times->{ minute };
}

sub get_averages_string {
    my $yesterday = DateTime->now()->subtract( days => 1);

    my $start_of_day = DateTime->new(
        year    => $yesterday->year,
        month   => $yesterday->month,
        day     => $yesterday->day,
        hour   => 0,
        minute => 0,
        second => 0,
        time_zone => 'America/New_York'
    );

    my $end_of_day = $start_of_day->clone->add( hours => 24 );

    my ($start,$step,$names,$data) = RRDs::fetch (
        $rrd_path,
        'AVERAGE',
        '-s ' . $start_of_day->epoch,
        '-e ' . $end_of_day->epoch
    );

    if (my $error = RRDs::error) {
        die "Error reading RRD data: $error";
    }

    my (@ext_temp, @int_temp);
    for my $row (@$data) {
        next unless grep { $_ } @$row;
        my ($outside, $inside) = @$row[2, 5];
        push @ext_temp, $outside;
        push @int_temp, $inside;
    }

   return  sprintf "averaged %.1fF outside and %.1fF inside",
        average( \@ext_temp), average(\@int_temp);
}

sub average {
    my $list = shift;
    return sum(@$list) / @$list;
}

Tweets look like:

• Yesterday averaged 59.5F outside and 67.9F inside with no heat or A/C used.
• Yesterday averaged 64.2F outside and 70.1F inside with heating runtime of 0:17.
• Yesterday averaged 58.9F outside and 69.0F inside with heating runtime of 0:31.

You can follow my house on Twitter as @mikegrbs_house.

1
2
3
4
5
6
7
8

---
layout: post
title: Devops w/ Perl @ Linode PPW Talk Slides
wordpress_id: 330
wordpress_url: http://michael.thegrebs.com/?p=330
date: 2011-10-27 14:46:31 -04:00
---
Earlier this month I gave a talk about...

Having the wordpress post id means extracting the post tags from the db should be quite easy. First we define our desired output:

1
2
3
4
5
6
7
8
9

---
layout: post
title: Devops w/ Perl @ Linode PPW Talk Slides
wordpress_id: 330
wordpress_url: http://michael.thegrebs.com/?p=330
date: 2011-10-27 14:46:31 -04:00
tags: geek perl slides
---
Earlier this month I gave a talk about ...

The tags field really can appear anywhere in this YAML fragment but I chose to throw it at the end. With 103 posts to loop over, run a query and insert a new line a short script makes sense. The real win for our script though is using the Tie::File module which presents each file as an array with an element for each line.

From there it’s simply a matter of reverse engineering the Wordpress schema to come up with a query that will return a space delimited list of tags for a given post id.

1
2
3
4
5

SELECT GROUP_CONCAT(t.`name` SEPARATOR " ") FROM `wp_term_relationships` r
INNER JOIN `wp_term_taxonomy` tax ON r.`term_taxonomy_id` = tax.`term_taxonomy_id`
INNER JOIN `wp_terms` t ON tax.`term_id` = t.`term_id`
WHERE r.`object_id` = ?
AND tax.`taxonomy` = "post_tag";

Throw that query in a script that iterates over the list of files and uses Tie::File to add a line to the post and we get:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

#!/usr/bin/perl 

use 5.010;
use strict;
use warnings;

use DBI;
use Tie::File;

my $path_to_posts = 'source/_posts';

my $dbh = DBI->connect('DBI:mysql:db_name:db_host','db_user','db_pass');

my $get_tags = $dbh->prepare(q{
    SELECT GROUP_CONCAT(t.`name` SEPARATOR " ") FROM `wp_term_relationships` r
    INNER JOIN `wp_term_taxonomy` tax ON r.`term_taxonomy_id` = tax.`term_taxonomy_id`
    INNER JOIN `wp_terms` t ON tax.`term_id` = t.`term_id`
    WHERE r.`object_id` = ?
    AND tax.`taxonomy` = "post_tag";
    });


for my $file (glob "$path_to_posts/*.markdown") {
    say $file;
    add_tags_to_file($file);
}

sub add_tags_to_file {
    my $filename = shift;
    tie my @file, 'Tie::File', $filename or die "No tie: $!";
    my $tags;
    while (my ($rec, $data) = each @file) {
        if ($data =~ m/^wordpress_id: (\d+)$/) {
            $tags = get_tag($1);
        }
        if( $data =~ /^date:/) {
            splice @file, $rec + 1, 0, $tags if $tags;
            return;
        }

    }
}

sub get_tag {
    my $post = shift;
    $get_tags->execute($post);
    my ($tags) = $get_tags->fetchrow_array();
    return "tags: " . $tags if $tags;
}

DevOps w/ Perl @ Linode.pdf (2.1MB)

Skip to the next section if you just care about the end result. In the past, I’ve had my remote Irssi client send UDP Growl packets to my static home IP that were then forwarded to the broadcast address on the local network. This worked great and allowed me to get Growl notifications on which ever computer I happened to be sitting at. These days, I’m always on my laptop, even when sitting at another computer (Teleport for the mega win).

I wanted a solution that would allow me to receive Growl notifications without having to forward any ports and no matter what the public IP for my laptop may be. I use App::PersistentSSH to maintain a persistent SSH control master connection to my Linode so the ideal solution uses a reverse tunnel over this connection to get the notifications too my laptop.

My Current Solution

• Added --ssh_opts -R 127.0.0.1:22992:127.0.0.1:22 to my App::PersistentSSH command line. This connects localhost:22992 on my Linode to port 22 on my laptop.
• local-growl.pl – an Irssi script that uses growlnotify to send growl notifications
• growlnotify.pl – an ssh proxy for growlnotify, passes it’s arguments to growlnotify on a remote system via ssh

Simple push growl notifications from my Linode -> my MacBook Air whenever it is online. The scripts and an irssi.png to use in the notifications are available on GitHub.

Configuration for local-growl.pl is via Irssi’s in built settings, type /set growl to see a list of possibilites:

1
2
3
4
5
6
7

[local-growl]
growl_enabled = ON
growl_growlnotifypath = /home/michael/bin/growlnotify
growl_image_path = /Users/mgreb/Documents/irssi.png
growl_show_hilights = ON
growl_show_private_messages = ON
growl_sticky = OFF

Configuration for growlnotify.pl is via a set of config variables near the top:

1
2
3
4

my $ssh_host    = 'localhost';
my $ssh_port    = 22992;
my $ssh_user    = 'mgreb';
my $growlnotify = '/usr/local/bin/growlnotify';

Hopefully you will find this useful.

The wattvision (~$250) most closely resembles the TED in terms of price and features. The wattvision uses an optical sensor that counts the rotation of the disk in the utility meter. This sensor is connected to the device, which is powered by an AC adapter and sends the data to wattvision’s servers via your home wifi network. This is the easiest to install, but would require running the sensor cable from the outside to inside. Additionally, all data is sent to wattvision’s servers. I’d also need to subscribe to wattvision’s $8.99/month service for the other features I want (like API access.)

The eMonitor (starting around $688 for 12 circuits) is something I just recently discovered. Really, this is my ideal solution: for $1,277, you get the necessary equipment for monitoring the power feed plus 44 individual breakers. This gives a much better view of where your power consumption is going. Per-circuit monitoring also enables nifty alerts – an SMS for power draw in the kids room after school starts on a week day, or if the compressor on the fridge is running longer than normal (time to clean the coils, etc.) I just can’t justify the expense at $1,277. The price is certainly reasonable for what you are getting, but there is no way the wife would approve the purchase :/

The Energy Detective (TED, ~$200) from Energy Inc provides full house consumption monitoring like the wattvision. Unlike the wattvision, the data is stored and served from a gateway device on your home network. Two current transformers go around the two lines for the incoming split phase feed. These are connected to a box, which is installed next-to-or-inside the breaker panel. The breaker panel is powered and communicates via a connection to a breaker on each phase. The gateway is installed elsewhere in the house and plugs into an outlet for power and communication with the current sensor, and via Ethernet to serve its precious data up.

So, February 10th I finally got approval from the wife to order the TED and purchased the TED 5000-G with overnight shipping. It arrived as expected on the 11th and I was eager to install it. A coworker (also interested in the TED,) came over for dinner and to help out with the installation. I was too excited to wait for his arrival and finished the install before he got there ;-).

It’s now February 27th and I still don’t have a working TED system. The gateway I was originally shipped has a defective Ethernet port. It’s already been to Energy Inc and back and is still defective. They finally agreed to ship me a replacement gateway on the 25th but sent it with 2nd day shipping, which has the same transit time as ground (just more expensive.) The new unit should arrive March 1st.

I’m quite eager to get things up and running, and anticipate no problems once I have a working gateway. The most common issue people run into is excessive noise or attenuation of the power line communications (PLC) signal between the sensor and gateway. The forums seem to be full of people with lots of grief around this issue. The gateway does contain a ZigBee transceiver but that is for communication with the optional wireless display. Some have questioned switching from PLC to ZigBee for the current data but a device inside the metal breaker box would have a hard time getting any sort of RF signal out, and PLC seems the most logical solution (even with it’s inherent issues.)  Of course, this is easy for me to say since I don’t anticipate having any issue with PLC. I can see a clear ~3-4Vpk signal on the zero crossing of the A/C at the outlet I plan to install the gateway:

I have another blog post in the works documenting my seemingly unending issues with the other half of the TED solution: the support staff and engineers backing the product. To be fair, the support staff is 1:2 – the second guy I spoke to there was great, but I’m pretty sure their engineers shouldn’t be allowed to know customers even exist, let alone talk to them on the phone. But, this is a story for my next blog post.

I composed my first recipe the other night and figured I’d share it with you in the hopes that your doctor might hate me as much as mine does.

Bacon Salad

Ingredients

• 1lb Pancetta
• 1lb Virginia Bacon
• 1lb Peppered Bacon
• 1lb Canadian Bacon
• 1lb Apple-Wood Smoked Bacon
• 1lb Irish Bacon
• 1lb Slab Bacon
• 2lb Hog Jowl
• 1 Bottle reduced fat Bacon Ranch Salad Dressing

Directions

1. Fry each, crispy.
2. Cut into 1x2 inch rectangles.
3. Toss in bowl with salad dressing.

Makes 2, snack sized, servings.

At Linode we have a wiki page where we list 5 or more tasks we wish to accomplish during the week. There is a heading for each employee and below the heading we place our tasks. Throughout the week we can add additional tasks or mark existing ones as done.

I’ve used Hiveminder for some time. When we started the weekly task lists at Linode I found that taking a few minutes to figure out which tasks I wish to complete in the coming week works quite well for me. I started marking these tasks with the ‘week’ tag in Hiveminder. I quickly ended up writing a perl script, week.pl, to help me manage hem.

My Weekly Workflow

First thing Monday morning I run:

$ week.pl report

This prints a report with two sections. The first section lists tasks that currently have the ‘week’ tag with a line through the task ID if it is completed. This gives me a nice summary of what I planned on accomplishing the previous week and how I did. The second section lists all of my tasks currently visible in Hiveminder. I hide tasks that I know I’m not going to work on in the next few weeks so this list is usually no more than 20 or 30 items.

I take this report into the Monday morning meeting with me. During the meeting, I’ll glance over this list and select items for the upcoming week. I also use this page to take notes on during the meeting, writing down any new tasks that come up in the meeting.

After the meeting, I add any new tasks generated in the meeting that I won’t be working on this week to Hiveminder.

$ todo.pl braindump

`todo.pl` comes from App::Todo, a command line Hiveminder interface. The braindump command launches $EDITOR where I add new tasks, one per line. The braindump syntax allows for specifying tags, setting priorities, and other things as well.

Next, I prepare the task list for the upcoming week:

$ week.pl edit
Carry over the following tasks?
bring about world peace (y or n) [default y] y
write some awesome pre
do some other cool stuff
create practical cold fusion (y or n) [default y] n
return library book

The `edit` command iterates over each task tagged with ‘week’ if the task is not marked completed. It prompts whether or not I wish to carry the task over to this week (leave the tag). Any tasks marked completed have the tag removed automatically.

$ week.pl add
Created:
        #YRVK write an awesome report for Tom [week dev]
        #YRVL test some new stuff for deployment [week admin]

The `add

$ week.pl update https://path.to.trac/wiki/Tasks/2010-03-15
Sup dawg, I heard you like tasks so I did ur shit for you

The `update` command grabs my tasks tagged with ‘week’ and formats them one per line started with ’ * ‘, a wiki bullet list. It grabs the current wiki page, finds my heading, substitutes the formatted task list under the heading, and submits the change. It also stores the path given in the YAML config file.

$week.pl go

This opens the stored URL for this week’s tasks wiki page in my default browser, allowing me to confirm week.pl did what it’s supposed to.

Later in the week once I’ve done something:

$ week.pl done tom
#YH7T bring about world peace [dev week]
#YRVL test some new stuff for deployment [week admin]
[DONE] #YRVK write an awesome report for Tom [week dev]

This retrieves the task(s) tagged ‘week’ that are not marked completed containing the given string. If there was only one match, the script marks it as done and then outputs the current state of tasks tagged ‘week’.

$ week.pl update
Sup dawg, I heard you like tasks so I did ur shit for you

Same as `update` before, except when no URL is given, the URL is read from the configuration file. This way I only need to worry about the URL once per week, the first time I update for the week.

Conclusion

So there you have it. If you are also using Hiveminder, maybe aspects of my work flow will make sense for you and pieces of the Perl script may be useful. If you aren’t using Hiveminder, maybe you will be inspired to check it out. I use michael@thegrebs.com on Hiveminder in case you feel the need to assign me a task or wish to gift me another year of Hiveminder Pro ;)

week.pl

Usage looks like:

1
2
3
4
5
6
7
8
9
10
11

use WebService::MobileMe;

my $mme = WebService::MobileMe->new(
    username => 'yaakov', password => 'HUGELOVE' );
my $location = $mme->locate;
print < <"EOT";
    As of $location->{date}, $location->{time}, Yaakov was at
    $location->{latitude}, $location->{longitude} (plus or minus
    $location->{accuracy} meters).
EOT
$mme->sendMessage( message => 'Hi Yaakov!', alarm => 1 );

The online documentation is available via search.cpan.org.

• Git Web: http://git.thegrebs.com/?p=WebService-MobileMe
• Git Clone: http://git.thegrebs.com/git/WebService-MobileMe

Old Google Calendar embed removed.

This wasn’t quite what I wanted and the playTone function expects the notes and timing to be in global variables which makes the baby jesus cry. The premise was simple though. Take the period and divide by two then bring the output high then low for this amount of time, repeat to make up the desired duration.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

int pinSpeaker = 10;

void setup () {
    pinMode(pinSpeaker, OUTPUT);
}

void loop () {
    playTone(750, 500);
    delay(750);
}

// duration in mSecs, frequency in hertz
void playTone(long duration, int freq) {
    duration *= 1000;
    int period = (1.0 / freq) * 1000000;
    long elapsed_time = 0;
    while (elapsed_time < duration) {
        digitalWrite(pinSpeaker,HIGH);
        delayMicroseconds(period / 2);
        digitalWrite(pinSpeaker, LOW);
        delayMicroseconds(period / 2);
        elapsed_time += (period);
    }
}

This simple sketch plays a 500Hz tone for 750 mSec, pauses 750 mSec and repeats. To use it in your sketch simply define pinSpeaker and set it for output, copy playTone to your sketch and call it with the duration in milliseconds and the frequency in hertz.

1
2
3
4
5
6
7

RT 30
REPEAT 3 [REPEAT 3 [FD 100 RT 120] RT 120]
PENUP
FD 100
PENDOWN
RT 90
REPEAT 360 [FD 1.75 RT 1]

The output:

Reading my RSS feeds before bed, I found “My new ticket tracking system is now vaporware” from Matt Wilson’s blog talking about Pitz, his soon to exist Python implementation of Ditz.

Please take a few moments to read over the feature set and example commands on the Pitz site and let Matt know about any ideas/suggestions you may have.

$ perl -MPOE::Filter -E 'say $POE::Filter::VERSION'
1.2357

So I added a quick function to .bashrc:

1
2
3

pm-vers () {
    perl -M$1 -e "print \$$1::VERSION, \"\n\""
}

Now I just run:

$ pm-vers POE::Filter
1.2357