We were asked, "Which code is more readable, one that uses longer variable names or short ones?"
Maybe some historical perspective will help answer this question.
In the very early days of computing (I was there), we used short variable names because:
* Programs were fairly short and simple, so scope wasn’t much of a problem.
- Memories were small, so programmers didn’t want to waste memory with long names.
- Compilers and assemblers were slow, and long names made them slower.
- Many compilers and assemblers wouldn’t allow names longer than a few characters, because of speed and memory limitations.
- We didn’t think much, if at all, about who would maintain a program once it left the hands of the original programmer.
As programs grew larger, one result of short naming was difficult maintenance, so the movement toward longer names grew stronger. It wasn’t helped by COBOL, which asserted that executives should be able to read code. Lots of COBOL code was littered with super-long names, but that didn't help executives read it.
The COBOL argument proved to be nonsense. Still, the maintenance argument for longer, more descriptive names made sense.
Unfortunately, like many movements, the long-name movement went too far, at least for my taste. It wasn’t because long names were harder to write. After all, a typical program is written oncem but read for modification and testing many, many times. So, if long names really made reading easier and more reliable, it was good.
But the length of a name is not really the issue. I’ve seen many programs with long, long names that were so similar that they were easily confused, one with another. For instance, we once wasted many days trying to find an error when the name radar_data_station_#46395_azimuth_reading was mistaken for radar_data_station_#46895_azimuth_reading. Psychologists and writers know well that items in the middle of long lists are frequently glossed over.
So, like lots of other things in software development, long versus short names becomes a tradeoff, a design decision for a programmer for which there is no “right” answer. Programmers must design their name-sets with the same kind of engineering thought they put into all their design decisions.
And, as maintainers modify a program, they must maintain the name-set, so as to avoid building up design debt as the program ages.
So, sorry, there’s no easy answer to this question, nothing a programmer can apply mindlessly. Just as it’s always been, programmers who think will do a better job than those who blindly follow simplistic rules.