good robots do what they're told

Currying Functions in Java & Scala

Currying is the technique of transforming a function with multiple arguments into a function with just one argument. The single argument is the value of the first argument from the original function and the function returns another single argument function. This in turn would take the second original argument and itself return another single argument function. This chaining continues over the number of arguments of the original. The last in the chain will have access to all of the arguments and so can do whatever it needs to do.

You can turn any function with multiple arguments into it’s curried equivalent. Let’s have a look at this in action.

Calculate the Optimum Number of Threads

Working out the theoretical optimal number of threads you should use for your application is fairly straightforward. You do, however, need to understand your applications runtime characteristics. Is it mostly occupied with CPU intensive work or is it mostly waiting for IO?

In this post, we look at how to work out a good thread pool size for your CPU and IO based tasks.

Writing my Book

There haven’t been many posts on the blog recently because I’ve been super-busy working on my book Essential Acceptance Testing. It’s published via Leanpub and talks about the typical acceptance testing strategy and how, more often than not, it’s driven by dogma rather than by a genuine testing need.

Acceptance testing in it’s generally accepted form, is so full of duplication and cruft that gaining software confidence can come at a high price. It doesn’t have to be this way. The book talks about how we can reclaim all the good parts of acceptance testing without suffering the long build times and specification overload.

It also talks about when not to bother; how gaining software confidence isn’t always about testing. Fast feedback and writing software that’s cheap to change can be an effective alternative to testing and help shorten the path from concept to cash.

Java Stack vs Deque

Java has long had a badly written implementation of a stack. The stack is a great example of single responsibility; it’s supposed to implement LIFO and only LIFO behaviour. Java ignores this principle with the default implementation of Stack. It extends Vector and so is implemented in terms of inheritance rather than aggregation. It’s both a Stack and a Vector. They haven’t made the situation any better when recently deprecating Stack in favour of Deque.

Sending Messages vs Method Invocation

In object-oriented languages, some people talk about sending messages whilst others talk about invoking methods. In this post, we’ll take a look at the conceptual difference in terminology and the more concrete, technical differences. Whilst we’re on the topic, we’ll look at the difference between a function and a method and discuss the difference between an object reference and a pointer.

Daily Standups Don’t Work

At some point, standups have stopped working for me. They’ve certainly moved away from the original intention to improve collaboration and communication. I’m not sure I can put my finger on why, but I’m just not getting much out of them any more. It’s led me to think that standups per se just don’t work. At least in most of the environments I’ve encountered. So I’ve been thinking about what could work in their place and I think its just to talk more.