I can think of one reason why portability can be desirable, and why focusing development efforts solely on the Linux platform might be undesirable, that I haven't seen mentioned yet. Namely, on the grounds of avoiding a operating system software monoculture.
My understanding is that software monocultures are often thought of as undesirable, because when a sufficiently severe problem occurs within the members of the monoculture it can wipe them all out (similarly to how a disease or pest can destroy an ecological monoculture vulnerable to that disease/pest) and, if there are no other alternatives available for use, then the functionality provided by that software will be lost until (and if!) the software can be altered to resist or become immune to the problem. When that software is the operating system, which provides the foundation required by all other uses of the computer (such as application software), it seems as if it would be even more important than usual to avoid the risks caused by a software monoculture.
We can easily see a real-life example of exactly this sort of situation in the problems regularly encountered by users of the Microsoft Windows family of operating systems. Historically, every so often we see a great furor erupt in the mainstream media, as another vulnerability is discovered and exploited within Windows which results in many people world-wide losing the use of their computer for a time, or even losing their data, until the vulnerability is patched or otherwise remedied. Of course, Windows is known to be especially vulnerable to this sort of thing due to its historical underpinnings and ancestry, as well as due to the fact that many Windows users are non-technical and unwilling (or unable!) to be proactive in keeping their systems (relatively) secure.
However, the fact that Windows is an especially vulnerable target with relatively unskilled users, while Unix-like operating systems (including Linux) are relatively resistant targets with (presumably) relatively knowledgeable users, does not excuse the latter group from having to beware the risks inherent in being a software monoculture! We know that Unix-like and Linux-based operating systems are known to have vulnerabilities too, and if we don't know this we can simply look at the ongoing series of vulnerabilities announced by CERT and listed in LWN every week. And, we've had our moments of furor and panic in the mainstream media spotlight too -- perhaps the most well known of these was Robert Morris's Internet Worm. (See, for instance, http://en.wikipedia.org/wiki/Morris_worm .)
A second reason for considering software monoculture to be undesirable is that it reduces the opportunity for instances of hybrid vigor (see http://en.wikipedia.org/wiki/Hybrid_vigor ) to occur. In the context of software, this would be the porting or reimplementation of desirable features or capabilities originally provided by some other independent implementation of that type of software (such as operating systems). Of course, with software, there are unique impediments to the act of hybridization that can occur, such as incompatible software licenses. Even so, we see instances of software hybridization occur all the time at all levels of software.
I agree that it is desirable and usually a good thing to try to fully use the capabilities provided by an operating system, including those capabilities which might not be portable to or currently unavailable on by other sibling operating systems. (If nothing else, we want to try to use those capabilities to see if they're worth the effort to reimplement elsewhere!) I agree that worrying about portability issues can make software harder to implement and slow down the pace of development. I agree that, in at least some instances, it may not be worth worrying about portability issues, or at least considering them only at very most a distant second (if not even lower) in terms of importance. In other instances, perhaps worrying about portability should be left to "somebody else", while the original developer concentrates on advancing the state of the art on the primary development platform.
However, I disagree that we should blithely agree to establish or limit ourselves to a software monoculture, especially an operating system software monoculture, without duly recognizing and considering the risks of this decision and the costs accompanying those risks (which costs might reduce or even eliminate the benefits of living within a software monoculture), and also recognizing the benefits and value potentially provided if we do not limit ourselves to a monoculture environment.