(Thread/setDefaultUncaughtExceptionHandler
   (reify Thread$UncaughtExceptionHandler
     (uncaughtException [this thread throwable]
       ;; do something with the exception here.. log it, for example.
       )))

Leiningen

Most Clojure projects use Leiningen as their build and dependency management system. Project dependencies and their required versions are placed in a file called project.clj, and Leiningen takes care of downloading them. Leiningen also creates JARs of the release versions of your project, and can bridge to Emacs’ SLIME mode, run a REPL at the command line, and so on. Many plugins exist to extend Leiningen’s functionality for other things like testing and deployment.

Under the covers, Leiningen uses Maven for dependency management. Maven is one of those ridiculously over-engineered Java projects that we all love to hate where you have to write 100 lines of XML boilerplate around 2 lines of actual project-specific configuration data. Fortunately, Leiningen insulates us from all of that.

Users should be aware that, as of this writing (May, 2012), Leiningen is about to release version 2.0, which uses a slightly different project.clj format. Some Leiningen plugins have not been updated for the new format. This is easy enough to work around if you know that there has been a specification change. In particular, many :dev-dependencies that affect Leiningen itself have to be moved to the new :plugins key.

Clojars and GitHub

Most Clojure libraries are provided in binary JAR format on Clojars, and have their source code hosted on GitHub.

Clojure developers frequently face the situation where some critical bugfix or new feature exists only on somebody’s GitHub fork, but not in the mainline repository. The best option in this case is to get the maintainer to push a new official release with the required changes, but this is not always possible. If the project has a slow release cycle, or if the original developer is not very into the project, it can be months between the creation of patches in a fork and their release from the mainline repository to a new version on Clojars. We have a few options in that case.

For development, it can be convenient to use the lein-git-deps plugin. This extends Leiningen to allow it to download dependencies from GitHub into a hidden directory in your project. This is something of a fragile hack, though. If the subproject has any dependencies, they will not be checked out by Leiningen — you have to manually install them in the parent project. Worse, the code on GitHub can change at any time (unless you specify a particular release). If you redeploy your code in the future, you might wind up with a broken project. If it’s impractical to get the maintainer of a library to produce a new official release, it’s best to fork the library and make your own stable release.

If you just want to use it locally, check out your fork to your local machine, bump the version number, and do lein install. Within your organization, you can easily host a private Maven repository. If you want to deploy publicly, you can push a forked release to Clojars with a different group-id. Detailled instructions on how to do these things can be found in the Leiningen documentation.

Add an Apache Commons Compress dependency to your Leiningen project.clj file like so:

(defproject bz2reader "0.1.0-SNAPSHOT"
  :dependencies [
                 [org.clojure/clojure "1.3.0"]
                 [org.apache.commons/commons-compress "1.4"] ;; Read/write compressed files (BZip2, etc.)
                 ])

Then, you can make a BZip2 capable reader-generating function as follows:

(ns bz2reader.util
  (:require [ clojure.java.io :as io])
  (:import (org.apache.commons.compress.compressors.bzip2 BZip2CompressorInputStream)
   ))


(defn bz2-reader
  "Returns a streaming Reader for the given compressed BZip2
  file. Use within (with-open)."
  [filename]
  (-> filename io/file io/input-stream BZip2CompressorInputStream. io/reader))

This is based on a line from the fs utilites project, which includes a function to uncompress the file on disk. Rather than send the output of our BZip2 stream to a copy function which writes it to disk, we just return the stream for the user to use in the program. You can use the BZip2-enabled stream with any of the normal Clojure I/O methods, just like any other stream.

Here’s an example of how you can print the contents of a BZip2-compressed file to stdout using the above function:

(defn print-bz2-file [filename]
  (with-open [rdr (bz2-reader filename)]
    (doseq [line (line-seq rdr)]
      (println line))))

It’s easy to create similar readers for GZip files, zip files, and so on using the other Apache Commons Compress classes. You can also write BZip2 compressed files similarly, just by piping your regular OutputStream through the encoder.

First, set up your project.clj file to load the appropriate libraries:

