craigaspinall.com blog

Can Kotlin K.O. contenders?

2011-07-29T00:00:00-07:00

If you follow my Twitter feed then you may have seen my initial reaction to Jetbrains announcement that they were working on another JVM language was one of disdain. Not because I don’t think Jetbrains can create a compelling language, but because I was concerned that the JVM language space is becoming saturated, and too much choice can be just as harmful as no choice at all!

Having had a bit more time to look into it, I don’t think my initial reaction was warranted, and I shouldn’t have been so dismissive of Kotlin. When you look closely at the successful JVM languages, all of them with the exception of Scala are dynamically typed. If you want a statically typed alternative to Java that has a reasonable chance of still being around in a few years, you really only have the choice of Scala, Groovy++ or Gosu. There is clearly room for more choice in this space and Kotlin (and Red Hat’s Ceylon) are trying to fill it. Hopefully the competition will be healthy and we’ll end up with more than one good language to choose from.

So far Scala has been the main contender to challenge for the position of a better Java, yet it seems to divide opinion very easily. Jetbrains have labelled it too complex in their justification for creating Kotlin, a topic which Martin Odersky has addressed before. I think the real problem is just that Scala is a different language to Java and therefore (as with all new languages) you have to put some effort into learning it and practicing with it before you can use it proficiently. Whether Kotlin is enough like Java to avoid the mental leap remains to be seen, but I wish JetBrains (and all the language creators) the best of luck in their battle royale for the title of The Better Java. Without them, the Java ecosystem would be a very dull place!

My technology radar

2011-07-28T00:00:00-07:00

One of the things I learned at Uberconf was how to build your own technology radar, a tool that ThoughtWorks use to decide what technologies they should (or would like) to use either internally or on customer engagements. I’ve built two so far, one for myself and one for my day job, and in both cases I’ve found it to be a really useful thought exercise.

This is my personal radar:

It is split into four technology quadrants:

Tools
Techniques
Platforms
Languages

And into four levels of interest (with my personal spin on the meanings):

Hold – do not use on anything new
Assess – is it something I can use
Trial – look for an excuse to use it on something
Adopt – one of my go to technologies

Also things in red are on an outward trajectory and things in green are on an inward trajectory.

So what I decided is that I’m putting GTD on hold so I can try out personal kanban and see how that works out for me. I’m also leaning much more heavily on Acceptence Test Driven Development and Test Driven Development and will be encouraging others to do the same, as well as learning and promoting functional programming.

In the tools space, I’ve dropped Subversion and Mercurial in favour of Git, and I’ve dropped Maven in favour of Gradle, and I’ll assess whether I need to use Leinengen to build my Clojure projects or whether I can do that in Gradle too. I’m siding with Jenkins over Hudson and I want to use Sonar much more effectively.

Groovy is now my go to language and Clojure is the language I am most interested in learning. I don’t want to write Java code if I can avoid it so I should be looking more closely at Groovy++, Scala and Gosu for the times when I need a statically typed JVM language. I’m still interested in Haskell (primarily to learn functional programming) but I’m also keen to get more into the web space, hence JavaScript and CoffeeScript being on my radar too.

Finally in the platforms space, since I am moving more towards web applications, I am looking at the cloud computing offerings from EC2, AppEngine, NineFold and CloudBees (although I’m also interested in CloudBees for the hosted Jenkins offering). I’ve also dropped Bitbucket and Google Code in favour of GitHub in line with my change over to Git.

Uberconf, Uber Geeks, Uber Tired!

2011-07-15T00:00:00-07:00

My first Uberconf is over. Was it worth the 16,000 mile (26,000km) round trip and a week away from my family? It was definitely worth making the trip but now I need a holiday to get over it because I’m exhausted and next time, I’ll bring my family along for the ride!

The conference is a learning and networking feast, with a wide variety of great content delivered professionally by awesome speakers that really understand their subject matter. The Westin Westiminster hotel was also a great vanue that catered well for a conference of this size, in terms of the rooms, the delegate accommodation and the food.

Almost all of the sessions I went to were good, but if I had to pick my top three sessions it would be these:

Encryption on the JVM: Boot Camp by Matthew Mccullough

Matthew completely blew me away with this talk. Not because of the subject matter but how he delivered it. I have never seen anyone deliver a presentation as professionally as Matthew did. I attended two of his other talks and he was just as good in both of those, even when the wifi was conspiring against him! He is definitely the Steve Jobs of the No Fluff Just Stuff crowd!

This is a subject that I knew next to nothing about before the session and I left feeling confident that I could go and implement encryption correctly and effectively afterwards. I also really enjoyed his Thinking in Git presentation which gave me lots more reasons to love Git!

I also got the chance to sit next to Matthew for dinner one evening and he is a really nice guy too. Very engaging, humble and friendly. A definite star in our industry.

Complexity Theory in Software Development by Tim Berglund

Like Matthew, Tim is an excellent presenter and this talk was probably the most thought provoking of all those I attended. It was a whistlestop tour of what complexity theory is and what bearing is has on our daily lives and the software we write. It was both educational and challenging in exactly the right proportions.

He also delivered a wonderful skit after dinner one evening, called Oh, The Methods You’ll Compose, which almost got a standing ovation from the audience! It reminded me very much of Guy Steele’s and Richard Gabriel’s 50 in 50 keynote that I was fortunate enough to see live at YOW! Brisbane last year.

Towards a Humane Interface by Venkat Subramaniam

I wasn’t able to make any of Venkat’s other talks but I had been told that he was an excellent speaker and didn’t want to miss out on the opportunity to see him. This subject wouldn’t have been top of my list of his talks, but it was the only one where I didn’t have a clash!

As it happened it was the last session of the conference and Venkat was in excellent form! He engaged the audience with some great anecdotes and was animated and jovial throughout. He clearly has a passion for all the work that he does and it was a great privilege to see him in action.

Narrowing it down to three talks was very difficult and the three I’ve picked out are the ones I enjoyed the most, but these guys also deserve special mention:

Neal Ford for Build Your Own Technology Radar, which was another very thought provoking session.
Frank Kim for Tricks of the Trade: What Every Developer Should Know About Application Security, which was both educational and very scary as we worked through case studies of actual security breaches and Frank demo’d how easy some of the common hacks are!
Hamlet D’Arcy for Effective Groovy which was my first Uberconf session and had some great lessons for intermediate Groovy developers such as myself to learn and improve from.

Last but not least I need to say thank you to Jay Zimmerman, Mr. No Fluff himself. I know that he was very helpful in getting me to the conference and he made a point of coming over and checking how I was getting on, obviously remembering the e-mail exchange he had with my team leader. Now I know that is just typical of his attention to detail and the reason that the No Fluff Just Stuff conferences have the reputation that they do.

The only criticisms I had from the conference (and I know other attendees had the same problems) were:

There were 10 tracks and in many slots I wanted to attend five talks. Having too much good content is clearly an excellent problem to have, but I really feel like I missed out on more than I got (which was still a lot).
The multi session workshops meant you had the choice of missing out on 1-4 sessions at a time, or not attending the workshop.

Clearly the conference couldn’t be any longer, neither the speakers or the delegates would survive! Maybe grouping the sessions so that all the beginner/introductory sessions ran concurrently, then the intermediate then the expert ones. Given everyone will be at different levels on different tracks, they could have the choice of going from beginner to expert in one track, or cut between them depending on their existing expertise level. Also grouping the workshops together might work better.

Finally, I met a lot of very talented, very passionate and very friendly people at this conference, delegates and speakers alike. I cannot recommend it highly enough.

What is functional programming?

2011-06-23T00:00:00-07:00

I gave a talk at our Coding By Numbers meetup tonight that attempts to peel away some of the mystery surrounding that question. It was a small audience but they appeared to appreciate it and I hope I was able to show them that many of the benefits of functional programming are easily accessible.

The slides and handouts are available here.

I didn't get Git

2011-06-20T00:00:00-07:00

OK, I admit it, I didn’t get Git when I started playing around with distributed version control last year. In fact I dismissed it as being too complicated for my needs after about five minutes. Boy, what a mistake! .

The main reason I was looking at distributed version control systems was because I was doing a lot of work on the train and I wanted something that could track changes locally so I could revert when I inevitably screwed something up. I also wanted to be able to push the changes to a hosted repository when I got home, so I had an offsite backup and to share the code with others. This ruled out the likes of Subversion and I ended up settling on Mercurial with Bitbucket for free repository hosting.

Whilst I still think that Mercurial and Bitbucket are fantastic tools, the process of moving this blog to GitHub Pages has forced me to learn Git properly and I’ve had a bit of an epiphany with it. Now I’m starting to think that Git is the way that all version control should be.

The staging area

At first, having to add changes to the staging area before each commit was bugging the life out of me. That was until I made changes for more than one reason at once. Of course, it makes sense to separate these changes, and git forces to operate that way by default. Of course you can do this with Subversion by committing specific files, but git forces you to think about it.

