This post comes from a need I had to start cassandra in multiple instances on a single Mac (testing a cluster configuration out), and failing to do so. Previously on Linux, I had configured multiple instances to bind to 127.0.0.1 and 127.0.0.2 and it worked without any trouble. On the Mac though, I got the exception:

java.net.BindException: Can't assign requested address
	at sun.nio.ch.Net.bind(Native Method)
	at sun.nio.ch.ServerSocketChannelImpl.bind(ServerSocketChannelImpl.java:119)
	at sun.nio.ch.ServerSocketAdaptor.bind(ServerSocketAdaptor.java:59)
	at sun.nio.ch.ServerSocketAdaptor.bind(ServerSocketAdaptor.java:52)
	at org.apache.cassandra.net.MessagingService.listen(MessagingService.java:138)
	at org.apache.cassandra.service.StorageService.initServer(StorageService.java:319)
	at org.apache.cassandra.thrift.CassandraDaemon.setup(CassandraDaemon.java:99)
	at org.apache.cassandra.thrift.CassandraDaemon.main(CassandraDaemon.java:177)

Until Jonathan Ellis and Peter Schuller on the cassandra list told me I could alias the extra addresses to loopback using this:

sudo ifconfig lo0 add 127.0.0.2

After that, ifconfig shows the added IP under the “lo0″ device and cassandra can connect to it.

Well, here’s a quick and dirty solution to creating a non-blocking waitFor() call:

  public boolean nonBlockingWaitFor(Process proc, long procMaxTimeoutMillis) throws InterruptedException {
    final long TIMESTAMP_BEFORE_EXECUTE = System.currentTimeMillis();
    boolean hasExited = false;
    while (!hasExited) {
      try {
        // set/calculate your own granularity of check, which fits your procMaxTimeoutMillis
        Thread.sleep(500);
        // using the IllegalThreadStateException side-effect of exitValue() if process hasn't exited
        proc.exitValue();
        hasExited = true;
      } catch (IllegalThreadStateException e) {
        if (System.currentTimeMillis() > (TIMESTAMP_BEFORE_EXECUTE + procMaxTimeoutMillis)) {
          break;
        }
      }
    }
    return hasExited;
  }

This little block of code makes use of the fact, that Process.exitValue() will throw IllegalThreadStateException if one tries to peek at the exit value before the process has exited.

Is it nice? No!
Does it work? Yes!

I have a base class like this:

import org.springframework.test.jpa.AbstractJpaTests;

public abstract class AbstractCxfWsBeanTest extends AbstractJpaTests {
  public static final String[] SERVICE_CONFIG_LOCATION = new String[]{
      "classpath*:/applicationContext.xml",
      "classpath:/datasourceContext.xml",
      "classpath:/cxf.xml",
  };

  @Override
  protected String[] getConfigLocations() {
    return SERVICE_CONFIG_LOCATION;
  }
}

One thing here: cxf.xml is loaded from classpath by the test code, but it resides in src/main/webapp/WEB-INF in my source tree, which is not exactly classpath stuff. I came around that with this little snippet in the <build> section of the maven pom.xml:

  <build>
    <testResources>
      <testResource>
        <directory>src/test/resources</directory>
        <includes>
          <include>*</include>
        </includes>
      </testResource>
      <testResource>
        <directory>src/main/webapp/WEB-INF</directory>
        <includes>
          <include>cxf.xml</include> <!-- needed to make tests have cxf beans injected on them -->
        </includes>
      </testResource>
    </testResources>
  </build>

And finally, I can write a test like this one:

import org.springframework.beans.factory.annotation.Autowired;

public class TestMyWebService extends AbstractCxfWsBeanTest {

  @Autowired
  private MyWebService myWebService; // this is where I get my CXF WS impl injected

  public void testFoo() {
    assertEquals("bar", myWebService.foo());
  }
}

After some investigation we concluded, that, …the database was too loaded. Duh! Okay, so why? It turns out we hadn’t been using the insides of our heads that much. Each webapp deployed on tomcat had its own database pool defined in its own context. With many webapps, this summed up to a large max-value for how many connections we could open against oracle. Something that oracle couldn’t scale to.

