First, update your ~/.ssh/config to be sure that your Host * section has at least this in it:

Host *
	ServerAliveInterval 30
	ServerAliveCountMax 2
	ControlPath ~/.ssh/master-%r@%h:%p
	ControlMaster auto

Second, add this shell script to your ~/bin or wherever you keep your shell scripts:

#!/bin/bash

SSH_OPTIONS=" -MNf"

export AUTOSSH_GATETIME=0
export AUTOSSH_PORT=0

function makefast {
        HOST=$1
        shift
        ADDITIONAL_ARGS=$@

        CMD="autossh -M 0 -f -- $HOST $SSH_OPTIONS $ADDITIONAL_ARGS"
        `$CMD`
}

makefast bamboo@bamboo
makefast gerrit
makefast jira

Edit fastssh.sh and add new lines for the servers you connect to. In my above example, I have 3 servers defined “jira”, “gerrit”, and “bamboo”.

If you want to provide additional SSH arguments like port forwarding, just add them after the hostname/username.

Finally, make sure you install autossh.

Cool, what does all of this mean?

• .ssh/config
  • ServerAliveInterval: 30 – Check that the connection is alive every 30 seconds.
  • ServerAliveCountMax: 2 – If there are 2 consecutive keep alive failures, kill the connection.
  • ControlPath: ~/.ssh/master-%r@%h:%p – The location to save persistent connection information.
  • ControlMaster: auto – If there is a persistent connection, use it. If not, create one.
• autossh – This is a tool, that spawns SSH for you and if SSH quits for an irregular reason, relaunches ssh.

Update: Added explanation of some of the configuration and commands below.

[Discuss at Hacker News]

From the Student perspective:

Most students need word processing. Fewer need spreadsheets. Fewer still need to give presentations.

Options: $20-$60 for iWork on the App Store, paid with your itunes account that your parents probably pay for or $150 for MS Office Student Edition.

Winner: Apple

From the Small Business perspective:

Most businesses need word processing and excel. Few need presentations.

Options: $40-$60 for iWork on the App Store or $280 for MS Office for Home and Business.

Winner: Apple

From Microsoft’s perspective:

Best Buy, OfficeMax, Amazon, etc all need to make some profit. From what I can tell from wholesale prices online, most stores will sell you Microsoft products for 15% off. Obviously these companies are still making a profit. I’m guessing that MS sells wholesale at at least 20% off and 30% off wouldn’t be a stretch.

This kills the argument “Microsoft doesn’t want to give Apple 30%”. They give 30% to everyone else for handling their business, Apple would be no different.

But more important for Microsoft is that they are starting to lose the game. There are Macs and iPads in the enterprise. Some companies use Google Docs. The App Store is simple. Its cheap. Unless you absolutely had to get Office, most people will be buying iWork. I can promise you that Apple Store employees will be telling every new Mac buyer that they can get office software for much cheaper in the App Store, rather than buying it in a box from Microsoft.

Options: Continue to have declining business in the Office arena or slash some prices, join the app store, and give Apple 30%.

Winner: I don’t know what Microsoft will choose, but in the first case, it’ll likely be Apple that wins. In the second case, they both win.

Time will tell.

This morning I came across an article on Lifehacker about converting your router into a wifi repeater, which sounded really cool to me, so I started reading. Unfortunately about halfway down the page I realized I couldn’t care less about this.

Sure, I can reuse that old hardware collecting dust in the garage. But why? To save a few bucks? What happens when I’m at work and my wife is at home with the baby and the thing stops working? Now I’m getting phone calls to do tech support because I saved $100 and can do that one “cool” thing that I never actually needed in the first place.

When I was 13, the hacky free way was always the best way, not because it was free, but because it was fun to tinker. While it is still fun to tinker, some things should just work. My router should just work. My wife, my mom, and my grandma should be able to use it without calling for help.

The same goes for my phone, my “tablet”, and to some extent, my laptop.

The Android argument that you can install whatever you want and that you can even replace the ROM that runs the phone/tablet is insane. 99% of people don’t need that capability. They don’t need the ability to shoot themselves in the foot. I’m sure it would be fun to hack the OS of my iPhone, but at the cost of possibly not making calls? I don’t think so.

