My Imaginary Friend

Abseiling for ECHO

2011-02-18T19:42:00.000Z

Well, I think I've finally gone mad :)

Despite the fact that I'm more than a little scared of heights, I shall be abseiling off Guy's Tower (at 469ft the tallest hospital in the world!) on May 2nd. It's in aid of ECHO (Evelina Children's Heart Organisation) who have been such a great support to us given my daughter, Sophie's, heart condition.

So wish me luck, and if you'd like to support ECHO by sponsoring me then you can do so here.

Yay! Got to Level 1 on Project Euler

2010-11-02T22:38:00.001Z

As you may have guessed from the title, I've been hacking away at problems on Project Euler, and in fact have now managed to complete the first 25.

Much of my recent "acceleration" seems to have come from using Scala, as with these "one-off" coding exercises it's very helpful to have powerful functional constructs available when it makes sense to use them, but also to be able to fall back on a "normal" imperative style when it's more convenient.

Which will be first, though... reaching Level 2 or coming up with some "proper" code in Scala to really get a feel for how good it is?

Dependency injection in Scala

2010-10-14T12:49:00.001+01:00

Here are a few thoughts and code snippets from my admittedly brief experiments with dependency injection in Scala. Comments most welcome, as always!

Option 0: Use your favourite Java framework

I only know Guice, but I imagine the pros and cons are pretty much the same for any other framework. Porting Java annotations to Scala takes some getting used to, and occasionally it's a bit tricky to get right. And, of course, and it might not quite feel like Scala, but at least you'll know the framework and any quirks it may have.

Plenty of tutorials exist already for this option, so I'm sure your favourite search engine can help you find some. Any links I post here are sure to become stale pretty quickly given the rate at which Scala is developing.

Option 1: Just use implicits

Scala implicit parameters can easily cope with simple cases of DI, and have the added advantage that the code is somewhat more idiomatic Scala than would generally result from Option 0. For example, try pasting the following into an interactive Scala session:

trait Logger {
  def log(msg: String)
}

object StdOutLogger extends Logger {
  override def log(msg: String) { println(msg) }
}

object Config {
  implicit def provideLogger = StdOutLogger
}

import Config._

def logTest(msg: String)(implicit logger: Logger) {
  logger.log(msg)
}

logTest("Hello world")

One thing to note is that implicits operate at the function level, whereas DI is normally at the object level (via either constructors or setters). The former can easily be achieved via implicit parameters to an class's constructor, though. Following on from the code above:

class Test(implicit private val logger: Logger) {
  def doSomething {
    logger.log("Doing something...")
  }
}

(new Test).doSomething

Option 2: Adding annotations to implicits

The approach above works fine when you're injecting fairly specific, single-purpose objects. But what if you wanted to inject a string or an integer. Typically DI frameworks use some form of annotation in these circumstances, so let's see if we can come up with a version for Scala implicits (again this should work if pasted into a Scala REPL):

class Annotated[A, T](private val t: T) {
  def value = t
}

object DeepBlue {
  def answer(implicit annotated: Annotated[DeepBlue.type, Int]) {
    println(annotated.value)
  }
}

object Config {
  implicit def provideAnswer = new Annotated[DeepBlue.type, Int](42)
}

import Config._

DeepBlue.answer

Note that the example above, and the Annotated class in particular, is the simplest possible thing I could come up with that would work, and could likely be improved upon in several ways:

1. I used the (generated) class of the DeepBlue singleton object just because it was handy. Often you'd want to use a class or singleton object created specifically for the purpose. It might even be possible to use case classes or even enumerations to good effect here.

2. It doesn't do anything clever with the annotating type (A). One or more factory methods in a companion object which restrict their arguments a bit more (and maybe the addition of an Annotation trait to help with this) might lead to some nice type inferencing possibilities, especially with singleton objects as in the example. For instance, it would be nice to be able to write the RHS of the provider method as simply Annotated(DeepBlue, 42).

3. I might also be possible to mark the value method as implicit, and have the injection site implicitly convert from an Annotated[A, T] to a T when required. This might be one step too far, though, and just plain confusing rather than helpful (quite a common theme with implicits, unfortunately).

Option 3: For more functionality, implicitly pass an injector