And it doesn’t end there. Using git add -p, you can reduce the granularity of your commits to individual lines within a file. This is a huge get out of jail free card for me, as I often end up fixing one thing within a file whilst working on something else in the same file. Using this mechanism, the two changes can be committed separately, as they should!

Welcome to the real world!

2011-06-10T00:00:00-07:00

To hijack and abuse yet another quote from The Matrix, “welcome to the real world!” (or at least my new home in the virtual one)! After being inspired by @TheColonial and his adventures with Blogofile, I decided that I needed to move my blog to a system that was backed by a version control system.

I had a number of reasons for doing this:

I wanted to be in complete control of all of my data.
I wanted to be able to compose and edit posts offline.
I wanted to somewhere to host materials from the talks that I give.

The solution I ended up going with was GitHub Pages. Firstly because it is free. Secondly because it is awesome!

Your entire site is a repository that you can clone like any other git repository. The difference is that when you push changes back to GitHub, it automatically runs Jekyll (a blog aware static site generator) and republishes the resulting site for you. The beauty of Jekyll is that a normal HTML site is also a valid Jekyll site, so normal HTML sites will pass through unchanged.

If you do take advantage of Jekyll however, you can create HTML templates using Liquid and author content in Markdown or Textile. It even supports syntax highlighting courtesy of Pygments.

I’ve moved the technical and technology related posts from Tumblr over to here so anyone transferring over can still access my old content, and anyone arriving here for the first time has something to read.

Quitting Facebook

2011-04-24T00:00:00-07:00

After listening to Mark Pesce’s controversial keynote presentation at LinuxConf Australia 2011 (and giving myself a couple of months to think about it), I’ve decided that the time has come to leave Facebook, and to encourage others to do the same. If you want to understand why, I strongly recommend you read Mark’s presentation but here are the reasons in a nutshell.

The most valuable piece of information about you is your social graph and the communication that occurs across that graph. That reveals more about you, your personal interests, even your secrets, than anything else that you do online. And Facebook is watching and recording it all.

This might not be so disturbing if Facebook had not repeatedly let members down with regards to the privacy of their data. Or if people actually understood what information they are divulging to Facebook. Whilst many have pointed to the likes of Microsoft and Google as potential dystopian “big brother” overlords, Facebook is probably much better poised in reality.

So I’m making my own (sadly insignificant) stand by quitting. I encourage you to do the same.

Extending classses at runtime with Groovy

2011-03-03T00:00:00-08:00

I gave an introduction to Groovy at our local JUG this week and didn’t quite manage to make it through all the material I wanted to cover, so I decided to add the missing content here! The part I missed out in the meetup was how to extend a class at runtime via it’s metaClass.

If you add a named closure to the metaClass of an existing class, then it essentially becomes available as a method on that class. In this example, I’ve added a containsOnly(Collection anotherCollection) method to the Collection class, which returns true if two collections have the same content but not necessarily in the same order.

Collection.metaClass.containsOnly = { Collection otherCollection ->
    delegate.containsAll(otherCollection) && delegate.size() == otherCollection.size()
}

a = [1, 2, 3, 4]
b = [2, 4, 3, 1]
c = [2, 4, 3, 5]
assert a.containsOnly(b)
assert !b.containsOnly(c)

delegate is an implicit argument referring to the object on which the containsOnly() method is being called.

In the following case, I have extended the Collection class again to add a choose(int numberOfElements) method, which selects a supplied number of elements from the collection, chosen at random. Note that the return keyword is optional, I’ve used it here for clarity.

Collection.metaClass.choose = { int numberOfElements ->
    if (delegate.size() <= numberOfElements) {
        return delegate
    } else {
        List previouslyUsed = []
        List chosen = []
        while (chosen.size() < numberOfElements) {
            int index = new Random().nextInt(delegate.size())
            if (!previouslyUsed.contains(index)) {
                chosen << delegate[index]
                previouslyUsed << index
            }
        }
        return chosen
    }
}

a = [1,2,3,4,5,6,7,8,9,10]
one = a.choose(1)
assert one.size() == 1
assert a.containsAll(one)
five = a.choose(5)
assert five.size() == 5
assert a.containsAll(five)
twelve = a.choose(12) // should only return 10!
assert twelve.size() == 10
assert a.containsAll(twelve)

My final example extends the String class so that you can easily cast it to a Date instance using a fixed conversion format. Groovy uses this syntax for casting (which is much nicer than Java):

"08/08/1988" as Date

Under the hood, Groovy calls the asType(Class targetType) method to perform the conversion, and that already supports casting to a number of different types. To add Date casting I had to replace the existing method definition. So that I didn’t lose the original functionality, I captured the original method and delegated to it if we’re not trying to cast to a Date.

def oldAsType = String.metaClass.getMetaMethod("asType", [Class] as Class[])
String.metaClass.asType = { Class targetType ->
    if (targetType == Date.class) {
        Date.parse("dd/MM/yyyy", delegate)
    } else {
        oldAsType.invoke(delegate, targetType)
    }
}
// Now we can call...
"08/08/1988" as Date

The role of automated testing

2010-11-28T00:00:00-08:00

Over the last week I’ve had a lot of discussions about the underlying motive of the roles that my colleagues and I are currently performing. We are responsible for improving the quality of software being produced by the teams we are involved with, and the main focus of our recent work has been creating automation tools to assist the testers. There are three possible motives for our roles:

to reduce costs
to increase productivity
to improve quality

For us it’s a simple case of improving quality but that doesn’t necessarily mean that our leaders have the same motives. In fairness they do overlap, but focusing too much on any one of them can be to the detriment of the others.

For example, if you want to reduce costs and automated testing makes the testers four times more productive, then in theory you can remove three quarters of your testers without any loss of quality or productivity. Of course the theory and reality are quite different! Similarly, if you go all out for quality, you may need more people or tools or equipment which will result in increased costs, and progress may be slower.

The catalyst for the discussions was that we just found out that the number of testers is being reduced on one of the projects we’re working on and we were horrified. We were very concerned that the work we have been doing was being used to justify cost reductions but fortunately that isn’t the case (at least not this time).

Since our goal is to improve quality we expect that any cost savings we enable during development are re-investing into improving quality in other ways. This should include freeing up the testers to do more exploratory testing, but could also include things like performance, security or usability testing that often get overlooked.

Even with that investment, we expect that there will still be an overall reduction in cost, simply because less defects will get to production. The cost of fixing defects increases exponentially the later in the process they are found, because more and more people become involved in the development, testing and technical support of the fix. Unfortunately the total cost of ownership is not easy to quantify and rarely gets the focus it deserves.

Episode 18 of the Coding By Numbers podcast (which I co-host) has a much more in depth discussion on this subject if you want to hear more!

Is Haskell actually a simple language?

2010-11-27T00:00:00-08:00

Whilst I was writing the previous post about learning Haskell, I was reminded of a post by Martin Odersky about the complexity or otherwise of Scala. In that post he tries several metaphors to determine what simple really means, finally settling on Duplo versus Technics Lego. You can build anything with either (just as you can with turing complete languages) but a solution built with Duplo is unlikely to be as elegant as a solution built with Technics.

I like his comparison because it shows how much simplicity is a concept that means different things to different people. I’m starting to think that Haskell is a really simple language, even though I’m finding it difficult to learn!

One of the relative measures of complexity used in the article is the number of keywords in a language. Carlos Quintanilla’s comparison of CLR and JVM languages ranges from 139 to 31 keywords. Haskell has just 20!

And the more I use the language, the more it strikes me as being ruthlessly consistent. Take functions for example:

add :: Int -> Int -> Int
add x y = x + y

Nominally you can read this as a function called add that takes two Int parameters and returns an Int. Except it isn’t. It’s a function that takes an Int and returns another function that takes an Int and returns an Int! Which means you can do this:

plusOne :: Int -> Int
plusOne = add 1

I’ve defined a plusOne function by fixing the first parameter of add to 1, which returns a function that will always add 1 to whatever value is passed to it. By applying the same principle again we have a function that takes no arguments and returns an Int.

two = plusOne 1

This concept is one of the reasons why I’m struggling with Functors. It seems mind numbingly simple to me and yet so mind bogglingly powerful at the same time!

And that is the paradox I keep banging my head against!

Haskell's type system made me cry

2010-11-26T00:00:00-08:00

My functional programming with Haskell journey continues and every time I think I understand something, I discover there’s another layer of complexity underneath the one I just peeled off! There are so many metaphors that spring to mind that I’m just going to avoid them all!

What I’ve found so far is that I typically go through three or four stages of learning functional concepts. In the first stage I don’t understand it at all. In the second stage I start learning matched pairs of input and results, so I can start to use the concept but I don’t understand how the input is transformed to the output. In the third stage I start to get that understanding of how it works as well as what it does. And in the fourth stage I realise how much more there is that I don’t understand yet!

