No problem, I’ll find a Java solution and Groovify it. How about the Apache XML-RPC implementation?. Excellent. However, I need to know that it works in its most basic, i.e. Java form. I’d rather not sandbox up an entire XML-RPC solution just to see how this thing works. Though small, there ought to be a better way than throwaway, experimental code. A nice way to deal with this is to use the published Calculator example with easyb.

The calculator class was unchanged. Here’s the easyb story that combines the xmlrpc server and client sides.

import org.apache.xmlrpc.client.*;
import org.apache.xmlrpc.webserver.*;
import javax.servlet.http.*;

scenario "apache xmlrpc server should work", {

        given "an xmlrpc servlet",{
          def sum = 0
          servlet = new XmlRpcServlet()
        }

        and "a servlet webserver", {
          webServer = new ServletWebServer(servlet, 4000)
          webServer.start()
        }

        when "the calculator.add method is invoked by an xmlrpc client", {
          config = new XmlRpcClientConfigImpl()
          config.setServerURL(new URL("http://127.0.0.1:4000/"))

          client = new XmlRpcClient()
          client.setConfig(config)

          sum = client.execute("Calculator.add", [33, 9])
        }

        then “the sum should be correct”, {
          sum.shouldEqual 42
        }

        and “stop the webServer”, {
          webServer.shutdown()
        }
}

Also, very nice how easyb allows some relaxation of the strict Java syntax in the xmlrpc client section. That starts to suggest what a Groovy subclass might look like. Next, a git commit to capture this working example in a readable form for the lifetime of the project.

This all bubbled up again for me recently on an embedded project I’m working on to optimize security policy lookups on a multicore security platform. The task was to optimize performance of the vendor’s C reference implementation. Policy insertion used a simple, but unscalable single linked list having O(n) performance. Of course, the code comes without tests of any kind, so how does one know that the optimization changes don’t break basic functionality?

Obviously, the best thing to do in this situation is to write tests for existing behavior so that as the API is refactored and reimplemented, the tests find any new logic errors. I got payback even before the optimization work got started. The linked list insert (implemented thousands of times by thousands of developers) had a bug in it. Policies that were supposed to be stored in priority order after insert were off by one.

Definition: Reference System n. A software implementation provided by hardware vendors to demonstrate programming of a target device; not intended for deployment in end user products. (2) A software implementation provided by hardware vendors that is for the most part, directly inserted into the systems of end users.

This really isn’t a rant about reference code, it’s about defensive testing and the fact that writing tests are not just for dynamic languages. The Java community is mostly on board with this, but it seems to have gotten slower adoption by the C variant world. So c’mon embedded developers. Let’s stop pretending that the type safety testing by our compilers is good enough.

Here’s one option. I really like check as a unit test tool for C. It has a niced xUnit flavor and ought to be in everyone’s toolbox.

START_TEST(it_should_insert_in priority_order)
{
    Policy* policy5 = alloc_policy_with_priority(5);
    Policy* policy6 = alloc_policy_with_priority(6);
    insert_policy(policy5);
    insert_policy(policy6);
    fail_if(policy_find(policy5) == NULL);
    fail_if(policy_find(policy6) == NULL);
    fail_unless(policy_first() == policy5);
}
END_TEST

And if you happen to be implementing reference code, a set of tests for your API would be a welcome addition to your product; not a program to exercise the hardware, but tests that verify and document the behavior of your APIs. It will reduce the bulk of documentation that needs to be provided to end users and may allow you to remove those weasel words, “not intended for deployment”.

“A players hire A players,” he said. “B players hire C players. Do you get it?”

[From Folklore.org: Macintosh Stories: How to Hire Insanely Great Employees]

It turns out that some changes to the Linux kernel — Ubuntu 8.04 uses Linux 2.6.24 — have introduced some issues that make running Ubuntu in a VMWare virtual machine difficult. Ubuntu will install just fine, but you won’t have access to VMWare Tools, which provides some nice features like shared folders and clipboard syncing.