So, to maximize throughput and sacrificing a bit on individual request processing time, we decided to define one single pool in tomcat, and let each webapp reference that pool. Here’s how it’s done:

In conf/server.xml in the <GlobalNamingResources> element, define the global database pool with a <Resource> element like we normally do inside each context. Something like this:

  <GlobalNamingResources>
     <Resource name="jdbc/yourglobaldsname" auth="Container" type="javax.sql.DataSource"
               maxActive="20" maxIdle="5" maxWait="20000"
               username="scott" password="tiger" driverClassName="oracle.jdbc.OracleDriver"
               url="jdbc:oracle:thin:@dbhostname:1521:sidname" initialSize="0" minIdle="1"
               validationQuery="select count(*) from smalltable"
               testOnReturn="false" testOnBorrow="true" timeBetweenEvictionRunsMillis="60000"
               numTestsPerEvictionRun="20" minEvictableIdleTimeMillis="120000"/>
  </GlobalNamingResources>

Then, in each context you remove the resource definition of the per context pool, and instead inserts a <ResourceLink> element, to refence the global pool. Like this in conf/Catalina/localhost/yourcontext.xml:

    <ResourceLink name="jdbc/yourdsname" global="jdbc/yourglobalds" type="javax.sql.DataSource" />

With a lot less load on the database, all users get a chance to get their work done. So by actually lowering the amount of concurrent requests we allow against the database, we get both better throughput and better processing time pr. request.

Just wanted to give a quick view on what IDEA can do for you with some of the latest JetGroovy support for @Grab annotations. With my projects I use maven for building, and as such, I have my dependencies in the pom. I then use the excellent maven integration in IDEA by simply opening project from the pom.xml, hereby letting IDEA build dependencies for all modules. Works well.

With my groovy code module though, I have the dependencies listed as @Grab annotations instead, as that will help my deployment. What I do not want then, is to have to put them into the pom.xml too. In essence, IDEA should be able to add module dependencies by recoqnizing the @Grab annotations.

Luckily, this is under way, and you can already now try it out. There is a small extra Grab plugin, that needs to be installed. When you have that plugin installed, you get an intention action for the @Grab annotations, saying if you would like to download. If executed, they will also appear on the module dependencies, nicely marked with “Grab: ..” names.

For further info see this issue and the Grab plugin can be found here.

One small note: If running maven-based projects in IDEA like me, you might need this Ivy dependency

    <dependency>
        <groupId>org.apache.ivy</groupId>
        <artifactId>ivy</artifactId>
        <version>2.1.0</version>
    </dependency>

…in your pom to make the plugin work. I think a fix is under way for this though

@Grapes([
   @Grab(group = 'oracle', module = 'ojdbc15', version = '11.2.0.1.0'),
])
class SqlTool {
  private sql;

  public SqlTool(url, driver, username, password) {
    this.sql = Sql.newInstance(url, username, password, driver)
    // ... do sql stuff
  }
}

new SqlTool("jdbc:oracle:thin:@dbhost:1521:dbsid", "scott", "tiger", "oracle.jdbc.driver.OracleDriver")

Because the oracle driver will be in the GroovyClassLoader, which is down the hierarchy relative to java.lang.Class, which is up in the root classloader, the loading will fail.

The @Grab annotation seems not to support the definition of which classloader to add the dependencies to, but luckily we have programmatic access to grape too. What we need to do is something like this:

import groovy.sql.Sql

def classLoader = this.getClass().getClassLoader();
while (!classLoader.getClass().getName().equals("org.codehaus.groovy.tools.RootLoader")) {
  classLoader = classLoader.getParent()
}

// force grape to use the root classloader - to ensure that Class.forName works for dependencies
groovy.grape.Grape.grab(group:'oracle', module:'ojdbc15', version:'[11.2.0.1.0,)', classLoader: classLoader)

class SqlTool {
  private sql;

  public SqlTool(url, driver, username, password) {
    this.sql = Sql.newInstance(url, username, password, driver)
    // ... do sql stuff
  }
}

new SqlTool("jdbc:oracle:thin:@dbhost:1521:dbsid", "oracle.jdbc.driver.OracleDriver", "scott", "tiger")

Use Grape!

