Witty Keegan

GMaven 1.4 Released today!

2012-01-07T18:57:00.000-05:00

As many of you already know, I've joined the GMaven team and have been working with Jason to push a new release out. We're pleased to announce that the long overdue 1.4 release has been released today. You'll find the artifacts in their usual place. The release announcement can be seen here. I didn't have it set up when I sent the announcement, but starting now everything is also available through Nabbble.

I'm still thinking about what 2.0 should look like, and I'm not sure if 2.0 or 1.5 will be released next. The latter is looking more likely as I think it will take some time to do a major rewrite and there are some issues that don't look too terribly difficult to get resolved that I'd like to make available to the community as soon as I can. I do promise whatever and whenever the next release is, that I won't let things get as behind as they did between 1.3 and 1.4 and as long as Groovy and Maven continue to be relevant in the industry (something I don't see changing any time soon), you can count on your friends at GMaven to provide the tools you need to do your job.

Running Lego Mindstorms RIS 2.0 on newer windows

2011-12-28T22:56:00.002-05:00

While getting my old Lego Mindstorms (an RCX 2.0 setup) set up for my little brother to play with, I learned some thigns about using it with newer versions of Windows (Windows 7 in my case). I found out here that there is a patch needed for the USB IR tower, which resolves the problem of the system locking up when the tower is plugged in. You can download it here: http://cache.lego.com/downloads/education/tower164.zip.
After installing this, things will run fine, unless you decide to use the official program and launch it more than once.. At which point you will see a message like "A critical error has occurred. You may be running out of memory, or you may needto reinstall Robotics Invention System 2.0." The solution to this is a bit more messy. There is a file left behind here
Vista/Win7: C:\Users\\AppData\Local\Temp\Ris 2.0.mov.#res
XP: C:\Documents andSettings\\Application Data\Temp\Ris 2.0.mov.#res
This file must be deleted each time before the program is launched. What I did was create a batch script to do this, and a Visual Basic script to launch the batch script (so it could happen without launching a command prompt window).
You'll find both scripts here: https://gist.github.com/1531705
I recommend replacing all shortcuts to theLaunchRis2.exe with a shortcut to the Visual Basic script. Note that the VB script assumes you will put put the batch script in %PROGRAMFILES(X86)%\LEGO MINDSTORMS\launchRis.bat (or %PROGRAMFILES%\LEGO MINDSTORMS\launchRis.bat on a 32 bit system), but you can easily edit the script to change the location.
Of course, this second problem is irrelevant if you decide to write the programs youself (I preferred this over the graphical tool Lego provided). There are several languages available.
Let me know if you have suggestions for improvement or run into any issues.

Introducing GMavenPlus

2011-09-02T16:45:00.000-04:00