This week I really started to understand type classes and monads, only to discover that monads are just the tip of the iceberg. My brain then started to melt as I went back to stage one and two with functors and applicative functors!

It’s also beginning to dawn on me just how amazing the Haskell type system is. One of my friends once said that Haskell’s type system made him cry. Not tears of pain but tears of joy at how elegant it is!

Tackle the technical debt first

2010-11-23T00:00:00-08:00

In my last post I talked about the large refactoring I am doing. One of the reasons that this is a large refactoring is because I have been putting it off. I wanted to deliver something to the customer. I kept telling myself that if I just went with what I had I’d soon have something to give them and then I would have some breathing room to refactor. Of course thats a complete fallacy!

What I actually did was rack up technical debt. I kept adding more code that was dependent on API that I knew needed to be refactored. That meant the new code would also have to be refactored when the API changed. The net result is that I still wasn’t able to handover what I wanted when I wanted to, and now I am having to take a couple of days to perform this refactoring, which is delaying the delivery even more!

I’ve made this mistake before and I should have known better, but the pressure I (it wasn’t even the customer) was putting myself under to deliver got the better of me this time. Hopefully I learned from my mistake. I think I’ll print the quote by basketball coach John Wooden: “If you don’t have time to do it right, when will you have time to do it over?” and pin it on the wall of my cubicle!

The great thing about standards...

2010-11-22T00:00:00-08:00

… is that there’s so many of them to choose from. They’re like Java frameworks, everyone has got one! I guess it’s down to control. People don’t want to invest in something that they don’t have control over, so they create another standard, manage to get it ratified by some standards body, and then claim that they are standards compliant. But if we’re not all using the same standard, how much value does the standard have?

I’ve spent a considerable amount of time this weekend creating alternative versions of the Coding By Numbers podcast. We have been using the AAC format since it gives you the best bang for your buck in terms of quality versus size, but we’ve had a bunch of feedback asking for an MP3 version because not all media players support AAC.

A few weeks ago, my co-host Steve was fortunate enough to meet with Richard Stallman from the Free Software Foundation, who won’t listen to any digital audio unless it is recorded in an open format such as Ogg Vorbis. In fact he thinks we shouldn’t be offering anything but open formats and he’s probably right, but if people are having problems with AAC support, can you imagine the problems people would have if we only offered Ogg Vorbis?

So there’s three standards that we now offer for the podcast, but those aren’t the only standards we could choose from. There’s also FLAC, MP2, WAV, WMA and that’s before we even start on the voice specific codecs we could use! And there’s so little real difference between them that you have to question why they all exist. Perhaps standards would be better controlled by a benevolent dictator than committees?

Tackling big refactoring jobs

2010-11-22T00:00:00-08:00

For the first time last week, I actually used a spreadsheet to keep track of a large refactoring that I needed to complete. We’re not talking about a huge project, less than sixty classes in total, but they needed to be broken into three projects, and a number of the classes were going to disappear altogether as their functionality is absorbed into other classes. The two additional projects are going to be simple libraries that can be re-used, and the original project will retain the domain specific tests and configuration and have dependencies on the two new libraries.

The spreadsheet itself isn’t anything complicated. It has the following columns:

Class Name
Existing Package
Target Project
Target Package
Target Class
Completed

By setting filters on each of the columns and using some conditional formatting, I was able to manipulate the view to narrow the scope to the specific set of tasks I was working on or get a broad overview of where I was up to. It enabled me to take small steps and keep the codebase running whilst I was refactoring, which has usually been my downfall!

The day to day refactoring I normally do is small enough to be held in my head and larger ones usually cause me some level of grief before they are completed, which is why I decided to take different approach this time around. What I found is that by taking the time to lay everything out first, I could see what needed to be done and in which order. It goes to prove that “just enough” planning goes a long way!

Dead trees are dead to me

2010-11-19T00:00:00-08:00

I haven’t bought a dead tree version of a book for years. If it’s not available as either an ebook or an audiobook then I don’t buy it. The same goes for music, and when the film industry realises that DRM is a fallacy, I’ll be able to do the same with video too.

Ideally I want to have my entire collection of books with me wherever I go, but not just books. I want to take my music and video collection too. The iPhone kickstarted a revolution in convergence devices that go a long way towards making this possible. Whilst I can’t carry my entire music and video collection on my phone because they are too large, I can carry my favourites and still have enough space for all my ebooks.

Recently I’ve encountered a couple of situations where my phone doesn’t suffice though. I write a lot of notes on paper (or 3×5 index cards) and they are prone to getting lost or recycled accidentally. For this the phone keyboard is too small, and I’m not sure whether I would be more comfortable with a pen or stylus over a keyboard anyway. I also started playing the guitar again and printing guitar tab is a waste of paper and often difficult to read. Again the phone is too small to display this type of content effectively.

I thought about getting an eReader like the Kindle or Nook to address this issue, but I’m not convinced they will provide everything I need. I think they would be fantastic for replacing paper content, but I’m not so sure about the note taking, even though the Kindle has a physical keyboard and the Nook has a virtual keyboard that would fill an iPhone screen.

The elephant in the room is the iPad. It can do everything my phone can do but has a bigger screen. The battery life isn’t as good as an eReader and the screen will get full of fingerprints, but it will do everything I want. When it came out, I said I couldn’t see a need for one in my life because it didn’t solve any problems for me. Then I chuckled to myself as I saw lots of people buy them, play with them for two weeks and then struggle to figure out what they were going to use it for! Now I do have a use for a 10” iPhone I feel like a bit of a dummy. I hate it when Apple are right!

Even so, given my feelings towards Apple right now though, I am loathed to give them more of my hard earned cash. The only semi-viable alternative I have found is the Archos 10 internet tablet. There are plenty of cheap Chinese rip offs of the iPad, but I’ve used Archos devices before and they were very good quality. Physically and technically it has very similar specifications to the iPad but it runs the Android 2.2 Froyo operating system. Given that Android phones have similar capabilities to an iPhone, I figure an Android tablet must have similar capabilities to an iPad!

Only time (and finances) will tell whether I end up with an eReader, an iPad or another tablet device, but I wouldn’t be surprised if one of them turned to be my next gadget purchase, so I can remove more dead trees from my life!

What's the value of free?

2010-11-16T00:00:00-08:00

I was looking something up on Wikipedia when I saw this banner containing an appeal from Jimmy Wales for donations to the WikiMedia Foundation. It made me question how much we take services like Wikipedia for granted? If you decide that you should donate, how much would you give? How do you but a value on a free service?

I have no problem discerning the value proposition with the ‘Freemium’ services like LastPass, where the “extra” value I get from my $1/month are listed in bullet points before I hand over my money. However in this case you don’t get any “extra” value in exchange for your cash. There is the possibility of less value being delivered if you don’t make a donation, but that’s not a certainty either.

So how much should you donate? Perhaps it should be the cost of a reasonable “dead tree” encyclopaedia? On the other hand if every user gives a nominal $1 donation, it would raise $400,000,000, which I think would see them through for a while!

Of course, just like free and open source software, there is more than one way to contribute. You could also contribute with your time, by adding, editing or reviewing articles.

I decided that I’d like Wikipedia to stick around, so I’ll make a small donation and start contributing where I can. If you use it, what will you do?

Play in your own sandbox

2010-11-15T00:00:00-08:00

Following on from my previous post, one of the other things I always strive to do from the outset of a project, is ensure that everyone has their own sandbox to play in. Every developer (and the CI machine) should be able to run the project independently of each other, without any reliance on common resources such as application servers or database instances.

In previous projects that has always been fairly easy because the projects were either Java desktop or web applications using free and open source software. Right now I am spending a small amount of my time helping out a ColdFusion project. I thought it was going to be painful and expensive to create a sandbox for them but actually, thanks to some friendly developer licensing, I don’t think it’s going to be such an issue.

What I want is for each developer to be able to launch their own their own test environment, which means running ColdFusion in a JRun instance with a SQL Server database that always starts in a known state. Adobe kindly provide free developer licenses for ColdFusion and JRun as do Microsoft for SQL Server, so licensing isn’t an issue.

We’ve already spent a little bit of time getting an Ant script together with a tool called MXUnit to give them a way of running unit tests against their code using a central server, so that is our starting point. My end goal is to have the Ant script launch all the services and execute the tests locally, thereby removing the dependency on the shared resource. I’ll share any lessons learned here.

Click. Click. Build.

2010-11-15T00:00:00-08:00

These days, the first thing I do whenever I start a new project is figure out how to build it. It’s a lesson I learned from Ship It! by the Pragmatic Programmers and a habit that I have gotten into.