[From Ubuntu 8.04 Causes Problems With VMWare Tools, Open Source to the Rescue | Compiler from Wired.com]

It isn’t just VMWare. Mac Parallels has likewise bitten me and many others judging by the considerable forum angst. My peeps have been telling me to cutover to Fusion. I’d say if VMWare fixes their tools issues before Parallels, I’ll consider it.

I’m intrigued by the number of casual conversations lately that have touched on the theme of embracing constraints as a gateway to creative solutions. Are artists as constraint infected as their tech world brethren? There seems to be an awareness that unrestricted composition is a daunting task and that introducing constraints can get you to the downbeat.

Instead, someone says, “Write me a piece of music using only a flute, saw, and this broken toy piano. You can only use the notes D, E, and B - but never all 3 at the same time. It has to be in 3/4 time, start quiet, get loud, then get quiet by the end. Go!”

Aha! Now you’re cookin’!

[From Restrictions will set you free | Derek Sivers]

Recently, I’m hearing folks talk about their timed dashes. Duff says Nokahuna was a 48 hour burst effort and Nathaniel is crafting his weekly schedule to create artificial calendar constraints.

There, I did it. A blog post constrained to three paragraphs, a quote plus six links that associate 37signals with a broken toy piano. How’s that for a creative solution?

Freedom’s author is none other than Fred Stutzman, co-founder of claimid and local ibiblio dude. Now, can I get a weekend version to lock the keyboard…

Freedom is an application that disables wireless and ethernet networking on an Apple computer for up to three hours at a time. Freedom will free you from the distractions of the internet, allowing you time to code, write, or create. At the end of your selected offline period, Freedom re-enables your network, restoring everything as normal.

[From Freedom, OS X Networking Freedom Software]

Unfortunately, wading through junk recordings to find something fresh gets harder every month of the plan. I was in for the jazz and classical recordings primarily, but the eMusic offerings just don’t include the small labels who are publishing really good, modern stuff.

Lots of good jazz is archive and if you’re interested in early, classic recordings then eMusic can help fill the holes in your collection. Outside of that, eMusic won’t help you much.

So, goodbye eMusic. It was a great start, but you’re history; just like most of the jazz recordings in your library.

About the same time I described a local company’s IT abomination as “antiquated”, I came across loosewireblog’s post about user determined computing. An apt description of a blossoming concept.

Why do companies inflict IT systems on their employees that they wouldn’t dare ship to their own customers? Sadly, use of the word enterprise in the name or description is an early warning that it is going to suck. Here are a few examples of internal enterprise solutions I’ve encountered recently:

• Restricted email clients. If you don’t use the corporate approved client, you can’t get support.
• Internal mail lists that don’t archive messages. What’s the point?
• Time accounting systems that suck.
• Gold plated, IEEE compliant project management tools that make your eyes glaze over with features, links, colors, formatting, buttons… Please make it stop.
• Wikis (nice try, though) that have no RSS feeds or change notification.
• Byzantine process for scheduling conference calls on an internal bridge.
• Serialized document collaboration based on email workflow.
• Over engineered bug tracking and case management tools.

Some companies see their IT services as cost centers rather than strategic. When that’s the case, employees suffer the consequences and ignore the tools. Everyone loses.

First jazz gem discovery of 2008. This album from Alan Pasqua has throwback fusion undercurrents spiced with enough modern freshness to make it extremely interesting.

The album opens with a slightly restrained title track, but quickly gets edgy on “George Russell”.

“Prayer” begins as a quiet rhapsody for piano and morphs into a meaty set of funky tunes.

Pasqua likes a growling, electric Fender Rhodes sound over lots of laid back grooving.

Much of The Antisocial Club has a hard, driving ensemble feel that you’ll love if you’re into modern quintets. Trumpet and sax are out front, frequently doubled, with twisty, harmonic melodies. Tasteful use of electronica in solos and breaks is a really nice contrast to the rhythmic beats.

The album closes with “Message to Beloved Souls Departed”, a reflective, muted ostinato with simple, rich harmonies; possibly for Michael Brecker who passed away last year.