Programmer Excuses: 1992

Programmer Excuses: 2012

Turns out Google has a page with all of the data center locations, which is just one part of their ‘Data Center’ details area. There are 6 Google data centers in the United States, 2 in Europe, and 3 in Asia. Each data center has a page with more details.

I’m using Chrome 19.0.1084.36 beta as my primary browser, and I noticed something really odd recently. Chrome 19 beta crashes any time I visit stevesouders.com (Steve is the web performance guru at Google).

This isn’t an isolated single tab crash, the whole Chrome browser comes tumbling down. I tried it with Firefox 12 and Safari 5.1.5 and both worked fine.

I think this makes Chrome 19 the worst performing browser when viewing stevesouders.com :-)

The Utah Open Source Conference is back for 2012. This year it is May 3 – 5 at Utah Valley University.

My session, Improving Front End Web Performance, is on Friday May 4th at 11:15am in room 501. If you’ll be at the conference be sure to stop by and say hi.

After using a Sony PSP back in April 2005 I wrote Sony PSP, Can It Do VOIP?. I specifically suggested Skype support:

So VOIP on a PSP. Hmmmm, what would sort of software would you actually use to do such a thing? Then another idea came to mind, Skype. If you could port Skype to the PSP then you’d not only be able to VOIP with your PSP, you’d get all of the other things Skype can do. VOIP to VOIP calls, VOIP to POTS calls, conference calls, file transfers and chat. You’d be limited to where you could get WiFi access, but it’s a start.

With Skype now pwned owned by Microsoft, this seems like a strange time to make this move. I would have expected Microsoft push for Skype support on the Xbox to happen before a competing platform.

class Singleton {
    protected static $instance;

    private function __clone() { }
    private function __construct() { }
    private function __wakeup() { }

    final public static function singleton() {
        if ( !isset( static::$instance ) ) {
            static::$instance = new static();
        }

        return static::$instance;
    }
}

This base class can be extended to create simple singleton classes, like so:

class Example extends Singleton {
    protected static $count;

    public function add( $num = 1 ) {
        $this->count += $num;
        return $this->count;
    }

    public function get_count() {
        return $this->count;
    }

    public function subtract( $num = 1 ) {
        $this->count -= $num;
        return $this->count;
    }
}

Here is what this looks like in action:

echo "COUNT:\n";
$count = Example::singleton();
echo $count->add() . "\n";          // 1
echo $count->add( 4 ) . "\n";       // 5
echo $count->subtract( 7 ) . "\n";  // -2
echo $count->add( 10 ) . "\n";      // 8
echo $count->get_count() . "\n";    // 8
echo "\n";

echo "ANOTHER:\n";
$another = Example::singleton();
echo $another->get_count() . "\n";  // 8
echo $another->add( 2 ) . "\n";     // 10
echo $another->subtract( 3 ) . "\n";// 7
echo $another->get_count() . "\n";  // 7
echo "\n";

There are a few actions that the singleton class specifically fobids:

// Each of these will throw an error
$test = new Example();
$test = clone $count;
$test = unserialize( serialize( $count ) );

You could also do this via traits if you are using PHP 5.4.0 or newer. I wish PHP 5.0.0 had just gone with multiple inheritance in the first place.

It costs 2.4 cents to make each penny.

I’d heard previous statements that it costs more than a penny to make a penny, but this was the first time I’d seen a specific figure. Unfortunately there was no link to reference where that number came from, so I went looking for supporting data. I found it on the United States Mint Annual Report page. Specifically the 2011 Annual Report (PDF), page 11. It breaks down the cost of a 1 cent piece (penny) as:

Making the total cost for a $0.01 piece $0.0241. Not hard to see how the math works against us there. But the Fortune article also made this claim, that I hadn’t heard before:

It also costs more than a nickel to make a nickel, but there’s no movement to discontinue that coin.

So back to page 11 of the 2011 Annual Report for the total cost to produce a nickel:

The cost overrun of a five cent piece is in the same ball park as the one cent piece, with a cost that is 2.236 times the value of the coin. If your reason for wanting to ditch the penny is the crazy cost to value difference then the nickel needs to go as well.

Thankfully the total cost to make a dime ( $ 0.0565 ), quarter ( $ 0.1114 ), and one dollar coin ( $ 0.1803 ) are well below their stated value. But how long would that be true? This got me wondering how long the penny and nickel have been upside down in value. I started going through earlier U.S. Mint Annual Reports to see what could be learned from the cost trends. Lucky for us their site provides data on the costs going back to 2000.

To simplify the issue some what I choose to focus only on the cost of goods sold (COGS) for each coin. I did this for a couple of reasons. First, I felt like it was better to focus on the specific issue of the production costs, instead including administrative and distribution costs. Second, for some years there is no data for administrative costs, making a direct comparison on the total cost unreliable.

Here is the COGS history for the penny:

The same data in graph form:

Penny Cost of Goods Sold

It was 2006 when the COGS for a penny went above one cent, to $0.0119.

Now for the nickel:

And the graph:

Nickel Cost of Goods Sold

I double checked that I had the 2009 number correct because it was such a large dip. That 0.0579 was reported in multiple annual reports, so I’m going to take it as correct. It does leave me wondering why the production cost dropped so much for that one year.

Just like the penny it was 2006 when the nickel COGS, 0.0592, exceeded the value of the coin. And since 2006 their upside down situation has continued to go from bad to worse.

Looking over the production costs for the penny and nickel since 2000 they’ve both gone up in cost dramatically. The penny costs 2.43 times more to produce in 2011 than it did in 2000. The cost of a nickel has gone up 2.99 times during the same time frame.

Focusing only on costs, the penny and nickel really don’t have a leg to stand on. Perhaps instead getting rid of just the penny, rounding to the nearly five cents, we should stop using nickels too. That would leave us with rounding to the nearest ten cents, which gives me an idea.

What if, instead of getting rid of the coins, we took a one time across the board reduction in value of 10% for everything? Move the decimal place to the left for everything on the same day, say 1 Jan 2015. Your $200,000 mortgage would then only be $20,000. The $10,000 in your savings account would become $1,000. And the $0.0197 cost for a penny would become $0.00197.

Instead of getting rid of pennies and nickels because they are basically worthless and cost more to produce than their stated value, they’d instantly become valuable again. Practical? Perhaps not, but in some ways simpler than adjusting everything to the nearest five or ten cents.

The idea of having a built-in framework that takes care of updates for you, on the fly, is compelling. I also liked the example of being able to work with the MongoDB data right from the client (that also scares me).

I’m not ready to abandon all other web development platforms and move strictly to Meteor, but I’ll definitely be watching it. I’d like to dig deeper into the details of what makes Meteor tick.