I’m not talking about clicking the “build” button in the IDE either. I’m talking about a build that can be run independently on any machine, preferably with a single checkout from the version control system then a single command. If you can do that, then setting up new development machines and/or continuous integration builds is a cinch!

Sounds great, but how do you do it? I’ve only really got experience of doing it with Java projects, although they included a lot of JNI code and I was able to include that too.

First up, you need to decide on a build tool. It could be as simple as a batch file but my current tool of choice is Maven. I’ve also used Ant in the past and I’m looking at Gradle for future builds. The reason I switched to Maven was for it’s dependency handling and reporting, and now it’s well integrated into the popular Java IDEs, meaning your developers can choose their favourite.

Once you’ve got a build tool, you need to ask yourself what you files do you need to build your project? Obviously the source code and build script will be needed but what about resource files, test environments or any other tools that assist with the build. In the past I’ve taken this to the extreme of checking in a copy of the build tool itself and even the JDK. This meant that the only thing you needed to set up a new developer machine was a copy of Subversion, everything else came from the version control system!

The only exception to this rule were the dependencies that I mentioned. When we were using Ant, our projects had a ‘lib’ folder and the dependencies were checked in with the code. With Maven, we set up our own internal repository and shared the dependencies from there. However if you’re going to do this you need to make sure that your Maven repository is backed up with the same frequency as your source code repository!

Oracle, the best thing to happen to OpenJDK?

2010-11-14T00:00:00-08:00

I can’t believe I am writing this, but could Oracle be the best thing to happen to OpenJDK? I know that writing 30 posts in 30 days is driving me a little crazy, but have I really lost that many marbles before the halfway point? Just how can the company that is being sued by the US government for their alleged dishonesty be doing good things with such an indispensable open source project?

Well, despite my many misgivings about the delays to all the interesting content in JDK7, their willingness to take the flak and do what is necessary to steady the ship shows they have the guts to make tough decisions. Sun kept promising but never really delivered. If Oracle start delivering regularly then I’ll be less critical of the additional delays to JDK7.

They’ve also persuaded IBM and Apple to join the OpenJDK effort, something which Sun never managed to do. This brings all the major JDK vendors together in one place and hopefully we will see the best features of each of the JDK implementations (IBM, Oracle/BEA, Oracle/Sun and Apple) being merged into the open source offering.

The only question that still nags in the back of my mind is their motive. Whilst it all seems rosy on the surface, persuading IBM to back OpenJDK instead of Apache Harmony could have an ulterior motive. Oracle are attempting to sue Google over the use of Java in Android, and which class libraries do you suppose Android uses? You guessed it, Apache Harmony’s! By getting IBM to switch to OpenJDK, it further isolates Google.

I’m not quite ready to believe that is a co-incidence yet!

Is Apple an abusive partner?

2010-11-14T00:00:00-08:00

I have a dilemma. I love Apple products. I love the hardware. I love the software. I love the presentation. I love that their products are “friendly”. But I also see an ugly side to Apple. The side that is cold, ruthless and oppressive.The side that decides what is good for it’s customers and what isn’t. Do I want to continue is a relationship with a partner that gives me beautiful things but makes all my decisions for me?

Alarm bells started ringing when Apple started making arbitrary decisions about approvals to the App Store. Blocking Google Voice was a big mental hurdle for me. Apple’s excuse that it replicated functionality that already existed in the incumbent phone application seemed to be stretching the truth.

The next warning was section 3.3.1 of the SDK license, which prevented anyone from using anything other than sanctioned programming languages to create applications for iOS devices. This sent them into a bitter war with Adobe. Apple had already refused to allow Flash into iOS, prompting Adobe to invest in cross compiling to native iOS devices. Almost antagonistically, Apple introduced the new restriction just before Adobe launched their new Creative Suite!

The latest slap in the face was the announcement to drop support for Java from OS X 10.7. It felt like Apple was systematically removing anything but it’s own technology from their system. Up until now, I liked being in Apple’s walled garden because things just work there, but when the walls are closing in, it’s time to find a way out!

There are some positive signs however. The restrictions in section 3.3.1 have been relaxed and Apple is going to contribute to the OpenJDK effort, which I think is definitely the “right thing” to do. The question is whether these concessions are just to lull us into a false sense of security before the next sucker punch, like the Mac App Store for example?

Mmmmm... Minty Macbook!

2010-11-13T00:00:00-08:00

When I started on my current project and got a new developer workstation, I took advantage of an official Ubuntu distribution sanctioned for use within the company. Apart from a few wrinkles with the authentication against the Windows domains, it has been a real pleasure to use, so when I rebuilt my MacBook recently, I decided that I would use Bootcamp and tri-boot it (Max OS X, Windows 7 and Linux).

I started out with the regular Ubuntu distribution, but it didn’t seem to work all that well. It certainly wasn’t a slick as it is on my workstation at work. I was having problems with the trackpad and the wifi adapter in particular. Then someone recommended Linux Mint, so I scrapped Ubuntu and installed that instead.

It installed straight away and everything aside from the iSight camera worked immediately. It can access the OS X and Windows 7 partitions and even the MP4 video and MP3 audio codecs were installed so I could play back my media from my iTunes library.

On top of that, it performs snappily and it still has the excellent package management of Ubuntu. I was even more pleasantly surprised when it paired with my iPhone and connected to the internet on the first attempt!

So if you’ve been thinking about giving Linux a whirl, then Linux Mint is a really good, low fuss candidate.

Meetings are toxic

2010-11-12T00:00:00-08:00

That is the title of a chapter in Jason Fried and David Heinemeier Hansson’s (37signals) book, Rework, and I have to admit that I agree with them. I’ll also admit that I’m a little jaded by the number of unproductive meetings that I’ve attended in my career, so my view may be tainted!

One of the key points in the book is that meetings are terribly expensive. A one hour meeting between 10 people is a 10 hour meeting. That’s before you factor in the cost of stopping what your doing, or any preparation work. It’s at least a day and a half of productivity gone! Sadly most people don’t think about that when they book meetings.

There are three problems with most meetings that I attend:

The wrong people: There are usually too many people and often key individuals (decision makers and/or subject matter experts) are missing. What’s the point of holding a meeting if you can’t get the information you need and reach a decision?
Poor facilitation: I cannot criticise anybody for not defining a clear agenda, with defined goals/outcomes, and time boxing effectively. I am not very good at it either. At least I’m cognisant of that fact and try to mitigate it by not calling meetings! I use face to face discussion, phone calls, IM or e-mail instead.
The length: Most of the meetings I attend are at least an hour long. The majority of attendees are bored in half that time, because the outcomes can normally be reached in half the time if the right people are there and the meeting is well facilitated.

I don’t agree with everything that David Heinmeier Hansson says, but there are some things where I think he is spot on, and this is one of them. Next time you go to book a meeting, please weigh up the cost and think about whether there is a better way to achieve the outcome you want!

Being a good FOSS citizen

2010-11-10T00:00:00-08:00

Do you use free and open source software? Do you contribute back? I have to hold my hands up and admit that I have not contributed back as much as I feel I should have and I feel bad about it.

The obvious way to contribute is with code, be that feature enhancements or bug fixes, but there are many ways in which to contribute back. You can work on documentation or subscribe to the mailing list and help out by answering questions and helping people with problems that you might have already solved. Even evangelizing about free and open source software is contributing in some way, and the one in which I have been most active.

However, twice in the last couple of months, I have found and fixed bugs in open source libraries. I depend very heavily on one of those libraries (WebDriver) for my current project and despite the best of intentions, I still haven’t submitted a patch for the fix. My “excuse” is that I haven’t had the time to create the patch and a unit test example to demonstrate the problem and solution, but let’s face it that is a poor excuse! If I have the time to learn to use someone else’s software, and I expect it to be there in the future, then surely I can make the time to send them a fix I’ve already written?

So my conscience has finally got the better of me! Just as I committed to blogging once a day for 30 days to kill my procrastination about blogging, I am making a commitment to contributing patches for the fixes I have by the end of the week to kill my procrastination about contributing back too!

Why doesn't everyone strive for better?

2010-11-09T00:00:00-08:00

Why don’t some people want to do better at their jobs? I don’t understand. I’m talking people involved in developing software here, but I’m sure the same problem affects many occupations.

I had one meeting last week where I made the case very passionately that people should be actively seeking to improve the things that they find difficult. Sadly I think it fell on deaf ears, but the discussion certainly ruffled a few feathers and acted as a catalyst for other changes that needed to happen!

I’ve been discussing this problem with a number of different people recently and they are as baffled as I am. The only consensus of opinion I was able to gather is that people who don’t want to improve don’t really care about their craft. Unfortunately most employers are not very good at fostering an environment that inspires people to care either, which leaves the few of us that do care being frustrated by those that don’t.