If you need more advanced DI functionality then you may well hit the (somewhat ironic) restriction that all implicit functions (i.e. those that provide the values for implicit parameters) must be explicitly coded, i.e. there's no way (that I know of at least) to programmatically influence the resolution of implicit parameters. I've not spent too much time on this, but the obvious (to me, with my own unique set of influences/biases) way around this would be to build a Guice-like Binding/Module/Injector framework, and then implicitly pass the injector to functions which need injected instances of objects. It may even be possible to use Scala's flexible syntax to create a nice DSL for specifying the bindings. As a warning, though, I have not tried this (yet!) and I suspect it may involve quite a bit of reinventing the wheel, so at this point it may well be worth reverting to Option 0, and using an existing framework.

I hope this was useful, and happy coding!

ScribeFire for Chrome now "official"

2010-05-18T21:50:00.001+01:00

Announcement here - and I'm writing this post using it :)

Now I've got even less excuse not to post more frequently, except maybe that I've also just discovered how addictive StackOverflow is.

It might not be the test that's flaky

2010-03-31T21:27:00.000+01:00

I have a feeling this was glaringly obvious to everyone but me, but late last week I had a bit of an "a-ha" moment.

When we say "flaky test" we imply that the test itself, or the test environment, is somehow at fault. Although this may often be the case, it's just possible that the test itself is perfectly sound and the implementation is flaky.

Nothing earth shattering, but I just thought I'd mention it...

Kojo - Scala for Kids

2010-03-24T13:12:00.000Z

Via: www.scala-lang.org:

Kids love computers and many would love to learn how to program them too. Lalit Pant, volunteer Math teacher at Himjyoti School for under-privileged girls in Dehradun, developed Kojo in his 'free' time. Kojo is a very polished, easy to install, cool IDE in which children, (or even grown ups) can learn to program using Scala. Lots of examples, a turtle to drive, good documentation and interactive geometry for those budding mathematicians. If you have kids then Kojo could be a fun experience to share with them. On the other hand if you have some 'free' time Lalit would welcome help to develop Kojo, an Open Source project, further.

Just in time for the Easter holidays :)

Using abstract type fields instead of parameterised types in Scala

2010-03-17T10:00:00.000Z

I've been continuing my exploration of Scala by writing some code to do multi-dimensional measure calculations (something with which I'm quite familiar after about 5 years of doing it "as a day job" in the past, but which I've never been quite happy with a representation for). This can be found at http://code.google.com/p/lascala if you're interested, and any comments (especially on making it more idiomatic in its use of the language) would be much appreciated.

However, the main point of the post was to note that I've found, a little to my surprise, that when building type hierarchies using abstract type fields is often cleaner (less verbose, more DRY) than using parameterised types. When I first saw them mentioned I was sceptical about their usefulness, as I couldn't see why I'd prefer:

trait Base {
  type T
  ...
}

trait Super extends Base {
  type T = String
  ...
}

to:

trait Base[T] {
  ...
}

trait Super extends Base[String] {
  ...
}

And while in such a simple case there is no particular reason to, when building more complex hierarchies it can in fact save some repitition. For example:

trait Measure {
  type K
  type V
  def aggData: Iterable[(K, V)]
}

trait Measure1[U, T1] extends Measure {
  type V = U
  type D1 = T1
  type K = T1
}

trait Measure2[U, T1, T2] extends Measure {
  type V = U
  type D1 = T1
  type D2 = T2
  type K = (D1, D2)
}

trait PreAggregated extends Measure {
  def data: Iterable[(K, V)]
  def aggData = data
}

object ExampleMeasure1 extends Measure1[Int, String] with PreAggregated {
  data = ...
}

object ExampleMeasure2 extends Measure2[Int, String, String] with PreAggregated {
  data = ...
}

This is already appreciably less verbose than the following, especially in the use of the classes which is arguably more important than in their definitions:

trait Measure[K, V] {
  def aggData: Iterable[(K, V)]
}

trait Measure1[V, D1] extends Measure[D1, K]

trait Measure2[V, D1, D2] extends Measure[(D1, D2), K]

trait PreAggregated[K, V] extends Measure[K, V] {
  def data: Iterable[(K, V)]
  def aggData = data
}

object ExampleMeasure1 extends Measure1[Int, String] with PreAggregated[String, Int] {
  data = ...
}

object ExampleMeasure2 extends Measure2[Int, String, String] with PreAggregated[(String, String), Int] {
  data = ...
}

Some of the duplication could be avoided by having a series of PreAggregated traits mirroring the dimensional MeasureN ones, but this can get bloated very quickly, especially as it's likely that I'll need to support at least six dimensions. And repition also reappears when traits are stacked (e.g. to encapsulate storage and caching behaviours):

trait Measure[K, V] {
  def aggData:Iterable[(K, V)]
}