(defproject my-project "1.0.0-SNAPSHOT"
  :description "My Project"
  :dependencies [
                 [org.clojure/clojure "1.3.0"]

                 [log4j/log4j "1.2.16" :exclusions [javax.mail/mail javax.jms/jms com.sun.jdmk/jmxtools com.sun.jmx/jmxri]]
                 [org.slf4j/slf4j-log4j12 "1.6.4"]
                 [org.clojure/tools.logging "0.2.3"]                 
                 [ clj-logging-config "1.9.7"]
               
                 ])

Then, run lein deps to fetch these dependencies, and just add a line like the following to your code:

(ns my.namespace
  "Logging setup"
  (require [ clj-logging-config.log4j :as log-config]
           [ clojure.tools.logging :as log]))


(log-config/set-logger! :level :debug
                        :out (org.apache.log4j.FileAppender.
                              (org.apache.log4j.EnhancedPatternLayout. org.apache.log4j.EnhancedPatternLayout/TTCC_CONVERSION_PATTERN)
                              "logs/foo.log"
                              true))

(log/info "This is a test log message.")

This will get you started with some basic logging to logs/foo.log

If you want log rotation, use the DailyRollingFileAppender class instead of FileAppender. Many other setups are possible, too, such as logging to Syslog or logging to a socket. Take a look at the subclasses of AppenderSkeleton to get an idea of what’s there.

If you use the TTCC_CONVERSION_PATTERN as above, each line will automatically be prepended with the elapsed time since program start, thread name, severity, category, and “nested diagnostic context.” It’s easy to make your own prefix format; take a look at EnhancedPatternLayout for the options.

Check the clj-logging-config docs and its examples for more ideas. You may also need to delve into the Log4J JavaDocs.

Coming soon: how to colorize your logs.

Paragraph after paragraph of heart-rending, maudlin emotional manipulation over the tragic fate of the cherubic little scholar whose only wish is to learn math, but whose test scores will inevitably fall below those of his classmates due to his Dickensian plight; hungry, cold, and homeless, yet cruelly expected to learn as well as his advantaged peers, though his frozen little fingers are too numb to grip a pencil and his stomach rumbles even after the meagre gruel the school provides him for breakfast…

Then, an entire section is devoted to exploring the city’s budget for accommodating homeless people at public expense, the message being that the government is failing in its responsibility to this kid by not providing free housing for him and his family.

Not a word is mentioned about any parental responsibility for getting their kid into this situation, nor for their responsibility to get the kid out of it. In fact, his parents are barely mentioned at all, other than to say that they sold all their possessions and moved to SF in September because his dad thought he had a job lined up which didn’t work out.

What compelled them to pack up and move without any savings? Was it bad luck, desperation, stupidity, some combination of the above? Are they looking for work? Do they have friends or relatives in other cities? Did their savings run out? Were there unexpected medical expenses or something like that? They’ve only been there for a few months, if the job didn’t work out, why don’t they move somewhere less expensive to live than the second-most-expensive city in the US, and to somewhere with better employment prospects for non-professionals? Why are they staying in San Francisco rather than moving somewhere cheaper? Who knows? The reporter didn’t even ask any of these questions.

To be absolutely clear, I am not against emergency public assistance to help those genuinely in need get back on their feet and begin to help themselves. Perhaps the family genuinely does need and deserve help. I don’t know; the reporter didn’t bother to tell us.

What I am against is the notion that the government (that is, the taxpayer) ought to function as a free-flowing money spigot without limits for anyone, forever. This is the mindset that informs both this article and the left wing of the Democratic Party generally. The only question asked is, “why is the government not doing more to help these people?” This could be a great question to ask in certain contexts. It should not stand alone as the only question to ask. The government should help, yes; but it should not be the primary responsible party. The key element of personal and parental responsibility is entirely absent from this discussion.