Ordinarily I wouldn’t post such an opinionated piece and I’ve sat on this for a number of days. In the end I decided to post something because this issue occupied my mind a lot last week, and the purpose of of this exercise is to record what is occupying my mind. I don’t expect that it will change anything, but it did make me re-evaluate what I was trying to achieve at work and why, which can only be a good thing!

Take the red pill...

2010-11-09T00:00:00-08:00

Right now I feel a bit like Neo being confronted by Morpheus and offered the choice of the blue pill or the red pill. Take the blue pill and I can go back to my comfortable world of Java and object orientation. Take the red pill – I learn Haskell and see how deep functional programming goes!

In a previous post I mentioned that I am in the process of learning functional programming in Haskell. The exercise this week was to write a monadic parser and what struck me about it was how much I was wrestling to keep a single function in my head. With Java I can hold several classes and the interactions between them in my head, and even do a half decent job with multi-threaded code (I’m sure Tony would disagree and he’s probably right, but for now I am no more disillusioned than most Java programmers).

I think the part of the reason I struggled is because Haskell code is a lot more dense than Java code i.e. less code does more. The type system in particular, is so rich that trying to keep track of what types were in play at each point in the function was a challenge in itself. Whilst I was working on the exercises, I got to a point where I knew the understanding I needed was just beyond my grasp, and the penny dropped just as I answered the last question!

It was at that point that I began to understand what one of the functions I had written early on actually did. That enabled me to clean up my code considerably because I had been rewriting the same function over and over in the subsequent questions. That in turn made the code a lot easier to reason about.

It really shows the importance of understanding a function before you use it. At the end of today’s lesson we had an interesting discussion about unwittingly misunderstanding code, because we think we understand it when actually we don’t. Languages like Haskell can reduce the ambiguity which reduces the chance of misunderstanding. Unfortunately, it can also lead to non-understanding for beginners like me, which isn’t much help either!

Mixin it up

2010-11-05T00:00:00-07:00

A couple of days ago I talked about using Groovy’s metaClass to add a method to the Collection class at runtime. Today, I used Groovy’s mixin mechanisms to share common functionality between two classes that don’t share the same ancestry.

In my original Java code, one of the classes was actually an inner class of the other. When I converted that code to Groovy I found that Groovy’s inner class support was a little bit… iffy (at least in the sense that the behaviour is not exactly the same as Java)! So I promoted the inner class to a top level class. That left me with two functions that both classes needed to share.

The obvious options were copy and paste (over my dead body), try and force a common parent (inheritance), or refactor the shared functions into their own classes (composition). I felt the only reasonable option was composition, but I didn’t want my new concise code being messed up with lots of indirect method calls! Having used Scala traits before I figured I would look for the Groovy equivalent.

My first port of call was Groovy’s mixin() method, which works like this:

class Logger {
    def log(message) {
        println "> $message"
    }
}

class Foo {
    static {
        Foo.class.mixin Logger
    }
    
    def bar() {
        log "Foo.bar() called"
    }
}

foo = new Foo()
foo.bar() // prints "> Foo.bar() called"
foo.log "log called directly on Foo instance!"

Perfect! Easy to implement, not too difficult to follow, and no (source code) overhead to calling the mixed in methods. I committed the code and was about to get on with the next task when I discovered another mechanism…

There is an @Delegate annotation you can place on a field within a class. It triggers an AST transformation which injects the interface of the delegate into the enclosing class, giving me the same net result as the mixin() method:

class Logger {
    def log(message) {
        println "> $message"
    }
}

class Foo {
    @Delegate Logger logger = new Logger()
    
    def bar() {
        log "Foo.bar() called"
    }
}

foo = new Foo()
foo.bar() // prints "> Foo.bar() called"
foo.log "log called directly on Foo instance!"

I ended up going with the @Delegate mechanism because the IDE (IntelliJ IDEA in my case) can resolve references to the delegated methods (because the transformation is applied at compile time) which it couldn’t do using the mixin() method (because it is applied at runtime). I imagine therefore, that it makes sense to use @Delegate on your own classes and mixin() on other peoples.

I didn’t delve into them, but there are more mechanisms available than the two I’ve highlighted here. There are @Category and @Mixin annotations and you can roll your own AST transformations too. They might be the subject of another blog post!

Is meta better?

2010-11-04T00:00:00-07:00

Yesterday I did my first bit of meta-programming in production code. It wasn’t anything particularly fancy, but it does extend the functionality of a class (that I didn’t write) at runtime, to provide an additional function.

There is a really handy matcher method in the FEST-Assert library called containsOnly(), which ensures that two collections have the same contents but doesn’t care about the order. Now I’m using Spock, I’m trying to stick to the basic Groovy assertions because Spock uses them implicitly, they are easier to read and write, and the output when an assertion fails is excellent:

assert collectionA == collectionB
       |           |  |
       [1, 2, 3]   |  [2, 3, 4]
                   false

The Groovy JDK already adds a whole bunch of useful methods to the stock Java collections, but there isn’t a containsOnly() method. However it is easy to provide the function using two of the existing methods:

def containsOnly(collection) {
    size() == collection.size() && containsAll(collection)
}

So I added it by modifying the metaClass when my code is initialized:

Collection.metaClass."containsOnly" = { Collection other ->
    size() == other.size() && containsAll(other)
}

And it works beautifully. The question is whether or not it is better than trying to solve the problem some other way, such as using a proxy class or a utility class to provide the extra function? It would certainly be easier to track where the containsOnly() method is defined, rather than it appearing by magic as it does with meta-programming (unless you know in advance where the metaClass extension is being done). On the flip side, it takes a lot more code to do the same using a proxy or utility class, and only a proxy would allow me to keep the API I want in this case.

I guess in the end it’s a swings and roundabouts argument. What you gain with one you lose with the other. Both introduce some overhead to future maintenance of the code. It’s just that it might not be obvious to the person that comes after you where that overhead is if you’re using meta-programming!

Follow the types (not the white rabbit)!

2010-11-04T00:00:00-07:00

For a while I have been trying to learn Haskell as a way of getting my head completely around functional programming. I started with “Seven Languages in Seven Weeks”, moved on to “Real World Haskell”, and now, Tony Morris is very kindly donating some of his time to help me and a few other guys to get to grips with the concepts that underpin the language.

Every week, he sets exercises for us to complete, which involves writing solutions to a bunch of functions that pass the acceptance tests that he supplied. This week we are writing a parser, but the real challenge for me is that none of the tests will pass until all of the functions have been completed. Writing around 20 functions before being able to get any feedback is almost a bigger challenge than writing the functions themselves!

Tony’s advice was to “follow the types” and I’m sure he is right. If you follow the type signatures and you have a vague notion of what the function is supposed to do, there are only a limited number of options open to you. The HaskellWiki also says that “Once your code compiles it usually works”. I’m halfway through the functions and really hoping that is true! Perhaps I’ll report back in a future post.

In any case, I can already say that what I have learned so far has influenced the code I write, and I can only see good things coming from having a better understanding of type theory and functional programming.

Consoling oneself

2010-11-02T00:00:00-07:00

The last time I used the Groovy Console (several years ago) it was painful, but now I have to say that it is one of the most useful tools I’ve come across.

The thing I like about it is that you have an actual editor, so you can work multi-line statements. It means that you can write small classes and then refine them, which can be difficult in a genuine REPL. And because everything is there right in front of you, when you make the inevitable mistake, you can look back at what you have written and correct it far more easily.

In fact I’ve found it so useful, that I’ve started using it whenever I want to do a quick spike to investigate an idea, or refresh my memory about some API. It’s also ridiculously easy to embed a console into your application which allows you to access everything that is on your classpath (assuming that Groovy is also on your classpath of course!):

import groovy.ui.Console

def console = new Console()
console.setVariable("foo", "bar")
console.run()

I’m using this as a debug aid in my current project, which uses a private in-memory database initialized from another system at startup. With the embedded console, I can run the initialization and then inspect the contents of the database when queries are not behaving as expected, to quickly find and fix the cause of the problem. I’ve also been able to very quickly prototype new ideas, then cut and paste the code into the application proper, as a starting point for the production code. For me, being able to interactively execute code in my application at runtime has been a massive productivity boost.

And of course, you don’t have to programming in Groovy to use it. You could just include the Groovy jar and your Console bootstrap class in a debug build of your Java project!

Groovy baby!

2010-11-01T00:00:00-07:00

For the last few weeks, I’ve been using Groovy (and the Spock BDD framework) on my current project at work, and after initially being reminded why I don’t like dynamic programming languages, I have to admit that I’m slowly being converted.

Those of you who know me (or have listened to the podcast) will know that I am not a big fan of dynamically typed programming languages. I like knowing the fact my code compiles makes some statement about it’s correctness. Obviously it doesn’t mean that your code is right, but at least stupid mistakes like typos in names are picked up by the compiler. I’ve always thought that people accept the compromise of dynamic typing a little too easily.