In Turbo Hearts, the 10♣ doubles your score final score, the J♦ gives you -10 points (good), the Q♠ is worth 13 points, and each heart is worth 1 point. “Running” is defined as taking the Q♠ and all of the hearts. This is equivilant to “shooting the moon” in regular hearts. Nines are also special in Turbo Hearts; if they are played in suit, they make a trick go around twice. Charging is a technique that happens before a hand begins that has a few effects:

• The charged suite is now worth double. A charged Q♠ is now worth 26pts, a charged A♥ makes all hearts worth 2pts, a charged 10♣ is worth 4x your final score, and a charged J♦ is worth -20pts.
• The charged card must be placed face up in front of the player until they play it
• There is a caviate to charging a card however, you cannot play a charged card on the first trick in suit unless you are forced to do so. An example: You charge the 10♣ and the only other club you have is the 9♣. On the first club trick, you cannot play the 10♣ since you have another club, so you play your 9, making the trick go around again. Now, you have to play a second time and since your 10♣ is the only card in suit, you must play that card.

The game consists for 4 hands with the flow of the game as follows:

1. Passing – in order of the 4 hands: 3 left, 3 right, 3 diagonal, no passing.
2. Charging – anyone with a chargeable card (10♣, Q♠, J♦, A♥) can now charge.
3. Play starts – the person with the 2♣ plays first.
4. Tricks – gameplay continues until all tricks have been claimed
5. Scoring – scoring is tabulated and saved for later; more details below

Scoring may be the most complicated part of playing Turbo Hearts but it is really easy once you get the hang of it. Scoring is performed by totally up everyones points, multiplying if they got the 10♣, making negative if they “ran” and totally it up with the previous tricks. We keep a notebook of scores, with each hand taking a line, the hand total on the left and the cumulative sum on the right. Negatives are wrapped in parens. It looks like this:

These are your hand scores and as you can see, I did really well on the last hand (ran for 248 pts!)

These scores are then kept cumulatively across multiple games and multiple players. Your final game score is calculated by “paying out”. What this means, is your total number of points, you must pay to all other players (and they must pay to you). It is good to have a low hand score but the opposite is true for a game score; higher scores are better.

So the final games scores are:

We keep these numbers are a long term tally. You can just sum up everyones game scores to see their standings.

The best way to think of these game scores is as pennies. In this game, I would be making $7.56 while the others would be paying out $1.46, $2.14, $3.86 respectively.

In my next post, I will lay out some basic strategy, but now you know how to play.

TabNamer @ GitHub

The script is:

This script assumes you have an exchange account and a folder in that exchange account you want to use.

If you want to use an archive folder that is a subfolder of another folder, you’ll want to tweak the script to say something like “to folder archiveFolderName in folder parentFolderName in Exchange account exchangeAccount” and add a parentFolderName variable to the top of the script.

Now all you have to do is save the script in: “~/Documents/Microsoft User Data/Entourage Script Menu Items/Archive\cA“

This will put it in your script menu and set the keystroke ctrl+a to “Archive”.

Enjoy!

What in the world was Apple thinking when you try to upgrade/register/sync your iPhone/iPod and you get “Error: -19″ or “Error: -20″?? What good does this do any one? How am I supposed to fix the problem if I don’t know what the problem is? Isn’t Apple the king of user-friendliness?

When you write software, you should use good error messages. You should use good exceptions. You should use descriptive values.

Granted, some things the user cannot fix. Telling the user the database connection was lost on a web application does very little good for the user. You can however tell the user that an error that was not their fault occurred. At least then I know I can come back and try again later.

Luckily, after rebooting my iPhone I was able to install the recent software update. This may not have been the problem, but certainly Apple could have notified me that I should attempt rebooting.

In any case, be nice to your damn users!

So, assuming you have some unit tests, how useful are they if they don’t test everything? At some level you will want to have a good idea that you’re testing everything. (NOTE: I mean everything really important. Writing perfect 100% coverage like this would likely be too expensive for the entire codebase.) This is where Emma comes in (and more importantly for us, EclEmma, an Eclipse plugin for Emma). Emma is a code coverage tool which lets you visual which parts of your code get executed during some execution (regular or JUnit).

Lets walk through using EclEmma to ensure that we have adequate testing being done. Lets test the following two classes.

GuessTheNumber.java:

import java.util.Random;

public class GuessTheNumber {

	private final Integer value;
	private final int min;
	private final int max;
	private int guesses = 0;
	private boolean solved = false;

	public GuessTheNumber(int min, int max, int value) {
		this.min = min;
		this.max = max;
		this.value = value;
	}

