The Last Line Effect (opens in new tab)

I'm not convinced that this is necessarily caused by people losing attention while they write the last line due to anticipation of finishing the task. Other possible theories I can think of:

* People make mistakes in any line, but they often unconsciously review them and spot the mistake while they're writing the next line. In the case of the last line there's no such automatic review.

* (plausible in some of the examples, not all of them) The last line was added by copy–paste at a later date than all the others.

The last line often has something extra - a semicolon or parentheses - or something missing, like no comma in an enum or no `&&` in a long chained conditional. Maybe that triggers the "gorilla on the basketball court" effect, and we miss the error in the meat of that line because we're focusing on the difference.

Sometimes copy paste is unavoidable, but a lot of times it can be replaced with a loop over a constructed array of "things that change" that achieves the same goal. I've been trying to do this recently in the spirit of DRY; it has the side benefit of often making the code quite a bit more readable.

This is really interesting. I just looked over some code I wrote this morning. There were 2 LLE errors. I'm sure I would have caught them in testing after lunch but, woah. For the life of me, I can't reconstruct my mental state when I edited those code bits though, so I don't know what the root of the error is. I think now though, I'll be on the lookout and perhaps gain some insight.

In retrospect, I've had quite a few of these - once pointed out as a pattern, it's fairly easy to see it's a "thing".

I wonder what sort of IDE or other tooling could be put in place to hint those errors out of existence.

In my experience this effect is real, but I wouldn't always see it in the last line. A coworker proved this to me years ago by making me keep a tally when errors were caused by copy-and-pasted code, versus all other causes. Copy-and-paste won hands down.

I just wrote a script (https://github.com/Glank/repeat_test) to see if I could catch these sorts of errors. It does OK. I looked for repeated lines based on their levenshtein percent difference. Then for those repeating groups, if the percent difference between any of the lines is an outlier it returns a positive result.

I would be more skeptical, but this just happened to me this morning!

I try to discipline myself to retype code instead of copy-pasting (unless it's lengthy, then I should refactor instead of copy-pasting). It always saves more time that it takes to retype. But sometimes I'm lazy.

Another possible symptom is a merge conflict.

Programmer A makes a change that adds a list of things out of one thing and checks in. Programmer B checked out the "one thing" version and made an update to it. They check in, and they now need to deal with a merge conflict into a list of things that they now need to expend mental energy understanding. Mistakes get made.

This is potentially an interesting effect and worthy of some consideration, but the analysis needs to include some regression of this possible factor:

An increased number of errors on "return" lines.

Which naturally should be more frequently last lines than otherwise.

I would agree. Anecdotally, from me writing this kind of code requires a conscious effort to not make a mistake specifically closer to the end of the series.

Of course, the ideal way to avoid such problems is to embrace the lack of patience and properly structure the code. :)

An interesting article and I am guilty of copy and paste errors myself. But the bias towards the last line may be because those mistakes are tested less then other parts i.e. in an if statement early conditions mean the final condition is never tested.