trait Measure1[V, D1] extends Measure[D1, K]

trait Measure2[V, D1, D2] extends Measure[(D1, D2), K]

trait PreAggregatedMeasure1[V, D1] extends Measure1[V, D1] {
  def data: Iterable[(D1, V)]
  def aggData = data
}

trait PreAggregatedMeasure2[V, D1, D2] extends Measure2[V, D1, D2] {
  def data: Iterable[((D1, D2), V)]
  def aggData = data
}

object ExampleMeasure1 extends PreAggregatedMeasure1[Int, String] {
  data = ...
}

object ExampleMeasure2 extends PreAggregatedMeasure2[Int, String, String] {
  data = ...
}

Comments?

Handy iGoogle gadget for good habit forming

2010-02-27T20:59:00.000Z

I recently found the Days Since gadget, which seems to be a nice complement to to-do lists as a way to make sure I'm doing the right things. Sciral Consistency is a rather more full featured implementation of the idea, but at the moment I'm finding the fact it sits nicely in my home page as more of an advantage, rather than having yet somewhere else to check.

My attempt at graph humour

2010-02-27T20:50:00.001Z

I've been enjoying GraphJam for quite some time, so thought I'd have a go myself:

moar funny pictures

Playing with Scala again...

2010-02-17T21:22:00.003Z

Bought PDF version of Programming in Scala today, and seems pretty good so far. Definitely a step up from the already good (and free!) Scala by Example. Have just hacked the following to check my understanding of currying and by name functions:

scala> def times(n: Int)(op: => Unit) = { (1 to n).foreach(_ => op) }
times: (Int)(=> Unit)Unit

scala> times(4) { println("Hello") }
Hello
Hello
Hello
Hello

Sophie's fame just keeps on growing

2009-02-21T20:10:00.002Z

Looks like we've been featured on GeekParenting's "Lil' geeks of the week" spot. The photo's from a few year's back, I should point out...

RAND#33: The Twitter ecosystem

2009-02-18T10:26:00.002Z

Or should that be the Twitterverse, or even Twittersphere?

I've already blogged about Track Daily Goals, and am now following some "corporate" users (tworps instead of tweeps?) such as CNN Breaking News and BBC Click, and recently took a look at Twitter-based charting tool (twool?) Uladoo.

Are there any others interesting bots, tools, etc. you've come across that are worth looking at?

RAND#32: This mobile life

2009-02-12T18:56:00.004Z

Since getting a G1 for Christmas (thank you Google!) and then managing to pick up a good deal on a dataplan from T-Mobile, I've had far more reliable mobile Internet access than the "Will the coach have wifi?" situation before.

So what have I been doing with it, you may ask? Well truth be told not that much for the first couple of weeks, mainly trying to keep on top of email and blog reading. However, in the last week I've rediscovered Twitter (catch me here), found the excellent Track Daily Goals to give it a chance of having a net positive effect on my productivity, and even written a couple of blog posts.

At first I thought Twitter would finally kill off my attempts to blog more frequently, given the obvious overlap between microblogging and my RAND#nn posts. However, at the moment the two seem to be synergistic, as Twitter gets me in the habit of writing more about what I'm up to, whilst the fact that not every subject fits in 140 chars means that at least some should end up as blog posts. Well that's the theory anyway - let's see how it turns out in practice. After all:

Q: What's the difference between theory and practice? A: In theory nothing, but in practice plenty!

RAND#31: C++, dialects and compilers vs. toddlers

2009-02-10T08:30:00.006Z

(Some fairly random thoughts, triggered by me doing some C++ at work recently)

C++ has many "dialects" and is often spoken with a very heavy accent. By this I mean that in most C/C++ code I've written, the density of macro calls and/or typedef usage is pretty high. The bulk of my (semi-)recent experience was with ATL/COM code, so seeing a new C++ codebase was kind of odd - it was recognisably C++, but it was a while before I actually knew what it was doing. And I'm pretty sure exchanging the codebases in question (i.e. showing some of my younger colleagues some ATL code) would have produced the same effect.

Even compilers speak with different dialects; it was a good few minutes before I worked out what gcc was trying to tell me when it said "Incomplete type Foo used in nested type definition" or something similar. As an aside I noticed that compilers are very much like toddlers in such situations; you keep on asking questions in subtly different ways but keep getting the same (unsatisfactory) response. And although a compiler has never actually told me "No!" or "Why?" I'm sure that's what they normally mean :)

RAND#30: Snow!