With groovy comes Grape and the @Grab anotation. Grape is capable of downloading dependencies from maven repositories, much like maven does at compile time, but Grape can do it at execution time of the groovy script. In addition to the automatic resolving and downloading of dependencies, Grape is also capable of adding the dependencies on the script classpath before running it. Cool eh!? Here’s a small example:

package net.techper.foo.bar;

import org.jfree.chart.JFreeChart
import org.joda.time.DateMidnight

@Grapes([
   @Grab(group = 'jfree', module = 'jfreechart', version = '1.0.12'),
   @Grab(group = 'joda-time', module = 'joda-time', version = '1.6'),
])
class YourCoolTool {
   ....
}

This script use jfreechart and jodatime, both of which will be downloaded at runtime and added to classpath before the actual script execution.

Grape Internal and Config

Of course, dependencies only need to be downloaded the first time. The downloaded files are kept in $HOME/.groovy/grapes in a maven-like repository structure.

So what about dependencies that are not in the public repository? Well, you can get them too, as long as the target environment, in which the groovy script is executed, can reach the local repository, where you have these non-public dependencies stored.

Internally, Grape is implemented with Ivy. And Grape can be configured with a Ivy configuration file. Inside the jar distribution of standard groovy lies a default Ivy config, which has some of the major maven repositories predefined. You can provide your own though, by adding a file $HOME/.groovy/grapeConfig.xml which could look something like this:

<ivysettings>
  <settings defaultResolver="downloadGrapes"/>
  <resolvers>
    <chain name="downloadGrapes">
      <filesystem name="cachedGrapes">
        <ivy pattern="${user.home}/.groovy/grapes/[organisation]/[module]/ivy-[revision].xml"/>
        <artifact pattern="${user.home}/.groovy/grapes/[organisation]/[module]/[type]s/[artifact]-[revision].[ext]"/>
      </filesystem>
      <!-- todo add 'endorsed groovy extensions' resolver here -->
      <ibiblio name="codehaus" root="http://repository.codehaus.org/" m2compatible="true"/>
      <ibiblio name="ibiblio" m2compatible="true"/>
      <ibiblio name="java.net2" root="http://download.java.net/maven/2/" m2compatible="true"/>
      <ibiblio name="yourid" root="http://your/local/maven/repository/" m2compatible="true"/>
    </chain>
  </resolvers>
</ivysettings>

Notice the extra ibiblio element, that is used to define a private repository!

All this makes it possible to write a small script in groovy, deploy it simply by copying it to the target environment, and then execute it at that place with no extra fuss.

If you are using selenium rc to remote control a Safari on a Mac, remember to turn off pop-up blocking, or else your tests will hang in “selenium.start()” somewhere deep down in HttpURLConnection.getResponseCode() because the selenium-rc server never returns with any content.

In Safari menu, de-select “Block Pop-Up Windows”.

Let’s just say this wasted some time on me, so hope this will help someone out there in the same starter problems

If you have Hibernate configured to use JDBC batching, then statements in the same transaction might be batched into one or few update trips to the server. In case of any errors when performing the batch operation, you wont be able to see which statement that failed. What you will see is something in the lines of this stacktrace:

org.hibernate.exception.ConstraintViolationException: Could not execute JDBC batch update
	at org.hibernate.exception.SQLStateConverter.convert(SQLStateConverter.java:94)
	at org.hibernate.exception.JDBCExceptionHelper.convert(JDBCExceptionHelper.java:66)
	at org.hibernate.jdbc.AbstractBatcher.executeBatch(AbstractBatcher.java:275)
	at org.hibernate.engine.ActionQueue.executeActions(ActionQueue.java:266)
	at org.hibernate.engine.ActionQueue.executeActions(ActionQueue.java:167)
	at org.hibernate.event.def.AbstractFlushingEventListener.performExecutions(AbstractFlushingEventListener.java:321)
	at org.hibernate.event.def.DefaultFlushEventListener.onFlush(DefaultFlushEventListener.java:50)
	...
