Boldly Open

Having finally recovered my blog (well, until the next crash, that is), I can finally comment about what happened last week at the Italian Java Conference. Having been a speaker, I probably shouldn't say so, but for the first time in a few years I actually found the event to be interesting, entertaining and informative.

The Italian Java Conference used to be a sales pitch event, with little to no content. During the past years I went there maybe two or three times, basically because it was a free event, a day off and a way to catch up with some people I know. This year it has been quite different: the theme being Open Source, sales pitch were bearable and reduced to a minimum. A few notable speakers jumped into the stage (among them Dirk-Willem van Gulik, Simon Phipps, Craig Lorman, Craig McLanahan and a few others) and the few sessions I could attend have definitely been interesting.

Unfortunately, I spent most of my time at the demo spot the organization gave us, where we have been presenting our latest and greatest XML Validation Server (guess what, Cocoon based) and giving away quite a few Pro-netics hats (basically we were the only ones distributing gadgets, and I guess that made the difference). Having to man the booth, I had to miss a few interesting presentations. To add insult to injury, my talk was colliding with what was to me the most interesting event (three notable guys talking about OOP and Agile stuff), however I managed to have an almost filled up room and a very interested audience who seemed to like what I've been saying (Apache Cocoon stuff, surprise!).

The expo area was filled up with italian companies selling Open Source stuff. I have to confess, though, that the overall situation looked quite depressing: we have a good number of organizations "promoting" Open Source solutions, but no one really seemed to have a clue. Most of them are what I call "cherry pickers", people browsing the OSS world to grab solutions, wrap them into brochures and sell services around them, the only added value being in most case an Italian localisation.

The few ones actually building OSS still have to get how real Open Source is about communities, itches and scratches: most of them are software houses using an Open Source license to sell their products better, hosting their projects on SourceForge and being done with it. I have been unable to find anyone participating to larger communities, no matter funding one: most of them look like they're just there to exploit Open Source and try to ride the wave.

I know they are doomed to fail, but my biggest fear is how their failure will impact the very few ones that are trying to have a dialogue with the OSS world instead than just listening or - even worse - shouting to an empty room and enjoying their voice. Time will tell, of course, but my suggestion to the plethora of OSS companies I met in the last few days would be learning to be a part of the bigger picture before planning to be "someone" in the commercial OSS world. If markets are conversations, then clearly no man (and no company) is an island. Is it that hard to understand?

After reading the latest post from Ugo, I tried to play the Google Maps game as well. It looks like I've been lucky enough not to be on Google Maps for a couple of miles:

let's say I live up north the blurred line, just follow the highway, take the next exit, turn right, left, then right and you're basically there. So, waiting for Google Maps to arrive, at least I know that for a while I'll be safe from Internet aware missile bombers.

My English is just too bad to express in a "haniful" way my feelings, so please insert random curses and swearwords yourself: I'll just jot down a few notes to let some steam off.

Suppose you're a pretty successful software house: you have been developing a nice product and, also thanks to some kind of "innovative" and apparently OSS-friendly license model, you had some success and recognition. So much that you start having partners around the world, people who - apart from selling your stuff - are doing integration work for the enterprise.

Suppose that, due to some kind of oversight, you built your data model around a (weak) Map object, providing a simple API around it:

interface SuccessfulCompanyInterface {

     void doSomething(Map objectModel);
}

so that people extending your stuff had to do something like this:

class ConcreteStuff implements SuccessfulCompanyInterface {

     void doSomething(Map objectModel) {

          String foo = (String)objectModel.get("foo");

          Bar bar = (Bar)objectModel.get("bar");

          performSomeUsefulStuff(foo, bar);
     }

}

Now, some engineer with a clue notices how the model contract is too loose, and decides to build a proper object model:

interface ObjectModel {

     String getFoo();

     Bar getBar();
}

So far, so good, uh? Now, however, you have a problem: what happens to the SuccessfulCompanyInterface? How can you deal with that Map being passed around instead than your new nice and dandy ObjectModel? Well, for one everyone with some software engineering experience would think about something like this for a while:

/**
 * @deprecated starting from version x.x this interface
 *             will be abandoned in favor of NewSuccessfulCompanyInterface
 */
interface SuccessfulCompanyInterface {

     /**
      *
      * @deprecated Don't use this anymore
      */

     void doSomething(Map someKindOfObjectModelAdapter);
}

coupled with:

interface NewSuccessfulCompanyInterface {

     void doSomething(ObjectModel model);

}

As an alternative, you could fire your engineer with a clue and make your partner's life a living hell just like this:

class SuccesfulCompanyController {

   void someWhereInsideTheMainLogic() {

       ObjectModel model;

       Map letsFuckUpOurPartners = new HashMap();

       letsFuckUpOurPartners.put("model", model); // FOOOOOD FIIIIGHTTT!!!

       while (successfulCompanyInterfaceIterator.hasNext()) {

            ((SuccessfulCompanyInterface)successfulCompanyInterfaceIterator.next()).
                doSomething(letsFuckUpOurPartners);

       }
   }
}

so that EVERY piece of your partner's code has to become:

class ConcreteStuff implements SuccessfulCompanyInterface {

     void doSomething(Map objectModel) {

          ObjectModel model = (ObjectModel)objectModel.get("model");

          String foo = model.getFoo();

          Bar bar = model.getBar();

          performSomeUsefulStuff(foo, bar);
     }

}

See? Now, to further ensure that you're going to piss people off big time, just include this massive pile of stinking stuff inside a DAMN MINOR VERSION. And double check not to include this in the release notes, or at a very least hide it deep down a sleeve of perfectly useless stuff.

This minor nit (NOT!) is going to cost us a few days of painful debugging and double checking - of course there is no way to check this crap at compile time - loads of money and massive delays, not to mention a significant branching of our code to support this "minor version" change. Shouldn't I be pissed off?

This is yet another proof that "bastardization" of Open Source doesn't really work. In a fully disclosed environment, we would have had a guy developing stuff for the project, or at least monitoring mailing lists and giving us a decent advance warning before stuff hit the fan.

What really matters, once more, is an open process rather than just available source code. And while I do like (usually) the way the guys above work, I'm even more convinced that there is no substitute for the amount of control available in Open Source Software: it's our business after all, for $DEITY's sake!

It looks like the DNS pain is over and my blog has switched. My secondary DNS, coupled with some CNAME weirdos due to nameserver synchronization, have been giving me some interesting time to wonder how the whole Internet can live on such a crappy infrastructure, where if you happen to make a mistake in DNS configuration you have to wait for every lame server out there to grasp your modifications. But it seems to be OK from a few hours.

So, I'm hosted on my new server now, even though I didn't move my blog to Wordpress as I expected to do. Actually I did install WP, and I also migrated my old posts: unfortunately the migration wasn't as smooth as I wished it to be (encoding woes - surprise!), which means I'm a kind of b2evolution hostage at the moment. Not that I care this much, actually: I liked some WP features, but I can perfectly live without them for the time being. Finding time to blog is much more of a problem for the time being than dealing with the blogging software.