2009-02-02T17:37:00.002Z

I’m conscious of the fact that way, way back I was once rather dismissive about people blogging about the weather.

I’m also rather embarrassed at how ill-prepared the UK always seems to be for any type of weather.

But it’s another excuse to post a couple of pictures, and try out the Polaroid Picture Plugin for Windows Live Writer so here goes :)

RAND#29: Coding update

2009-01-27T18:23:00.003Z

Aside: looks like I'm falling back to my old infrequent blogging ways. Must... try... harder... :)

Very quick summary:

Sophie loves Storytelling Alice
I'm going to take a quick look at Processing before deciding on what to do for my next mini-project (Or at least what I say I'll do, and then never quite get around to. Sigh...)
I took a look at the Google AJAX APIs Playground last night - looks pretty neat!

More updates soon - honest :)

RAND#28: More poetry

2009-01-18T21:45:00.003Z

I started with some poetry, albeit in German, and it seems like time for some more...

Josh Kaufman over at The Personal MBA just posted about "Desiderata", which got me thinking of one of my favourite poems, namely "If". Though not actually a poem I also admire "The Serenity Prayer":

God grant me the serenity to accept the things I cannot change, courage to change the things I can, and wisdom to know the difference.

Changing the last line to "the firepower to make a difference" seems to show up as an anonymous quote, though for some reason I though it was "The Minuteman's Prayer" -- not sure where I got that from! It does remind me of Jack Nicholson's line from "A Few Good Men" though (excellent film, so many great quotes to choose from...):

Walk softly and carry an armored tank division, I always say.

RAND#27: Gaming keyboard for dev work?

2009-01-13T21:04:00.002Z

Just seen the specs of the new Logitech G19 gaming keyboard and I can't help but think some of the LCD and programmable keys could be useful for a developer.

Anyone tried using a gaming keyboard for dev work?

RAND#26: A couple more kid-oriented programming ideas

2009-01-08T19:28:00.005Z

A bit convoluted, but thanks to Harry "DevHawk" Pierson's post I found out about Kodu. As this is for the XBox 360 it's not much use to us (Wii + PS2), but the team page mentioned Alice which looks interesting, especially in its Storytelling Alice variant.

Phew!!! Got all that? ;)

RAND#25: What next?

2009-01-04T21:30:00.003Z

OK, photo kit time... I have a Nikon D60 with 18-55 and 55-200 VR lenses, an Olympus FL-36R flash, a couple of cheap pan-and-tilt tripods, a wireless flash kit and a 5-in-1 reflector. I mainly shoot general family stuff, plus loads of portraits of my daughter (show-off that she is), and whatever compos are going on at any given time (esp. DPChallenge). So what should I buy next? My thinking is along the lines of:

Nikkor 50mm f/1.8 prime: But what about the AF-S 1.4?
Backdrop of some sort: I have a T-bar stand already, which cuts down on the cost, but then again I also have a couple of sheets of A1 card that are fine for head shots
Lighting stand(s): But my flash currently fits OK on a tripod via the receiver end of the wireless kit
Umbrella: Probably favourite currently, but will it need a lighting stand?

Or maybe something I've not even thought of? Suggestions in the comments...

RAND#24: Merry Christmas

2008-12-28T16:27:00.004Z

Hmmm... bit of break in posts, but things got just too hectic pre-Christmas...

News is:

New toys: well, the wireless flash thing-a-me-bob arrived OK and seems to work fine, and I also completely went back on my plan and bought a Nikon D60 with a 18-55mm VR kit lens and also a 55-200mm VR one (was aiming to get th 50mm f/1/8, but doesn't seem to be available anywhere). Still, it does seem very nice, and I'm sure I'll be posting some shots here soon!
Dolls house: wasn't quite finished in time for Christmas, but Sophie was nevertheless the very grateful recipient of a "dolls construction site". The sides and all internals walls were up, and all the channels cut for the lighting, so it's just a case of finishing off the wallpapering, attaching the back and front, then actually fitting the lights and running the cables. I'll post a photo or two when it's finished, no doubt.

I hope everyone's had a great Christmas, and that it continues into an excellent New Year!

RAND#23: Anyone playing Runes of Magic?

2008-12-15T17:46:00.001Z

It's a new, free-to-play MMORPG that enters open beta today, so just wondered if anyone is either playing it already (maybe via the closed beta) or considering doing so?

Personally I'll probably stick with Guild Wars for a bit longer - I've just hit level 12 and am quite enjoying it when I get the time. Anyone reading here play, and need of E/W for their party? If so just leave a comment, or look out for Edmund Luftmann in game.

RAND#22: LanguagesNow = [ "Erlang" | LanguagesBefore ].

2008-12-10T13:37:00.003Z

Back to some coding :)

