The thing that people need to keep in mind when discussing the GPL is that it was created to achieve an ideological and political goal, namely that users of software should have the right to modify and extend the software as they see fit. To achieve this goal, the GPL seeks to ensure that the source code is always available and that reusing the source code in question comes without any restrictions save for what the GPL itself imposes in order to ensure this "right" is never withdrawn. There are certainly noble aspects to this goal, but there are also consequences for programmers that run into code under the GPL. The biggest is that the GPL is basically an all or nothing proposition. If you wish to use GPL covered code directly in your own application, your own code then becomes bound by the GPL and you are obliged to produce that code upon request. This obligation should not be considered trivial or burdenless, which all too often happens with some of the more fanatical free software advocates. After all, their goal is to see all software fall under the GPL because they consider that to be the 'correct' state of things in the software industry. The problem however is that by placing advancement of an ideological position as the primary objective, the GPL can actually discourage the reuse of code licensed under it.
As mentioned above, when one uses GPL covered code, one's own code then comes under the GPL and an obligation is created to make the source available upon demand. Again, this is a burden in that there is a cost in time and resources to make the source available. If a developer does not believe in the ideology of the GPL, then the burden must be weighed against the benefit of not having to write whatever functionality the GPL code provided. In many instances, the cost is far greater than the benefit because once the code is under the GPL, that iteration will always be under the GPL, creating a long term obligation and burden. As such, it can become cheaper in the long run to roll one's own solution than to reuse existing GPL covered code. Another alternative is to go with code covered under more permissive licenses such as the Apache or BSD license. These require that their code and direct modification of their code remain under the BSD, but there is no requirement that every other piece of the software come under the same license. These licenses thus make it easier to use their code by limiting any obligations that are imposed by the use. For developers that do not care about ideology or for companies that have considerably complex intellectual property agreements, it becomes easy to pick which body of code they would rather use.
While I make no argument about which position is "right" or "wrong," I do make an argument about which is ultimately more usable from a programmer's perspective. The software world is a complicated place and programming is difficult enough without having to think about the additional legal complexities of a certain body of code. Metaphorically, open source versus closed source can be considered white and black whereas free software is gray. With open and closed source, you know fairly easily whether you can or cannot use the code. With free software, the situation can become sticky very quickly.