It didn’t even occur to the reporter to ask such very basic questions about their situation because these more extreme versions of the postmodernist-liberal worldview include a complete abdication of all personal responsibility for one’s situation in life. The individual is considered a mere kite in the social wind whose thin tether has broken loose, buffeted about by forces entirely beyond his control and with which only a massive and benevolent government bureaucracy can possibly contend. It’s all up to the government to save this family from the consequences of their bad luck and poor planning, to the extent that questions revolving around the details of the situation are not considered worth mentioning at all, in favor of a discussion of how woefully little money the government is spending on fixing the situation.

Indeed, the notion that government spending programs are the sole answer to this situation is taken entirely for granted in that article and not even an issue; the only point of contention is exactly how much more than present levels the government ought to be spending to fix things. Even then, “the government finding the parents jobs” is not floated as a solution; the government ought to just give them a free apartment for as long as they like, apparently.

Anyone who dares suggest that parents have any sort of primary responsibility to provide for their kid rather than the city government and the taxpayer is dismissed out of hand by the far-left as a cruel and unfeeling monster, etc.

Well, awareness of the deeper dynamics is the first step towards halting this trend. There you go.

Libyan Oil Production

• Prewar Libyan oil production capacity ≈ 1.8 million bbl/day in 2010.
• Prewar Libyan oil actual production in 2010 ≈ 1.65 million bbl/day. (ibid.)
• Libyan Proven reserves ≈ 46.4 billion barrels. (ibid.)
• Libyan reserves tend to be high quality light (high API gravity), sweet (low-sulfur) oil. (ibid.)
• “the vast majority” of Libyan oil is exported to Europe (85%); 5% is exported to the US. (ibid.)
• Libyan oil sells for an average price of $117.13 per bbl, as opposed to the world average of $113.87. For reference, Saudi light (high-quality) goes for $114.87; Saudi heavy (low-quality) oil goes for $110.43/bbl; and Mexican Maya heavy goes for $103.29 / bbl.
• For comparison:
• US domestic proven reserves ≈ 20 billion barrels.
• US domestic daily production ≈ 7.48 million bbl /day.
• Saudi production ≈ 9.78 million bbl/day.
• Saudi proven reserves ≈ 266.7 billion bbl. (ibid.)
• World oil production ≈ 86.8 million bbl/day.
• World proven reserves (2009) ≈ 1,341 billion bbl.
• The US government estimates that OPEC immediately available surplus production capacity is 1.5 to 2 million bbl/day, excluding Iraq and Venezuela; over half of this capacity is in Saudi Arabia.
• The Saudis claim to have surplus capacity of 4 million bbl/day.
• Western oil companies are well represented in Libya (“Eni, Total, Repsol YPF, StatoilHydro, Occidental, OMV, ConocoPhillips, Hess, Marathon, Shell, BP, ExxonMobil and others.”)

Cost of NATO intervention in Libya

• £260 million to the end of June to Britain
• $716 million through June 3rd to the US alone.
• €160 million to France through July 10th.
• Operations began March 17th.)

Libyan oil production analysis

#!/usr/bin/env ruby
#
# torrentdump - prints the contents of a torrent.
#
# Copyright (C) 2011 Paul Legato. All rights reserved.
# Licensed for personal, non-commercial use only.
# This code comes with NO WARRANTY, express or implied.
#
# Prerequisite gem setup:
#   sudo gem install bencode awesome_print
#

require 'rubygems'
require 'bencode'
require 'awesome_print'

unless ARGV[0]
  STDERR.puts <<END

Usage: torrentdump <filename> <-v>

If -v is given, prints the entire contents of the torrent except the binary "pieces" hash data.

If -vv is given, prints everything, including the binary hash data.

Otherwise, prints only the file list.

END
  exit 1
end

# Method from http://stackoverflow.com/questions/3201890/is-there-an-elegant-way-to-remove-a-specific-key-from-a-hash-and-its-sub-hashes
def recursive_delete!(hash, to_remove)
  hash.delete(to_remove)
  hash.each_value do |value|
    recursive_delete!(value, to_remove) if value.is_a? Hash
  end
end

data = BEncode.load(File.read(ARGV[0]).force_encoding("binary"))

if ARGV[1] == "-vv"
  ap data