Having gotten the hang of some basic Clojure it's time to start again with a new language, and this time it's Erlang's turn. I've been meaning to give it a spin for a few months, ever since Tim Bray and others started looking at it.

So here's my attempt at generating primes in Erlang:

-module(pdb).
-export([primesTo/1]).

primesTo(N) -> processSieve(N, makeSieve(N, []), []).

makeSieve(1, List) -> List;
makeSieve(X, List) -> makeSieve(X - 1, [{X, true} | List]).

processSieve(_, [], Primes) -> lists:reverse(Primes);
processSieve(N, [Head | Rest], Primes) ->
  Max = math:sqrt(N),
  case Head of
    {X, _} when X > Max -> copyRemaining([Head | Rest], Primes);
    {_, false} -> processSieve(N, Rest, Primes);
    {X, true} -> processSieve(N, markMultiples(X, Rest, []), [X | Primes])
  end.

markMultiples(_, [], Done) -> Done;
markMultiples(X, [Head | Rest], Done) ->
  case Head of
    {_, false} -> markMultiples(X, Rest, Done ++ [Head]);
    {N, true} when N rem X == 0 -> markMultiples(X, Rest, Done ++ [{N, false}]);
    {N, true} -> markMultiples(X, Rest, Done ++ [{N, true}])
  end.

copyRemaining([], Primes) -> lists:reverse(Primes);
copyRemaining([{X, B} | Rest], Primes) when B -> copyRemaining(Rest, [X | Primes]);
copyRemaining([_ | Rest], Primes) -> copyRemaining(Rest, Primes).

Because of it's famed concurrency capabilities I'm now playing with using it to run some MapReduces. Here's my initial single-threaded version (with some functionality missing as well):

-module(mr).
-export([run/3, test/0]).

test() -> run(fun(X) -> [{X, 1}] end,
              fun({K, L}) -> {K, length(L)} end,
              [1, 2, 4, 2, 3, 1, 1, 4, 3, 4, 3, 2]).

run(M, R, Input) ->
  reduce(R, shuffle(map(M, Input))).

map(F, Data)    -> lists:flatmap(F, Data).
shuffle(Data)   -> do_shuffle(Data, []).
reduce(R, Data) -> lists:map(R, Data).

do_shuffle([], TL) -> TL;
do_shuffle([{K,V}|R], TL) ->
  Told = lists:keysearch(K, 1, TL),
  Tnew = case Told of
    {value, {K, L}} -> {K, [V|L]};
    false           -> {K, [V]}
  end,
  do_shuffle(R, lists:keystore(K, 1, TL, Tnew)).

Any Erlangers out there fancy tearing my code to pieces now, or would you rather wait until I add the concurrency bits? ;)

RAND#21: More toys!

2008-12-09T21:30:00.002Z

A few more photo-related items arrived today, courtesy of eBay:

24 inch, 5-in-1 reflector
3-way hot-shoe spirit level
4x magnifying filter
Circular polarizing filter
8-point star filter

Here's a quick test shot from the last of these:

Now all I'm waiting for is my wireless flash transmitter/receiver...

RAND#20: English is weird, but I love it. Most of the time...

2008-12-05T21:20:00.002Z

On the coach into work this morning I was getting rather annoyed by the inane chatter from a couple behind me (how many times is it really worth noting that it's raining?) when I began to think about the word inane, or more particularly the non-existence of a word "ane". Or "ept" for that matter. Though a former colleague of mine did like to use the non-word "tuitive" (Paul Leigh - where are you now?).

Is there a name for words like this, that almost seem as if they're pre-negated? And what about their opposites? There's counter-intuitive, but what are the opposites of inane and inept? And don't get me started on how many people say disinterested when they really mean uninterested.

Well, fast-forward to tonight for a little irony. The Live Writer spell checker has kindly highlight the above "non-words" which I intentionally used, but I've also been typing up a CV for a friend of my wife and happened to misspell "education" as "eduction". But this didn't get flagged as it's actually a word. Surely it would useful to give warnings (orange squiggles, maybe) if it comes across rather uncommon words that are very similar to much more common ones? And for some meta-irony the spell checker in Live Writer has flagged "eduction" as wrong, and also helped me out when I misspelled "misspell" as "mis-spell"!