Caused by: java.sql.BatchUpdateException: ORA-00001: unique constraint (XXX) violated
	at oracle.jdbc.driver.OraclePreparedStatement.executeBatch(OraclePreparedStatement.java:10055)
	at oracle.jdbc.driver.OracleStatementWrapper.executeBatch(OracleStatementWrapper.java:213)
	at org.apache.tomcat.dbcp.dbcp.DelegatingStatement.executeBatch(DelegatingStatement.java:297)
	at org.hibernate.jdbc.BatchingBatcher.doExecuteBatch(BatchingBatcher.java:70)
	at org.hibernate.jdbc.AbstractBatcher.executeBatch(AbstractBatcher.java:268)
	... 112 more

You can see the offending SQL exception, in this case a Oracle unique constraint violation, but you cannot see the SQL from the batch.

Hibernate uses a class called org.hibernate.util.JDBCExceptionReporter when logging JDBC exceptions. It either WARN of ERROR logs, and most people have at least ERROR level activated for something like hibernate. But, this little piece of the class is interesting:

	public static void logExceptions(SQLException ex, String message) {
		if ( log.isErrorEnabled() ) {
			if ( log.isDebugEnabled() ) {
				message = StringHelper.isNotEmpty(message) ? message : DEFAULT_EXCEPTION_MSG;
				log.debug( message, ex );
			}
			while (ex != null) {
				StringBuffer buf = new StringBuffer(30)
						.append( "SQL Error: " )
				        .append( ex.getErrorCode() )
				        .append( ", SQLState: " )
				        .append( ex.getSQLState() );
				log.warn( buf.toString() );
				log.error( ex.getMessage() );
				ex = ex.getNextException();
			}
		}
	}

What is does is WARN and ERROR log a given exception and its causes. But it as has a part only executed, if DEBUG level has been turned on for this particular class/logger. It DEBUG logs the incoming parameter message and this message just so happens to be the offending SQL statement.

So, turn on DEBUG level for the org.hibernate.util.JDBCExceptionReporter logger and get more information on your failing SQL.

Okay, I know that was a bit harsh, and I do use basic auth myself sometimes. Like for instance with something dead-simple on an intranet, where we just need to shut out the masses a bit.

But what is wrong with basic auth then?

Logout Not Possible

Because the browser remember the authentication data and keep resending it for each request to the host authenticated against, there can be no logout, aside from closing the browser. Often, this is seen done with Javascript (closing the browser window), but a) it is not safe as the client can say no and b) some browsers deny it.

It Does Not Present Itself Nicely to the Client

It is the browser, that pops up a dialog. Basically, you cannot as a developer, control how this dialog looks and behaves. And it looks different in each browser. So, you cannot even determine if it needs to ask for “username”, “login” or …

Also, the application cannot show meaningful information to the client, when authentication goes wrong. This could be “you have xx tries left, before the login is locked”.

No Way To Provide Extra Functionality

Like a “change password” option, when the login has expired. Or a “remember me” option. Or whatever the application would like. Again, it is the browser, that does it all.

All this stems from the fact that it is the browser, that controls the authentication. It is the browser, that stores the authentication data and send it on with each request. And it does not have an API or the like to clear it, hook into missing auth or anything like it. The application is out of the loop.

Just say no!

@WebService(targetNamespace = "http://blah")
public class ClientData {
  @WebMethod
  public String getSomething() {
    return something;
  }
}

you can experience problems if you annotate the web service methods with something that spring-aop needs to process. Like when using perf4js nice @Profiled aspect, like this:

@WebService(targetNamespace = "http://blah")
@Profiled
public class ClientData {
  @WebMethod
  public String getSomething() {
    return something;
  }
}

This is due to the fact, that spring will produce a proxy of the @Profiled bean, a proxy that will not have the annotations of the proxied bean. In turn, this will hide the annotations from CXF, which can come out and complain about missing methods on the server side. Like this:

