Last Line Effect

I have studied many errors caused by the use of the Copy-Paste method, and can assure you that programmers most often tend to make mistakes in the last fragment of a homogeneous code block. I have never seen this phenomenon described in books on programming, so I decided to write about it myself. I called it the “last line effect”.



When carrying out analysis on various projects, I save the bugs I find, along the corresponding code fragments, in a special database. By the way, anyone who is interested can take a look at this database. We convert it into a collection of html-pages and upload them to our website in the “Detected errors” section.

This database is unique indeed! It currently contains 1500 code fragments which contain errors, and is waiting for programmers to study it and reveal regular patterns among these errors. That may serve as a useful basis for much future research, along with many manuals and articles.

I have never carried out any special investigation of the material that I’ve gathered in all this time. One pattern, however, is showing up so clearly, that I decided to investigate it a bit deeper. You see, in my articles I have to write the phrase “note the last line” pretty often. It occurred to me that there had to be a reason behind this.

Last line effect

When writing program code, programmers often have to write a series of similar constructs. Typing the same code several times is boring, and inefficient. That’s why they use the Copy-Paste method: a code fragment is copied and pasted several times, with further editing. Everyone knows what is bad about this method: you risk easily forgetting to change something in the pasted lines, and thus giving birth to errors. Unfortunately, there is often no better alternative to be found.

Now let’s speak about the pattern I discovered. I figured out that mistakes are most often made in the last pasted block of code.

Here is a simple and short example:

