The Last Line Effect – typos and fun

Our team has checked a big number of projects – more than 250 and collected about 9800 bugs. Thus, we 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. We have never seen this phenomenon described in books on programming, so we decided to write about it and call it the “Last line effect”.


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 we discovered. We 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, we are 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.

A random fact: 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. We guess something similar happens to programmers.

Now some figures.

Having studied the bug database, we singled out 84 code fragments which we 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.

We 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:image3

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.

We 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.


Here are some examples proving that:

We 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. We hope the examples we 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. This bugs was found with PVS-Studio static analysis tool.

It has to do with the specifics of human psychology, not professional skills. We 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.

We hope these observations will be useful for programmers, and perhaps urge them to investigate our bug database.

Ok. Here are some hilarious typos that were collected from the net. Time to relax and smile a bit.








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 )

Google photo

You are commenting using your Google 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 )

Connecting to %s

This site uses Akismet to reduce spam. Learn how your comment data is processed.