elsif ARGV[1] == "-v"
  recursive_delete!(data, "pieces")
  ap data
else
  if data["info"]["files"]
    dir = data["info"]["name"] || ""
    ap data["info"]["files"].map {|x| dir + "/" + x["path"].join("/") }  
  else
    ap data["info"]["name"]
  end
end

A quick example:

% torrentdump ubuntu-10.04.2-server-i386.iso.torrent 
"ubuntu-10.04.2-server-i386.iso"

Torrent dissection: of interest here..

• Ruby 1.9 imposes a character encoding on every string by default. This is fine for dealing with text, but caused errors in the BEncode library. (For some reason, the authors of BitTorrent chose to re-invent the wheel and developed their own binary encoding format.) We use the #force_encoding method on the torrent data to make Ruby treat the data as raw binary data and not try to interpret it.
• More than you ever wanted to know about what’s inside a .torrent file

The Torrentdump source code is available on GitHub.

They’re not “stories”. They’re tests. They don’t tuck you into bed with a glass of warm milk and a nice fairytale to dream about; they assert that certain things should happen and complain when they don’t, in a purely mechanical and precise way. We’re programming computers, machines of pure logic here, not reading to children. Let’s dispense with the pointless cutesy façade and focus precisely on the task at hand.

They don’t deliver what they promise, anyway. Frameworks like RSpec and Cucumber do not let you write tests in “plain English”. They let you write tests in a horrible chimeric programming language that adopts a superficial English-like veneer over top of what’s essentially a regular old unit testing framework.

It winds up giving you the benefits of neither English nor a well written testing API; your code simply becomes excessively verbose for the sake of a (highly fake and brittle) natural language veneer. You’re still highly restricted in what you can say, just like a regular old programming language. The set of Englishisms that you can use is so grossly restricted and precisely defined that you can’t think in anything remotely like English. You have to memorize a precise set of rigid, fixed English labels and use that and only that. You do get the verbosity of natural language, though, along with the restricted semantic domain of the API. You get the benefits of neither and the disadvantages of both.

Since you’re memorizing a highly restricted API anyway, skip the twee cruft and just use a short and precise API from the start, without the pseudo-natural language clutter.

Free mp3s/FLACs/etc are available on my Bandcamp site.

Cocos2d makes it easy to convert your drab standard UIAlertViews into glorious customized color dialog boxes. Above is an actual UIAlertView / custom dialog box transition from my upcoming iPhone game. Here’s how I did it.

Implementing a Custom Dialog Box in Cocos2d

Cocos2d Scene Structure

Cocos2d uses a scene graph to hold everything being displayed at any given point in a game. Informally, this data structure is a hierarchy of objects, each of which might display something onscreen, contain other objects to be displayed onscreen, or both. In Cocos2d, these objects are descendants of the CCNode class.

Related objects can be placed into a single container object, which allows them all to be manipulated as a unit when necessary. The root, or lowest-level, container at any given time is an instance of the CCScene class. A CCScene contains CCLayer objects, which themselves contain other objects such as menu labels or sprites to be displayed. Layers, as the name implies, are displayed superimposed upon each other onscreen, which makes a CCLayer perfect for our custom dialog box.

Custom CCLayer

Here’s the code for DialogLayer.h and DialogLayer.m. These implement a basic but perfectly servicable custom iPhone dialog box. It can be used as-is or expanded in any number of ways for particular situations. Take a look through the finished product, and then we’ll go over it below.

DialogLayer.h

//
//  DialogLayer.h
//  concentrate
//
//  Created by Paul Legato on 12/4/10.
//  Copyright 2010 Paul Legato. All rights reserved.
//

#import <Foundation/Foundation.h>
#import "cocos2d.h"

@interface DialogLayer : CCLayer {
  NSInvocation *callback;
}

-(id) initWithHeader:(NSString *)header andLine1:(NSString *)line1 andLine2:(NSString *)line2 andLine3:(NSString *)line3 target:(id)callbackObj selector:(SEL)selector;
-(void) okButtonPressed:(id) sender;

@end

DialogLayer.m