inline Vector3int32& operator+=(const Vector3int32& other) {
  x += other.x;
  y += other.y;
  z += other.y;
  return *this;

Note the line “z += other.y;”. The programmer forgot to replace ‘y’ with ‘z’ in it.

You may think this is an artificial sample, but it is actually taken from a real application. Further on in this article, I am going to convince you that this is a very frequent, and common, issue. This is what the “last line effect” looks like. Programmers most often make mistakes at the very end of a sequence of similar edits.

I heard somewhere, that mountain-climbers often fall off in the last few dozen meters of their ascent. Not because they are tired; they are simply too joyful about almost reaching the top – they anticipate the sweet taste of victory, get less attentive, and make some fatal mistake. I guess something similar happens to programmers.

Now a few figures.

Having studied the bug database, I singled out 84 code fragments which I found to have been written through the Copy-Paste method. Out of them, 41 fragments contain mistakes somewhere in the middle of the copied-and-pasted blocks. For example:

strncmp(argv[argidx], "CAT=", 4) &&
strncmp(argv[argidx], "DECOY=", 6) &&
strncmp(argv[argidx], "THREADS=", 6) &&
strncmp(argv[argidx], "MINPROB=", 8)) {

The length of the “THREADS=” string is 8 characters, not 6.

In the other 43 cases, mistakes were found in the last copied code block.

Well, the number 43 looks just slightly bigger than 41. But keep in mind that there may be quite a lot of homogeneous blocks, so mistakes can be found in the first, second, fifth, or even tenth block. So we get a relatively smooth distribution of mistakes throughout blocks, and a sharp peak at the end.

I accepted the number of homogeneous blocks to be 5 on the average.

So it appears that the first 4 blocks contain 41 mistakes distributed throughout them; that makes about 10 mistakes per block.

And 43 mistakes are left for the fifth block!

To make it clearer, here is a rough diagram:


Figure 1. A rough diagram of mistake distribution in five homogeneous code blocks.

So what we get is the following pattern:

The probability of making a mistake in the last pasted block of code, is 4 times higher than in any other block.

I don’t draw any grand conclusions from that. It’s just an interesting observation that it may be useful to know about, for practical reasons – you will stay alert when writing the last fragments of code.


Now I only have to convince the readers that it all is not my fancy, but a real tendency. To prove my point, I will show you some examples.

I won’t cite all the examples, of course – only the simplest or most representative ones.

Source Engine SDK

inline void Init( float ix=0, float iy=0,
                  float iz=0, float iw = 0 ) 
  SetX( ix );
  SetY( iy );
  SetZ( iz );
  SetZ( iw );

The SetW() function should be called at the end.


if (access & FILE_WRITE_DATA)
if (access & FILE_WRITE_EA)
if (access & FILE_WRITE_EA)

The last block, and the one before it, are identical.


if (*ScanString == L'\"' ||
    *ScanString == L'^' ||
    *ScanString == L'\"')

Multi Theft Auto

class CWaterPolySAInterface
    WORD m_wVertexIDs[3];
CWaterPoly* CWaterManagerSA::CreateQuad (....)
  pInterface->m_wVertexIDs [ 0 ] = pV1->GetID ();
  pInterface->m_wVertexIDs [ 1 ] = pV2->GetID ();
  pInterface->m_wVertexIDs [ 2 ] = pV3->GetID ();
  pInterface->m_wVertexIDs [ 3 ] = pV4->GetID ();

The last line was pasted mechanically and is redundant. There are only 3 items in the array.

Source Engine SDK


The programmer forgot to replace “BackgroundColor.y” with “BackgroundColor.z” in the last block.

Trans-Proteomic Pipeline

void setPepMaxProb(....)
  double max4 = 0.0;
  double max5 = 0.0;
  double max6 = 0.0;
  double max7 = 0.0;
  if ( pep3 ) { ... if ( use_joint_probs && prob > max3 ) ... }
  if ( pep4 ) { ... if ( use_joint_probs && prob > max4 ) ... }
  if ( pep5 ) { ... if ( use_joint_probs && prob > max5 ) ... }
  if ( pep6 ) { ... if ( use_joint_probs && prob > max6 ) ... }
  if ( pep7 ) { ... if ( use_joint_probs && prob > max6 ) ... }

The programmer forgot to replace “prob > max6” with “prob > max7” in the last condition.


inline typename Value<Pipe>::Type const & operator*() {
  tmp.i1 = *in.in1;
  tmp.i2 = *in.in2;
  tmp.i3 = *in.in2;
  return tmp;


for( int i = 0; i < 2; i++ )
  sliders[i] = joystate.rglSlider[i];
  asliders[i] = joystate.rglASlider[i];
  vsliders[i] = joystate.rglVSlider[i];
  fsliders[i] = joystate.rglVSlider[i];

The rglFSlider array should have been used in the last line.


if (repetition == QStringLiteral("repeat") ||
    repetition.isEmpty()) {
  pattern->patternRepeatX = true;
  pattern->patternRepeatY = true;
} else if (repetition == QStringLiteral("repeat-x")) {
  pattern->patternRepeatX = true;
} else if (repetition == QStringLiteral("repeat-y")) {
  pattern->patternRepeatY = true;
} else if (repetition == QStringLiteral("no-repeat")) {
  pattern->patternRepeatY = false;
  pattern->patternRepeatY = false;
} else {
  //TODO: exception: SYNTAX_ERR

‘patternRepeatX’ is missing in the very last block. The correct code looks as follows:

pattern->patternRepeatX = false;
pattern->patternRepeatY = false;


const int istride = sizeof(tmp[0]) / sizeof(tmp[0][0][0]);
const int jstride = sizeof(tmp[0][0]) / sizeof(tmp[0][0][0]);
const int mistride = sizeof(mag[0]) / sizeof(mag[0][0]);
const int mjstride = sizeof(mag[0][0]) / sizeof(mag[0][0]);

The ‘mjstride’ variable will always be equal to one. The last line should have been written like this:

const int mjstride = sizeof(mag[0][0]) / sizeof(mag[0][0][0]);

Mozilla Firefox

if (protocol.EqualsIgnoreCase("http") ||
    protocol.EqualsIgnoreCase("https") ||
    protocol.EqualsIgnoreCase("news") ||
    protocol.EqualsIgnoreCase("ftp") ||          <<<---
    protocol.EqualsIgnoreCase("file") ||
    protocol.EqualsIgnoreCase("javascript") ||
    protocol.EqualsIgnoreCase("ftp")) {          <<<---

A suspicious string “ftp” at the end – it has already been compared to.


if (fabs(dir[0]) > test->radius ||
    fabs(dir[1]) > test->radius ||
    fabs(dir[1]) > test->radius)

The value from the dir[2] cell is left unchecked.


return (ContainerBegLine <= ContaineeBegLine &&
        ContainerEndLine >= ContaineeEndLine &&
        (ContainerBegLine != ContaineeBegLine ||
         SM.getExpansionColumnNumber(ContainerRBeg) <=
         SM.getExpansionColumnNumber(ContaineeRBeg)) &&
        (ContainerEndLine != ContaineeEndLine ||
         SM.getExpansionColumnNumber(ContainerREnd) >=

At the very end of the block, the “SM.getExpansionColumnNumber(ContainerREnd)” expression is compared to itself.


bool operator==(const MemberCfg& r) const {
  return _id==r._id && votes == r.votes &&
         h == r.h && priority == r.priority &&
         arbiterOnly == r.arbiterOnly &&
         slaveDelay == r.slaveDelay &&
         hidden == r.hidden &&
         buildIndexes == buildIndexes;

The programmer forgot about “r.” in the last line.

Unreal Engine 4

static bool PositionIsInside(....)
    Position.X >= Control.Center.X - BoxSize.X * 0.5f &&
    Position.X <= Control.Center.X + BoxSize.X * 0.5f &&
    Position.Y >= Control.Center.Y - BoxSize.Y * 0.5f &&
    Position.Y >= Control.Center.Y - BoxSize.Y * 0.5f;

The programmer forgot to make 2 edits in the last line. Firstly, “>=” should be replaced with “<=; secondly, minus should be replaced with plus.


qreal x = ctx->callData->args[0].toNumber();
qreal y = ctx->callData->args[1].toNumber();
qreal w = ctx->callData->args[2].toNumber();
qreal h = ctx->callData->args[3].toNumber();
if (!qIsFinite(x) || !qIsFinite(y) ||
    !qIsFinite(w) || !qIsFinite(w))

In the very last call of the function qIsFinite, the ‘h’ variable should have been used as an argument.


if (!strncmp(vstart, "ASCII", 5))
  arg->format = ASN1_GEN_FORMAT_ASCII;
else if (!strncmp(vstart, "UTF8", 4))
  arg->format = ASN1_GEN_FORMAT_UTF8;
else if (!strncmp(vstart, "HEX", 3))
  arg->format = ASN1_GEN_FORMAT_HEX;
else if (!strncmp(vstart, "BITLIST", 3))
  arg->format = ASN1_GEN_FORMAT_BITLIST;

The length of the “BITLIST” string is 7, not 3 characters.

Let’s stop here. I hope the examples I have demonstrated are more than enough.


From this article, you have learned that with the Copy-Paste method, making a mistake in the last pasted block of code is 4 times more probable than in any other fragment.

It has to do with the specifics of human psychology, not professional skills. I have shown you in this article that even highly-skilled developers, of such projects as Clang or Qt, tend to make mistakes of this kind.

I hope my observations will be useful for programmers, and perhaps urge them to investigate our bug database. I believe it will help reveal many regular patterns among errors, and work out new recommendations for programmers.

By Andrey Karpov

7 thoughts on “Last Line Effect

  1. Pingback: Logical Expressions in C/C++. Mistakes Made by Professionals | How Not To Code

  2. Pingback: Searching for bugs in Mono: there are hundreds of them! | How Not To Code

  3. Pingback: Development Donderdagen 23 – houstonwehaveabug

  4. I used to think I was good at programming (I had 20+ years of experience when I thought that). Then with Test-Driven Development, my errors were put in my face (for the last 16 years). I came to realize I make lots of mistakes. I discovered in myself what you are showing in your research. If I copy/paste and N changes are needed, on a good day I can get N-1 of the changes right.


  5. Pingback: I used to think I was good at programming | James Grenning’s Blog

  6. Pingback: สิ่งที่น่าสนใจจากบทความเรื่อง Last Line Effect

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s