	public GuessTheNumber(int min, int max) {
		this(min, max, getRandomNumber(min, max));

	}

	public int guess(int i) {
		if (solved)
			throw new IllegalStateException();

		guesses++;

		int ret = value.compareTo(i);

		if (ret == 0)
			solved = true;

		return ret;
	}

	public void resetCount() {
		guesses = 0;
		solved = false;
	}

	public int getValue() {
		if (solved == false)
			throw new IllegalStateException();

		return value;
	}

	public int getMin() { return min; }
	public int getMax() { return max; }

	private static int getRandomNumber(int min, int max) {
		return new Random().nextInt(max - min + 1) + min;
	}
}

And SequentialStrategy.java:

public class SequentialStrategy {

    private final GuessTheNumber guesser;

    public SequentialStrategy(GuessTheNumber guesser) {
        this.guesser = guesser;
    }

    public int solve() {
        for (int i=guesser.getMin(); i<=guesser.getMax(); i++) {
            if (guesser.guess(i) == 0)
                return i;
        }

        throw new IllegalStateException();
    }
}

Finally, we’ll write up a basic StrategyTest.java:

import junit.framework.TestCase;

public class StrategyTest extends TestCase {

    public void testSequentialStrategy() {
        GuessTheNumber guesser = new GuessTheNumber(5, 100);
        SequentialStrategy strategy = new SequentialStrategy(guesser);

        int value = strategy.solve();
        assertEquals(guesser.getValue(), value);
    }
}

So the question is, how good is our test? If you installed EclEmma, you can right click on your Unit Test in Eclipse, head to “Coverage As” -> “JUnit Test”

This will run your unit test against your code and when complete, highlight the code green, yellow, or red for covered, partially-covered, and not-covered respectively.

According to EclEmma, our code coverage when running StrategyTest is:

Thats not too bad, lets take a look at the output for SequentialStrategy:

We may want to test the IllegalStateException since we currently don’t and we are expecting it to happen if we’ve guessed everything between min and max and haven’t solved the problem. This would ensure if someone else comes in behind us and changes this code, the unit test will fail if they take that out and change it to return, say, Integer.MIN_VALUE.

Lets also take a look at some of GuessTheNumber:

It appears we also want the contract to include an IllegalStateException being thrown if you have already solved the guessing game. It also looks like we don’t ever call resetCount() and possibly retest after doing that. We also never check if getValue() fails prior to having a solution.

If we modify the test slightly to:

import junit.framework.TestCase;

public class StrategyTest extends TestCase {

    public void testSequentialStrategy() {
        GuessTheNumber guesser = new GuessTheNumber(5, 100);
        SequentialStrategy strategy = new SequentialStrategy(guesser);

        for (int i=0; i<3; i++) {
            try {
                guesser.getValue();
                fail("An exception should have been thrown");
            }
            catch (IllegalStateException ex) { /**/ }

            int value = strategy.solve();
            assertEquals(guesser.getValue(), value);

            try {
                guesser.guess(guesser.getMax() + 1);
                fail("Shouldn't reach this point");
            }
            catch (IllegalStateException ex) {/**/}

            guesser.resetCount();
        }
    }

    public void testBadGuessGame() {
        GuessTheNumber guesser = new GuessTheNumber(1, 10, 3000);
        SequentialStrategy strategy = new SequentialStrategy(guesser);

        try {
            strategy.solve();
            fail("Should not reach this point");
        }
        catch (IllegalStateException ex) { /**/ }
    }
}

And now our code coverage is:

I know this was a very basic example that really didn’t test any complex logic or conditions, but I hope it gives you a good idea of how you can use code coverage to improve your unit tests.

Apparently, you can just click that “Use bright colors for bold text” checkbox and all of a sudden typing things like ls is no longer painful. Just thought I’d share the tip.

That said, after installing the plugin, press Command+Shift+T to name a tab (or use the Name Tab option under the View menu).

NOTE: This has only been tested on Intel Macs with the latest version of SIMBL. If you have a PowerPC and it works for you, I’d love to hear about it in the comments.

Also, due to the nature of me giving this away for free, I cannot guarantee it won’t harm your computer, nor can I promise it will fix your marriage. This is for use AT YOUR OWN RISK. I wash my hands completely of responsibility.

Enjoy!

Terminal Tab Namer v0.1 ALPHA