Question

I prefer to use long identifiers to keep my code semantically clear, but in the case of repeated references to the same identifier, I’d like for it to “get out of the way” in the current scope. Take this example in Python:

def define_many_mappings_1(self):
    self.define_bidirectional_parameter_mapping("status", "current_status")
    self.define_bidirectional_parameter_mapping("id", "unique_id")
    self.define_bidirectional_parameter_mapping("location", "coordinates")
    #etc...

Let’s assume that I really want to stick with this long method name, and that these arguments are always going to be hard-coded.
Implementation 1 feels wrong because most of each line is taken up with a repetition of characters. The lines are also rather long in general, and will exceed 80 characters easily when nested inside of a class definition and/or a try/except block, resulting in ugly line wrapping. Let’s try using a for loop:

def define_many_mappings_2(self):
    mappings = [("status", "current_status"),
                ("id", "unique_id"),
                ("location", "coordinates")]
    for mapping in mappings:
        self.define_parameter_mapping(*mapping)

I’m going to lump together all similar iterative techniques under the umbrella of Implementation 2, which has the improvement of separating the “unique” arguments from the “repeated” method name. However, I dislike that this has the effect of placing the arguments before the method they’re being passed into, which is confusing. I would prefer to retain the “verb followed by direct object” syntax.

I’ve found myself using the following as a compromise:

def define_many_mappings_3(self):
    d = self.define_bidirectional_parameter_mapping
    d("status", "current_status")
    d("id", "unique_id")
    d("location", "coordinates")

In Implementation 3, the long method is aliased by an extremely short “abbreviation” variable. I like this approach because it is immediately recognizable as a set of repeated method calls on first glance while having less redundant characters and much shorter lines. The drawback is the usage of an extremely short and semantically unclear identifier “d”.

What is the most readable solution? Is the usage of an “abbreviation variable” acceptable if it is explicitly assigned from an unabbreviated version in the local scope?

Answer 1

I would go with Implementation 2, but it is a close call.

I think #2 and #3 are equally readable. Imagine if you had 100s of mappings… Either way, I cannot tell what the code at the bottom is doing without scrolling to the top. In #2 you are giving a name to the data; in #3, you are giving a name to the function. It’s basically a wash.

Changing the data is also a wash, since either way you just add one line in the same pattern as what is already there.

The difference comes if you want to change what you are doing to the data. For example, say you decide to add a debug message for each mapping you define. With #2, you add a statement to the loop, and it is still easy to read. With #3, you have to create a lambda or something. Nothing wrong with lambdas — I love Lisp as much as anybody — but I think I would still find #2 easier to read and modify.

But it is a close call, and your taste might be different.