# Introduction

My name is Andrey Karpov and I do an unusual job — I analyze program code of various applications with the help of static analyzers and write descriptions of errors and defects I find. I do this for pragmatic and mercenary reasons because what I do is the way our company advertises its tools PVS-Studio and CppCat. The scheme is very simple. I find bugs. Then I describe them in an article. The article attracts our potential customers’ attention. Profit. But today’s article is not about the analyzers.

When carrying out analysis of various projects, I save bugs I find and the corresponding code fragments in a special database. By the way, anyone 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 with errors and is waiting for programmers to study it and reveal certain regularity patterns among these errors. That may serve as a useful basis for many future researches, manuals and articles.

I have never carried out any special investigation of the material gathered by now. 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 some reason behind it.

# 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 of 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 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 at the last few dozens of meters of 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 that I found to have been written through the Copy-Paste method. Out of them, 41 fragments contain mistakes somewhere in the middle of 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 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 may be useful to know about for practical reasons — you will stay alert when writing the last fragments of code.

# Examples

Now I only have to convince the readers that it all is not my fancy, but a real tendency. To prove my words, 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.

## Chromium

`if (access & FILE_WRITE_ATTRIBUTES)  output.append(ASCIIToUTF16(“\tFILE_WRITE_ATTRIBUTES\n”));if (access & FILE_WRITE_DATA)  output.append(ASCIIToUTF16(“\tFILE_WRITE_DATA\n”));if (access & FILE_WRITE_EA)  output.append(ASCIIToUTF16(“\tFILE_WRITE_EA\n”));if (access & FILE_WRITE_EA)  output.append(ASCIIToUTF16(“\tFILE_WRITE_EA\n”));break;`

The last block and the one before it are identical.

## ReactOS

`if (*ScanString == L’\”’ ||    *ScanString == L’^’ ||    *ScanString == L’\”’)`

## Multi Theft Auto

`class CWaterPolySAInterface{public:  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

`intens.x=OrSIMD(AndSIMD(BackgroundColor.x,no_hit_mask),  AndNotSIMD(no_hit_mask,intens.x));intens.y=OrSIMD(AndSIMD(BackgroundColor.y,no_hit_mask),  AndNotSIMD(no_hit_mask,intens.y));intens.z=OrSIMD(AndSIMD(BackgroundColor.y,no_hit_mask),  AndNotSIMD(no_hit_mask,intens.z));`

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.

## SeqAn

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

## SlimDX

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

## Qt

`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;`

## ReactOS

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

## Quake-III-Arena

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

## Clang

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

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

## MongoDB

`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(....){  return    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.

## Qt

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

# OpenSSL

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

# Conclusion

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 observation will be useful for programmers and perhaps urge them to investigate our bug database. I believe it will help reveal many regularity patterns among errors and work out new recommendations for programmers.

--

--

## More from Andrey Karpov

Microsoft MVP. Founder and DevRel of PVS-Studio static code analyzer for C, C++, C# and Java.

Love podcasts or audiobooks? Learn on the go with our new app.

## Andrey Karpov

Microsoft MVP. Founder and DevRel of PVS-Studio static code analyzer for C, C++, C# and Java.