org.apache.cxf.interceptor.Fault: Message part {http://blah}getSomething was not recognized. (Does it exist in service WSDL?)

Solution?

Add the implementorClass attribute on the JAXWS endpoint definitions in your cxf bean definitions xml. This way you tell CXF which class to look for annotations on, instead of just looking on the class of the proxied instance it is passed at runtime.

Here is a small spinning wheel example on how to do this with an old style ASCII spinning wheel animation. Enter the LabelProgressIndicator.mxml component:

<?xml version="1.0" ?>
<mx:HBox xmlns:mx="http://www.adobe.com/2006/mxml">
    <mx:Script><![CDATA[
        [Bindable]
        private var statusText:String;

        [Bindable]
        private var progressText:String;

        private const SPIN_CHARS:String = "/-\\|/-\\|";

        private var workingDotsTimer:Timer;
        private var progressCounter:int;

        public function startProgress(status:String):void {
            if (workingDotsTimer == null) {
                statusText = status;
                workingDotsTimer = new Timer(200);
                progressCounter = 0;
                workingDotsTimer.addEventListener(TimerEvent.TIMER, onWorkingDotsTimer);
                workingDotsTimer.start();
            }
        }

        public function stopProgress():void {
            if (workingDotsTimer != null) {
                workingDotsTimer.removeEventListener(TimerEvent.TIMER, onWorkingDotsTimer);
                workingDotsTimer.stop();
                workingDotsTimer = null;
                statusText = null;
                progressText = null;
            }
        }

        private function onWorkingDotsTimer(event:TimerEvent):void {
            if (progressCounter == SPIN_CHARS.length - 1) {
                progressCounter = 0;
            } else {
                progressCounter++;
            }
            progressText = SPIN_CHARS.charAt(progressCounter);
        }

        ]]></mx:Script>

    <mx:Label id="status" text="{statusText}"/>
    <mx:Label id="progress" text="{progressText}" fontFamily="courier" fontWeight="bold"/>
</mx:HBox>

and here is how to use it:

<?xml version="1.0"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" xmlns:ui="*">

    <mx:Button click="progress.startProgress('working')" label="Start"/>
    <mx:Button click="progress.stopProgress()" label="Stop"/>

    <ui:LabelProgressIndicator id="progress" />

</mx:Application>

Vanilla Example

Here is a dead simple vanilla sample of flex that does a little bit of data binding:

<?xml version="1.0" ?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml">
    <mx:Script><![CDATA[
        [Bindable] public var value: String = "blah";
    ]]></mx:Script>

    <mx:TextInput id="textInput" text="{value}"/>
</mx:Application>

where value is bound into textInput.text will generate quite a bit of supporting code, when being mxmlc’ed. Basically, it seems like flex operates with two concepts behind the scenes: Bindings and Watchers.

Bindings

A Binding is a one-way connection, that can read a value from a source and set it on a destination, but only when explicitly executed. There is not listening for changes built into a binding as such, it is just a mechanism that can be executed by someone, to transfer a value between a source and a destination.

So, how does a binding get executed? It does so, when the Watchers it is connected to fires. A binding acts as listener for watcherFired on a Watcher, which is how it gets executed when changes happen.

Here is the binding setup, that flex generates for the above example:

        binding = new mx.binding.Binding(this,
            function():String {
                var result:* = (value);
                var stringResult:String = (result == undefined ? null : String(result));
                return stringResult;
            },
            function(_sourceFunctionReturnValue:String):void {
                textInput.text = _sourceFunctionReturnValue;
            },
            "textInput.text");

basically, it instantiates a mx.binding.Binding with the parameters:

• this which is this context – pun intended – means the FlexTest application class
• a function that can read the source value when executed
• a function that can set the target property when executed
• a textual string of the target (docs says it is used for validation)

this sets up a “channel” from source to target.

Watchers

While Bindings only implement the reading of the source and setting into target, the other big part of flex data bindings is actually determining if and when, a binding should execute. This is where Watchers come in.

A Watcher can watch for changes on something, one typical example is a change of a property value. When such a change is detected, the watcher notifies its listeners (which are Binding instances) about the change. It is then up to the listener (the bindings), to actually read out the source and set the target (aka: Execute the binding). It is the Watcher, that determines if a value has actually changed.

Here is the watcher setup, that flex generates for the above example:

        watchers[0] = new mx.binding.PropertyWatcher("value",
            { propertyChange: true },
            [ bindings[0] ],
            propertyGetter);

as you can see, it instantiates a mx.binding.PropertyWatcher instance, as it is a property we are binding from, with the following parameters:

• a map of event names as keys, that are the event to listen for, when watching changes. This is what can be overridden with [Bindable("otherEventNameHere"])
• an array of listeners, that get called on their watcherFired method when the watcher detects a change (the listeners are Binding instances, and in this context bindings[0] is the exact binding that we saw the code for just before
• and lastly propertyGetter is a method, that can return access to properties in the context watched

I am sure you can image how this works then. By hey, … when is the “propertyChange” event being dispatched in our code. I mean, when you look at the initial example code, if I was to assign a new value to the value property, there sure ain’t any code there, which fires any events.

Well, it turns out mxmlc has generated code for that too:

    [Bindable(event="propertyChange")]
    public function get value():String {
        return this._111972721value;
    }

    public function set value(value:String):void {
    	var oldValue:Object = this._111972721value;
        if (oldValue !== value) {
            this._111972721value = value;
            this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "value", oldValue, value));
        }
    }