As some of you already know, I'm now fairly far along in the process of rewriting the GMaven plugin (which I've dubbed GMavenPlus for lack of a better name). My intent was to allow the user more control over the configuration (something which I'm still improving on), to simplify the plugin to make future maintenance easier, and to try to breathe new life into an abandoned project. This last reason was a pretty big motivator for me. Their wiki page currently reads "This project is no longer under active development, although it is still in wide use.". No project's page should ever say that, especially one as important as Maven support for a language (and a language I consider pretty important in the Java community at that, it's surprising the Groovy guys haven't addressed this). Another fairly big motivator was that one of the biggest complaints people have about GMaven (other than it's not being updated) was that some people (I was never one of them) have had issues with Java stubs being incorrectly generated. This actually isn't GMaven's fault. There are issues with Groovy's tooling. So I felt it was important to expose the GroovyDoc tool as an alternative, since that's why most folks need the stubs anyway.

I also had this idea that perhaps the Maven project using the plugin should control the version of Groovy used for compiling, etc, and not the plugin itself (in this way, it'd be similar to how the groovyc Ant task works). This is a cool idea, but I don't yet know if it's a bad idea. Neither Scala's Maven plugin or Clojure's Maven plugin currently work this way. The next best alternative to this idea I think would be Jason Dillon's idea (he is the author of the original GMaven).

I've still got a ways to go before this is ready to see production (I pretty much hacked this together as fast as humanly possible just to see if my idea could work), so I'd be grateful for any suggestions/criticisms/etc you might have. I'm new to writing Maven plugins (and using git :) ) and have very little interest in compilers, so this whole thing has been a pretty foreign but interesting experience.
Please check it out and help me by providing feedback or contributing to the wiki: http://github.com/keeganwitt/GMavenPlus.

Oh, and for those wondering: I am trying to get Jason Dillon's opinion on this idea. But I haven't really heard anything one way or another on this as of yet. He's a busy guy and doesn't really want to work on GMaven anymore. Which is cool, as long as somebody is
And while I would like to get this added to (or at least linked on) CodeHaus I haven't been in contact with them about doing this yet (I wanted to be a little more sure this is actually usable first). I'll probably drop a note on the dev list first to see what kind of resistance I'll get there :P first.

Update: I'm discussing this with Jason and the Codehaus guys now: http://groovy.329449.n5.nabble.com/GMaven-Rewrite-td4785090.html

A userscript for Viewvc

2011-09-01T12:58:00.000-04:00

I've posted a userscript I've written as a workaround for a request for ViewVC that hasn't been done yet (despite the fact a patch has already been submitted). The missing feature is a link to the log view for directories.

A few Autohotkey scripts

2011-09-01T12:27:00.000-04:00

I decided to post the source for a few Autohotkey scripts a couple of days ago:

GW Tonic Bot : This one is a bot to drink tonics for you in Guild Wars to help you get your Party Animal title. It maps back and forth between your Guild Hall and drinks 2 tonics (yes, 2 tonics because of a bug in GW) each time it stops.
GW Drunkard Bot : This one was meant to drink alcohol at specific intervals to achieve optimal points towards your Drunkard title. This was made obsolete by the March 3, 2011 update. You can now click them (or have an autoclicker click them) as fast as you want.
Generic Autoclicker : This one can be for any kind of automated clicking, it just clicks (or double clicks) where you tell it to at an interval you specify.

Note that I haven't tested them in IronAHK, only Autohotkey on Windows. Also note that it's also easy to convert these to an .exe file if you don't want to install Autohotkey. And if a non-techie is reading this, I'm happy to provide that for you. Just leave a comment below.

Also feel free to comment (or fork) either of these scripts if you have improvements. Some people have found that the delay between mappings in the tonic bot is not long enough for slower internet connections and so you have to tell it to drink more tonics than you'd think (since some clicks will be wasted).

Musical Amateurism

2011-08-01T01:40:00.002-04:00

Warning: the following is at rant on the state of pop music that shamelessly derides the music industry. Reader discretion is advised.

I've been thinking about music and musical instruments lately. And it occurred to me how odd our current musical experience is. One of the oldest recorded songs in history dates back to about 1400BCE, but it's likely unrecorded music existed long before that. My point being that music has always been a very pervasive element in our cultures. It was performed by average Joes for average Joes, where many (if not all) of the listeners actively took part in the experience. But this is not reflected in our current musical culture. We now only passively engage with the music with our stereos, ipods, etc. And it is largely no longer done by amateurs. Teams of professionals (of whom the actual artist is often only a small part, as in the case of pop singles). And the industry that has been built to protect this corporatizing (like the RIAA) and wanting money practically every time someone sings one of their songs is also downright odd, when viewed in the context of most of our musical history. How can you copyright something so quintessential to the human experience? (By the way, the RIAA has yet to share a single penny of the settlements they've won with the artists they're supposedly protecting, I refuse to buy an album released by the RIAA).

I think this decline in musical amateurism started with the end of the Baroque period of music, when music began being performed by people whose profession was music and the instruments of choice became more complex (for example, the decline of the recorder). This was partly because of the growing world economy that made more leisure time possible. Whereas in the past, as my Western Civ professor put it, "Most of your ancestors were hungry most of the time." Aristocracies were falling, and more power (politically and economically) was making its way into the hands of the common man. But even in this period of history, folk music was still alive and well. And although amateur musicians were no longer the sole source of music, they were still a significant source of it. This continued for some time, with professional music comprising a larger and larger percentage of the music consumed by the population. Things changed again, and rather dramatically, with the advent of recorded music. In the past, it was still very typical for a household to have a means of producing their own music. A woman was considered more marriageable if she were able to provide this service for her home. The piano was the most popular choice for this, in my opinion because it arguably has a greater capacity to make a single musician a one man band than any other instrument. There were other factors as well. The depression hit, which drove down piano sales considerably, and recorded musical devices became more and more inexpensive. When these devices became relatively mainstream, it gave households the ability to have music without the need of any musical talent or the cost of maintaining a musical instrument (pianos generally need tuned about twice a year). This process, as most of you already know has been accelerated many times in recent history, with the advent of radio, CDs, portable players, and the MP3.

While I do still spurn what the pop single culture has become, with its uncreative and sometimes downright unpleasant lyrics, its increasingly heavy use of autotuners, and seeming desire to sell sex rather than musical talent, I do still enjoy the occasional good beat. What I'm really coming to sense as far as what's been lost over time is musical amateurism. These days, with the world as your critic, you can't even watch a Youtube video of a little kid plucking out their first tune without reading a comment below of "this kid sukx". Folk is essentially dead (at least in America). The closest thing you can get to this amateurism (aside from high school recitals) is Indie. And several of these bands are just corporate wannabes. And because of this, it seems to be hard to find bands willing to break the mold being created by the professionals (you might find some on Jamendo). This lapse in creativity and morality is disturbing. But so is how passive we've become in our interactions. This goes for all our interactions like texting your mom instead of talking face to face, but also for our music. Unless you count what establishments largely built on lecherous recreation, like clubbing joints, our interaction with music and musically with each other is largely minimal. I'm not saying that I'd like all such establishments shut down and the music industry to die. Maybe it still has a place in our society, I don't know. But I would like to see people become more involved in the musical process and increasing the level of creativity in the music listened to by the general populace. But If singing about getting probed by aliens or getting excited by chains and whips represents the pinnacle of creativity in popular music then

Why not mess around with music in your home? Get a cheap keyboard ($50), guitar ($40), recorder ($4), tin whistle ($10), fife ($5), or whatever floats your boat and create something! It can't be any worst than the wares the music industry is currently offering!

Tea is tea

2011-08-01T00:15:00.001-04:00

So, it turns out the dude at Teavana was right: all teas (e.g. black, white, green, oolong, etc) are all prepared (check out the cool chart) from the same plant (Camellia Sinensis). Naturally, this excludes Rooibus and herbal teas. But this surprised me.

Speaking of tea, I've always found this story interesting about how tea came to be. The Bodhidharma was meditating soon after arriving in China for 9 years. At some point during this time, he dozed off for just a second. He was so frustrated at having broken his concentration that he cut off his eyelids so that he'd never be distracted again by sleep. Guan Yin (Buddhist bodhisattva of compassion) caused the eyelids to grow into tea plants, used by Buddhist practitioners to this day to prevent sleep from interrupting their meditations. The Japanese character for tea leaf is the same as that for eyelid.

Maven 3 & profiles.xml

2010-12-17T14:16:00.010-05:00

There are some pretty cool things in Maven 3 (although mixins and global dependency exclusions have been tabled until 3.1). Matt Raible talks about some of them here. Significant points include dramatically increased performance (50% to 400% faster), unspecified plugin versions will pull the latest version and not snapshot versions (though it's best to be explicit about plugin versions), also Sonatype has developed Maven Shell and polyglot Maven to work with Maven 3.

There are, however, some compatibility concerns when moving from Maven 2.x. And not all plugins yet work. (Most notably they're refactoring the Site Plugin so it's not completely working yet). But the Maven team intends the new release to be usable as a drop-in replacement for Maven 2 (though this won't be the case for Maven 3.1).

Most changes for compatibility seemed pretty trivial. The biggest thing I see preventing Maven 3 from being a drop-in replacement for Maven 2 was their decision to remove support for profiles.xml. This was documented in MNG-4060, though not much discussed there. A few people have complained about this already here and it was discussed a little here. I haven't seen much justification for this, other than it's supposed to be difficult to test. Though I'm not sure why it'd be much harder to test than the use of profiles in the pom.xml. But the Maven team seems for whatever reason fairly committed to this idea, despite one of their committers (Milos Kleint) disagreeing with their position.

People use profiles for a variety of things. Where I work, they are commonly used for environment settings. For example, which version of a particular web service or database to use in prod, qa, etc. But also for which version of that service or database to use for a particular developer's sandbox (another common difference between developers is their log level). These typically use Maven filtering in conjunction with external profiles to accomplish this. These profile properties are also kept in our SCM so if something used by all developer's sandbox, it is easily changeable and transparent to all developers on the project. It is currently impossible to run Maven 3 in this way.

We are not entirely without options when it comes to addressing this, but none of the solutions in my opinion is as nice as the stable, built-in profiles.xml feature. Recently, I've asked if there is some other mechanism I should be using to accomplish this. To date, I've not seen anyone fully explore this issue that I think is important for Maven 3 going forward. So that's what I did here. If you'd like any of the sample projects I created for this exploration, just drop me a line. Maybe I'll put them up on GitHub or something at some point. So without further ado, here are the options I've found and their pros & cons.

1. Fork Maven and put the feature back in

Maybe it's my cynical nature, but this was actually the first thing that came to my mind. But I don't know that very many people would feel comfortable running a patched version of Maven. Plus, I'd want to keep forking them to keep getting all the other goodies they add, which makes a lot of work for me. Then I thought of submitting a patch to Maven for this. But when I found out the decision was pretty deliberate and not simply a lack of resources, I backed off that idea.

Pros	Cons
It's the way Maven should be	A lot of work
	Who's brave enough to use it?

2. Stick with Maven 2

Hey, there's nothing wrong with being old fashioned. There's strong logic to the "If it ain't broke, don't fix it" argument. Many people are even still happily on the 2.0.x branch rather than the 2.2.x branch.

Pros	Cons
The least work of any other solution	No Maven 3 goodies

3. Place all profiles properties in the POM

POMs in Maven 3 still use a <modelVersion>4.0.0</modelVersion>. There for you could put everything inside it like

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>org.foo</groupId>
  <artifactId>pomProfileTest</artifactId>
  <version>1.0</version>

  <properties>
    <!-- these are defaults, they can be overridden with a settings.xml -->
    <javaVersion>1.5</javaVersion>
    <junitVersion>4.8.2</junitVersion>
    <sourceEncoding>UTF-8</sourceEncoding>
    <resourceEncoding>UTF-8</resourceEncoding>
    <profile>dev</profile>
    <prop1>null</prop1>
    <prop2>null</prop2>
  </properties>

  <profiles>
    <profile>
      <id>developer1</id>
      <properties>
        <prop1>prop1Value</prop1>
        <prop2>prop2Value</prop2>
      </properties>
    </profile>
    <profile>
      <id>developer2</id>
      <properties>
        <prop1>anotherProp1Value</prop1>
        <prop2>anotherProp2Value</prop2>
      </properties>
    </profile>
  </profiles>
<!-- ... -->
</project>

This could then be invoked in the standard way:
mvn -P developer1 <goal>

Pros	Cons
Simple to implement: scripts can continue to invoke Maven in the current way	Clutters POM, particularly troublesome when the POM is also deployed.
Also works with Maven 2

Variations
1. Multiple pom.xml files could be checked into the project to cut down on the clutter inside the main pom.xml.

4. Place all an environment's (or developer's) settings in a single settings.xml

This seems to be Maven's official answer on the subject. For things that are common across many projects, this might be a decent solution. But for the many project specific settings (e.g. a db.url property), you'd have to make sure they are named uniquely across all projects so as not to conflict with each other. This makes for a real maintenance problem.
As one commenter in the mailing list noted, some developers have a fear of changing their settings.xml (even if they should be comfortable with this) and would prefer to simply change a few properties. But this should make us pause to make sure there's nothing we're using profiles.xml for when we should actually be using settings.xml.

Pros	Cons
Maven's official solution	Uniquely named properties causes maintenance issues
Also works with Maven 2	Changes not normally visible to all developers

5. Use separate settings.xml files

You can specify a different user settings file with
mvn -s path/someSettingsFile.xml <goal>
and create a file like

<?xml version="1.0" encoding="UTF-8"?>
<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0
                      http://maven.apache.org/xsd/settings-1.0.0.xsd">
  <profiles>
    <profile>
      <id>developer1</id>
      <properties>
        <!-- global properties -->
        <siteLocation>file://${user.dir}/site</siteLocation>

        <!-- project specific properties -->
        <prop1>prop1Value</prop1>
        <prop2>prop2Value</prop2>
      </properties>
      <!-- ... -->
    <profile>
  <profiles>
</settings>

Pros	Cons
Little profile clutter in POM	Massive clutter & overhead in profile settings file, as all your normal settings.xml things are now in each profile settings file
Checking all these settings files in allows developers to make sure they're all using and deploying to the same repos	profile settings are machine-dependent since <localRepository/> is also in settings file.
Also works with Maven 2

6. Use the Properties Maven Plugin

The Properties Maven Plugin allows for properties files to be loaded (and saved) just as if you had used <properties/> in the pom.xml itself.

Pros	Cons
Properties are cleanly externalized	Plugin is considered an alpha version
Also works with Maven 2

Variations
1. Use profiles to select the properties file
This could be invoked in the standard way:
mvn -P developer1 <goal>
And your pom might look like

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>org.foo</groupId>
  <artifactId>propertiesProfileTest</artifactId>
  <version>1.0</version>

  <properties>
    <!-- these are defaults, they can be overridden with a settings.xml -->
    <javaVersion>1.5</javaVersion>
    <junitVersion>4.8.2</junitVersion>
    <sourceEncoding>UTF-8</sourceEncoding>
    <resourceEncoding>UTF-8</resourceEncoding>
    <profile>dev</profile>
    <prop1>null</prop1>
    <prop2>null</prop2>
  </properties>

  <profiles>
    <profile>
      <id>developer1</id>
      <properties>
        <profile>developer1.properties</profile>
      </properties>
    </profile>
    <profile>
      <id>developer2</id>
      <properties>
        <profile>developer2.properties</profile>
      </properties>
    </profile>
  </profiles>

  <build>
    <plugins>
      <plugin>
        <groupId>org.codehaus.mojo</groupId>
        <artifactId>properties-maven-plugin</artifactId>
        <version>1.0-alpha-2</version>
        <executions>
          <execution>
            <phase>initialize</phase>
            <goals>
              <goal>read-project-properties</goal>
            </goals>
            <configuration>
              <files>
                <file>${project.basedir}/filters/${profile}</file>
              </files>
            </configuration>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>
  <!-- ... -->
</project>

Pros	Cons
Standard way for selecting profile	POM now is cluttered with mapping profiles to properties files

2. Use a variable to select the properties file
In my sample, the invocation would be
mvn -Dprofile=developer1 <goal>
And the POM would be like

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>org.foo</groupId>
  <artifactId>propertiesProfileTest</artifactId>
  <version>1.0</version>

  <properties>
    <!-- these are defaults, they can be overridden with a settings.xml -->
    <javaVersion>1.5</javaVersion>
    <junitVersion>4.8.2</junitVersion>
    <sourceEncoding>UTF-8</sourceEncoding>
    <resourceEncoding>UTF-8</resourceEncoding>
    <profile>dev</profile>
    <prop1>null</prop1>
    <prop2>null</prop2>
  </properties>

  <build>
    <plugins>
      <plugin>
        <groupId>org.codehaus.mojo</groupId>
        <artifactId>properties-maven-plugin</artifactId>
        <version>1.0-alpha-2</version>
        <executions>
          <execution>
            <phase>initialize</phase>
            <goals>
              <goal>read-project-properties</goal>
            </goals>
            <configuration>
              <files>
                <file>${project.basedir}/filters/${profile}.properties</file>
              </files>
            </configuration>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>
  <!-- ... -->
</project>

Pros	Cons
Little profile clutter in POM	No standard way of selecting profile

Conclusion

I still really wish the Maven folks would change their mind on this. But until then (unless you're sticking with Maven 2 -- which might not be a bad idea at least for now because of plugin incompatibilities), the best option seems to me to use the Maven Properties Plugin, either with a property or with a profile. (Personally, I'm leaning to the profile option beacuse I think the fact it can be invoked in a standard way is worth the extra POM clutter). Though it is technically an alpha version, it seemed to work fine for me and I believe Maven's decision to remove support for profiles.xml will cause people to flock to this plugin, and therefore likely to only increase its stability. Of course, IDE support for this practice is another question.

Conclusion Part 2

I do feel obligated to mention that the practice of using Maven filtering for things like database URLs where I work is actually changing to use runtime properties instead. (Generally by building a property reader class using java.util.Properties to read different properties files based on the name passed with -Denv=<environmentName>). This has the advantage (besides working with Maven 3) of not requiring separate deployments just for environment differences or redeploys for changes to an environment property.
I still think removing profiles.xml support is bad since the intent was to keep backward compatibility, thus making pointing my M2_HOME to Maven 3 a bit painful when working on old and new projects. It also seems a bit strange that they removed support for profiles.xml when they but not for profiles. It was nice to be able to have those external to the POM.
However, for my (and probably the gentleman on Nabble also) use case, Maven filtering with profiles probably may not have been the right idea in the first place.

My Review of Medal of Honor (2010)

2010-10-24T15:18:00.001-04:00

I was on the fence about getting this game. If they didn't offer guns that were only available through pre-ordering, I may not have even gotten the game. But this coupled with the bonus sniper rifle for having BC2 VIP, and my lack of interest in the upcoming CoD game nudged me to the purchasing side of the fence. Oh, one other bonus is that you get in on the beta for Battlefield 3 (if that's important to you). And probably there'll be other bonuses through EA's Gun Club.

First off: everything mediocre I've read about this game is true. The single player is unremarkable in almost every way, it does suffer from a few scripting issues (I don't think worst than other MoH titles I've played, but our standards have gone up since then), and the graphics stutter in a few places (seemed to me to be mostly around save points). On the plus side, the sliding into cover system they have in single player is pretty cool. Unfortunately, this isn't available in multiplayer. Which is the other unfortunate thing about this game: how disconnected the singleplayer is from the multiplayer. It was done by two teams, in two countries, with two different engines, and they seemed to communicate very little between them during development. It's amazing how much time (3 years) was spent on the singleplayer and yet it still rings pretty hollow at the end of the day. Interestingly, EA's stock dropped 6% on launch day, due to investors being worried by the mediocre reviews. There are a couple of interesting levels, but nothing we haven't really seen before and no level sticks out in my memory as "woah, that was awesome!". There's a level where you get to use attack helicopters, a sniping level, a level with ATVs, and the cinematics are pretty good (and you could skip them if you wanted to, which I've not seen in recent games). The storyline could have been a little tighter (for example the incompetent, friendly-fire causing general is all but forgotten later in the game), but I did like that it was grittier and had fewer Jack Bauer-esque moments than MW2's storyline.

For the mulitiplayer side: It's actually pretty good, and I've found the description as a hybrid of BC2 and MW2 to be true. This game differs from BC2 in that there is limited destructibility (one of the coolest things about BC2), and most game modes don't have any vehicles (the other really cool thing about BC2), although there are light tanks in one of the modes. There are perks like in MW2, but you don't roll through them in the frantic pace that seems to dominate MW2. The guns do seem more balanced than either of the other 2 games. The maps are bigger than MW2, but smaller than BC2. One thing that is unique about their perk system is that every time you unlock a perk, you can choose between a defensive and an offensive action. Defensive actions include stuff like enemy radar and flak vests for your buddies, and offensive actions involve things like mortar strikes and rocket strikes. But unlike MW2, then chain of perks is not configurable. Like BC2 and MW2, you unlock new guns and stuff for your guns as you progress ranks by earning points. The number of rounds to take down an opponent is about the same as BC2 (they have a hardcore mode too, which I haven't tried yet).
The only major downside to the multiplayer is the spawn points. They're awful. In BC2, you'd only get popped on spawn if you spawned on a buddy about to get pwnd. In this game I find myself spawning into a mortar strike or into a gang of enemies fairly often. Which, needless to say, is intensely aggravating (particularly after it happens 4 times in a row -- not uncommon since kills with a perk count towards the next perk). In some modes, you can spawn back to your base instead of the front, but not all modes have this idea (for example their version of Death Match). But sometimes you can use this to your advantage. On some maps, I've been able to run up to one of their spawn points with my M60 a few seconds into the game and wipe half their team before they can put a stop to my mayhem. A dirty trick, but it made me giggle.

Overall, if you have to choose between this game and BC2 and MW2, I'd say get either BC2 or MW2 (depending on your playing style). But if you already have those games and are looking for something with a little less Vietnam and RC cars, this might make for a good distraction until something better comes along. It's definitely not a terrible game, but its not an amazing game either. The worst thing about it is realizing what could have been...

Bad Company 2 vs Modern Warfare 2

2010-10-24T14:33:00.000-04:00

I'd played and loved Modern Warfare 2. I still believe it to be the best multilayer first person shooter I've ever played. That said, when MW2 released their so-called stimulus package at a rate of $15, I felt like that was kind of an insult to their playerbase, which helped them to record-breaking profits in the midst of a recession (particularly when 3 of the maps weren't even new). When I saw that BC2 offered new maps for free (and had already released 2), and claims some were making that it was a better game than MW2, I had to give it a try. What follows is my impressions in contrast to MW2.

When I first started playing the game, I felt a bit underwhelmed. The single player in MW2 is short, but intense. The single player in BC2 might be worth playing to get a feel for the characters, but its a pretty forgettable experience. But the singleplayer isn't why you bought the game anyway.

The sound is great, the graphics look not quite as nice as MW2 in particular with regard to weapon detail, but I think some of this is the scaling. My impression is that BC2 drew humans with a more realistic relative size, this coupled with that the maps are much larger makes everything seem a bit smaller, and perhaps not as graphically wowing. But if you look at the water, buildings, and people (up close), the graphics actually are pretty good. You just might not notice it at first.

There's also some fun stuff about BC2's personality. In singleplayer, whilst riding some 4-wheelers, they comment how much more awesome 4-wheelers are than snowmobiles. While heading into a mission, one says that they want to go in first, because otherwise they'll send some pansy special ops group with rifles and heartbeat sensors. All, of course, references to Modern Warfare 2's singleplayer campaign.

Gameplay: I'd have to say neither are 'better' than the other. BC2 is a different kind of game than MW2. MW2 is a run & gun fragging game, with BC2 there's more strategy. MW2 is on smaller maps, where people routinely camp in predictable places. BC2 has huge maps where camping is largely meaningless. MW2 lets you build a custom warrior with a wide array of addons and perks. BC2 has some customization, but not as large as MW2, and only within your class (rifleman, recon, medic, and engineer). There are no perks like MW2 has after a certain number of kills. BC2 has vehicles prominently featured in combat. MW2 does not. BC2 has destructible environments. MW2 does not. (As a MW2 player, you'll be really lost at first 'How the hell am I supposed to take cover? Everything is exploding!').
I also really love what they've done with the sniper, calling it recon. This makes the role more useful than some griefer only contributing a few kills, because they can call out enemy positions they observe through their scope and place motion sensors.

There are some minor gripes I have with BC2. Such as the repeating sound on the unlock page once you unlock everything for a class, the small and difficult to read menus when not displayed on a widescreen TV, the awful guns you start with in assault class, the unskippable cinematics when you start the game and at the end of each round of multiplayer.

They do seem to have taken a cue from MW2 when it comes to unlocks. You'll be able to win new guns and gadgets as you play along in multiplayer. The pace seemed slower to me than MW2 because there weren't a lot of little things that you unlocked like MW2. But many people find 'the hump' less than MW2. I'd say the guns are more balanced overall (with the exception of the M80 for the medic class). One thing I don't get is the pins you win for doing things like getting a revenge kill, being thrifty with your LMG ammo, etc. They award them to you, but you can't really do anything with them. It was nice in MW2 to be able to brag about them by putting them up with your nametag.

What others have said about BC2 being more strategy and team oriented is true. You can't win the game by yourself. While they do have a deathmatch, I play (and most others too I think) rush or conquest, mostly rush in my case. It doesn't matter if you go around slaughtering the other team (although I think you'll find that more difficult to pull off in this game). If your buddies don't have your back, your team will still lose (and you will probably die).

I didn't feel like BC2 was a better game, especially with respect to single player. And while instinctively I'd say buy MW2 before buying BC2, I also have to recall that since getting BC2 I've barely touched MW2. I certainly don't miss the camping, lag & DCs. If you have a preference for fragging games, get MW2. If you enjoy multiplayer shooters that involve a little more strategy, get BC2. If you've got enough money, get both. They each have something different to offer, and having both provides for a good change of pace.

Cousins Cousins Cousins

2010-07-18T16:38:00.000-04:00

I consistently forget the difference the various kinds of cousins you can have. Fortunately, I recently found a chart that explains it all (and not just cousins) on Wikipedia:
http://upload.wikimedia.org/wikipedia/commons/0/00/Relatives_Chart.svg

I opened a new IntelliJ issue

2010-07-14T22:04:00.000-04:00

I opened an issue for IntelliJ IDEA to highlight TODOs in blue in gsp files like they do for other files tonight. Vote if you're interested.

Greasemonkey and local files

2010-07-13T17:07:00.003-04:00

I'm a big fan of the Javadoc Search Frame userscript. Today's apperent outage of the Javadoc page has forced me to use a local copy of the documentation. I did some poking around on the Greasemonkey mailing list and found that if you still want to run this userscript (or any other userscript) on local files, you will need to edit your about:config. An update changed the default greasemonkey.fileIsGreaseable in about:config from true to false for security reasons. If you want to run Greasemonkey on local files, simply change that value to true.

Also, if you're using the shiny new Scriptish, the value to set to true is extensions.scriptish.fileIsGreaseable.

Cheers!

BASH Colors

2010-07-12T10:29:00.002-04:00

I was messing with my .dir_colors file (about.com also has a good article on this) and wanted a chart to help me pick out my colors. So I modified the popular script that is floating around on the internet to display every possible combination in a graphical chart.
The way it is read is foreground and effect is on the row titles and the backgrounds are on the column titles. Hopefully someone else will find this useful.

#!/bin/bash
#
#  This file echoes a bunch of color codes to the 
#  terminal to demonstrate what's available.  Each 
#  line is the color code of one forground color,
#  out of 17 (default + 16 escapes), followed by a 
#  test use of that color on all nine background 
#  colors (default + 8 escapes).
# 
#  Attribute codes: 
#   00=none 01=bold 04=underscore 05=blink 07=reverse 08=concealed
#  Text color codes:
#   30=black 31=red 32=green 33=yellow 34=blue 35=magenta 36=cyan 37=white
#  Background color codes:
#   40=black 41=red 42=green 43=yellow 44=blue 45=magenta 46=cyan 47=white
#
#  A quick test can be done by echo -e "\033[<color code><test text>\033[0m"
#   e.g. echo -e "\033[01;32mHello World\033[0m"
#
#  Modified from: http://tldp.org/HOWTO/Bash-Prompt-HOWTO/x329.html

T='gYw'   # The test text

# smaller set without attribute codes commented out below
#echo -e "\n                 40m     41m     42m     43m     44m     45m" \
#        "    46m     47m";
#for FGs in '    m' '   1m' '  30m' '  31m' '  32m' '  33m' '  34m' '  35m' \
#           '  36m' '  37m' ;
echo -e "\n                  40m     41m     42m     43m     44m     45m" \
        "    46m     47m";
for FGs in '     m' '    1m' \
           '   30m' '01;30m' '02;30m' '03;30m' '05;30m' '07;30m' '08;30m' \
           '   31m' '01;31m' '02;31m' '03;31m' '05;31m' '07;31m' '08;31m' \
           '   32m' '01;32m' '02;32m' '03;32m' '05;32m' '07;32m' '08;32m' \
           '   33m' '01;33m' '02;33m' '03;33m' '05;33m' '07;33m' '08;33m' \
           '   34m' '01;34m' '02;34m' '03;34m' '05;34m' '07;34m' '08;34m' \
           '   35m' '01;35m' '02;35m' '03;35m' '05;35m' '07;35m' '08;35m' \
           '   36m' '01;36m' '02;36m' '03;36m' '05;36m' '07;36m' '08;36m' \
           '   37m' '01;37m' '02;37m' '03;37m' '05;37m' '07;37m' '08;37m';
  do FG=${FGs// /}  
  echo -en " $FGs \033[$FG  $T  "
  for BG in '40m' '41m' '42m' '43m' '44m' '45m' '46m' '47m';
    do echo -en "$EINS \033[$FG\033[$BG  $T  \033[0m";
  done
  echo;
done
echo

As a side note, for those who may be like myself and didn't see any logic to the codes used for colors, ls and most terminals use the ANSI escape codes (ECMA-48), which is where the numbers come from.

Snapshots of Wave Robot API Now Available

2010-06-07T23:41:00.010-04:00

I've Mavenized the Wave Robot API and the Wave model portion of Wave Protocol, a dependency of Wave Robot API and deployed snapshots to my public repository. Currently, I've only deployed snapshots since the use of this artifact is completely untested. I'm working on creating a Maven archetype for Wave robots (which will use this repository until Google uploads it somewhere), and an example using the archetype. After I've done this and am sure it works (and that I haven't done anything stupid with Maven), then I will tag a release and put it on my release repository.

If anyone would like to try it out in the mean time, your feedback would be most appreciated! Here is what you would need in your pom.xml:

<dependencies>
    <dependency>
        <groupId>com.google.wave</groupId>
        <artifactId>wave-robot-api</artifactId>
        <version>20100408-SNAPSHOT</version>
    </dependency>
</dependencies>
<repositories>
    <repository>
        <id>public-repo_maven2-repository</id>
        <url>http://public-repo.googlecode.com/svn/repository/</url>
        <snapshots>
            <enabled>false</enabled>
        </snapshots>
        <releases>
            <enabled>true</enabled>
        </releases>
    </repository>
    <repository>
        <id>public-repo_maven2-snapshots</id>
        <url>http://public-repo.googlecode.com/svn/snapshots/</url>
        <snapshots>
            <enabled>true</enabled>
        </snapshots>
        <releases>
            <enabled>false</enabled>
        </releases>
    </repository>
</repositories>

Some stuff I picked up along the way:

When using the WebDAV wagon with Google Code, make sure you use https, otherwise you're liable to get a 405 method not allowed error on a deploy.
There's an interesting bug with the Robot API's EventSerializerTest. The behavior is different in Javac 1.5 vs 1.6 but compile fine with the Eclipse compiler. There is bug report for Javac here (fixed in 1.7). I opened a ticket for Google to explicitly cast this in the method so the compiler doesn't have to do any inference, so that way it will build fine with Javac even if they're using JDK 1.6. In the mean time, I've opted to use the Eclipse compiler in the pom rather than altering my local copy of the source. My goal is to make this an exact match to the class files in the zip they've distributed.
Guava, the successor to Google Collections (as a backwards compatible superset) and dependency of the Wave model API is on Maven central, but not on Google's repository. It's a little odd, but shouldn't cause any issues.

A special thanks to Jurgen and commenters for the helpful post that got me started.

Bots updated to v2 API

2010-06-04T00:17:00.010-04:00

I've updated WorldCat-Bot and Yodaspeakify to v2 of the Wave API, which boasts some fantastic new features, including an easier way to do annotations, doing away with Cron, no need for a separate profile servlet, and the capabilities.xml is automatically generated for you using annotations.

One thing I voted for as an improvement was to use regular expressions in this method. I'm not sure what the author of the issue was talking about with iterating over Elements since, as I understand, these don't include text. The artifacts are still not on Google's repository and I'm getting pretty tired of a 5 minute commit time when I change some jars around. I'm working on using Google Code as a repository and adding these artifacts after I mavenize them, then I'll create archetypes for Wave -- watch for an update on this soon, now that my bots are done this is the next project.

Some snags I ran into:
The .replace() of BlipContentRefs doesn't work the way you'd think it would. I thought I could do

BlipContentRefs content = blip.first(originalText).replace(newText);

But the BlipContentRefs will be empty. I got a hint for how to do this from wadrobotframework's BlipUtils:

public static void replaceBlipContent(Blip bleep, String nextContent) {
    BlipContentRefs bcr = bleep.all();
    if (bcr != null) {
        bcr.delete();
        bleep.append(nextContent);
    }
}

Thanks, wadael!

Another issue was when I used DocumentChangedEvent and then did a .getBlip() it would return a null Blip. My understanding of the JavaDoc was that it would return the root blip if no Blip was associated with that event, but this didn't seem to be happening. So, I opted for a BlipSubmittedEvent instead. Which, now that I think about it, is probably the desired behavior anyway.

Another issue was when I was trying to take advantage of the cool new filtering options. WorldCat-Bot used to surround it's searches with angle brackets (<>), but when I tried to filter on this

@Capability(filter = "<.*>")
@Override
public void onDocumentChanged(DocumentChangedEvent event) {
  ...
}

It didn't work because the capabilities.xml that was generated was not well formed. I also tried the escaped version

@Capability(filter = "&lt;.*&gt;")
@Override
public void onDocumentChanged(DocumentChangedEvent event) {
  ...
}

But this didn't work either, it looked for the entire literal not the unescaped form. I don't think this is currently possible to do, so I now use square brackets ([]) to filter on.

While trying to debug this, I set up logging (GAE supports JUL), but I learned it only logs things with INFO, WARN, and SEVERE levels (though I couldn't get INFO to work even with the logging.properties file with .level = ALL. Maybe something else is misconfigured).

But overall, the new API has been a very positive experience.

Chai I've tried

2010-06-03T21:30:00.003-04:00

On chai:

Tazo's Chai Latte -> thumbs up: Best off the shelf chai I've tasted
Oregon Trail Original Chai -> thumbs down: tasted like southern sweet tea mixed with milk. I ended up dumping it down the drain after not being able to finish a single glass :(

On an unrelated note, Mrs. T's pierogies are pretty good as well (especially the 4 cheese). While they can be prepared many ways, I think they're best prepared by defrosting in the microwave then sauteed.

GMaven & source encodings

2010-06-02T15:34:00.011-04:00

I'm re-posting this because I made some more discoveries after I had initially posted it.

I discovered apparently SourceEncoding is completely broken in GMaven. I tried on Linux where the platform default encoding is UTF-8 and on Windows XP where the platform default encoding is Windows-1252. In both cases, it used ISO-8859-1 as the encoding of the class file it generated, despite the fact the source was encoded in the platform default encoding. I tested this with version 1.2 of the plugin and Groovy 1.7.0. Why this is happening makes no sense to me; I could understand if it used the platform default...but why always ISO-8859-1? I think this is the Jira for this: http://jira.codehaus.org/browse/GMAVEN-13.
I find it shockingly disappointing that a 'critical' issue can go unassigned for almost an entire year. I wonder if it is working in Ant. Their documentation seems to suggest that it does. If that's true, it might tell us something about where the Groovy team's priorities are.

In practice, this often is not problem, since if you're only using ASCII characters in your source code, the first 128 bytes have identical mappings in UTF-8, ISO-8859-1, and Windows-1252, so it won't matter which of those the plugin tries to use. However, I view this as a major obstacle to Groovy's gaining dominance, as it should support Maven (since for better or worst it's become the leading standard) and it should support encodings to support global growth.

Am I missing something? Any good workarounds? I'm also happy to share my experiment project with anyone who wants to play with it.

I've also discovered yet another way in which GMaven's documentation is fail. I was trying to get my project to work with the latest version of Groovy, when I came across this unrelated StackOverflow discussion which use the new 1.2 version of the plugin (which isn't in the archetype or anywhere documented as released -- I thought the artifacts were released by mistake since nothing has even been tagged in their repository for 1.1 or 1.2, although IntelliJ already supports it, plus nabble and some blogs talk about it so I guess it is released). Here are the needed bits from the pom:

<dependencies>

    <dependency>

        <groupId>org.codehaus.gmaven.runtime</groupId>

        <artifactId>gmaven-runtime-1.7</artifactId>

        <version>1.2</version>

    </dependency>

    <dependency>

        <groupId>org.codehaus.groovy</groupId>

        <artifactId>groovy-all</artifactId>

        <version>1.7.0</version>

    </dependency>

<dependencies>

<plugins>

    <plugin>

        <groupId>org.codehaus.gmaven</groupId>

        <artifactId>gmaven-plugin</artifactId>

        <version>1.2</version>        

        <configuration> 

            <providerSelection>1.7</providerSelection>         

        </configuration>

        <executions>

            <execution>

                <goals>

                    <goal>generateStubs</goal>

                    <goal>compile</goal>

                    <goal>generateTestStubs</goal>

                    <goal>testCompile</goal>

                </goals>

            </execution>

        </executions>

    </plugin>

    <plugin>

        <groupId>org.apache.maven.plugins</groupId>

        <artifactId>maven-compiler-plugin</artifactId>

        <version>2.3</version>

        <configuration>

            <source>1.6</source>

            <target>1.6</target>

        </configuration>

    </plugin>

</plugins>

Update: According to this Jira, this is fixed in the 1.3 release. And it appears from my tests that this is the case.

Firefox vs Chrome Performance: A language difference?

2010-05-28T13:56:00.005-04:00

Like many folks, I've been pretty blown away by the speed of Chrome (especially with respect to running JavaScript intensive sites). Currently, I use both Firefox and Chrome (depending on what I'm doing), but primarily Firefox as there are still some addons I can't live without.

Though I am excited to see the Out Of Process (OOP) Electrolysis project (which is now in beta) and the upcoming JägerMonkey JavaScript engine, I've begun to wonder if some of the performance differences we're seeing are more deeply rooted. Now I do know there are things that are supposedly not possible with Chrome's extension support, and of course with greater functionality comes reduced performance. But I've lately been wondering if the differences are at the language level. Does the language each was written in greatly alter performance? Have a look at this graphic

Source: Ohloh

Just look at all that JavaScript! While some sources favor JavaScript as a "first-class language" (and maybe I'm misinterpreting their meaning here), I'm not convinced that makes sense for desktop applications. There are some advantages to having portions of Firefox be in a web language, it makes it easy for web developers to extend & theme. But I'm not sure it makes sense to use it as extensively as they appear to have done.

For example, it would seem that the addon manager (nsExtensionManager.js) and session storage (sessionStore.js) are both JavaScript. How do I know these are their names? I didn't look at the code, but apparently I was putting Firefox under a bit too much pressure and I got the message saying these scripts had stopped responding (not at the same time). (Though this does happen less often with my portable Firefox, so maybe I need to clear out the profile).

It will of course help when we have the content and the UI in separate processes, and maybe help some more when Firefox gets a faster JavaScript engine, but I wonder if you can ever get really good performance from a language like JavaScript. I'm not saying to write the thing in assembly, I'm just saying maybe it makes sense to write the lower level components in a lower level language. What do you think?

As two somewhat unrelated sidenotes: What do you think the impact on Firefox's future will be with the loss of their tech lead? And do you think Google will finance Mozilla now that they're in some competition with each other?

Syntax Highlighting in Blogger: Round 2

2010-05-21T13:36:00.009-04:00

So I'm now able to use the popular SyntaxHighlighter that most blogs use. I don't know what was stopping me before: maybe I've gone up in intelligence or they've fixed some bug. There's excellent instructions here. I think I'm going to make the move to this, since it's easier to read, has more features, and is more standard that the Prettify script I was using before. And one additional nice feature is I don't have to manually set my style="overflow:auto;", instead I just do

<pre class="brush:xml; wrap-lines:false">

And there's no longer a need to do an onLoad in the body tag, and a Groovy brush!
I've gone back to old posts and switched the styles, let me know if I've missed any.

Edit: Actually I think maybe the reason was my own lack of attention. I think I forgot to add 'alexgorbatchev.com' to NoScript's whitelist, and that's the host the scripts are currently hosted on, and it magically started working for me because I was in Chrome instead of Firefox. Doh! ... Doh? Who knows for sure?

Edit: The instructions aren't really up to date anymore, as new brushes have been added. Here is an updated example (note this uses the default theme, but you can choose to use other themes):

This still goes inside the header area of the template, which means you'll still need to manually edit the HTML.

OK Maven, You Win

2010-05-21T00:46:00.000-04:00

So, I've tried every combination of dependencySets, fileSets, and copyDependencies I could think of, nothing I did seems to work. All I wanted was to have a runnable jar with its dependencies in unexploded jars (something I've done before when making a jar by hand, although I used the default package in that case, not sure if that makes a difference). When I failed in this, I tried to have a runnable jar with its dependencies exploded into a lib directory. I failed in this as well. The only thing that seems to work is to have everything exploded into the same level. I tried this briefly with the shade plugin, but have mostly been trying with the assembly plugin. I give up, Maven. You win.
I've seen this mentioned fairly often on the web. If someone has a working example of a Groovy project compiled into a runnable uber-jar, I'd love to see it.

Workaround for JRA-19248: 401 on Jira Gadgets

2010-02-26T14:11:00.002-05:00

Here is a workaround for JRA-19248: Dashboard widgets fail with HTTP 401 malformed security token, when left unattended for some time. Set the 'Refresh Interval' on the gadgets to 1hr (or less). It's worked for me so far.
Edit: Well, it worked for several days, but apperently 1hr wasn't quite often enough. I'm trying with 30min, someone else reported having to use 15min. One more thing to note is that this issue is fixed with Jira 4.1.

Windows Profile Woes

2010-02-09T20:37:00.001-05:00

After struggling for months with folders magically changing ownership (first noticed when iTunes couldn't save podcasts) and messages saying the roaming profile did not synchronize completely, I believe I've found the problem. Apparently, Windows profiles changed (though I don't understand how this affects me since although I did an upgrade install of Win7 from Vista, my machine never ran XP or earlier). The migration was failing because there wasn't enough hard drive space to copy all my music, documents, everything twice to do the migration. Though even once I resolved the issues preventing the sync (by moving to a temporary folder in C), it still didn't perform the sync. What I ended up having to do is create a new user, then copy everything over, take ownership, then delete the old user. This problem was also the cause of the mysterious S-{A bunch of meaningless numbers} user and the messages saying I wasn't the owner even though the username of the owner was my username. This was my user account's SID, which it apparently uses as part of the migration.

I also learned that there is no Windows equivalent of Linux's usermod (let alone a GUI like Gnome and KDE have) when it comes to renaming accounts and their homes. My plan was to create a new account named Keegan2 then delete the original and rename the new to the old name after I was sure everything was moved over. While you can rename accounts in Windows, it doesn't change the profile path as part of the renaming. There is a registry hack that can be done, but this method gave me issues (all kinds of software installed for all users was still looking in the old place). When I tested this with XP, when I removed the renamed user it didn't remove the files. It would seem like it should be possible to run a script similar to the initialization Windows does the first time a user logs in before migrating to the new name. This explains the laptop that was re-purposed a few times, but still had all the old usernames in 'Documents and Settings'.

It's a Windows world, but I find the longer I live in it, the more I suffer. Vive Linux!

Aero and LogMeIn

2010-02-01T10:16:00.002-05:00

I've had the problem on Vista and Win7 of having Aero disabled after a remote LogMeIn session, even after changing themes to an aero theme and rebooting (the only thing that worked was uninstalling and reinstalling LogMeIn). After having no luck searching the LogMeIn community forums, I finally stumbled across a tip from the folks at Windows 7 Forums:

Uncheck the 'Disable wallpaper and user interface effects on the host computer' in the LogMeIn preferences.
Uncheck the 'Use display accelerator' setting in LogMeIn preferences.
Disable the mirror display device in device manager.

That should do the trick! (Note that this will probably significantly reduce the responsiveness).

Prevent OpenDNS From Redirecting Google Searches – Fix for Firefox & IE Address Bar

2010-01-17T02:32:00.001-05:00

For those of us who enjoy the protection of OpenDNS, but don't want to use the OpenDNS guide, change the value of keyword.url in your about.config to http://www.google.com/search?q=. Thanks to digital inspiration for the tip.

How to fix Pidgin issue connecting to AIM, ICQ – receiving ‘unexpected response’ - TechSpot Blog

2010-01-14T22:56:00.002-05:00

I've been experiencing this issue with Pidgin 2.6.5, this seemed to do the trick.
How to fix Pidgin issue connecting to AIM, ICQ – receiving ‘unexpected response’ - TechSpot Blog

-- Edit --
This must have been some problem on AOL's side. It no longer seems to be occurring.

VirtualBox Tips

2010-01-13T09:20:00.001-05:00

I've been experimenting a bit with Sun's VirtualBox over the last few days. For the most part, its been pretty smooth. I now use this instead of VMware. I thought I'd pass along a few snags I ran into to save someone else some trouble. When upgrading, uninstall the previous version first (they claim it can be installed over the old version, but its given me problems both times I've tried to upgrade that way). It won't delete your VMs. Also, for those running Vista/Win7, when installing, run the installer in administrator mode otherwise it seems to fail when trying to install the virtual network devices. I'm not sure why they don't have their installer set to require these permissions, and it doesn't seem to write a log either when it fails, making debugging difficult.

GoogleMonkeyR and SkipScreen Incompatibility

2010-01-12T08:54:00.000-05:00

I'm a user of the GoogleMonkeyR userscript, and for a few months I had been thinking that Google had changed something that caused the script to have the first result right-aligned instead of left-aligned. It turns out, the problem is actually because I'm also a user of SkipScreen. The problem lies in the 'search refinements' setting, it must be disabled for GoogleMonkeyR to work properly, either do this from the GUI SkipScreen options dialog, or change the value extensions.skipscreen.searchrefinementsactive to false. Hopefully, this saves someone else some confusion.

More Groovy Bugs

2010-01-11T15:20:00.002-05:00

While trying to add some sorting to my ValidateMe script, I discovered a Groovy bug that someone else reported on Thursday. It appears that although inner classes are supposed to be supported in the new Groovy 1.7, calling methods on enums inside a class do not. I've also created another suggestion for a reverse() method on Maps. I did add the changes I wanted to ValidateMe without these Jiras being addressed. What I did for the reverse was do something like

theMap.reverse{it.value}

A Couple Of GroovyConsole Jiras

2009-12-30T14:45:00.003-05:00

I find myself relying more and more on the GroovyConsole for testing out Java and Groovy stuff (especially regular expressions and xml processing), for writing scripts it basically is my IDE. There's a few irritations for which I opened a couple of Jiras for today, as I didn't see comments on them. All pretty minor, the first two deal with the open/save dialogs, the third deals with process management and output. We'll see what happens. If they're open to the changes, but don't have the time, a couple might be something even I could do. Anyway, here they are:

http://jira.codehaus.org/browse/GROOVY-3961
http://jira.codehaus.org/browse/GROOVY-3962
http://jira.codehaus.org/browse/GROOVY-3963

Gettin' Groovy with xml validation

2009-12-21T13:32:00.001-05:00

So, I wanted to be able to tell learn some things about the validity of a particular xml document I was working with a few days ago. If you use something like XMLSpy or the xml plugin for Notepad++, they will display only the first validation error. So, I wrote a Groovy script to let me control the amount of errors reported, and collect some statistics about the document. I call it ValidateMe. And now, I'm sharing it with you. You can get the script off its Google Code page. As usual, it's MIT licensed, so you can do pretty much whatever you want with it. It's usage is described by running 'groovy validateMe.groovy help'. It's pretty straightforward, about 130 lines or so, but I think it's pretty slick.

As a result of doing this, I also learned that you can have multiple classes in the same .groovy script file, as long as the class with the main method is first.

Launching a GroovyConsole Without a cmd window

2009-12-16T13:23:00.007-05:00

I run Groovy 1.7 from the .zip files (which doesn't yet have the native launchers built for it), and I love the line numbering, and many other things about it. The one thing that was irritating is that a new cmd window would have to be opened every time I launched the groovyConsole.bat. I now have a workaround. Create a new .vbs file in the bin folder of your groovy with the following contents:

Set WshShell = WScript.CreateObject("WScript.Shell")
obj = WshShell.Run("groovyconsole.bat", 0)
set WshShell = Nothing

You can then put a shortcut to this wherever, and even make it pretty by setting the icon to this. Oh, and make sure you have your GROOVY_HOME set up.

Actually, this can be used to run any batch script in the background, as long as you don't need to be able to let the user pass in arguments. My thanks to Koushik Biswas from Yahoo Answers for the tip.

Which Child Am I?

2009-12-11T11:05:00.009-05:00

I don't know if this is worth blogging home about, but I've needed this solution a couple times, and I found myself referencing this blog entry draft, so I'll put it out there and maybe someone else will find it useful. The problem is I have an xml node, and I want to know the order it is (as an index integer) in relation to its siblings. You may have to modify this of course, if the children you are comparing are deeper down than 1.

def CAR_RECORDS = '''
<records>
  <car name='HSV Maloo' make='Holden' year='2006'>
    <country>Australia</country>
    <record type='speed'>Production Pickup Truck with speed of 271kph</record>
  </car>
  <car name='P50' make='Peel' year='1962'>
    <country>Isle of Man</country>
    <record type='size'>Smallest Street-Legal Car at 99cm wide and 59 kg in weight</record>
  </car>
  <car name='Royale' make='Bugatti' year='1931'>
    <country>France</country>
    <record type='price'>Most Valuable Car at $15 million</record>
  </car>
</records>'''

def records = new XmlSlurper().parseText(CAR_RECORDS)
def record = records.car[2].country

int index = 0
Boolean found = false
record.parent().parent().children().each {
  if (it == record.parent()) {
    found = true
  } else if (!found) {
    index++
  }
}
assert index == 3
return index

Using Groovy from the .zip file

2009-12-07T13:05:00.007-05:00

I had always had trouble launching groovysh or groovyConsole from the .zip releases of groovy, and always waited until they released the installer for Windows, never knowing why. There is a simple fix, but one that didn't occur to me right away. The cause is that the GROOVY_HOME variable needs set before startGroovy.bat tries to add it to the classpath, so just add

set GROOVY_HOME=..\

to startGroovy.bat (anywhere before the classpath gets set), and let the good times roll...
This also, of course, overrides whatever you have set as system or user variables, so you can safely play with other versions from the .zips without needing to change anything (or needing admin rights).

My First DMCA Notice

2009-12-04T13:24:00.002-05:00

I got a little popup in Blogger today, letting me know that they had moved one of my posts on WittyReads (where I reblog things) has been moved to draft status because of a DMCA takedown notice they (Google) got. The post in question was a reblog of an entry from Fluxblog on one of Julian Casablanca's songs. (Will I get sued for posting a link to a link to a link of an mp3?) Needless to say, I'm kinda pissed about this. What I did was reblog a post of a blog that allegedly has the blessings of the various related copyright lawyers. I didn't myself host the mp3 nor provide details on how it could be obtained through unauthorized channels. My reblogging it helps get the word out about the album, potentially driving up their sales (the original post even has a link to the amazon page to purchase the album). I'm going to leave it down for now, but I feel as long as that fluxblog post is legal than what I did is perfectly in my rights and after doing some more research I may just put it right back up (provided Google doesn't ban me to protect themselves from possible lawsuits). I think the little javascript popup said something about an email being sent about this yesterday, which I haven't yet received, though I should, a little popup hardly qualifies as notice, it should be on permanent record through a system that isn't as prone to glitches as javascript. In the mean time...Guess who's album I won't be buying? (though in this case I'm not sure I would buy it anyway, since some of the money supports the professional bullies at the RIAA) I congratulate Julian's legal team. You've demonstrated a sophisticated understanding of the Internet and blogging, forward-thinking, and strength of character. Outstanding work.

My Second Wave Bot

2009-12-03T10:02:00.001-05:00

Inspired by Piratify, I decided to make a bot that makes everyone talk like Yoda (Yodaspeak as I call it). The bot lives at yodaspeakify.appspot.com, and can be added by adding yodaspeak@appspot.com to your wave. The sourcecode is available here. It works, but needs more work to improve its results.

My First Wave Bot

2009-11-23T13:30:00.003-05:00

I finally got my Wave invite, and I immediately got interested in coding with it. I recently finished creating a bot for it that allows you to search WorldCat from inside Wave. The main servlet is in Groovy, the profile is in Java. Their tutorial pretty much works, though one of the methods was renamed:
getRobotProfileUrl() should be called getRobotProfilePageUrl() (there's a request filed to fix this). Google's plugin for Eclipse also works very well. JetBrains also has a plugin for IDEA, though I didn't test this. In their sample project SpringSource has a build script that uses AntBuilder, which I modified to use the folder structure that was already created by the Eclipse plugin. I successfully built with this and deployed the app using appcfg.cmd from the SDK. I used straight html for the bot's profile page, but in their sample SpringSource shows how you could use the MarkupBuilder in groovlets.

Anyway, the app is deployed on the Google App Engine here, it's homepage (where the sourcecode is also available) is here. You can add it to your waves by adding worldcat-bot@appspot.com. For even more bots, check out the list. Mine's listed too. There is another list out there, but it doesn't seem used as much.

Some gotchas:

You cannot test robots without deploying them to the Google App Engine, this makes you waste some of the number of deployments you have on the free account (currently you get 1000).
Wave caches its bots, so you have to change the version in appengine-web.xml (I don't think you have to change the version in capabilities.xml too unless the capabilities have also changed, but I've been changing both to match). They tell you this, but you have to be careful because even though you may have deleted the old version if you reuse a version descriptor text Wave may still try to call the old version and you will get a ServletUnavailable exception and waste another deployment. You have to wait for the re-caching to occur.
If you are using Groovy, you have to upload the groovy-all jar in the war/WEB-INF/lib directory (the war folder can be a different name, but that is the convention used by the Eclipse plugin).

For those who haven't heard about Wave, it's basically a kind of collaborative IM (I once jokingly described it as an MMIM - Massively Multiperson Instant Messaging). But it isn't quite accurate to describe it as a kind of IM. The text is live, you can see it as the person is typing it, but whether its treated as an IM or more like an email is fluid. It depends only on if other people are there at the same time. So, it can be viewed as a kind of mashup between email, IM, and collaborative documents and is more concurrent than traditional email. LifeHacker has some use cases, which make for good propaganda.
Anyone in the conversation (called a Wave) can edit any of the messages (blips). Side conversations can occur in the same stream, these side conversations are called wavelets. APIs exist to have bots in a conversation that automate tasks (such as links for searches, posting the conversation to a blog, bringing in text from a feed, or converting everyone's text to pirate talk) and for gadgets that let you put different kinds content inside the conversation, such as documents, polls, etc. Google plans to open source most of Wave once it's finished, allowing other 'federated' servers to become Wave providers, and they plan to make the protocol they use the predominant protocol on the internet. The Google Wave Federation Protocol is itself built off XMPP (the same protocol Jabber and GoogleTalk use). They have bindings for Python and Java currently (I've heard the Python API is not as polished as the Java one, but I don't know that for sure and I'm sure it will improve), and will probably be adding more languages in the future to support their goal of making their protocol #1. Wikipedia has a pretty good article on Wave as well.

I still have Wave invites left for my friends, if you're interested.

MySQL and Oracle

2009-11-18T10:32:00.001-05:00

I've recently reversed my position on the EU's opinion on the Sun/Oracle merger. I had always taken the position of Oracle's CEO which was that since MySQL is open source, it can never really be killed. While this is true, when something like that loses its corporate backing it can languish if someone doesn't step in, making it effectively dead. Now I don't know what the ideal situation would be, but one must question the motives of a company that allows themselves really to lose money, as Sun's stock continues to drop well below the price Oracle will be paying. Why are they so insistent in keeping MySQL if they have no plans to quash it? Why don't they save themselves some money and grief and just give up MySQL? I still don't understand why quashing it is in their interest anyway, as many projects using MySQL wouldn't consider Oracle as a solution because of cost and probably would turn to another open source alternative if MySQL weren't an option. I don't think Oracle will see a dramatic fiscal difference after they destroy MySQL, but it certainly seems to be their goal. While their motivation may be that they are hoping to move some of MySQL's customer-base (particularly the enterprise ones) over to their products, their long-term interest in maintaining MySQL is questionable at best and it will be the smaller businesses (non-enterprise users) that will pay the price.

I had always thought IBM would have been an ideal buyer, but it recently occurred to me: why didn't Google buy Sun? They already use Java for many of their internal stuff, and they're steadily becoming a bigger player in enterprise with their apps and search solutions. The would be acquiring SPARC, which I'm not sure would be very useful but I could see Google building off Java, JavaFX, Glassfish, NetBeans, MySQL,VirtualBox, and maybe even OpenOffice. Heck, they might have even worked on the red haired stepchild of Java: JavaME. We all know they have the money, and with their strong support of open source it actually wouldn't have been a bad match. EU probably wouldn't have an issue with it either.

Functional Programming

2009-11-11T16:22:00.001-05:00

I know this is old news, but it's new to me. I've been thinking about an article by Paul Graham which is basically about how functional languages are superior to OOP and other imperative languages, and languages are shifting towards functional programming in general, and LISP in particular. I disagree on both counts. Ignoring the fact that whether its right or not, OOP isn't going away any time soon, I think that there are certainly problems that are better suited to that paradigm, but there are many problems that are not. This is a good part of the reason that we see more multi-paradigm languages that pure languages.

I specifically object to the example he chose to demonstrate the 'power' of Lisp. He chooses a problem that Lisp and similar languages are naturally going to win. He wants to return a method that is an incrementer as the result. Its going to be ugly in any language where methods are not first class objects.

He also claims that design patterns exist to make up for shortcomings in a language. There is a related question on StackOverflow. The study referenced there states that 7 of the 23 patterns in the GoF still applied in functional languages. Even Lisp is not a purely functional language and needs what can be regarded as a design pattern (Monad) to allow for something stateful (like IO). (When was the last time you wrote a program that didn't use some kind of IO?).

Languages are not becoming more and more like Lisp, though many of them did borrow some concepts from Lisp. One of the main reasons for this is that Lisp was one of the first high level languages (even before C). Yes, things like garbage collection, dynamic typing, and recursion were initially eschewed by the programming community only to be later made mainstream. This is for reasons of computing power rather than a sudden realization that Lisp had it right all along. Paul Prescod talks about how Python isn't moving towards Lisp and how many former Lispers have adopted Python. I think Paul's statements stem from having sour grapes over the lack of success of his pet language more than historical fact.

That being said, Java certainly isn't perfect and has been constrained by Sun's unwillingness to break compatibility to add new features. Wouldn't it be better to say languages like Java could benefit from some additional Lisp-like options, such as lamda (available as closures in groovy) and first class methods (available in Scala) rather than immature statements like Lisp >> Java? While I agree that there might be a place for a language that keeps things simple to help curb mistakes, I would rather see greater flexibility and choice given to empower the programmer, allowing for whatever style best suites the problem at hand. Some problems lend themselves to functional programming, and some problems are stateful in their very nature. I find OOP easier to think in, because we fairly naturally think of things as interactions of systems. Though, this is perhaps overused currently in our industry for problems it shouldn't be used to tackle.
For this reason, I would like to study and work with functional languages more than I currently am to recognize and take advantage of those situations in which functional languages are the right choice (assuming the decision is up to me).

On a related note, the Computer Language Benchmarks Game is also good fun, for those who find religious wars amusing. 99 bottles of beer is also an interesting reference. It is programs that print the lyrics to the song 99 bottles of beer, in many languages. (check out an Erlang version, Lisp version, and a Java version).

Related links
http://norvig.com/design-patterns/
http://www.norvig.com/lisp_talk_final.htm
http://www.norvig.com/python-lisp.html
http://www.paulgraham.com/power.html

Something unrelated, but funny
http://www.willamette.edu/~fruehr/haskell/evolution.html

Groovy - Sometimes you still need a semicolon

2009-11-11T08:12:00.004-05:00

I Was ploughing through my overly-large blogroll the other night when this article caught my eye.
http://groovy.dzone.com/articles/groovy-sometimes-you-still
I gave it a read, because I wanted to know all the cases where you had to have a semicolon.

He gives two examples, the first of which he’s wrong about, it works fine in 1.6.5 and I believe it works for anything >= 1.6.

def list = [1,2,3] as List<Integer>
println list

This second one (not the exact same example he used) does need a semicolon

{-> assert true == true }()
{-> assert false == false }()

Should be

{-> assert true == true }();
{-> assert false == false }()

This is only the case if you have two closure calls next to each other with nothing in between.

{-> assert true == true }()
println ""
{-> assert false == false }()

works fine.

Are there other times when you need a semicolon at the end of the line (assuming only one statement per line)?

Groovy 1.7 Beta 2 Available

2009-11-06T11:51:00.009-05:00

It’s a bit of old news, but I don’t remember seeing anything about it until today.
It was available 12 Oct, and Windows installer binaries were available 18 Oct. Get yourshere.

A draft of the current features is available at http://docs.codehaus.org/display/GROOVY/(draft)+Groovy+1.7+release. This release is mostly bug fixes, with two notable improvements. They have added the ability to alter the meaning of Groovy Truth. This lets you add some truth to your own class by adding the asBoolean method:

class Foo {
  String value
  boolean asBoolean() { value == "something true" }
}
assert new Foo(value: "something true")
assert !new Foo(value: "teh cake is a lie")

And of course, using ExpandoMetaClass, you can alter the behavior for Groovy classes that already have a Groovy Truth defined:

Integer.metaClass.asBoolean { int value ->
  return value > 0
}
Integer foo = 7
assert foo.asBoolean()

They’ve also added stylish outputs for assertion failures (I guess taken from the Spock testing framework):

int foo = 0
int bar = 1
assert foo == bar

will display:

Assertion failed:
assert foo == bar
       |   |  |
       0   |  1
         false

AHCI in Windows

2009-10-31T21:13:00.004-04:00

A recent discovery I made because of my mobo's odd controller:
While its true that AHCI works out of the box with Vista/Windows 7 (that is, there is no need for third party drivers) -- If you did not have it enabled when you first install Windows, it will be disabled to save some boot time. Makes sense. What's odd is what you have to do to enable it. You have to change HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\services\msahci\Start from 0x3 to 0x0. Otherwise, you get a blue screen when you try to boot. The fancy startup repair that comes with Vista/Windows 7 will be launched the next boot (if you let it), but won't be able to figure this out for you.

So yea, I tried moving the cables around on the inside (thinking it might be a bad sata port), and changed to AHCI, and my cd drive was still the one that disappeared, not the drive in that port. I thought it might be some incompatibility with the firmware, but the updater fails to run. :'( I suppose it's also possible it's a bad cable.

I'm Dying

2009-10-27T07:48:00.000-04:00

I was digging through old journal entries I've made in .txt files buried in my hard drive (most of which I'm sure I'll have to apply an electromagnet to in the event of my death) and happened across this piece that is probably about as close to poetry as my pathetic writing skills will ever achieve. This one wasn't so much poetry as much as me trying to capture how I felt in a dream I had at about 3AM a few years back.

I'm Dying
You feel the life slowly leaving your body
panic grips you, as your clammy skin perspires slightly
in your head, you can hear yourself screaming, "I'm dying!", but your lips make no sound
the wait is unbearable, its like slowly bleeding to death
you can almost feel the life running off your fingertips, like blood
your eyes grow dim, unable to bring your surroundings in focus
things look darker, as though the color itself were being drained from your world
you feel a chill shiver, and a sudden sense of aloneness
you want to reach out for something, but your body betrays you
you feel the moment drawing nearer, as a dread shadow in the night
your chest feels as though a weight were upon it, your eyes see almost nothing now
voices in your ears, calling your name seem ironically unimportant as they slowly fade away
you see only darkness, and hear only silence as a great void seems to devour you
you feel the thick, inky darkness penetrate you, you become unsure of where the darkness ends and you begin

Woman is the Mother of Human Race

2009-10-22T23:42:00.000-04:00

I don't say I agree with everything in this story, but it does sound pretty. This is taken from Dastur Dr. M.N. Dhalla's Homage Unto Ahura Mazda at http://www.zarathushtra.com/z/article/dhalla/. Zoroastrianism predates Christianity by over 1000 years, but later writings were greatly influenced by Christianity's writings. You'll therefore notice some definite similarities. Though perhaps a fanciful notion, I've found the account much preferable than the version of the story we're taught in Christianity. This respect for women, I've found unparalleled for the time (~1700BCE). Though certainly values and gender roles have changed a bit since then (I'm not sure yet whether its for the better or for the worst). I also find the notion of no original sin greatly appealing. I think most Christians don't completely accept. (It's kind of a new doctrine anyway, initially put forth by Paul if stories are to be believed, but not popularized until about 200CE by Irenaeus to combat Gnosticism).
A note on terms: Ahura Mazda means wise lord, it is the Zoroastrian term for God. The Amesha Spentas can be roughly thought of as angels, that's more or less what they were understood as by the time this was written. In any event, try to see past the semantic differences and realize the relationship they are describing. I wish I was this positive about life and relationships.

Woman is the mother of human race

Seated under the Tree of Life all alone, was Mashya, the First Man. Morose and moody and melancholy was he. Oppressive and killing was his solitude in this strange, new world. He dreaded life. He cursed his existence. Then did Spenta Mainyu, Ahura Mazda's superb Fashioner of mortal clay, take compassion on him and made Mashyani, the First Woman. Mashya took Mashyani as his wife. With his life-mate Mashya set up his first human household upon earth.
When Spenta Mainyu made man, he was acclaimed in the heavenly world as a good architect. When, with softer and finer clay and with unprecedented craftsmanship he made woman, he was hailed by all as the best and matchless Moulder of all time. Woman is the marvel of creation. Unrivalled and unequalled in form and beauty is she in this wide world of the seven zones. She is the blooming flower in the garden of life that breathes perfume all around.
Woman is the teacher of gentility to man. She helps man to grow in moral height. She is the sustaining power of the life of man. Much has she that man has not. Man is not man until woman breathes manhood in him. She is the life of man. She has genius to love and she loves more intensely and more faithfully than man. In the virtues of the heart, she excels man. She is more patient and enduring than man. She suffers silently and hides her grief in her bosom and smothers her tears. She comforts and she soothes. She dispels the darkness of the depressed spirits around her. Wilderness would this world be without woman. There is freshness and there is sweetness, where woman steps in. When life becomes a-weary, woman makes it a-cheery.
Man delights to lay at the feet of woman all that he wins from the world. The fanatic iconoclast turns docile idol-worshipper, when he approaches woman, the eternal idol of humanity in flesh.
Life becomes livable for man, for woman shares it. Woman is the helpmate of man. She is not his drudge or chattel. Woman, again, is not man in the making. She has not to ape man and grow mannish. Woman is woman and always and ever woman. Wifehood and motherhood are her most sacred functions. As a prudent wife and a loving mother, she forgets her own self for the tender love of her dear ones and trains her children to virtue.
Gentle and tender and delicate is womanly virtue. The slightest waft of vicious wind soils and withers it. Chastity is woman's priceless wealth. Purer than pearl and brighter than diamond is Asha Vanghuhi's chaste woman. Give us, Ahura Mazda, woman as chaste as Hvovi, as loving as Rodabeh, as devoted as Tehmina, as virtuous as Firangiz, as faithful as Manijeh, as pure as Pouruchisti and as brave as Gurdafrid.

Children are nearer heaven than we are

Fresh from the land of the angels, the child is angelic at birth. It is godlike. The soul enters the body of a child and it sleeps its childhood. The reason sleeps. The conscience sleeps. The child exists. It has not yet begun to live a reasoned, responsible life. The child is innocent, for it knows no guile. It is pure, for it has come not across impurity. It is angelic; for it has faced not the demon lurking within it. The flower of life has not yet budded and blossomed. Innocent, pure and angelic is childhood. To see children is to see the Yazatas and Amesha Spentas, the Angels and Archangels of Ahura Mazda.
Nature abounds in many a charming object, but none so sweet as a child. Children fill our eyes with light and our hearts with delight. They gladden and they brighten our homes with their bright faces and happy smiles and sweet prattlings. They amuse us and cheer us and enliven us. Incomparable is the joy to fondle them and love them and play with them. Children in their budding tender life, are the poetry and song of human life.
Childhood has no past. The present and the future are the two seasons of children. They dream not of the future. The present is all their life. No care, no anxiety, no fear have they. Life to them is joy and sunshine, frolic and fun.
Childhood is the season of planting seeds that will blossom into rich harvest. As the farmer anxiously awaits the nature of the season's crops, so do fond parents look year after year how the child-mind develops and the child-soul unfolds. The child is the man and the children are the nation of the morrow. One day will the nation be as children grown up to maturity, will make it.
As the rose bud unfolds its petals to the beams of the rising sun, so does blooming youth outgrow its childhood and with wide awake reason and conscience assumes the responsibilities of life.
Now begins the journey on the rough and rugged path of life of hope and despair, joy and sorrow, success and failure, honor and shame, happiness or misery. Blank was the tablet of the soul in childhood. Youth now begins to record its daily doings and creates its history. Childhood was unsoiled by the vulgarities of the world. Youth now lives and works in the midst of temptation and vice. The light of reason brightens the paths of his life and the inner, infallible, divine voice guides him. The child was the angel by birth. Man or woman has to live the angelic life and fighting evil and living for good, has to become angel on his or her own merit.
The child is every parent's hope. All long to live in their children. Give us children of sound minds in sound bodies, who may grow up to be men and women of brilliant career and pure character, diligent and honest, upright and true, wise and virtuous, patriotic and selfless, and live and work for thee and thine, Ahura Mazda.

Body Swapping

2009-10-22T23:04:00.000-04:00

I've been thinking about body swapping the last couple days. Aside from the obvious means of temporarily escaping boredom, what other benefits could come from the ability to move from body to body? What sort of commercial ventures would naturally arise?

Fitness centers would probably offer training services where professionals could tone your body for you, then transfer your mind back once it is complete. Another idea I had was using the transference as a means of transportation. How handy would it be to transmit your mind into another body waiting for you at your place of business? People suffering from chronic pain could find respite by temporarily swapping minds with someone else. Walk a mile in someone else's shoes? Why not walk a mile in someone else's feet? And of course the human computational potential could be maximized using this method. Take the brightest minds of our world and put them in the brains with the best connected neurons.

Personally, I think it would be pretty interesting to transfer my mind into the same brain as someone else. If it were an active presence, it would be interesting to see what kind of communication could be achieved. Could emotions be directly shared instead of simply described? If a passive presence, it would be a great way of observing people and better understanding how we work. This could be a new form of counseling. Marriage problems? Download the mind of a marriage counselor who will observe your interactions then be able to give the most relevant advice. And of course, if external storage is a possibility, this could open up all other kinds of possibilities. We could preserve the best leaders and thinkers, we could offer individuals the opportunity to experience life 100 years in the future (assuming we manage not to destroy ourselves for that long). How would you capitalize on this new technology?

As a side note, Dollhouse on Fox has largely been an uninteresting series of glorified pimping. I think they're trying to make some kind of commentary on the nature of human existence, but aren't doing a very good job of it. But the last episode of season 1 is really cool. It is set in a post-apocalyptic world where transferring minds has gone awry. If they show more of that, I may start to actually care about the series again.

What would you do with the ability to jump from body to body?

Java vs Groovy: Polymorphism

2009-10-16T00:21:00.005-04:00

While doing some studying for SCJP, I was tinkering with some stuff in the Groovy console as a way of testing some stuff in Java and I found they actually behave differently.

class Person {
  protected String name
  protected int age
  
  public Person() {
    name = "secret"
    age = -1
  }
}

class John extends Person {
  int favoriteNumber
  
  public John() {
    name = "nobody special"
    age = 0
    favoriteNumber = 7
  }
  
  public String doNothing() {
    return "junk"
  }
}

Person p = new John()
println p.doNothing()

If you do this in Java (splitting the classes out to their own files of course), it won't compile. Java looks at the reference type for available methods, so you will get a NoSuchMethodException. In Groovy, however, it looks at the type of the object, not the type of the reference so the method is found at runtime. And this is probably what you would want, so I can refer to John or Mary as a generic Person, but they still do the things they do in a John or Mary way.

Java vs Groovy: Overriding static methods

2009-10-16T00:21:00.004-04:00

The Java equivalent of below will not compile, but in Groovy it works fine. Groovy supports overriding static methods, whereas Java does not.

class Person {
  protected String name
  protected int age
  
  public Person() {
    name = "secret"
    age = -1
  }
  
  public static String doNothing() {
    return "junk"
  }
}

class John extends Person {
  int favoriteNumber
  
  public John() {
    name = "nobody special"
    age = 0
    favoriteNumber = 7
  }
  
  public String doNothing() {
    return "more junk"
  }
}

Person p = new John()
println p.doNothing()

I don't think this would be a problem. You might want each inherited class to have its own (maybe static) version of a method, but for every instance of the class to only have one in memory. If you don't want the children overriding the method, you should just make them final.

Skip The Tests

2009-10-15T22:17:00.004-04:00

Skipping tests is generally a bad idea. But, if you are changing things just to tinker and see results, without particularly caring about the tests, it is easily skipped from the command line:

mvn install -DskipTests

This is something I'm sure you've seen. What I didn't know is that you can also skip the compiling of the tests:

mvn install -Dmaven.test.skip=true

Code in Blogger

2009-10-15T21:01:00.019-04:00

So, I've been looking for a way to make my code examples in blog posts more readable. I had tried to use the hosted version of SyntaxHighlighter, but couldn't seem to get it working right (I'm sure it was something simple) and it needed several lines added to the Blogger html template. Instead, I've opted to use google-code-prettify. Though it doesn't support as many languages (in particular no groovy), all I needed was 2 lines pasted into the template, and making it load the class when the body element is. Couldn't be simpler. I followed the instructions (slightly tweaked) from here. Thanks Luka.

These are the lines you need (anywhere in head tag):

<link href="http://google-code-prettify.googlecode.com/svn/trunk/src/prettify.css" type="text/css" rel="stylesheet" />
<script type="text/javascript" src="http://google-code-prettify.googlecode.com/svn/trunk/src/prettify.js" />

Then modify body tag to load the script:

...
<body onload='prettyPrint()'>
...

Use:

<pre class="prettyprint" style="overflow:auto;">
  <!-- Your code goes here -->
</pre>

You don't need to specify the language since the script will guess, but you can if you like:

<pre class="prettyprint lang-html">
  <!-- HTML code here -->
</pre>

The lang-* class specifies the language file extensions. File extensions supported by default include "bsh", "c", "cc", "cpp", "cs", "csh", "cyc", "cv", "htm", "html", "java", "js", "m", "mxml", "perl", "pl", "pm", "py", "rb", "sh", "xhtml", "xml", "xsl".

I've gone back and added the syntax highlighting to all my code examples in previous posts.

Boolean.flip()

2009-10-15T20:20:00.009-04:00

Recently I needed a Boolean in a groovy project I was working on to alternate back and forth (for row highlighting with Apache POI). I thought it would be slick to metaclass a flip() method (something I've always thought should be there) into Boolean. It turns out, this is not possible. I browsed the Java source and learned that all primitive wrapper classes are immutable. I'm not completely sure why they did this. My guess is to protect programmers from hurting themselves by mutating objects in a collection and possibly creating unexpected behavior or a race condition. I could have created my own boolean wrapper class, of course, or use Apache Commons MutabeBoolean. In the end, I decided not to be fancy and just reference a new object like

Boolean foo = false
foo = !foo

But boy, it would have been pretty & nice to have

Boolean foo = true
foo.flip()

Yay! Someone else agrees with me!

2009-10-06T08:24:00.001-04:00

A couple days ago, I blogged about some of my frustrations with task estimation. This morning, I saw an article posted on AgileZone that seemed to echo my words (though in a more concise and articulated fashion than I managed to).

Things About This Universe That Amuse Me

2009-10-05T18:21:00.000-04:00

We live in a weird universe.

There are more species of beetles than any other order the animal kingdom, comprising 25% of all known life-forms.
Humans are the only species that drinks milk from a species other than their own.
There are significantly less than a googol of atoms in the known universe.
Onomatopoeias
Time is relative.
More people have died than are currently alive (6% of all people who had ever existed were alive in 2002).
The chimpanzee genome is 95% identical to the human genome. And up to 95% of our genome may be junk left behind by retroviruses and evolutionary artifacts.
Humans are the only species known to use the smile to express something other than fear and aggression.
∞ - ∞ != 0
Human childbirth. How does this not kill us? The infant's skull actually changes shape as it passes through the birth canal.
Human flora. The womb is sterile, but after the family has finished kissing and caressing, 500 to 1000 kinds of bacteria live in the gut, and just as many on the skin. Cool.

Song in my head today: Cassie from the self-titled album by Flyleaf.

Project Estimation

2009-10-04T22:29:00.001-04:00

I've been thinking about project estimation the last several days. What initially got me thinking about it was the links off of this article. I find the notion of using story points instead of hours for sprint estimates appealing. I like the idea of having a set number of story points per sprint, it keeps everyone apprised of the complexity of the issues at hand. It also encourages the use of stories instead of use cases for requirements, which has some advantages. I buy the idea that estimating story points is easier than estimating time. Scrum-Breakfast likens it to a train

Traditional estimates attempt to answer the question, "how long will it take to develop X?" I could ask you a similar question, "How long does it take to get the nearest train station? The answer, measured in time, depends on two things, the distance and the speed. Depending on whether I plan to go by car, by foot, by bicycle [...], the answer can vary dramatically. So it is with software development. The productivity of a developer can vary dramatically, both as a function of innate ability and whether the task at hand plays to his strong points, so the time to produce a piece of software can vary dramatically. But the complexity of the problem doesn't depend on the person solving it, just as the distance to the train station does not depend on how I get there.

However, I think this ignores a fundamental aspect of human nature (at least of modern day humans): our need for instant gratification. We don't really care how far away something is (except for concerns about fuel). When we ask someone how far away they live from some particular point, they usually give an answer in hours and minutes, not miles. They view it as a question of how long they have to wait before they get what they want. Similarly, product people and especially the customer don't particularly care how complex a problem is to solve. They just want it solved, and want to know how long they have to wait before they get what they want.

It seems to me that eventually someone will have to make the translation to hours (even if only done implicitly). Users care about release dates -- "when are the features I want going to be available?". Even if you schedule sprints with story points, someone is going to have to figure out how long those will take to complete in order to set a reasonable release date. When you make this conversion, you will have to account for variances in velocity (the speed at which people work). Even if you do decide to use story points, this correlation will be necessary at first to establish how many story points are possible in a sprint.

Still, there are some advantages to this approach that come to mind. When you estimate story points, you don't have to estimate both complexity and your ability to solve the complexity. You only have to worry about the complexity. The hours for big things are often pulled out of the air and aren't very accurate until they are broken down into tasks. Story points provide a good way of looking at the big picture without fleshing out all the details. One additional cool thing about story points is that they have built in variances, as Scrum Breakfast points out

The thing to realize about about estimates is that they are very imprecise. +/- 50%. One technique for dealing with a cost ceiling is to define an estimate such that the actual effort needed will be <= the estimate in 90% of the cases, regardless of whether they are measured in days, hours or point. So Story Points are usually estimated on the Cohn Scale (named for Mike Cohn, who popularized the concept): 0, 1, 2, 3, 5, 8, 13, 20, 40, 100. Why is there no 4? Well a 3 is a 3 +/- 50%, so a three actually extends from 2 to 5, a 5 from 3 to 8, etc. The difference between 3 and 4 is nowhere near as significant and between 1 and 2, so we don't give estimates that give us a false sense of precision. Summed together, many imprecise estimates give a total that is a remarkably accurate estimate of the work to be performed (the errors tend to cancel each other out, rather than accumulate).

Mule also had an interesting approach to creating a product backlog, where they used a sort of bucket sorting rather than choosing actual numbers for story points. This is what Chris Sterling calls affinity estimating.

Mike Cohn says that sprint backlogs and product backlogs should have different units to prevent confusion, since if you use hours for both it doesn't show that hours on a sprint backlog have been thought about a lot more than hours on the product backlog. Speaking of Mike Cohn, he has an interesting notion for the role of story points. He suggests they are a good long-term indicator, but the short term should focus on the product backlog and prioritize stories, then break them into tasks and estimate those using hours. Some have suggested using task points in a similar way as story points, but for individual tasks. This might provide some room for variance if you really suck at estimating. Additionally, you will only have to update the estimates when complexity changes not when velocity changes. This also might be a more lean approach since it doesn't waste time on an artifact that is not needed. However there are some downsides to this approach. One is that there is no easy way to track the progress of the task (e.g. in Jira), unless a conversion to hours is first made. It also presents a challenge to HR, which may wish to account for hours for financial reporting purposes.

I think it makes a bit of sense to use hours to estimate at the task level, since you should be able to give more detail at that point (as opposed to the bigger items, like stories where any hours ascribed would basically be pulled out of thin air). This is what I'm interested in. How can I make my task estimates more accurate to make sure I can deliver what I think I can deliver? To me, it seems the issue with both of these methods of task estimation is that they do not address the real problem with why tasks get off schedule in the first place. Actually, there are two, but both deal with an unknown. The first is if there are other tasks competing for the same resource (e.g. your time) that weren't initially accounted for: either they came up after the estimation or were a result of oversight. The second is because you have misjudged the complexity of a task. You look at a problem, it seems pretty simple, you ascribe a few hours/points/whatever to it, but once you start digging into the problem you realize its going to take longer than you thought. Then you are left with the question of whether or not to re-estimate. I think while the original estimate should be retained for posterity's sake, its useful for the product people to have a new estimate for planning purposes...perhaps pushing back to another sprint.

The only certainty is the certainty of uncertainty, but that's probably why you're doing agile in the first place. This is especially true when new technology is involved. While there are some who advocate task points for breaking down tasks (pieces of a story), most advocate to use hours at this level. And this is what I do not understand. Why are we going to all the bother to make all these estimates about minutia? Get a commitment from developers, keep a backlog, and get to work! I can't believe some agile teams are willing to spend several hours (some say 8 hours) on sprint planning. That doesn't sound agile to me at all. A practice that seems to work pretty well for some of my colleagues here at OCLC is to use units that are a bit fuzzier than an hour. They tend to estimate in 1/2 days, which is a bit less precise, but allows for greater accuracy because it is easier to ballpark. But unless you are continuously updating estimates (as the Scrum Primer suggests) so that volunteers can move around on tasks (perhaps in a paired situation), I don't see much point in having exact hours.

Honestly, I'd rather do away with task estimates altogether. Maybe its because I don't like submitting something that I know I can't do a good job on (at least not yet). But it also seems to me that you are spending time creating an artifact that doesn't necessarily help you finish the sprint. There are some out there who have suggested this. Including Jeff Sutherland here. Jurgen De Smet has an interesting blog post on it here. I feel that as long as I'm reasonably certain I can get tasks X, Y, Z done in sprint N, I don't' really need to make up numbers for how long they'll take. Maybe I'd feel differently if I were on multiple teams and close to being overworked. But I feel developing this sense is developing a skill that isn't really useful for anything. I can't even get good at estimating to apply it to other areas to improve productivity, this 'gut' sense is a rather domain specific intuition. What's the point? Am I completely missing something?

P.S. This didn't really fit with anything else, but I wanted to pass it along. It is about building a common definition of done:
http://chrissterling.gettingagile.com/2007/10/05/building-a-definition-of-done/

Vaccuum Your Firefox

2009-09-25T13:46:00.000-04:00

This has been blogged about in the usual places already, but for those who haven't seen it:
There's an addon for Firefox that defragments its sqlite database, called Vacuum Places. I recently gave this a whirl and was pleased with the results. The responsiveness of my address bar was noticeably improved. Now, bear in mind that I use Firefox a lot. I have over 4000 bookmarks -- its kinda getting out of control. Those who don't use it as much probably won't notice much of a difference, but give it a whirl and see what it does for you. Note that there is a disclaimer saying to backup you profile (easily done with MozBackup), but I haven't had any issues with it.

Some other addons you might want to check out:
Adblock Plus - never see another ad
SkipScreen - auto waits on file upload sites
DownloadHelper - download youtube videos, a page of images at once, and more

DownThemAll! - download everything on a page, based on filters (all pdfs, all images, etc)
Greasmonkey - run custom javascript in website to do all sorts of nifty things (use Greasefire to light up when scripts are available on the current site or get some here)
Stylish - loads custom css into sites (get some here)

Tab Mix Plus - one of the biggest reasons I use it is for the 'duplicate tab' option, but the 'close other tabs', 'close right tabs', and 'close left tabs' are pretty nifty too.

Duct Tape Programmers

2009-09-25T13:07:00.000-04:00

Wednesday there Joel blogged about the first chapter of Coder's At Work, where he admired duct tape programmers that were willing to skip unit tests and code quality in order ship on time. I don't really have much to say about it that Uncle Bob and his commenters have said. I agree with just about everything Bob said except for

I found myself annoyed at Joel’s notion that most programmers aren’t smart enough to use templates, design patterns, multi-threading, COM, etc. I don’t think that’s the case. I think that any programmer that’s not smart enough to use tools like that is probably not smart enough to be a programmer period.

In an ideal world, this would be true. And as the industry matures, I think this is becoming increasingly true. However, there are still some programmers out there that aren't very talented and probably shouldn't be programming, and yet they still are. Now I'm not an advocate of making your life difficult to weed out the less talented, but our ever increasing toolbox is lowering the barriers to entry. This isn't necessarily a bad thing. I have a fair amount of faith in the invisible hand and if this allows businesses to get their needs met, then so be it. Just be aware there are people programming that aren't the sharpest knives in the box out there, and they may even be getting away with it...at least for now.

Free

2009-09-25T08:12:00.001-04:00

Today's XKCD:

Free: ""

How about those labels like on bottled water "0 calories" (uhh, its water...I should hope so). Reminds me of that Head and Shoulders commercial. "I'm gunna make tires with zero death crystals...and those will be the tires to have"

2009-09-25T01:09:00.004-04:00

Highlights from today's thoughtstream:

I've always wondered why there was no netflix for cds...turns out there is. And you can keep the cd for $7 each. Not a bad deal.
I've also wondered why the speed on the rear window wipers is so damn fast...in most vehicles you need to wipe it at least 1/3 of the number of times as the front, perhaps less -- unless you are driving 70mph..in reverse.
I Tried Japanese green tea with Matcha the other night...bit of a different flavor than the usual and lighter more lime green color. I particularly like the bags on these, I believe they are silk. The paper bags always leave an aftertaste.
Women have a lower amount of body water than men, not higher as I previously believed. However, The Science of Flexibility supports our belief that woman are more flexible than men. This is because the placement of the hips are wider, allowing for greater range of motion (wouldn't it be cool if they could unhinge somehow?). We know that women have a lower hematocrit and higher levels of subcutaneous fat, but this would presumably only affect endurance and not flexibility. I haven't seen anything about differences in muscular composition that could contribute to increased flexibility.
Song stuck in my head today: Flobots - Mayday!
A talk with Kyle reminded me of an interesting article I read about the sons of world leaders. I especially like the section on Kim Jong Il's son
I've been looking for a music search engine that finds songs of similar acoustic quality and style of queried songs. I found this one, but its not very easy to use.
Enabling piplining in firefox (in about:config) and turning up the maxrequests to 15 or so makes firefox considerably more peppy.

Don't Bother Testing for Null?

2009-09-23T10:15:00.000-04:00

This appeared on Rainsberger's blog a couple of days ago

Unless I’m publishing an API for general use, I don’t worry about testing method parameters against null. It’s too much code and too many duplicate tests. Besides, I would be testing the wrong thing.
When a method receives null as a parameter, the invoker—and not the receiver—is missing a test

I think I've got to disagree with him on this one. Unless I'm misunderstanding 'general use'. It might be OK not to test for null if it's just your code calling your code (of course what happens when this gets pushed out, maybe serviceized and suddenly others are calling it?) Even if you do not guarantee the right results if the method is passed a null, I would think you should at least make sure that it doesn't blow up. If it fails, it should fail gracefully. It's true that it's not the responsibility of the receiver to make sure the invoker is calling it correctly, and I wouldn't expect a test for every conceivable possibility necessarily. But nulls happen all the time, its not unreasonable to expect a quick check. There wouldn't even be a lot of code. something like

if (someVar == null) {
    Log.error("it was null");
    return;
}

would do nicely. I do agree there is test duplication between the reciever and invoker, in that both are testing for the null condition on the same variable, but this doesn't really bother me. It seems to me there are lots of tests that have overlap or dependencies. Maybe I'm just crazy. I left a comment on the post.

I guess I just don't understand Europe

2009-09-23T08:10:00.000-04:00

I saw this article today, which said that Larry Ellison (Chief Executive of Oracle) stated that Sun was losing $100 million every month their proposed merger doesn't go through. The reason the EU commission has been reluctant to put the deal through? They're worried MySQL might get dumped. Well, so am I --- but, uh, it's OPEN SOURCE. It can't be killed. If Oracle decides they're not going to do any further work on it whatsoever, someone else can pick it up and continue development. Don't like the direction the company is going with it? Fork it! Someone actually already has, actually two have. That's the whole point of open source.
"The Commission has to ensure that such alternatives would continue to be available." Uhh, duh?!

Open source: Have it your way

Extending NTFS with Bad Sectors

2009-09-21T10:38:00.000-04:00

I wanted to grow an NTFS partition to use unallocated space this weekend on an XP machine. If it were Vista or Win7, I would have used the built in resizing ability in disk management, and I found I could not do so with my usual tool of choice (GParted Live CD). The error message said that it could not complete the operation because of two bad sectors, and to run chkdsk (which I did) and then use ntfsresize with the --bad-sectors option. When I tried this, it said it couldn't grow it unless I make it bigger with fdisk. The only way I know how to do this would be to create an entirely new partition (which would mean all the hassle of reinstalling windows and the needed apps). I was finally able to do it with EASEUS Partition Master Personal. Unfortunately, it is not open source, but it is free and it did what I was trying to do without restarting in minutes.

Types of Reviews

2009-09-18T14:36:00.000-04:00

An interesting discussion was started in this month's section meeting about code reviews. People brought up the point that catching flaws in design implementation requires knowledge of the requirements and that not having such knowledge allows the reviewer to only look for bad programming practices in general. Of course, I'm new to all this, but it seemed logical to me to have three kinds of reviews.

- Design Review

- Implementation Review

- Code Review

The purpose of a design review would be to review the design of the system. This is a higher level view and shouldn't involve any code. The purpose of an implementation review is to review how well the code meets the requirements (somewhat similar to acceptance testing), this test is probably the most time intensive of the three. A code review is a review of the code itself (perhaps with some context, but not at the level of an implementation review. This should focus on errors in logic, and adherence to accepted coding standards (not style). Am I missing something that should be reviewed?

I think when I prepared code for review, it helped when I attached an overview of the classes and what their purpose and general relation to each other was. If a class is very large (probably needs refactored), it may also help to attach an overview of it (at least for the methods most important to complete its job).

It was also pointed out that having people read over requirements and code would take a fair amount of time, which is time not spent on other tasks. An unanswered question was whether pair programming should complement standard reviews or replace them altogether, and how time could be used most efficiently. Everyone agreed that in some way the feedback loop needed to be shortened, whether that be through pair programming or reviewing more often over smaller amounts of code or some other means.

These aren't the leaks you're looking for

2009-09-14T23:14:00.002-04:00

So I got back to my computer today and found my computer moving so slow the mouse was chugging across the screen and the start menu essentially unresponsive. I discovered explorer.exe consuming 3.8 GB of memory. It was awesome. (BTW I'm running Windows 7 64bit RTM). Naturally, I'd expect some poorly written shell extension to be the culprit (which I intend to investigate further). But seeing as how I've been enjoying the bliss that is Redmond since XP with the same problem (even more memory with Vista and Win7), I have a hunch its not. Now remember, according to Microsoft:
begin Jedi mind trick:
There are no memory leaks in Windows Explorer

Restarting explorer.exe brought it down to about 1.2 GB and restarting brought it down to like 50 MB. These are the leaks we're looking for... move along.

Why Cowon is Awesome

2009-09-14T22:50:00.003-04:00

The COWON S9 is infinitely more awesome than the iPod and the Zune. Here are a few reasons why: AMOLED touch display, video playback, FLAC and OGG compatibility (though unfortunately no apple lossless), a completely customizable interface (flash/actionscript), Themes and more themes, games and apps, drag and drop file syncing (no iTunes or special software required), highly customizable equalizer. And they regularly provide free updates. On August 17, they updated the firmware with even more features (previous update was July 24). It also has a microphone and a radio. I also hear they are working on porting rockbox to COWON.

I was a bit nervous when I purchased this, I carefully read reviews and so forth about it, but its a Korean brand I had not heard of before. I've owned it for about three months now and I have absolutely no regrets. It doesn't have quite the storage capacity of iPod or Zune (30GB), but don't think I could fit my entire collection on them anyway. I keep my music in three different places on my computer, some mp3, some flac, some ogg. With my S9, I can just drag and drop whatever in there and it maintains the same folder structure so you can easily find things (ever try making sense of the organization iPod uses?). I'm using my music collection in ways that were simply not possible with my old iPod. If your iPod or Zune has recently bit the dust, I highly recommend.

The Not So Answered Variables in GPathResult

2009-09-14T10:00:00.009-04:00

A while ago, I posted that I had gotten the answer on how to get the number of records in an xml file using XMLSlurper (or XMLParser) by passing a variable. It turns out, it was not so answered. This only worked for elements that are immediate children of the root. It seems XMLSlurper and XMLParser can't get longer paths from a single String, it needs to be broken up. (Not sure why it was implemented this way). Fortunately, our own brilliant, Jonathan Baker noticed this and suggested the solution below. It's not complicated once you figure out that the String has to be broken up:

def xmltxt = """
<file>
  <something>
    <record>
      <name>nakina</name>
    </record>
    <record>
      <name>buaboe</name>
    </record>
  </something>
</file>"""
 
def xml = new XmlSlurper().parseText(xmltxt)
def fullPath = 'file.something.record'

def pathElements = fullPath.tokenize('.')
pathElements -= xml.name()
def root = xml
pathElements.each {node ->
    root = root."$node"
}
return root.size()

You could also use split, as John Wagenleitner suggested in response to my comment on his answer on StackOverflow:

def xmltxt = """
<file>
  <something>
    <record name="some record" />
    <record name="some other record" />
  </something>
</file>"""
def xml = new XmlSlurper().parseText(xmltxt)
String foo = "something.record"

def aNode = xml
foo.split("\\.").each {
  aNode = aNode."${it}"
}
return aNode.size()

My thanks to you both.

After talking with Josh, I understand why the Groovy people had to do what they did. Dots (.) are still legal in XML element names, as long as the name doesn't start with a dot. (Actually, other punctuation is allowed as well, though it is not recommended). I don't think they could use forward slashes as XPath does because of how Groovy has overloaded the operators and dots had to be allowable, so this is what we're stuck with. Maybe they should have used spaces instead, since those aren't legal in element names. I don't know the impact this would have on other classes.

So, Why The Name?

2009-09-11T15:07:00.000-04:00

Thought I would give credit where credit is due. I'm not a terribly creative person, if someone else has something creative I can use, I'll most likely rip it off. 'Witty Keegan' is one of the nicknames bestowed upon me by my friend and college roommate, Vitus Pelsey. ('Keegasaurus' being one of the others). I thought a pun would make for a good blog title, while giving a false impression of witticism and intelligence.

Bad GString! Bad! --- Wait, My Bad

2009-09-11T14:45:00.004-04:00

I was trying to write a test for a method that inserted some stuff into a StringBuilder that was modified as a GString and was frustrated to find that my stubbed method was never called!

Initially I got mad, blamed Groovy for making my life more difficult with its ridiculous automagical boxing. Then Josh pointed out that StringBuilder is actually a CharSequence. It's not a Groovy thing, I'm just dumb. Fire up your GroovyConsole and observe:

StringBuilder.metaClass.insert = {int arg0, Object arg1 ->
  println "FOOO"
}
StringBuilder.metaClass.insert = {int arg0, String arg1 ->
  println "BARR"
}
StringBuilder.metaClass.insert = {int arg0, CharSequence arg1 ->
  println "I'M HERE!!!"
}

StringBuilder sb = new StringBuilder()
def foo = "ROGER"
def bar = "$foo"
sb.insert 0, bar

The result is "I'M HERE!!!". All I had to do was stub the right method.

If you're experiencing String vs GString issues, like I thought I was, you may find this helpful.

Integration Tests Are a Scam?

2009-09-11T11:13:00.008-04:00

I recently listened to a talk given by J. B. Rainsberger (author of JUnit Recipes) with the title Integration Tests Are a Scam (summary notes here). If the idea seems crazy, blame the fact that he's from Canada ;) These are some quick thoughts I had, I may expand on them later.

Here's some definitions he gives:

Basic Correctness: "Given the myth of perfect technology, do we compute the right answer?"
Myth of Perfect Technology: "Assuming we can use an arbitrary large amount of memory, for an arbitrary amount of time, on a Turing machine for spherical people[...]"
Integration Tests: "...any test whose result (pass or fail) depends on the correctness of the implementation of more than one piece of non-trivial behavior."

"You should never need to write an integration test to show basic correctness." He believes our largest problems lie in basic correctness. After we get this right, then we can worry about issues of performance, security, etc. The question of basic correctness is where he focuses his efforts. (He paraphrases a quote I believe based on the Pareto Principle).

Downsides of integration testing:

Intergration tests are slow
Integration tests don't tell you where the failure occurred (may be difficult to find even with debugger, assuming TDD hasn't caused you to forget how to use one)
In order to have enough tests at the integration level to test thoroughly, the number of tests that need to be written increases combinatorially, based on code paths
There is a lot of duplication in test setup

Now, it should be noted that he is not talking about acceptance tests. He says that acceptance tests tend to be end-to-end, and that is OK. But end-to-end tests should not be used for developer tests. He is also not altogether against integration tests for finding bugs, he just doesn't want them permanently added to the project. Bugs found through an integration test should create new object tests. "I don’t doubt the necessity of integration tests. I depend on them to solve difficult system-level problems. By contrast, I routinely see teams using them to detect unexpected consequences, and I don’t think we need them for that purpose. I prefer to use them to confirm an uneasy feeling that an unintended consequence lurks."

Instead, he recommends 'collaboration tests' (commonly called 'interaction tests') and 'contract tests'. By collaboration tests, he means to stubbing out or mocking the collaborators to isolate functionality and make sure all the ways it can interact with collaborators behave as expected. This is 1/2 of the work (and actually the easier 1/2). You've checked if you've asked the right questions and able provide an answer for all the responses.
The missing piece (that commonly causes people to rely on integration tests) is a misunderstanding between the interaction of piece in question and its collaborators.

The second 1/2 is 'contract tests'. The first of the two checks on the other side of the interface is whether the collaborator able to provide a response when "the star" (Class in Test CIT) asks for it (is it implemented? can it handle the request in the first place?). The second is whether the the collaborator responds in the way the CIT is expecting. "A contract test is a test that verifies whether the implementation respects the contract of the interface it implements." There should be a contract test for every case we send the collaborator and every case the collaborator might send back. Again this will using stubbing and mocking. The advantage of this approach is that you know when you have enough tests (two for each behavior). I've tried to diagram the idea thusly:

He claims that if you ask these questions between every two services and focus on basic correctness, we can be "arbitrarily confident" in the correctness. The number of tests increases additively instead of combinatorially and is easier to maintain, with less duplication, and faster to run. If something goes wrong, you are either missing a collaboration test or missing a contract test or the tests do not agree. This makes troubleshooting easier. As of yet, there is no automated way of testing that every collaboration test has a matching contract test.

When I saw the title of the talk, I initially reacted rather violently against the notion. I'm still not sure if I'm 100% behind it, but I think there are some good points raised about integration tests and their utility. However, as Dan Fabulich points out in a reply to a response Rainsberger gave to a comment about a Mars rover failure, figuring out that you are missing a test may not come easily.

"The ability to notice things" is high magic. If you have that, you can find/fix any bug without any tests... why don't we all just "notice" our mistakes when writing production code? In this case you're just using intuition to notice a missing test, but that's no easier than noticing bugs.

As you know, I share your view that integration tests are tricky, in the sense that writing one tempts you into writing two, where instead you should be writing more isolated unit tests. But unit tests have the opposite problem: once you have some unit tests, it's too easy to assume that no more testing is necessary, because your unit tests have covered everything. By exaggerating the power of unit tests and the weakness of integration tests, you may be doing more harm than good.

Imagine you're actually coding this. You just finished writing testDetachingWhileLanded and testDetachingWhileNotLanded. (It was at this point in your story that you first began to "notice" that a test was missing.) You go back over the code and find you have 100% branch coverage of the example application. Your unit tests LOOK good enough, to a superficial eye, to an ordinary mortal. But you're still missing a critical test. How are you supposed to just "notice" this?

More generally, how are you supposed to build a habit or process that notices missing tests *in general*?

I've got just the habit: write all the unit tests you can think of, and then, if you're not sure you've got enough unit tests, do an integration test. You don't even necessarily have to automate it; just try it out once, in real life, to see if it works. If your code doesn't work, that will help you find more unit tests to write. If it does work, don't integration-test every path; you were just double-checking the quality of your unit tests, after all."

<edit>
While I wouldn't go so far as calling it 'magic', finding all the edge cases can be difficult and may require a fair amount of knowledge about the collaborator. Rainsberger later commented that his method of ensuring every condition is tested is

Every time I stub a method, I say, "I have to write a test that expects the return value I've just stubbed." I use only basic logic there: if A depends on B returning x, then I have to know that B can return x, so I have to write a test for that.

Every time I mock a method, I say, "I have to write a test that tries to invoke that method with the parameters I just expected." Again, I use only basic logic there: if A causes B to invoke c(d, e, f) then I have to know that I've tested what happens when B invokes c(d, e, f), so I have to write a test for that.

Dan Fabulich suggests adding either "Every time I stub a method that can raise an exception, I have to stub it again with a test that expects the exception" or "Every time I stub a method to return X, I also have to write a test where the stub returns Y. And Z. For all possible return values of the method." Of course, it's impossible (or at least very difficult) to be sure you've gotten all edge cases.

My takeaway from all this is that integration tests are overused, often perhaps as a half-baked attempt to remedy poor unit tests (even though the two different tests try to solve different problems). While I'm not quite ready to do away with integration tests entirely (I think they provide a useful documentation of examples of use without going into the nitty gritty details of a unit test and make a nice supplement to unit tests), I think one should recognize their place: performance testing, and as general review. NOT for finding bugs or ensuring changes didn't break anything and certainly not for finding where they occurred. One should add them as a separate module that is only built when requested, or using something like the FailSafe plugin for Maven.

</edit>

One idea that he mentions early on in the talk is the idea of having only one assert per test. This is something I'm occasionally guilty of (especially if the method being tested does several things). This should be a testing smell that may indicate the need for some refactoring.

He also mentions what first got him interested in TDD, which I thought was one of the most compelling reasons I've heard so far to use TDD. When you don't use TDD you have a seemingly endlessly depressing cycle of writing tests, fixing bugs, writing more tests, and so on...how do you know when you're finished? When you do TDD, it has a bit more definitive ending point:

Think about what you want to do
Think about how to test it
Write a small test. Think about the desired API
Write just enough code to fail the test
Run and watch the test fail. (The test-runner, if you're using something like JUnit, shows the "Red Bar"). Now you know that your test is going to be executed
Write just enough code to pass the test (and pass all your previous tests)
Run and watch all of the tests pass. (The test-runner, if you're using JUnit, etc., shows the "Green Bar"). If it doesn't pass, you did something wrong, fix it now since it's got to be something you just wrote
If you have any duplicate logic, or inexpressive code, refactor to remove duplication and increase expressiveness -- this includes reducing coupling and increasing cohesion
Run the tests again, you should still have the Green Bar. If you get the Red Bar, then you made a mistake in your refactoring. Fix it now and re-run
Repeat the steps above until you can't find any more tests that drive writing new code

(from the C2 wiki)
I like that. This would help address my previously mentioned fear of knowing when you've tested everything. (Though I'm sure it's not foolproof).

For my next trick....I will make a DVD drive disappear

2009-09-11T05:47:00.001-04:00

My DVD drive continues to disappear, only reappearing after a restart. I tried updating both the bios and the chipset drivers to no avail. Only the SATA drive disappears, the PATA drive remains. I have a P5N7A-VM motherboard and a Pioneer DVR-216D. I believe this to be a windows driver issue, but I don't know what I can do about it. (I certainly won't get any help from Microsoft). I guess I'm living with it.

iTunes Pains (Again)

2009-09-10T21:05:00.005-04:00

This time the upgrade to iTunes 9 broke my beloved MediaMonkey. I really should just use something else to get my podcasts and blow away iTunes. I don't even have an iPod anymore and have no plans of getting an iPhone -- there's really no reason to keep this piece of trash on my hard drive.
A work around was posted here: http://www.thebitguru.com/blog/view/310-MediaMonkey%20and%20iTunes%209
Granted, its not iTunes' fault per se, and I'm sure MediaMonkey will get it fixed soon, just damned irritating. I didn't follow his instructions exactly...what I did was rename d_iPhone.dll to d_iPhone.dll.disabled in the MediaMonkey plugins folder in program files.

EDIT:
MediaMonkey has pushed out a beta release (a bit earlier than they were planning) that fixes compatibility with iTunes 9, only 1 day after it came out: http://www.mediamonkey.com/beta/MediaMonkey_3.1.2.1267.exe. It might be better to delete the file rather than rename it (if you're comfortable with that), then it will be replaced when the new installer is run.

Beware of openStream

2009-09-10T12:57:00.016-04:00

Yesterday we discovered a bug where one of our projects hung and had to be CTRL-C'd. The culprit ended up being one line:

URL url = new URL("http://someurl")
InputStream is = url.openStream()//<---this one

The openStream method is actually shorthand for openConnection().getInputStream(). So it returns a newly instantiated URLConnection and calls getInputStream() on that. The problem is, which the API won't tell you (but is visible in the source) is that the default values for connectTimeout and readTimeout are 0. This means, if the connection/read fails, it will continue to try to connect/read forever. While we tested for the connection to be good before we began processing, getting from a URL caused it to hang when the service went down in the middle of processing.The solution was mentioned in this StackOverflow question. The solution lies in not creating the InputStream from URL, but from URLConnection and setting the timeouts:

int timeoutMS = 5000 // 5 secs
try {
  URL url = new URL("http://someurl")
  URLConnection conn = url.openConnection();
  conn.setConnectTimeout(timeoutMs);
  conn.setReadTimeout(timeoutMs);
  InputStream is = conn.getInputStream();
} catch (java.net.UnknownHostException uhe) {
    // something useful here
} catch (java.net.SocketTimeoutException ste) {
    // something useful here
}

Eric has posted about this as well (it was his project we learned this from).

Unit Testing: Mein Kampf

2009-09-04T22:41:00.012-04:00

So, over the last 1.5 weeks or so I've been having a bit of an identity crisis with unit tests. Sure, I got the basic idea of writing tests for each method in college but like most never used it much while in school. Now that I'm at OCLC and unit testing is expected, I'm trying to develop my own philosophy on the matter and get a feel for it.

I felt like I should bring code coverage up on the project I was working on, but for purely religious reasons. Now, granted, this project is heavy in IO (it's the same project I mentioned previously). So perhaps I'd see less benefit from unit tests on this project than others, but despite the fact I now have >70% coverage (up from 0%), I haven't found a single bug by using unit tests, only with integration tests. The results might also have been different had I used TDD or my home-brewed syncretic TOD approach.

Despite these facts, I don't argue that Unit Testing used with CI can help as a tool for preventing software regressions and as up-to-date documentation for the code (though I still don't find it a very natural read except for BDD approaches like EasyB). It's also useful for finding the root cause of a problem. Whereas an integration test might only be able to say "something blew up" a unit test might be able to tell "here is what blew up". However, the value of the unit tests I've created I think remains to be seen. Meanwhile, it did deliver value as a learning platform.

Groovy has served as an excellent testing platform for me. This particular project was written in Groovy, but I think this would work well with Java projects as well (there is, however, the slight overhead of the additional dependency). I was able to do everything I wanted (still a few kinks to work out) with stubbing using the wonderful, magical, ExpandoMetaClass. There are a few tests I have yet to do where I may have to use their mocking framework.

A couple gotchas:

// getters cannot be overridden using just the property name, even though they can be called that way
class Foo {
  int bar
}

Foo.metaClass.getBar {->
  return 44
}
foo1 = new Foo()
assert foo1.bar == 44  // this passes

GroovySystem.metaClassRegistry.removeMetaClass Foo
Foo.metaClass.bar {->
  return 42
}
Foo foo1 = new Foo()
assert foo1.bar == 42  // this does not

I wanted to send some precanned input to a method that uses BufferedReader to get its input. The constructor from it eventually constructs a File to get the data. I can't extend File or create a new interface with all the File stuff for a test, because that would require modifying BufferedReader and Reader classes to match these changes. I've not found a way around this.

Another problem was a method that takes a String path of a file that contains filepaths of input files to process and adds the string and a BufferedReader to that file to a collection (not sure why that decision was made). So, I tried to mock out eachline(). But there is a problem...

// you cannot metaclass constructors, therefore, this code doesn't work. I've still got to figure out a way of faking a file, since File cannot use map coercion because it has no default constructor
String aPath = "a/path/to/file"
String fakeData = "some\nfake\nstuff\n"

File.metaClass.init {String filePath ->
  def mock = [eachLine: {return "${fakeData}"}, exists: {return true}] as File
  return mock
}

File f = new File(aPath)  // doesn't work

There are still some larger questions I have that maybe I'll never get THE ANSWER to. One question in particular I've been struggling with is "How simple is too simple to break?" The JUnit authors suggest this is a never-ending source of pain:

becomeTimidAndTestEverything
while writingTheSameThingOverAndOverAgain
    becomeMoreAggressive
    writeFewerTests
    writeTestsForMoreInterestingCases
    if getBurnedByStupidDefect
        feelStupid
        becomeTimidAndTestEverything
    end
end

And it's still very easy for me to lose sight of what I'm actually testing in the midst of all the mocking, stubbing, and so forth. More than a few times this last week I've looked down and realized that what I've written is so paranoid that it is really testing stuff that can only fail if the compiler or JVM fails or cosmic rays come down and change my data.

Just as important as making sure your tests pass is making sure they fail. I struggled with this the most when I started this process. I thought "wonderful, everything works." When it turns out that the code didn't work quite the way I thought it did and my tests were actually written in such a way that they would NEVER fail. All those green bars might not actually mean much. That't not to say they're worthless, just maybe not as valuable as you might initially think.

And this leads to my greatest fear: How do you know when something is thoroughly tested? And can some sort of confidence be associated with your tests? Clearly, code coverage doesn't cut it. I'm still new to all this, but I'm not taking much comfort from unit tests. I feel a bit better when integration tests return exactly the result I'm expecting and I test several possible scenarios. Still, even with this, you cannot test all possible scenarios and when do you know you've got enough? I guess when something blows up and you didn't find it. (>_<)

P.S. by 'Mein Kampf' I just meant the literal 'my struggle' it has nothing to do with Hitler or his work.

iTunes Blows

2009-09-04T21:44:00.002-04:00

iTunes blows, but we all knew that. The latest chapter in the suckage occurred when I deleted UppperFilters from HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Class\{4D36E965-E325-11CE-BFC1-08002BE10318} in an attempt to solve my problem of the disappearing cd drive (it didn't). Instead iTunes lost the ability to write CDs, not something I really care about since I only use iTunes for podcasts now anyway, but the stupid error was kinda annoying. The message said to reinstall iTunes, yet neither a repair install nor uninstalling then reinstalling fixed the issue, even after I manually created the key. Apperantly there are some magic drivers in use by iTunes that their support site will tell you nothing about. I finally got it fixed. My thanks to Ralph and Google.

The Obvious

2009-09-04T08:36:00.002-04:00

Read a quote yesterday I rather enjoyed:

by C.A.R. Hoare
There are two ways of creating a software design. One way is to make it so
simple that there are obviously no deficiencies. And the other way is to
make it so complicated that there are no obvious deficiencies.

Why My GroovyConsole Wouldn't Open

2009-08-28T16:48:00.003-04:00

For a few weeks now, I've been wondering why I couldn't launch the pretty version of GroovyConsole on my home computer, but could on my work computer. It turns out this is a bug: http://jira.codehaus.org/browse/GROOVY-3655. Groovy needs the 32 bit JDK to launch. Nore more batch hack, I can now launch the GroovyConsole.exe directly. (Though they still haven't built this for the updated versions -- I assume they're holding off for the 1.7 release).

Problem was, at work I need to use HermesJMS which needs JAVA_HOME to be the 64 bit version (doesn't make sense, but it works). What to do? Fortunately, HermesJMS uses a batch file for its invocation, so just add

JAVA_HOME=C:\Progra~2\Java\jdk1.6.0_16

to line 23 (or anywhere in the beginning, really). Done.

Answered: Using variables in XmlSlurper’s GPath

2009-08-27T00:11:00.006-04:00

Yesterday I asked this question about using variables with XmlSlurper. I got an answer that works (although I don't see it anywhere in the documentation or the book Groovy in Action. Below is the example the answerer gave.


def xmltxt = """
<file>
<record name="some record" />
<record name="some other record" />
</file>
"""

def xml = new XmlSlurper().parseText(xmltxt)
String foo = "record"
return xml."${foo}".size()



Test Oriented Development
2009-08-26T22:34:00.001-04:00
The other day I had an idea.  Probably a bad idea, but its something I feel more comfortable with than diving straight into TDD.  The rules are
You are encouraged to write the test first, but are not forced to.
You may not write more than one method without a test.
This way, you write tests as you are writing code, you might write all your test first, but you will never write too much code that isn't tested (assuming you don't cram it all into one gigantic, godlike method).  I dub it TOD (Test Oriented Development).


GW2 Trailer
2009-08-26T22:30:00.000-04:00
ArenaNet has released their first trailer for Guild Wars 2 here: http://www.guildwars2.com/
I'm pleased to see that progress is being made.  However, I do have to admit a little disappointment at the graphics.  Although GW2 is supposed to use DX10, it doesn't look any different than the first GW (not that it's bad).  I really didn't like the first part of the movie where they gave movement to their concept art.  Made it look like construction paper glued to straws as puppets.  I don't if this was a stylistic decision or their way of combating a lack of content (though my guess is the former).  I'm sure the graphics will probably change before its final appearance.

One thing that definitely was a stylistic decision that disgusted me more than anything was how they made the Asura look.  They were already too cutesied up in GW1 (especially compared to the concept art), now they look like some kind of anime character.  That was one thing we all love about GW art was that it was fairly realistic, not the cartoonish fantasies of WoW.  PLEEEZ, don't change this ANet!


Integration Testing
2009-08-21T00:45:00.004-04:00
My colleagues and I have been learning a lot about testing this week.  One of my friends' thoughts are here.  He asks the question of whether it is a unit test if the method in question calls other methods.  I agree with him and would argue that no, it is not, since the culprit is unclear if the method fails (until you go into debugger).  Arguably, this could be worst for code that is properly refactored.  This is something I don't think code coverage tools will help you recognize.
StackOverflow has some good definitions of unit and integration testing here, and here.  I like Michael Feathers' definition:
A test is not a unit test if:
It talks to the database
It communicates across the network
It touches the file system
It can’t run at the same time as any of your other unit tests
You have to do special things to your environment (such as editing config files) to run it
Josh Brown, a colleague of mine, also suggests adding:
the code under test uses an external framework or library (Hibernate, Spring, some internal library, etc.)
the code under test calls other methods (that you didn't mock)
I wholeheartedly agree with both of these.

I had a case that was interesting to me.  I was working on some code that I've become the caretaker of to get it better tested (a good thing too, as a bug was discovered).  The project takes big files and chunks them into smaller files.  It handles any xml or delimited file.  The way I was testing it was to take different types of files, chunk them then merge them and make sure the record counts stayed the same.  This isn't really (even if I had more granular asserts) a unit test.  It relies on an external resource (the sample files) and involves multiple methods.  Someone else suggested unit tests using files loaded through classpath, which I disagreed with since they're not really unit tests.  Those File objects should be mocked (or possibly stubbed if using Groovy).

I did attempt to make these an integration test with FailSafe.  I decided against this when I figured out that I could not override the behavior to not run the integration test on deploys.  In my opinion, these should not be run on deploy, integration-test should be later in the Maven lifecycle.  The reason for this is that deploys are often done across different environments and the whole idea with integration tests is that they depend on external resources.  An example of this is a project my friend is working on, which works with the dev database, where it would be fine to run the integration tests on deploy, but when it is deployed to prod, we definitely don't want to modify our production database as part of running tests.  To continue to be able to access the QA environment or dev environment would mean adding special firewall rules.  What's more, when I set the configuration to skip the tests, it ran the tests anyway (maybe this is why it's alpha?).  According to their documentation, it shouldn't have even run the unit tests.  I just don't feel quite comfortable deploying something so young and apparently unstable into production code.  Maybe someday this will change.  There are some other suggestions here.  The page he links to from Codehaus states that there are rumors of a future version of Maven supporting integration tests with a src/it/java and its own integration-test phase.  Its kinda surprising that with so many organizations using continuous integration and it not being something all that new.

In the end, I decided to do what others have done, which is to have the integration tests in a separate module that is only built if the argument is passed for it.
The parent pom should have
<profiles>
<profile>
<id>integration-testing</id>
<activation>
<property>
<name>it</name>
<value>true</value>
</property>
</activation>
<modules>
<module>sampleProject-integration</module>
</modules>
</profile>
</profiles>
Also, do not list it in the modules section.  This way, the integration module will only be built (and the associated surefire tests run) when the -Dit argument is present.  I think for most projects, this makes sense for most projects, though I'm still a little torn on the issue.  While Failsafe lets you still build even if the integration test fails, doesn't this defeat the purpose of continuous integration?  This is especially the case if your integration tests depend on resources that may be going up and down all the time, it doesn't make much sense to run something every time if half the time you just ignore the results anyway.  I also wonder how practical this is for organizations that have resources on multiple subnets, where a deploy from one environment to another can result in failed integration tests not because of any problem with the code, but because of a technical failure.

The next part (and for me, the harder part) will be mocking out (and maybe stubbing with Groovy's metaclass) the pieces needed so I can isolate the methods in the classes for unit tests, as there currently aren't any for this project.  I'll post any interesting results I get from that.  For other initiates, such as myself, I've found this article helpful: http://martinfowler.com/articles/mocksArentStubs.html.


GW2 Update (well, sorta)
2009-08-18T19:12:00.004-04:00
Yesterday ArenaNet put the Test Krewe page back up and gave some small hints at forthcoming GW2 news.  They've posted a shiny swf on their homepage to be: http://www.guildwars2.com/, created a facebook page: http://www.facebook.com/GuildWars2, and a twitter account: http://twitter.com/guildwars2.  All indicators that they're preparing to release some news.  Probably nothing as dramatic as a date yet, but we should at least get a trailer and some concept art.  Maybe even some discussion about the professions (my prediction is that it will be the core professions from GW1 or very similar, based on the fact the shaping of the world has cut off Tyria from Cantha and Elona).
The related GWGuru page is here: http://www.guildwarsguru.com/forum/showthread.php?t=10395760.  Mostly people are excited (those that haven't left the game anyway) though some other pages lurking on the internets weren't as generous.
Am I peeing my pants excited?  No.  But as I've said, I do think little tidbits, even if they're contrived and only give the illusion of progress (which I don't think these will be) are an important part of keeping a feeling of aliveness in the community.


The Taste of Cha
2009-08-17T22:33:00.003-04:00
I've resumed my habit of regular consumption of green tea.  Every time I do, I think of the legend of how green tea came about:

Bodhidharma set about meditating for nine years facing a wall. After five years he was so sleepy that he could not keep his eyelids open and fell asleep. When he woke up he was so angry about this that he cut of his eyelids and threw them on the ground. The eyelids grew into the first green tea plants.  And from henceforth, tea has ever been the companion of monks for mediation (and apparently for geeks and programming as well).

It is said that "the taste of tea (cha) and the taste of Zen (Chan) are the same".  In Japanese, the characters for 'tea' and 'eyelids' are both 'cha'.

mmmmmm.....cha tastes good.


The Tao of Zen
2009-08-17T21:58:00.004-04:00
In pursuance of an ongoing 'independent research project' I am conducting, I recently 'read' (by read, I mean I took the chapters I needed to answer specific questions I had) The Tao of Zen by Ray Grigg.  Its a good book, I had to return it, but I may purchase it for myself and finish it.

The question I wished to answer was 'what was the historical relationship between Buddhism and Taoism, particularly Chan and Taoism in China and how this changed when it migrated to Japan.  This book argued essentially that Zen was a convoluted form of Taoism, tainted by later Mahayana thought that felt the need to establish a historical tie to the Buddha Gautama in India and through rapid expansion it adopted practices (like zazen and the hierarchy in temples) that were antithetical to the original teachings.  He states that it is this same difference that separates the northern and southern schools in Taoism and their Japanese counterparts of Soto and Rinzai.  This will take some more research to verify.  I'm not sure how highly regarded this work is in academia, it is certainly a possibility.  However, since not a lot of written materials has survived from this period intact, I should think it is a position that is hard to verify.

The gist was that Zen - Buddhism = Taoism.  While this appeals to me as someone who as adopted principles of Tao Te Ching in my own life, it is a bit too strong I think.  China's religious history (at least before the revolution, they're raised atheists now) is a syncretic one.  Taoism influence Chan (Zen in Japan) but Chan also changed Taoism.  Some of the practices, such as meditation seem to have had parallel histories.  When Buddhism first arrived in China, some believed it to be another form of Taoism, speculating that Lao Tzu must have traveled to India and now the teachings are returning.  This could explain why many of the early Buddhist texts of the period use Taoist words as the framework for understanding Buddhism (e.g. Tao in place of enlightenment, or Satori as it is called in Japan).  It's also important to note they are not in direct conflict with each other, and many people practice a combination of faiths.  It does beg the question though, for people like Alan Watts who purport to follow Zen, would it actually be more accurate to say they follow Taoism?  Alan Watts doesn't seem too concerned with the distinction from what I've read and heard from him.

I am not completely satisfied with this answer, and will be seeking a more rigorous investigative report.  In the mean time, the next step in this project will be to learn the relationship between Taoism and traditional chinese folk religion and animism.  Specifically, I would like to know if there is any relationship between it and the animism of Shinto in Japan.  More to follow.


Massive EMP
2009-08-17T21:27:00.002-04:00
I've often wondered: If a massive EMP (from a nuke or whatever) were to go off, wiping out all our technological achievements (silicon chip designs, computer languages, etc), how long would it take for us to rebuild?  Is the knowledge mostly inside us?  Or are we standing on the soldiers of giants to such an extent, we would have to invent the wheel all over again?


Skype Spam
2009-08-17T19:54:00.001-04:00
Been getting a lot of spam contact details requests lately.  Usually more than one in a day.  What's up with that?  How do they profit from this?


Traffic Calming Ahead
2009-08-17T08:04:00.002-04:00
I saw a sign that said "Traffic Calming Ahead" during my last shopping trip.  This morning I remembered to look up what it means since, in my mind, 'traffic calming' brings an immediate association with 'crowd pacification'.  Don't ask me why.  It turns out, its not all that exciting it's apparently just a more polite? way of saying speed bumps.


Substition in Java .properties
2009-08-16T11:35:00.000-04:00
Though I ended up not using it for a project I'm working on, I was interested in using the java.util.Properties with substituted strings, as can be done in Ant and Maven.  I came across this link to XProperties: http://www2.sys-con.com/ITSG/virtualcd/Java/archives/0612/mair/index.html


ArenaNet Fail
2009-08-14T17:12:00.003-04:00
This is something that has been bugging me, and I'm sure several others over the past couple months.  ArenaNet seems to be unable to meet deadlines or even keep up with routine maintenance.

The latest of ArenaNet's offenses has been the Test Krewe page.  They enlist players to play around with updates on a test server before it was pushed out to the live one.  Cool.  The problem?  Apparently they don't know how to write PHP!  Basic form validation was completely absent, people who used hard returns, too many characters, or certain punctuation broke the page.  Come on people, this is basic stuff.  They took it down until it could be fixed the same day it was up (Aug 11) and its still down.  Yet again, ANet kept the community in the dark.  While there was a post by Regina Buenaobra buried in Guild Wars Guru, if you navigate to the page today, you will just get the message "We're sorry, the page you requested could not be found."  How hard would it have been to put a message saying "We know this page is broke, we're fixing it".  As usual, there is no time estimate whatsoever for when the page will be back up.

Another example of their apparent complete lack of even basic web dev skills was the whole Xunlai Tournament House fiasco.  The page was taken down June 23 because of problems with the distribution of the points for May.  It's now been 2 months and there is no word on its status.  There are players who still haven't gotten their points.  Another 'It'll be done when it's done' deals.

GW2 news, plz.  I know, I know, everyone who plays Guild Wars would love to have some tasty morsel of information regarding Guild Wars 2 and ArenaNet doesn't want to jump the gun (though I think they already did by suggesting a beta in 2008 then reneging on it).  I think especially in the light that there won't be a beta, players would much appreciate a blog or something where once or twice a month SOMETHING is posted about GW2.  Maybe its an idea they have for a profession.  Maybe its some kind of rough sense of progress (1/2, 2/3, etc).  It doesn't have to be much.  It doesn't have to be written in stone.  Just something to let us know we aren't forgotten, and that GW2 is still making progress.

While this is a problem that is not unique to Guild Wars, I'd really like to see community involvement.  Take a look at GuildWarsGuru, there are several threads full of ideas people have for making the sequel kickass.  Why not find a way to incorporate these in some way?  Maybe even respond to some of them?

It seems to me that ANet is short-staff and/or over-tasked and anachronistic in its communication.  I know they're probably working on a tighter budget than some other game companies (though their quarterly report shows increased sales (up 51%), and growth in Guild Wars), but would it really be that expensive to be more open with your customers?

I'm kinda mad.


---Oh, and $20 is too much for character renames.


My First iGoogle Theme
2009-08-13T00:37:00.003-04:00
I experimented with making my own iGoogle theme
here
The interface they have is rather limiting (couldn't choose the color black for background) than their API, may experiment with that next.


You left your stuff
2009-08-12T21:19:00.002-04:00
I discovered why my bathroom sink drains so slowly this evening.  The previous renter must have been a girl with long black hair.  Diiiisssgusting.  I got what clumps I could from the top with Q-Tips, but its caked pretty thick.  I don't know what the hell she was doing, maybe she had cancer or something, its a fair amount of hair.  I don't have the wrenches to take the trap apart.  I'm going to see if I can get maintenance to do it.


Knowing Someone
2009-08-09T22:37:00.002-04:00
This is a subject that has been on my mind for a few years now, and probably the emotion most directly responsible for my feelings of isolation from the rest of my species.  I've always wanted to really, really get to know someone.  Yet, when I think about the people I know, even those I know really well, like my family, I never feel like I know them really.  When I think about knowing someone I see a face and collection of facts and behavior patterns.  I know their history, I know how they'll probably act, and to a certain degree how they think.  I may even be able to ascribe certain characteristic attributes to them.

Yet I can't help wanting more.  I would like to be able to have a melding of thought and emotion, something almost spiritual in its connection.  Is that what being married is like?  I feel limited, trapped by being in physical form.  Like a stranger in my own body.  I think life as a disembodied spirit might be more amusing, as well as enlightening.  Its very strange.  Maybe I should have been born in a species of em-paths.  I think I shouldn't feel this way, that I should be happy or at least satisfied with existence as a human, yet I find it rather unfulfilling.  Fortunately, there are enough diversions and things to learn to keep it tolerable most of the time for myself.
    <Buddha>: Existence is Dukkha.
     *Keegan sighs*
    <Keegan>: I know --- and everyone dies alone.

How strange am I?


Gone
2009-08-09T20:43:00.002-04:00

Somebody knocked down the robin's nest outside.  Luckily the inhabitants had already left.


Groovy & CXF JAXB
2009-08-07T09:07:00.012-04:00
I was working on making an existing application a mule service, when I ran into the snag that Groovy classes, when exposed as an parameter to the service method, which throws an error when JAXB attempts to deserialize the object to xml (for creating the wsdl).  Every Groovy object possesses a property called metaclass that cannot be serialized because it is an interface.  At the time, I solved this problem by wrapping the Groovy stuff with Java, to expose only what I wanted.  Another way I could have done it would have been to have the Groovy class implement a Java class.

I later found out a third method, when I attended a brown bag session where a colleague gave a talk about using JAXB.  Today, I found this link, which describes exactly that.  Annotations can be used to override the default JAXB behavior to exclude that messy Groovy stuff.  I haven't experimented with this yet (since I've already got my service working and there was no compelling reason to do it in Groovy instead of Java), but I wonder which of these three solutions would be the cleaner solution.  I don't have a really strong opinion on this, but its probably preferable to have extra annotations than to have extra classes.  Extra wrapping classes just result in more boilerplate code for the next guy down the road to wade through, at least annotations would only add a few lines (one line I believe in the case of CXF).  Allegedly, just adding the annotation
   
@XmlAccessorType(XmlAccessType.FIELD)
to your class will resolve the issue.  Has anyone else done this?  How did you resolve the issue?


Traffic
2009-08-06T20:30:00.002-04:00
For the first time in my driving experience, I experienced anger at the traffic conditions this afternoon.  My normal commute is about 25 minutes, which I don't mind too much (though I'd like to shorten it next year).  1 hour after leaving work, I was still in the same town, about 2 miles away.  I seriously could have gotten out and walked faster.  My foot got tired of holding down the brake pedal, so I put myself in park in a few places, to give it a rest.  The whole ordeal lasted 1.5 hours and I was ready to pour out merciless, meaningless destruction.  Instead, I watched reruns of Sarah Connor Chronicles and installed Windows 7.  I eventually forgot why I was mad.


@version JavaDoc Tags
2009-08-06T14:41:00.021-04:00
Another comment that came up in my code review yesterday was why I had an @version 1.0 in my JavaDocs for the class I wrote.  My reasoning was that, according to  Sun's documentation, the author and version tags are required (though obviously it won't throw a compiler error or anything like that, it may throw an error in Sun's Doc Check tool).  This launched a discussion about whether the version tag should indicate revisions in the version control system (in our case svn) or release tags of the software.  The practice varies from shop to shop, but my initial reaction (despite Suns' practice) considered tags to be logical, since that would indicate API changes.  However, @since I suppose is what really should be used, and a colleague pointed out that changing all the classes to match whatever release is current hides the fact that some classes (particularly abstract data classes) may not have changed at all.

My own conclusion out of this was to use svn keyword substitution to set the tags.  I used my favorite svn client, TortoiseSVN, to set the properties.  You can either set it as a global setting (which will add the property to new and imported files) or on particular files (need to do for files that already exist).  This matches Sun's practice of tying @version to their source control system.

While on the subject of JavaDoc, I was mocked for pointing out a spelling mistake in a JavaDoc comment.  In my view, JavaDoc is a special class of comment.  Whereas internal comments can contain all the mistakes and profanity you want, JavaDocs are something your client might actually see, and thus should be treated just the same as a mistake like
System.out.println("Pleez enter your name: ");
String name = bufferedReader.readLine();
Am I wrong?


Pieces Parts
2009-08-06T13:18:00.002-04:00
The term 'pieces parts' is popular here at OCLC, as a way of describing components, modules, and the like.  Is this the case anywhere else?  Or is this one of our unique quirks?


Things I Learned From My First Code Review
2009-08-05T21:48:00.015-04:00
Here's some interesting ideas I saw in my first code review at OCLC

instead of setting to a non-null in constructor to prevent null from being returned, check before it is returned by
doing this
public String getSomeString() {
  return (headerTag == null) ? new String() : headerTag;
}
instead of this
String foo = new String();
...
public String getSomeString() {
  return foo;
}

for String concantenation, StringBuffer is faster than String (http://java.sun.com/developer/JDCTechTips/2002/tt0305.html).  Unlike Strings, which are immutable, StringBuffers are mutable.

surround your log4j debug log statements in an
if (log.isDebugEnabled()) {
  log.debug("message here")
}
so that the string isn't needlessly constructed (http://logging.apache.org/log4j1.2/faq.html#2.3)

avoid NPEs in comparisons, do:
String foo = "Some_String";
if (foo.equals(someString)) { ... }
instead of:
if (someString.equals("Some_String")) { ... }



Stop Sign Trimming
2009-08-02T22:50:00.000-04:00
Why is it some stop signs have the reflective trimming around the edge and some don't?  I could understand if Ohio did and Michigan didn't, but it isn't standard even in the same county, let alone state.  What gives?  If the state wants my opinion, I say keep the trimming.  It looks nicer, and it points out the octagonal shape, making it clear what it is.


Wash & Wax
2009-08-02T12:48:00.002-04:00
I decided to wash my car yesterday (and of course it rained last night).  I was shopping for supplies to do so, when I noticed a large selection of wash & wax combination bottles.  Does anyone know if these actually work?  If it is made with that turtle wax that is supposed to last 1 year, does it provide the same level of protection?


My First Ride in the Back of a Police Car
2009-08-01T12:43:00.000-04:00
I must admit some embarrassment about this story.  I experienced my first (and hopefully only) ride in the back of a police cruiser Friday evening. I was on my commute home and went to pass someone, but my car didn't respond.  I punched the pedal to the floor, and I began decelerating.  Shit.  I had noticed that there was 1 bar left of fuel (I have some new fangled digital display) after my commute home the evening before, but I figured there was about 2 gallons left, which should give me around 50 mi.  I detest shopping and I was going to put it off until Saturday when I do the rest of my shopping (the gas is a few cents cheaper there anyway).  I pulled off to the side and consulted my gps for the nearest gas station (3.3 miles if I followed the road).  I was pondering what to do or who I could call when a K-9 deputy sheriff approached my door.  Interestingly, he didn't ask for my license or registration, I got patted down, and taken about a mile down the road (he can do that U turn thingy I can't) and got to buy an $8 1gal tank.

What I learned:
 * Get gas when there is only 1 bar left, there will be no further warnings.
 * There is a program in Franklin County called FIRST responders, which provides motorist assistance during certain hours on certain days.


Error in mule-cxf.xsd?
2009-07-30T10:27:00.007-04:00
I'm reposting this, as I've reached new conclusions. Originally, I was convinced that there was an error in the xsd for the cxf transport in mule.  A collegue of mine posted a question on this to mulesource, but we haven't gotten a response back yet (except from me).  Examples on their wiki feature using the inbound-endpoint in the cxf namespace with the address attribute, such as:
<cxf:inbound-endpoint address="http://localhost:63081/hello" wsdlLocation="foo/bar/hello.wsdl" />
And this style is correctly interpreted by Mule and runs fine.  However, the address attribute shows up in red in IntelliJ IDEA as an invalid attribute on the cxf namespace. Anyone else ran into this? I originally attributed this to its not being present in the inbound-endpoint element in the cxf namespace, but being present in core.  But the cxf inbound-endpoint is actually an extension of the one in core, this is visible in XmlSpy and it validates fine in Eclipse. I now believe this is some kind of problem with either the xml editor and/or error highlighting components of IntelliJ. I can't find any Jira cases about this or any reference to it in the forums, so I opened a Jira case here. Maybe we should all just use Eclipse?

During this research, I did come across another problem (which I originally thought was the cause of our issue). Some IntelliJ fans ran into it a while ago. There already is a Jira case with Mulesource for this here. The cxf shema wouldn't validate because there was a bad address for an imported schema for Spring. It's a one line fix. Instead of
<xsd:import namespace="http://www.springframework.org/schema/beans" schemaLocation="http://www.springframework.org/schema/beans"/>
It should have read
<xsd:import namespace="http://www.springframework.org/schema/beans" schemaLocation="http://www.springframework.org/schema/beans/spring-beans-2.5.xsd"/>
The fix was merged into the 2.2.2 branch last week (and into 2.1.4 as well I believe). I don't know when they're deploying these fixes though, in the mean time you can download the files here (for 2.1.x) or here (for 2.2.x). I've tried to validate with these new files and validation still fails, though its due to the spring-context.xsd not Mule. Why can't people get xsds right? It would seem kind of important, as it's what everyone will be building their xmls off of.

Coincidentally, I've learned in writing this post how to paste xml/html code in blogger (found it here).  Less than signs (<) must be written in their html equivalent, which is &lt;.  There's also a cool script to translate it for you here.  And to quote html special characters like I did above, use &amp; instead of &. Also, Notepad++ has a built-in TextFX that can escape to HTML.

-- UPDATE 2009-11-17 --
JetBrains has released an update to IDEA 8, which includes the fix to the bug I submitted. The update notes can be found here
It is available as a free upgrade for those already with IDEA 8, get yours.
I believe this fix is also in the upcoming IDEA 9, so it should be in the Community Edition, for those who don't want to shell out for full-featured IDE.


Windows 7 *cough* 6.1 *cough*
2009-07-28T20:49:00.003-04:00
So...I'm getting pretty sick of all this Windows 7 hype.  "Oh this is soo much better than Vista, all the bugs are fixed, angels will sing, and gumdrops will rain from heaven."  Bullshit.  Windows 7 is nothing more than a tweaked version of Windows Vista (which despite the rumors is not that horrible of an OS).  Even colleagues in my industry have been driven to excitement (a testament to the Microsoft propaganda machine). Thankfully, there are some more level-headed voices out there. It is interesting to note that the official kernel version of everything release to date is 6.1, and not 7 (EDIT: 6.1.7600 for RTM).  There's some minor UI changes, supposedly some performance increases (I have yet to see anything significant).  Even LifeHacker's Top 10 good things about Win7, while all well and good, aren't very compelling.

My biggest gripe about Vista is its hardware demands, which I consider unreasonable (at least in today's market).  I'm sure some day 8GB of RAM will be standard on desktops, but I think these days, 1GB should be fine.  Yet I wouldn't recommend anything less than 2GB for Vista and it doesn't look like Win7 will change a thing.  Very disappointing.  IMHO, the reason for the Win7 hype is purely a marketing campaign.  Microsoft knows that, deserved or undeserved, Vista has a bad rap in the minds of the public.  So, they've tacked on some UI changes and slapped on a shiny new label just to sell something that's not Vista (even though it is). Our dreams of a skinny little Windows have been quashed, at least for Win7, but it is a step in the right direction.

Maybe MS has just completely lost touch with their customers.  Why isn't IT jumping on the Vista train now that we're almost 3 years after its release?  Because they're not prepared for the increased cost of hardware.  Yet what does MS do?  They include a virtual machine (which brings its own host of problems) for compatibility.  I don't think compatibility is too much of a concern at this point, most apps have made the changes they need to work with Vista's UAC and new driver model. What MS really needs to focus their efforts on is making a leaner, meaner Windows.