For the last week, working through this project, I’ve re-learned and learned quite a lot about HTTP requests, Ant, DTD/XSD, and XPath, and I feel much more comfortable dealing with those now than I did a week ago. It’s a good feeling to have learned and done something new that’s kind of on the cutting edge of things, and to have fun doing so too! Ah, I sound so corny. Anyway, I can’t wait to get more involved with the company that this project is for and delve into some code that has a lot of potential and fun-value. I’m just waiting on approval from the developers now, but so far things look good. Wish me luck! =)

Hopefully these changes plus the smackdown on spam will encourage me to blog some more. (Comments will still be moderated until I am sure spam is under control.)

Now for some miscellaneous things:

In the meantime, for my reference, I like to keep two aliases for my bash shell:

alias ll='ls -l'
alias ls='ls -aG' # for the BSD ls
alias ls='ls -a --color=auto' # for the GNU ls

I also like to change the default color for directories (blue) to cyan when in BSD (cyan foreground not otherwise used) so that I can see it better.

export LSCOLORS="gxfxcxdxbxegedabagacad"

In GNU ls, there is a different method and cyan is used for symbolic links, so rather than have two different colors for directories, which I see far more often than symbolic links, let’s change the directory color to blue and symbolic link color to yellow:

—-I’ll finish this up soon—-

For compiling a Java program using Cygwin and including the jxl.jar library (typical bin, lib, src setup):

#!/bin/bash
javac -cp `cygpath -wp lib/jxl.jar:.` -d bin $(find src -name '*.java')

For running a Java program using Cygwin and including the jxl.jar library (two parameters passed):

#!/bin/bash
java -cp `cygpath -wp lib/jxl.jar:src/:.` main.class.Name $1 $2

For running the above Java program on a Mac without the Mac top menu bar and with a specified dock name:

#!/bin/bash
java -cp lib/jxl.jar:src/:. -Dapple.laf.useScreenMenuBar=true
-Xdock:name="Program Name" main.class.Name $1 $2

Note to self: <pre> tags do not have word wrap. Consider using a special scrollable text field or plugin for displaying code.

Apache Commons has one, but it was kind of annoying. It left a lot for me to do. I kept looking and found args4j and thought it looked really neat. It makes good use of Java 5 annotations, which I have seen in action when writing a class JSF project. I tried it out, and after a little trouble learning what the annotation parameters meant (hint: see the javadoc for @Option), and with the help of Eclipse’s automatic getter generator, I got my command line parser up and running in minutes! Ah, the magic.

Here is the code, simple and sweet:

CommandLineValues.java:

import java.util.Random;

import org.kohsuke.args4j.Argument;
import org.kohsuke.args4j.Option;

public class CommandLineValues {

	/** Max value for the random seed (minimum is 0). */
	public static final int MAX_RANDOM_SEED = 1000;

	/** Valid options for the experiment type */
	public static enum ExptOption {
		DEGREES,
		FEATURES
	};

	@Argument(required = true, index = 0, usage = "type of experiment")
	private ExptOption exptOption;

	@Argument(required = true, index = 1, metaVar = "FILE",
			usage = "the config file for the experiment")
	private String configFileName;

	@Option(name = "-r", aliases = { "--resultsDir" }, metaVar = "DIR",
			usage = "directory to place the results file")
	private String resultsDir = "results/";

	@Option(name = "-s", aliases = { "--seed" }, metaVar = "VALUE",
			usage = "seed to use for the program's random number"
			 + generator")
	private int seed = (new Random()).nextInt(MAX_RANDOM_SEED + 1);

	// getters for all of the fields
}

The first and second arguments (exptOption and configFileName) are required; their order is set by the index parameter. The other two arguments are optional and have both a short single-dash flag (the name parameter) and a longer double-dash flag (the aliases parameter, which can contain any number of strings). The metaVar parameter describes the type of the argument in short, and the usage parameter describes the value of the argument.

Here is code showing how CommandLineValues.java is used.

Main.java:

public static void main(String[] args) {

	// parse the command line arguments and options
	CommandLineValues values = new CommandLineValues();
	CmdLineParser parser = new CmdLineParser(values);
	parser.setUsageWidth(80); // width of the error display area

	try {
		parser.parseArgument(args);
	} catch (CmdLineException e) {
		System.err.println(e.getMessage());
		System.err.println("java DotsMain [options...] arguments...");
		// print the list of available options
		parser.printUsage(System.err);
		System.err.println();
		System.exit(1);
	}
	// use the getters
}

Awesome! =)