In the past I’ve used Groovy to script builds and deployments, but I’ve never really used it to write production code before. The reason I have turned to Groovy this time is beacuse I am building a framework that is to be used by a team of testers to write their automated tests. I need something that will allow me to take the Java code I have (which includes a simple DSL), hide all the boilerplate and remove as much punctuation as possible. I evaluated Scala and Groovy and much as I like Scala, I settled on Groovy for two reasons:

Groovy 1.8 includes a new Command Expression Syntax that really lends itself to the DSL I have created.
Groovy is already in use in the organisation.

And really it came down to the second of those. Using Scala and the Specs BDD framework I am pretty sure that I could create something very similar, but Groovy seems like the more natural fit for the organisation.

When I first started transitioning the codebase to Groovy I felt a lot of pain, which I have subsequently put down to my attempts to keep the static typing where I could. Things definitely got a lot easier when I jumped off the fence and planted myself firmly in the garden of dynamic typing!

Another benefit of coming off the fence is that the code has become a lot more concise and less distracting (than the equivalent Java code). For example,

public <T> T retry(final Callable<T> action)

became

def retry(action)

This example also shows how I’ve been able to eliminate the use of interfaces and classes as substitutes for closures (action is treated as a closure), and replace generics with dynamics.

I’m not completely sold on the dynamic typing argument yet, but I’m certainly a lot less sceptical than I was a few weeks ago. Only time will tell whether I become completely comfortable with it!

Captain Sensible at the helm?

2010-09-23T00:00:00-07:00

My initial reaction to the announcements from this year’s JavaOne was one of sadness, since it’s clear that Oracle has sapped the pioneering spirit that made Sun special. Having had a few days to reflect on it though, I don’t think it is as bad as my gut reaction would have me believe.

Oracle obviously has a clear focus of it’s intent with Java. It has been through all of Sun’s projects like Captain Sensible, culling anything that does not align with their goals. I’m guessing that Java the platform is much more important to them than Java the language, since they’ve dropped JavaFX Script and the interesting language features from Java 7. It appears that they are happy for the likes of Groovy and Scala to continue innovating in that space.

I’m not surprised that some key individuals left when Oracle took over if my interpretation is correct. It must have felt like the fun police arriving! On the whole though, I think Oracle’s ruthless business mindset will put Java on a steady course, which means it will be around for a very long time… I’m just not sure I’m all that interested anymore!

Flash - friend or foe?

2010-03-12T00:00:00-08:00

I attended Barcamp Gold Coast IV last weekend which was an awesome experience despite the low turn out. The lack of attendance did prompt me to host a couple of impromptu sessions though, one being a rehash of a blog post I wrote last year about RIA technologies and where I thought it was all heading.

The most interesting thing was that I conducted a quick straw poll at the start of the session to gauge feeling towards Flash, with surprising results. There were a mix of people in the audience, from accountants to developers, and every single one of them hated Flash! Some because of it’s use in advertising, some because it hogs resources on their system, but nobody wanted it on their system and some people were actively blocking Flash content from their browsers.

Now I’m no fan of Flash but I was not expected such a landslide result! Given that I already thought Flash was under threat from HTML 5, this lack of consumer enthusiasm for it has to be another nail in the coffin.

Since my last blog post, Google has also been successful in it’s acquisition of On2, the company from whom the Flash video codec is licensed. Google can now do what they want with that codec, such as open source it or freely license it to other browser vendors, subject to any contractual obligations On2 have with Adobe and Oracle (who license the same codec for JavaFX). Is that the sound of another nail being readied?

All told I think the developments of the last few months have been positive ones for internet consumers, since it should start to resolve some of the sticky issues with the HTML 5 specification process. But I think it is more bad news for Adobe who, sooner or later, are going to have to stop shoving the Flash runtime down people’s throats.

The only runtime people seem to want in their browsers now is the JavaScript runtime and between Google, Apple and Mozilla, we have three great implementations competing against each other. If the HTML 5 committee can reach an agreement on which video format the <video> tag must support, then I don’t see any reason left for any content provider to use Flash (or Silverlight or JavaFX) at all.

Physical media is dead to me!

2009-11-18T00:00:00-08:00

With the impending move to Australia coming up I decided to rip all of our music and video to the computer and abandon physical media altogether. We have a few hundred CDs and over a hundred DVDs so it wasn’t a trivial nor insurmountable task to rip them all but the switch away from physical media raises a number of questions.

The first decision I had to make was which format and quality to use to rip our existing content. I’ve had a number of conversations with my dad over the last few years about the quality of the encoding versus the quality of the content. The argument basically boils down to this. If there’s a song or piece of music you really love, you’ll enjoy listening to it on an AM radio almost as much as you would from a CD. The same goes for your favourite film. You will enjoy watching it on an analogue 14" TV from a VCR almost as much as on a 50" LED backlit 1080p TV from a BluRay disc. The bottom line is that the quality of the content is the most important part of the equation because that’s where you derive the majority of the enjoyment. So long as the quality of the encoding is good enough, then very little of the enjoyment will be lost.

Whilst I would have liked to use the open source and patent free FLAC or Vorbis codecs to encode the audio, I also wanted to make it as easy as possible to play the files back on as wide a range of devices as possible. That really meant the only available choice was MP3, since AAC is probably better quality for the same size but is not as widely supported. As for quality, I chose 256kbps because I can’t really hear a difference between that and a CD whereas I sometimes can at 128kbps. With the DVDs, I would have liked to use H.264, but it took 4x longer to encode than standard MPEG 4, and there are still a lot of devices that don’t support it properly, so I opted for the latter. Ideologically I would have used Theora (open source and patent free) but it is very poorly supported.

Having liberated all of our content from it’s physical medium, the ongoing challenge is to avoid acquiring any more physical media. With audio this is not too difficult, thanks to the likes of Amazon MP3 and 7Digital offering high quality, DRM free MP3 downloads, or if you’re really pushed, iTunes DRM free AAC downloads. Video however is another matter.

Just as the music industry has recognized that the only way to beat piracy is to make it easier to buy their content than to steal it, the TV and movie industry start making all the same mistakes! I can’t find anywhere to legitimately download DRM free video content. The iTunes store offers the best choice, at least in the UK, but all the content is protected by Apple’s Fairplay DRM, which means I can’t play it on anything other than iTunes or Apple’s portable media products. Tesco and CoolRoom also offer video download but only in WMV format protected by Microsoft’s PlaysForSure DRM technology that doesn’t work on Mac or iPods!

Case in point is the J. J. Abrams Star Trek movie that has just been released on DVD in the UK this week. I paid to watch this movie at the cinema and I enjoyed it so much I want to pay again to own a copy but I don’t want any physical media. My first port of call was the iTunes store who have it for £10.99 including extras but with DRM. Next stop, Google. None of the top 10 Google results for “star trek movie download” were legitimate links. One of the sponsored links was FindAnyFilm which lead me to CoolRoom where I can also download it for £11.99 without the extras but with DRM that won’t work on anything I own!

The simplest way for me to get this movie would be to bittorrent it, and I would have the option of a HD version to boot. When will the movie industry realise that it is currently easier to pirate their product than it is to buy it legitimately, and that is why piracy is rife? Why are they making it so hard for us to give them our money? The best legitimate option I have is to buy it on DVD (£8.00 from Morrisons), rip it straight to the computer and place the DVD in storage. That’s time and effort I would gladly pay an extra £2.99 to avoid if they would just get rid of the stupid DRM!

JavaFX - a case of closing the stable door?

2009-11-05T00:00:00-08:00

Since the news that Oracle was buying Sun, I’ve not been convinced about the future of JavaFX. In the last couple of months I’ve come to the conclusion that it doesn’t matter what Sun or Oracle does with JavaFX, it’s future as an RIA technology looks pretty bleak anyway. And it’s not alone. Adobe Flash and Microsoft Silverlight are in the path of the same train that is starting to build up a head of steam, namely the combination of HTML 5, CSS 3 and JavaScript. Let’s take a look at the evidence and see why I have jumped to this conclusion!

Two of the biggest proponents of the HTML 5 and associated standards are Google and Apple. Let’s start by looking at their recent behaviour.

About a year ago, Google launched their Chrome browser with the express intent of creating a platform to deliver HTML 5 applications. A few months ago, they announced Chrome OS, a lightweight operating system whose whole user interface appears to be web based. The next release of their Android operating system for mobile devices is also going to feature a HTML 5 browser. Apple have also been making sure that HTML 5 support is in all their products. Version 4 of their desktop Safari browser supports HTML 5 as does Safari on the iPhone. So they are both doing their utmost to ensure that people can use HTML 5.

Google has been re-encoding all the YouTube content in H.264 instead of Flash video. HTML 5 includes a <video> element which will eventually mean that webpages can include video without the need for additional plugins, like Flash Player for example. Apple’s iPhone has special support for YouTube so that the H.264 encoded content can be played, again avoiding the need for a Flash plugin. Apple’s steadfast refusal to allow Flash on to the iPhone is creating a headache for Adobe, as the iPhone becomes ever more popular and web developers are forced to provide Flash free sites (or at least Flash free alternatives) to avoid losing potentially lucrative audiences.

