ere and thus should still work. And yet, it didn't. So what they did was put a trace in the code to see exactly what was going on.

When the trace got to the part of the source code that was fixed, it didn't do what it was supposed to do. It was following the path of the original code. This made no sense. Well, after much investigation they finally found, by accident, that the programmer was using the wrong library routine. Even though the source code was fixed, the

We take so much for granted in this world. We expect everything we buy to work perfectly and when it doesn't, we throw a tantrum. Well, can you imagine what the programmer who creates your medical billing software feels like when he fixes one bug and then another one pops up? What follows is a true story, which just goes to prove that the truth can sometimes be stranger than fiction.

A medical billing software company was creating a new software package to bill UB-92 claims. Up until this point in time, they had only done NSF 3.01 specifications. So the first thing they had to do was get the specifications from the carrier and send them off to programming so that the programmer could begin work on them.

A few weeks passed and the programmer had the specifications completed and was ready to test the module. So they set up some test claims and transmitted them to the carrier. When the test results came back, they showed that there were several fields that were transmitted in error. No problem. The programmer made note of the fields and made the changes. He then transmitted the claims again and waited for the results to come back.

This is what happened.

In fixing the fields that were wrong, he inadvertently broke some other fields. Okay, no problem. He would simply fix the fields that he had broken. He proceeded to do this and retransmitted the claims back to the carrier. Much to his puzzlement, the original fields that were broken were broken again. Now he was really scratching his head. He knew he had these fields fixed. He even went over the source code to make sure that the fix was still in. It was. So what was wrong? None of this made any sense.

Well, he called together the programming team and they all looked at the original code and the fixed code. They all agreed that the fix that the programmer put in to fix the original problem was still there and thus should still work. And yet, it didn't. So what they did was put a trace in the code to see exactly what was going on.

When the trace got to the part of the source code that was fixed, it didn't do what it was supposed to do. It was following the path of the original code. This made no sense. Well, after much investigation they finally found, by accident, that the programmer was using the wrong library routine. Even though the source code was fixed, the o

laims. Up until this point in time, they had only done NSF 3.01 specifications. So the first thing they had to do was get the specifications from the carrier and send them off to programming so that the programmer could begin work on them.

A few weeks passed and the programmer had the specifications completed and was ready to test the module. So they set up some test claims and transmitted them to the carrier. When the test results came back, they showed that there were several fields that were transmitted in error. No problem. The programmer made note of the fields and made the changes. He then transmitted the claims again and waited for the results to come back.

This is what happened.

In fixing the fields that were wrong, he inadvertently broke some other fields. Okay, no problem. He would simply fix the fields that he had broken. He proceeded to do this and retransmitted the claims back to the carrier. Much to his puzzlement, the original fields that were broken were broken again. Now he was really scratching his head. He knew he had these fields fixed. He even went over the source code to make sure that the fix was still in. It was. So what was wrong? None of this made any sense.

Well, he called together the programming team and they all looked at the original code and the fixed code. They all agreed that the fix that the programmer put in to fix the original problem was still there and thus should still work. And yet, it didn't. So what they did was put a trace in the code to see exactly what was going on.

When the trace got to the part of the source code that was fixed, it didn't do what it was supposed to do. It was following the path of the original code. This made no sense. Well, after much investigation they finally found, by accident, that the programmer was using the wrong library routine. Even though the source code was fixed, the

e several fields that were transmitted in error. No problem. The programmer made note of the fields and made the changes. He then transmitted the claims again and waited for the results to come back.

This is what happened.

In fixing the fields that were wrong, he inadvertently broke some other fields. Okay, no problem. He would simply fix the fields that he had broken. He proceeded to do this and retransmitted the claims back to the carrier. Much to his puzzlement, the original fields that were broken were broken again. Now he was really scratching his head. He knew he had these fields fixed. He even went over the source code to make sure that the fix was still in. It was. So what was wrong? None of this made any sense.

Well, he called together the programming team and they all looked at the original code and the fixed code. They all agreed that the fix that the programmer put in to fix the original problem was still there and thus should still work. And yet, it didn't. So what they did was put a trace in the code to see exactly what was going on.

When the trace got to the part of the source code that was fixed, it didn't do what it was supposed to do. It was following the path of the original code. This made no sense. Well, after much investigation they finally found, by accident, that the programmer was using the wrong library routine. Even though the source code was fixed, the

ement, the original fields that were broken were broken again. Now he was really scratching his head. He knew he had these fields fixed. He even went over the source code to make sure that the fix was still in. It was. So what was wrong? None of this made any sense.

Well, he called together the programming team and they all looked at the original code and the fixed code. They all agreed that the fix that the programmer put in to fix the original problem was still there and thus should still work. And yet, it didn't. So what they did was put a trace in the code to see exactly what was going on.

When the trace got to the part of the source code that was fixed, it didn't do what it was supposed to do. It was following the path of the original code. This made no sense. Well, after much investigation they finally found, by accident, that the programmer was using the wrong library routine. Even though the source code was fixed, the

ere and thus should still work. And yet, it didn't. So what they did was put a trace in the code to see exactly what was going on.

When the trace got to the part of the source code that was fixed, it didn't do what it was supposed to do. It was following the path of the original code. This made no sense. Well, after much investigation they finally found, by accident, that the programmer was using the wrong library routine. Even though the source code was fixed, the object code for it was not placed in the library so it wasn't being processed.

These are the kind of nightmare's that programmers go through all the time. So the next time you open up your medical billing software and it doesn't quite work the way you expected it to, please remember that there is a human being on the other end who's as frustrated as you are by the whole thing.