//
//  DialogLayer.m
//  concentrate
//
//  Created by Paul Legato on 12/4/10.
//  Copyright 2010 Paul Legato. All rights reserved.
//

#import "DialogLayer.h"
#import "GameSoundManager.h"

#define DIALOG_FONT @"bicho.fnt"

@implementation DialogLayer
-(id) initWithHeader:(NSString *)header andLine1:(NSString *)line1 andLine2:(NSString *)line2 andLine3:(NSString *)line3 target:(id)callbackObj selector:(SEL)selector
 {
   if((self=[super init])) {

     NSMethodSignature *sig = [[callbackObj class] instanceMethodSignatureForSelector:selector];
     callback = [NSInvocation invocationWithMethodSignature:sig];
     [callback setTarget:callbackObj];
     [callback setSelector:selector];
     [callback retain];

     CGSize screenSize = [CCDirector sharedDirector].winSize;
     
     CCSprite *background = [CCSprite node];
     [background initWithFile:@"Dialog.png"];
     [background setPosition:ccp(screenSize.width / 2, screenSize.height / 2)];
     [self addChild:background z:-1];


     CCLabelBMFont *headerShadow = [CCLabelBMFont labelWithString:header fntFile:DIALOG_FONT];
     headerShadow.color = ccGRAY;
     headerShadow.opacity = 127;
     [headerShadow setPosition:ccp(243, 262)];
     [self addChild:headerShadow];

     CCLabelBMFont *headerLabel = [CCLabelBMFont labelWithString:header fntFile:DIALOG_FONT];
     headerLabel.color = ccBLACK;
     [headerLabel setPosition:ccp(240, 265)];
     [self addChild:headerLabel];

     //////////////////

     CCLabelBMFont *line1Label = [CCLabelBMFont labelWithString:line1 fntFile:DIALOG_FONT];
     line1Label.color = ccBLACK;
     line1Label.scale = 0.84f;
     [line1Label setPosition:ccp(240, 200)];
     [self addChild:line1Label];

     CCLabelBMFont *line2Label = [CCLabelBMFont labelWithString:line2 fntFile:DIALOG_FONT];
     line2Label.color = ccBLACK;
     line2Label.scale = 0.84f;
     [line2Label setPosition:ccp(240, 160)];
     [self addChild:line2Label];

     CCLabelBMFont *line3Label = [CCLabelBMFont labelWithString:line3 fntFile:DIALOG_FONT];
     line3Label.color = ccBLACK;
     line3Label.scale = 0.84f;
     [line3Label setPosition:ccp(240, 120)];
     [self addChild:line3Label];

     CCMenuItemImage *okButton = [CCMenuItemImage itemFromNormalImage:@"OKButton.png" selectedImage:@"OKButtonSelected.png" target:self selector:@selector(okButtonPressed:)];
     [okButton setPosition:ccp(0, 60)];

     CCMenu *menu = [CCMenu menuWithItems: okButton, nil];
     menu.position = ccp(240,0);
     [self addChild:menu];
   }
   return self;
 }

-(void) okButtonPressed:(id) sender
 {
   [[GameSoundManager sharedManager].soundEngine playEffect:@"OK.caf"
                                    pitch:1.0f
                                    pan:0.0f
                                    gain:1.0f];

   [self removeFromParentAndCleanup:YES];
   [callback invoke];
 }


-(void) dealloc
 {
   [callback release];
   [super dealloc];
 }
@end

Custom dialog box code analysis

Overview

The dialog box is implemented as a subclass of CCLayer. An initWithHeader method is provided to initialize the layer with a given message and a specified callback method that will be invoked when the dialog’s “OK” button is pressed. It also plays a confirmation sound and switches the “OK” button’s image to a “pressed button” when the user taps it.

DialogLayer.m requires a few external supports, which must be available as project resources. Dialog.png is the dialog box’s background image. bicho.fnt is an AngelCode format bitmapped font, used for the labels, and can be substituted with any font you like. OKButton.png and OKButtonSelected.png are the images to be used for the button in unpressed and pressed forms. Finally, OK.caf is the audio file to be played when the user taps the button.