The only thing slowing down the adoption of HTML 5 is bickering over the fine details. Everyone agrees that there should be a <video> tag, but no-one can agree which codec(s) should be supported in the standard, meaning that all browsers will have to include them. Most of the arguments are over potential patent claims but the three lead contenders are H.264 (an ITU-T standard), Flash Video (proprietary) and Theora (open source). As well as re-encoding YouTube content, Google has also been trying to buy On2, the company that owns the Flash Video codec (also used as the cross platform codec in JavaFX). Sounds to me like they are hedging their bets!

So two of the most successful technology companies of this millennium would appear to be set on a course to rid the web of Adobe Flash and replace it with standards based HTML 5. If they are making headway against Adobe Flash then the relative minnows of JavaFX and Silverlight stand no chance. Fortunately Sun/Oracle and Microsoft don’t have as much to lose as Adobe, who generate a significant income from Flash related authoring tools. In my humble opinion, they already ought to be thinking about how to leverage their well known and respected tool chain to produce HTML 5 based solutions. I figure that’s their best bet to keep their existing customer base if Flash use starts to decline.

Sadly the same cannot be said for Sun and JavaFX. If it isn’t going to be used for RIAs, what else can it be used for? There’s set top boxes of course, but many of them already use HTML under the hood and HTML 5 will probably do most of what they want. BluRay is another possibility, but you’ve got to figure that the days of physical media are numbered. I think the best bet for JavaFX is as a replacement for the Java language itself. It’s a modern language with some really nice features and would be a worthy competitor to the likes of Scala as the “new” Java. Here’s hoping!

A week with IntelliJ IDEA

2009-11-02T00:00:00-08:00

Since the start of last week I have been using the beta release of IntelliJ IDEA Community Edition and I have to admit I’m really rather impressed. It hasn’t been completely plain sailing but I’m prepared to give it the benefit of the doubt given that it is still in beta and it’s only fair to expect a few hiccups along the way.

One of the things I like most about IDEA is it’s keyboard centric and code centric approach. To call it a glorified text editor is doing it a disservice, but the feeling I get when I’m using it takes me back to my first job using vi on HP-UX terminals to write software for telephony switches. I don’t mean that it’s primitive, far from it, just that it gets back to basics and puts the emphasis back on writing code.

And yet it provides a tremendous amount of support. The code insight and refactorings are excellent. The inspections help keep you on the straight and narrow as far as good coding practice goes. It’s Maven and version control support is top notch too. The biggest problem is remembering all the keyboard shortcuts in the mammoth keymap.

The distraction free, code and keyboard centric approach means that it also works very well on my 13" MacBook screen, and for the first time I can remember, I’m actually enjoying coding with it’s limited screen real estate!

In fact the only thing I’m missing from NetBeans is auto closing a line when you enter a semicolon!

Will it sell more copies? I don’t know. As I said in my last post, there’s usually the best option and there’s the option that’s good enough. I think IntelliJ is probably the Apple of the Java IDE world, in that the attention to detail in IDEA is much better than Eclipse and NetBeans. But both those IDEs are good enough for the purposes of most developers. If IntelliJ ever make IDEA Ultimate Edition available for free then the others might be in serious trouble though.

If I were writing web apps every day, then I would definitely trial the Ultimate Edition and if the extra plugins are as good as the Community Edition, I would pay for it out of my own pocket, which is about as big an endorsement as I can give it! I’m also going to continue using it as my preferred Java IDE.

Having said all that I still doubt that this move will significantly increase it’s market. I hope I’m wrong, but in the current economic climate especially, people are going to be prepared to compromise!

Is it good enough or false economy?

2009-11-01T00:00:00-07:00

Throughout our lives we are told to do our best. We would all like to buy the best clothes, phone, car or house. We all want our football, rugby or team to be the best, not to mention our kids! But life is also full of compromise, and sometimes we have to make do with whatever is good enough since the best inevitably costs more of something, be that money, time or effort. There’s also the possibility that you pay the additional cost unnecessarily because the “good enough” option would have met your needs.

Let’s start with the device I am using to write this post, the iPhone. I don’t even need to think about this one. As soon as I saw the first videos of it I knew I was going to buy one as soon as it came out. Two years later and I’m still using my first generation phone and I’ve yet to see another phone that is as well made or works as well as an iPhone. I’ve had my moneys worth out of it many times over. Even when I replace it with the latest model I’ll be keeping this one and using it as an iPod Touch.

I’m of a similar mind when it comes to computers. I haven’t seen another computer as beautifully made as an iMac or MacBook, although the lead over the competition is not as great as with the iPhone, especially with Windows 7 having just been released. I’ve been very happy with my Mac Mini and MacBook purchases and I think my next purchase will be an iMac, but I am by no means as certain as I am about my next phone!

I’ve also had bad experiences when accepting the compromise and not going for the best option available. I’ve struggled with my DSLR camera for months because I’ve been using some no-brand-name 2600mAh rechargeable AA cells that I was previously using with other cameras. The problem is that this camera draws a lot of current and the batteries just can’t cope. Plus if you leave them in the camera for more than a couple of days, they discharge so quickly that the camera isn’t ready to use when you pick it up and inevitably you miss the shot you were trying to capture. I’ve spent a small fortune on different batteries and chargers without any resolution to the problems. Finally I’ve given in and purchased some Duracell rechargeable batteries instead. So far they have been in the camera for 2 weeks and I haven’t had a single glitch, so this was clearly a case of false economy.

But the biggest decision of our lives has been to move to Australia. This is a complex multifaceted decision but at the heart of it lies a desire for the best possible life for our family. The cost is also multifaceted. We are leaving behind friends and family, some of whom we know we will never see again. There’s also a substantial financial cost on top of the emotional turmoil. We aren’t there yet and only time will tell whether the cost of leaving the UK, which is a more than good enough place to live, is a price worth paying.

The good, the bad, and the GUI

2009-10-27T00:00:00-07:00

As a desktop Java developer, I have access to one of the best desktop user interface libraries around, Java Swing. Like it or loathe it, there isn’t a cross platform user interface library that even gets close to what Swing can achieve, both in terms of platform fidelity and custom components.

The biggest problem is that it is painful to use. It has a massive API which inevitably contains inconsistencies and leads to some pretty verbose code. In theory a good GUI editor should help ease the burden but I’ve never been a huge fan of them. Whilst they promise to save you from writing reams of code (by generating it for you instead) I’ve always found that somewhere along the way the tool screws up, and then you have to dig through all those reams of ugly machine generated code to fix the problem by hand.

That was until project Matisse, the latest NetBeans GUI editor, came along. Now here is a tool that actually works. So far I have not had to duck under the covers to fix a problem it has made. It allows me to design the user interface quickly and easily, and then expose the components that I need to access from my controller code. So far, so good.

Except this week I’m evaluating IntelliJ IDEA instead of using NetBeans. And Matisse uses a .form file to store meta data about the UI forms so it doesn’t have to infer from the code. That’s great whilst you stay within the walls of the NetBeans garden, but when you want to go play in the neighbour’s garden, the .form file can’t come with you. In fact, IDEA’s GUI builder has it’s own .form file that it incompatible with the NetBeans one!

So I’m back to being of the opinion that you should hand code your user interface and stay away from GUI builder tools, unless you are really prepared to be locked into a single toolset for the life of the product you are working on.

By way of an experiment, I converted one of the simpler application windows to use MigLayout, which promises much of the same magic that the GroupLayout does behind the smoke and mirrors of Matisse. It took me about an hour from start to finish but I now have the window behaving the way that I want it to, and with code that is reasonably easy to read, albeit still verbose (at least it is much less verbose than using GridBagLayout).

Whilst MigLayout is definitely a compromise, it might just be the best compromise if you’re stuck with Java the language and have been bitten one too many times by so-called “helpful” GUI editors!

Chrome gleams on OS X

2009-10-24T00:00:00-07:00

At long last, Google has released an official version of it’s Chrome browser for Mac OS X. It’s only a developer preview but that won’t stop me from making it my default browser! I’ve been using Chrome as my default browser on Windows for months and I really like it.

With the exception of Internet Explorer, the choice of browsers on Windows and Mac is now largely the same. As well as Google Chrome you have Safari, Firefox and Opera plus a slew of niche browsers. What I want from a browser is speed and standards compliance, plus a clean interface that doesn’t get in my way. Being a developer I’m more keyboard centric than most users and therefore I don’t like having to resort to the mouse unnecessarily.