it simply moves the original value property to a generated name _111972721value and adds a get/set pair on the value name instead. Clever. And hey, look into that setter. It dispatches the propertyChange event, when changed.

This is what the script does:

• Ask the user for an input folder and an output folder
• Ask the user for which ratio he wants to check against (e.g. 1.5 if you want a 2:3 ratio)
• Run throug all image files in the input folder, check if the ratio is the requested, and if not, moves files to output folder

All I have to do then, is to crop the files moved to the output folder, to my requested ratio. Actually, the “Image Events” library that I use to check dimensions can also crop, but it does so from the center. I want to control what is cropped myself.

And respect to Apple for giving us such an easy to use yet still powerful tool like AppleScript. I used the AppleScript Editor to write the script, and then noticed how I could just save it as an application. Cool!
Here’s the script:

-- ask for input folder containing images
set theInputFolder to (choose folder with prompt "Pick the folder containing the images to check ratio against") as string

-- ask for output folder to move files that does not fulfill ratio
set theOutputFolder to (choose folder with prompt "Move image files not fulfilling ratio where?" without multiple selections allowed and invisibles) as string

-- check folders are not the same
if theInputFolder is equal to theOutputFolder then
	error "Input and output folder may not be the same" number 500
end if

-- ask user for the ratio
display dialog "Enter image ratio" default answer "1.5"
set theRatio to text returned of result as real

tell application "System Events"
	set theImageFiles to every file of folder theInputFolder whose name does not start with "." and (file type is "TIFF" or file type is "JPEG" or name extension is "tiff" or name extension is "tif" or name extension is "jpeg" or name extension is "jpg")
end tell

repeat with i from 1 to the count of theImageFiles
	set theImgFile to (item i of theImageFiles as alias)
	tell application "Image Events"
		set theImg to open theImgFile
		set theDimensions to dimensions of theImg
		set theWidth to item 1 of theDimensions
		set theHeight to item 2 of theDimensions
		set min to theHeight
		set max to theWidth
		if (theWidth < theHeight) then
			set min to theWidth
			set max to theHeight
		end if
		close theImg
	end tell

	-- a little rounding
	set theImgRatio to (((max / min) * 10) as integer) / 10

	if (theImgRatio is not equal to theRatio) then
		tell application "Finder"
			move theImgFile to theOutputFolder
		end tell
	end if
end repeat

display dialog "Done" buttons {"OK"} default button 1

Sparks Creativity

Well, that one was kind of obvious, as that was one of the main reasons I started doing it. Nevertheless, it is pretty important.

Okay, I could have gone for a 365 days challenge, but that just seemed too much for me. Anyways, faced with the task of doing 30 self portraits in a row, one has to come up with some ideas. For starters, I have some myself, but what I also did (and do) was to go out there on the net, and see what others have done. Searching flickr for self portraits has proven really helpful, and sparked many ideas to new ways of doing portraits.

Force Learning of Techniques

Even though I have had a DSLR for some years now, it is only within the last copuple of months, that I bought myself a decent tripod. And even then, I haven’t taken that many shots using it yet. Going into self portraits, I am using my tripod for many of the shots. And already now, I feel much more confident using the tripod, setting it up, knowing what it can do and what it cannot, etc.

Another learning experience I am into currently, is setting up flashes. Not long ago, I bough some cheap wireless Cactus triggers and an extra cheap-o Hong-Kong flash. These are really fun to play with. More and more, I am starting to think lighting into my pictures. And that does not only go for the portaits, but for all shots. I acknowledge, that I should have done this long ago, but I haven’t.

