A recent paper by Gilles Dubochet, Computer Code as a Medium for Human Communication: Are Programming Languages Improving?, measured eye movements of people reading Scala code written in three different styles: a Java-like, looping style and two versions of a more idiomatic Scala style that used for expressions and higher-order functions instead of loops: one with meaningful variable names and one without. Although I was not surprised to see that the more verbose looping-style code took longer and/or was harder to comprehend than the more concise functional style code, I was not sure what to make of the difference between the two variable naming styles.

In one style, called grounded in the paper, intermediate functions and variables were given domain-meaningful names. A few intermediate variables were added as well, and given meaningful names to help readers connect each intermediate value to its domain meaning. In the other style, called ungrounded in the paper, concentrated solely on cleanly expressing the algorithm using as few intermediate names as possible, and always using meaningless words.

The results seem to show that the meaningless variable name version was easier and/or quicker to comprehend than the one with domain-meaningful variable names. One caveat they point out in the paper is that each participant in the study was made familiar with the domain before letting them see the code. It may be that people not familiar with the domain would have had an easier time figuring out the version with domain-meaningful names, however, in general I'd guess programmers reading code are usually familiar with the domain of that code to at least some extent.

A wise programmer once told me that the way he recommends people name variables is he asks them what the variable is, and whatever they answer, he tells them that's what the name should be. I tend to use descriptive names, but sometimes feel longer names have a tradeoff of cluttering the code, giving it a weight that takes away from seeing the structure of the code.

How do you decide what to name variables? When do you use single character names for variables? When do you use short abbreviations (but longer than one character)? And when do you use full words?

t match {
  case _: TestPendingException =>
    report(TestPending(tracker.nextOrdinal(), thisSuite.suiteName, Some(thisSuite.getClass.getName), testName))
  case e if !anErrorThatShouldCauseAnAbort(e) =>
    val duration = System.currentTimeMillis - testStartTime
    handleFailedTest(t, hasPublicNoArgConstructor, testName, rerunnable, report, tracker, duration)
  case e => throw e
}

  class Rational(numerator: Int, denominator: Int) {

    require(denominator != 0)

    private val greatestCommonDivisor = gcd(numerator.abs, denominator.abs)
    val numer = numerator / greatestCommonDivisor
    val denom = denominator / greatestCommonDivisor

    def this(numerator: Int) = this(numerator, 1)
    // ...

  class Rational(n: Int, d: Int) {

    require(d != 0)

    private val g = gcd(n.abs, d.abs)
    val numer = n / g
    val denom = d / g

    def this(n: Int) = this(n, 1)
    // ...