Up until now, my preferred browser on the Mac has always been Safari. Whilst I use Firefox occasionally it is slower to start, slower to browse and slower to use because it’s interface is less slick than Safari. I’m not a plugin junkie so Firefox’s greatest strength against it’s competition does little to persuade me. I also found that it used to slow the rest of the system down although this seems less of a problem since V3.5. I like Safari because it is simple and fast, exactly the same reasons why I like Chrome. Except I like Chrome more!

There are a few features that really make Chrome stand out from the pack. First of all it is the fastest of the browsers that I use. The SunSpider benchmarks show that Safari is about 30% slower than Chrome, and Firefox is over 150% slower! The V8 benchmark tests confirm these results.

I built Chromium for the Mac a few months ago to try it out, and ran the SunSpider tests against Safari and Firefox too. Since then it appears that Chrome has gotten faster whilst both Safari and Firefox are going in the wrong direction! Both Safari and Chrome also score 100% on the Acid3 test (not surprising given that they are both WebKit based browsers) but Firefox is still lagging behind at 93%.

The second thing I think Chrome has got right is it’s implementation of tabs. I’m quite a heavy user of tabbed browsing and Chrome’s tab feel the most natural to use, and once I got over the initial shock of them invading the title bar area, I’ve grown to really appreciate them.

But the killer feature for me is the omnibox. One box into which you either type a URL or a search term. I don’t know what else you would expect from the search company that is famous for it’s minimal web search interface but in the very first releases the omnibox was a bit of a pain. You would enter a URL and it would incorrectly interpret it as a search term, but now it has lost it’s rough edges and it is the one thing I miss more than anything when I have to use another browser. There is no need to have a separate search box, either I know the URL I want or I don’t. If I don’t enter a recognizable URL then send it to a search engine for me automatically. All other browsers need to implement this feature as soon as possible if they are to stay in the game.

Talking the talk ain't walking the walk

2009-10-23T00:00:00-07:00

I was talking to a colleague yesterday about this blog and I realised that I am guilty of talking the talk without walking the walk! One of those people that says they are going to do something and you smile and roll your eyes, because you know it unlikely that they ever will.

Well all that is changing. My family and I are following one of our dreams and moving from Blighty to Brisbane. We’ve never even been to Australia and soon we will be residents there. Now our life is an adventure!

One of my personal ambitions is writing hence this blog. One day I would love to be writing a tech column for a magazine or newspaper, but for now I can self publish whatever I like right here, in my own little corner of cyberspace.

I have a laundry list of other things that I want to do before I die and I’m starting to tackle them one by one. Hopefully the new friends I make in Australia will know me as someone who walks more than he talks!

IntelliJ IDEA is open sourced. Why?

2009-10-21T00:00:00-07:00

The cool kid, IntelliJ IDEA, has finally come to play with the young upstarts, NetBeans and Eclipse, in the free and open source Java IDE playground. This is great news but the big question is why now? And why has he left his most shiny toys at home? Is he going to be accepted? Will he be sent packing with a bloody nose? Here’s my initial thoughts.

Firstly, let me make some disclaimers:

Sadly, I have never used IDEA before. The last paid IDE I used was JBuilder 7 and since then I have always used Eclipse and NetBeans.
I am not against paying for software. I’ll spend my own money and my employers money on software that does a job right for me.
My day job involves mostly Java SE and Swing on the desktop.
My day job also means that I work mostly in Windows and Mac OS X, but also in Linux and occasionally Solaris.
At home, I only use a Mac.
I’m not sold on massive plugins that do everything for you, at least not to begin with. I like to understand how things work so that I know what the plugin should do and can fix it if it goes wrong!

Now I know that before this week I had never used IDEA but it is very highly rated by people whose opinion I respect. I have downloaded and installed it and will post again when I have been using it for a little while and have formed my own opinion of how it compares to NetBeans and Eclipse. For now I’m assuming that it offers more than both of these and I have to ask myself why JetBrains have open sourced IDEA now?

My gut reaction is that the commercial Java IDE market is dying. I suspect that IDEA sales are in decline and this is JetBrains last ditch effort to save IDEA as a commercial venture. NetBeans and Eclipse are more than ‘good enough’ for the majority of tasks that most Java developers face, so they have no need or desire to pay for an IDE, regardless of how good it may be. Listening to the Java Posse interview with the IDEA evangelist, Roman Strobl, and lead developer, Dmitry Jemerov, JetBrains strategy is to win developers over with the free Community Edition and expect them to upgrade to the Ultimate Edition.

Will it work? My gut reaction is no, for several reasons.

Borland failed. IDEA may be better than JBuilder ever was (although to listen to Joe Nuxoll on the Java Posse you would think it was the best Java application ever written!) but Borland was the king of developer tools and it was beaten by Microsoft and the open source alternatives.
All the Java EE goodies haven’t been open sourced, and the majority of Java developers they are trying to appeal to will be writing Java EE applications. If they can’t switch over wholesale to the Community Edition, why should they even install it. Especially when the equivalent plugins are also free and open source for NetBeans and Eclipse. They can install the trial of the Ultimate Edition and use it for 30 days, but they can do that already and would have done so if they were so inclined.
Personally I find it very irritating when software vendors carve up their products so the free (or inexpensive) version has almost enough functionality to be useful but not quite. I think Adobe has hit the sweet spot with Photoshop Elements. It has all the functionality that 80% of Photoshop customers need, and the remaining 20% have to buy the full version. For me, IDEA will probably do everything I want but I am probably in the minority and if it does, I have no need to upgrade anyway.

I hope I’m wrong and that JetBrains can continue to make money out of IDEA. Software doesn’t get that much respect without reason. If they can’t make money on IDEA I hope the make money on their other products because I would hate to see an innovative software vendor like them go out of business. I also hope that they fully open source IDEA if it doesn’t work out for them. Competition drives innovation and neither NetBeans or Eclipse wouldn’t be as good as they are if it wasn’t for IDEA leading the way.

I'm glad I was wrong!

2009-06-03T00:00:00-07:00

OK, I admit, I was wrong! Oracle are going to put their weight behind JavaFX and take the fight to Adobe and I’m glad they are because I think it is a superior technology.

I’m also really pleased with what they have included in V1.2, primarily:

Proper UI components such as buttons and sliders and text boxes
Cross platform support that includes Linux and Solaris (Microsoft might get away with supporting only Windows and Mac OS X and calling it cross platform but Sun can’t!)
Better startup and runtime performance

This is what the 1.0 release should have included but better late than never.

What will happen to JavaFX under Oracle?

2009-04-24T00:00:00-07:00

One of the main reasons Oracle is buying Sun is to get it’s hands on Java. Much of it’s middleware stack is Java based and having control of Java the language and the default implementation makes sense for them. I don’t really fear for Java or the JVM. If anything I think it will do better under Oracle’s stewardship than Sun’s, just because Oracle get things done. However, that also means that they will be prepared to do what Sun was not, kill off non-profitable areas of the business.

Java targets three markets: enterprise, desktop, and mobile/embedded. Two of those markets have historically received a lot of attention from Sun and have flourished, namely enterprise and mobile/embedded, whilst until recently the desktop market has been left languishing. Obviously Oracle’s main interest is in enterprise Java, that’s the bread and butter of it’s current business. I think Java’s ubiquity on mobile phones and the associated licensing revenue means that Oracle will see a viable business unit there and keep it running.

Unfortunately I don’t see how they are going to make money out of desktop Java. They can’t sell or license the technology, most of the best development tools are free and open source, and most enterprise UIs are heading more and more towards being browser based.

Sun’s decision to take on Adobe Flash with JavaFX has been driving improvements in whole desktop Java ecosystem. Whilst JavaFX has a lot more to offer than Flash because it runs on the JVM, the user experience is still has a long way to go before it even rivals Flash and Flash already plays very nicely with Java back end systems. meaning it can be used to provide compelling front end UI for Java enterprise systems already. I would be surprised if Oracle chose to continue fighting a battle that many people think was won by Adobe a long time ago.

The only saving grace for JavaFX might be as part of the mobile phone strategy (although that already has some excellent UI options such as LWUIT) or on the new battlefield that is emerging, televisions and set top boxes. I believe the next release of JavaFX will add the television profile, and at NAB this week, Adobe demo’d “Flash for Digital Home”. Here JavaFX might have a small head start, since every BluRay player already has a JVM capable of running JavaFX, a lot of set top boxes already run Java (I believe), and a lot of the TV manufacturers involved already have a relationship with Sun because they also manufacture mobile phone handsets (Sony, LG, Samsung etc.). Even if this saves JavaFX, it doesn’t mean they will keep it as a desktop technology.

The alternative is that they toss it out to the open source community, and whilst there is a lot of interest and enthusiasm, it’s never going to get gain traction without a major corporation behind it. I hope I’m wrong. I hope that Oracle keeps JavaFX and pushes it on the desktop as well as on TVs and phones. I wouldn’t go betting my mortgage on it though!