Opportunity to Gear Up

We all know it. Photography is a gear sport and I simply had to buy a wireless remote trigger for this project. Still eagerly awaiting it though, … from Hong-Kong again.

So, if you are into photography, I can only recommend taking up a photography challenge of some sort. You can follow the results of my challenge in my flickr set here.

A restrospective in an agile process is the simple idea about “stepping back and looking at the process”. What we did, was take out 30-45 minutes, where:

1. the development team meet up
2. an outsider acts as facilitator

I like agile processes for software development, but aside from that, I do not care much for a lot of process. I like my time spent on development – designing and writing code. This is also why I liked (and was surprised that) an agile restrospective can be so short and lightweight.

In the retrospective I participated in, I acted as the facilitator. As such, I was not a part of the development team. I had some, albeit little, knowledge of what they were developing, but that turned out to matter less. In short, this is what we did:

• on the morning of the retrospective day, we agreed on time to meet later
• at that time, the team and I met up in a meeting room – pretty much blank and unprepared
• I, the facilitator, started asking questions against the process
• the team answered and discussed back and forth

The whole thing took around 30 minutes. The questions asked were stuff like:

• what went well in the last sprint?
• what did not go that well?
• what to take with us and repeat in coming sprints?
• what to do better in coming sprints?
• …

but the really nice thing is, that having a project-external facilitator proved to be really helpful in the way that:

• He (the external facilitator) will ask the questions, that lies as implicit knowledge in team members, and hence wouldn’t be touched upon. Like, when I asked “how do you do your etimates”, which led to a discussion on diffent ways to do estimation.
• The team being retrospected can get new input from the knowledge of the facilitator – and the other way around, making the facilitator take something with him too (a true win-win)
• The facilitator gets insight into how other projects in the organisation is run and what they do. This is knowledge and project-status sharing while retrospecting.

All in all, I had the fealing that this was helpful. As a consequence of this, I repeated it on a project at a client where I was part of the team, and we brought in another party as facilitator – a developer on another project, but from the same organization.

Some important rules I feel compelled to emphasize:

1. Keep the retrospective short (less than 60 min), and
2. Come largely unprepared and resist documenting the output.

Now, do not get me wrong. I think everybody should pay for what they use. I think pirates are a bad thing. But we need an open solution, that everyone are free to provide implementations of, without the need to buy specs or pay roalties for the use or implementation of a certain codec.

This is also why I think Opera and The Mozilla Foundation are doing the right thing when speaking about which video codec to choose for the open web platform. Of course, either H.264 should be patent free or everybody should team up around an open, patent free codec like Ogg Theora.

If not, consumers will pay. Less products/players to choose from. No free players or encoders. Platform locked features. Etc. For instance, currently I have no way to use the SF Anytime VOD service on my Mac, because they have choosen to tie it to the Windows Media format and player. I understand their choice, given the current availability of DRM solutions around.

If everybody would just team up on an open, patent free codec, like Theora, I am sure there would be viable DRM solutions around too. Solutions that would play on all major platforms, and not just in one specific player on one specific platform. Instead of battling patents with eachother, the major players should battle on providing the best implementation and best products with the coolest features. Stuff that would really give the users a better experience.

Nice to see JetBrains are thinking some of the same thoughts, considering we never followed through on our own idea way back.

Currently, with the IDEA8, there is some support for importing POMs that use flexmojos. With the upcoming Maia release, this integration is further enhanced.

In this blogpost, JetBrains explains how to import for POM, and there are some good pointers, that I need to remember for my next POM import. Most notably, enabling the generation of a compiler config file, to have the same settings used by IDEA as flexmojos do at compilation.

Due to serious color-related limitations on the display of my wifes laptop, she currently imports her pictures onto my Mac. In addition, my oldest child is taking more and more pictures with her camera, all of which also goes onto my Mac. To avoid “polluting” my own iPhoto library, I wanted to create and manage separate libraries.

It turns out, that if you hold down the Option-key (Alt-key) while starting iPhoto, it will popup a dialog with the options to either create a new library or choose an existing one.

Nice!