Analysis

Storing the callback

     NSMethodSignature *sig = [[callbackObj class] instanceMethodSignatureForSelector:selector];
     callback = [NSInvocation invocationWithMethodSignature:sig];
     [callback setTarget:callbackObj];
     [callback setSelector:selector];
     [callback retain];

This code is Objective C’s (massively redundant) way of storing the callback to be activated when the dialog’s button is pressed. It’s based on the callback code in Cocos2d itself. (We could also have used Objective C’s new closure data type, called “blocks”, but that syntax grates my Lispy sensibilities even more than the overly verbose Javaish mess here, besides not working out of the box on older versions of iOS.)

The initWithHeader method is given a target object and a method selector. It looks up the class of the target object and then looks up the selector on that class at line 1, resulting in a NSMethodSignature object which encapsulates the class-method combination. Line 2 transforms that class-method signature into an “invocation,” which represents the act of actually calling that method on some as yet unspecified object. Line 3 associates the invocation with the particular target object we were given, and line 4 associates the selector (which is utterly odd, since the desired method is encoded in the signature object already.) Finally, we retain the callback so that we can save it for later (to be activated when the user actually presses the “OK” button) and it won’t be deallocated at the end of the present scope.

Setting up the background and labels

The remainder of the initWithHeader method, lines 25 to 68 in the main listing above, is pretty straightforward. A CCSprite object is created to store the background image and added to self, that is, to the new custom layer being created. Its position is set to be the center of the screen, and its level on the Z axis is set to -1 so that it will appear below anything else added in the layer.

CCLabelBMFonts are then created for the given text and added to the new layer. A shadow effect is created for the header by writing the same thing in grey at a slight offset underneath the main text. All lines except the header are then scaled down to 0.84 of their natural size, so as to enhance the prominence of the header.

A CCMenuItemImage is finally created to be the “OK” button. It’s added to a CCMenu, which handles the logic of button presses for us, and the CCMenu is then added to the new layer. It will take a little experimentation to get the exact placement of the OK button correct (lines 64 and 67) relative to your background image.

Note that the OK button itself takes callback arguments of exactly the same type that our initWithHeader method does (line 63). We might be tempted to forego the construction of our own callback object and just pass the given target and selector on to the OK button, simplifying the design of our DialogLayer a bit, but then we wouldn’t have the chance to play a sound when the OK buton is pressed. More seriously, we would have no way to destroy the dialog layer and remove it from the screen. So, we give the OK button a target of self and tell it to call the okButtonPressed method when OK is pressed.

The okButtonPressed callback

The CCMenuItemImage will invoke this method when the user presses “OK”. This means that it’s time to remove the DialogLayer from the scene (easy enough, line 80). Here, we also play a little click-type sound to make the game seem more interactive; also easy with CocosDenshion, lines 75-78. If you don’t want to play a sound, you can remove those lines and the GameSoundManager.h include file.

dealloc

Nothing fancy here; we just release our retained callback object and then defer to super.

Using the custom DialogLayer

Adding a custom dialog layer to your game scene is very easy:

   CCLayer *dialogLayer = [[[DialogLayer alloc] 
                            initWithHeader:@"Level 1" 
                            andLine1:@"Tilt The Phone" 
                            andLine2:@"To Balance" 
                            andLine3:@"The Ball!"
                            target:self
                            selector:@selector(beginLevelOne)] autorelease];
   [self addChild:dialogLayer z:200];

Future Expansions

DialogLayer is a simple modal dialog box that can only accept one action from the user. It can easily be enhanced in many ways, depending on your needs. The most obvious enhancement is to add multiple buttons to allow the user to make a choice rather than simply dismissing the box. It could be modified to accept an arbitrary amount of text and divide it up automatically into an aesthetically pleasing configuration.

One thing that DialogLayer does not do is pause the game. I decided that that is not necessarily desirable in all cases; many game scenarios need to present information to the user without stopping the action. It’s easy enough to pause manually when activating the dialog.

Little enhancements like this are critical as ‘polish’ for your game.