Old Dogs and New Tricks

Right now I’m playing around with Java and FitNesse and some related tools, and I’m starting to be comfortable with at least those first two, so it seems like a good moment to stop and reflect.

One of the pieces of advice you get over and over again as a programmer is that you should learn new things.  This is difficult as a maintenance guy because your ability to work with tools that people are actually excited about is limited.  Maybe your peers are excited about a language that’s coming into its own (Ruby, Python, LISP[again!]) or a back-end system that’s showing up in interesting places (Cassandra NoSQL, Django) or a design or coding practice (TDD, BDD, literate programming) or something that’s both fun and practical (AJAX/JSON/JavaScript).  When you’re in the back of the office writing another Excel-based tool, these things exist in a far-off, better, happier professional life.

I’ve struggled with that divide throughout my working life (except for the couple of times I tried to be an actor.  Let’s save that story for another day).  Currently, I’m leaning more towards spending more time learning as long as I’m still accomplishing things.  This works for me right now because while I am on deadlines, they’re mostly either really loose (and so the extra time doesn’t matter because I can get it done either way) or else extremely tight (and so the extra time doesn’t matter because I can’t get it done either way).

Java is a funny beast if you come from a Microsoft background.  It’s obviously the inspiration for C#’s approach to language, and I appreciate the historical impact – its particular implementations of generics and bytecode-based run engines and runtime compilation and especially JIT compilation really brought concepts from the periphery into the mainstream practicum of programming.  It has a gigantic community of users who are extremely talented and build amazing, free-ish tools that regularly percolate out into the world.  And it has some interesting features that reflect a very different value set when it comes to writing code.

It’s also, on a language and usage basis, almost painfully backwards in places in comparison to C#.   C# and .NET have, to my mind, taken the fore in innovative terms in much the same way that DirectX took the lead from OpenGL – the relatively closed nature of the platform has allowed Microsoft to iterate more rapidly and experiment more radically.  It seems like Anders et al have been killing it for a long time, and things like LINQ and the various object frameworks and the Visual Studio development environment in particular are pretty much the best version of a modern development experience.

Those tools make a code-monkey-in-the-middle into an amazingly productive human being, and I constantly have the feeling that I’m living in a better, happier future when I’m using those tools.  There are still drawbacks – here I’m thinking of things like the inherent complexity of a tool like LINQ-to-Objects and the rough, ugly “visual programming” stuff in the BizTalk end of that ecosystem.  But those drawbacks are largely avoidableand sometimes, as with the LINQ problem, they are a good thing – you get a sense from those bits that the toolset you’re using is making you better and smarter by association.

But there are things I love about Java now.  I mentioned in a previous post that I use single-assertion-per-test unit tests, and Java’s ability to run all of your tests and only fail a single test even when the failure is a compilation issue is lovely.  I can’t over-emphasize how much of a difference that is – this is much closer in spirit to a language like Python, where you are unconstrained by type checking, than to C#, which inherits a somewhat ugly obsession with static correctness from its namesake, C++And then there are tools like Glassfish, where I have a free, powerful, easily-implemented, web-native server product that has a number of similar peer products all of which have associations with a gigantic network of applications.  It’s not really a Java thing, exactly, but you don’t, in my experience, run into GlassFish and its peers and the many products that leverage its abilities until you start working with Java people.  .NET people have automated builds and even a decent Continuous Integration product in the form of CruiseControl.NET, but they don’t really have the high-visibility diversity of high-quality options that Java engenders.  I pulled down a copy of Hudson, for example, and they recommend that you either

a)      Install it as a service natively OR
b)      Install it in Glassfish OR
c)       Install it in TomCat.

Plus they hint that there are other options in the world.  It’s just a different culture altogether, and it’s kind of fun to live the difference.

Fitnesse, on the other hand, is a very specific type of tool and it has a very specific experience to offer.  It does one thing very well, and as long as you can orient yourself to that way of doing things it will reward you with some very important gains.  It gives you the ability to communicate your tests to non-programmers.  It lets you sit together with a couple of people and figure out basic cases that need to be covered in order for a product to work and then write rough test “sketches” for those cases.  It gives you some fairly powerful tools to organize and manage acceptance tests, which is something I really haven’t seen in too many other frameworks.

FitNesse, however, isn’t a friendly product.  It isn’t really even a complete product until you add fitlibrary to the toolset.  Finding documentation on both of these is, oddly, pretty difficult.  You get a very deep treatment of FitNesse on the wiki, but it’s a hard framework to grasp and the worked examples leave something to be desired.

Still, a couple of months to pick up a tool like this with no mentor or teaching resource is probably not that bad, and I do find that the more I use the tools the more I understand what they’re getting at.  I respect the fact that they’re unapologetic about their approach to things like shared objects, even if most folks probably cringe on first encounter.  And the tool does do the job.  At the end of the day, I respect that most of all.

I don’t know what I’ll learn next.  In another life I’m a game programmer working on mobile and web stuff, and so learning Java has crossover applicability there, but Android is a challenge because of the intensely framework-ey nature of the programming required, and because I’ve never really seen such an idiosyncratic platform for games.  It’s likely that somewhere in there I’ll take on OpenGL and WebGL.  Maybe I’ll write a 3D dashboard for fun at my day job.  I guess we’ll see!