Not sure where this thread is going, but I guess we may as well have some conversation.
I've dealt with plenty of platform specific bugs. If you rely on multi-platform frameworks that abstract from specific hosts, you can avoid a lot of this,
but even so there can still be problems. At any case, I guess that the overall number of bugs in the actual program core is usually higher, though.
Your program is of course embedded in a greater host system.
And each host may have different logic behaviour, in two ways:
Either it is obviously different in the interface.
So the part of your code that deals only with that host may have bugs that the software doesn't have on another host.
Or there are unspecified differences in the behaviour of the host implementation underneath.
An example I encountered were graphics driver problems I had on one system, that I didn't have on another.
The code was the same for both, and although valid in principle, needed additional provisions on the other.
I still have to deal with some such issues. Unfortunately, this time with the open source drivers on Linux.
There is a lot of things I like about open source projects, even though I don't see in it the greatest solution to every problem.
The Open Source movement is sometimes percieved as counter to proprietary industry.
But much more often it's complementary forces of something greater.
In reality, the industry has been very supportive to Open Source projects.
Many of the best projects have a good involvement with various companies.
Linux would not be where it is now, without it.
Some might say, it should be more, so they're bad.
But in many ways it's been plenty enough in my opinion.
The reason is simple: there is a need for Open Standards.
Open source software is part of the industry infrastructure.
At least with that code, you can bet it works pretty well.
However, agreement and compromise among many people is difficult to achieve,
and the need for that in a greater community project can also stifle development.
So it's not about what is the ultimate development pradigm.
Cooperative behaviour is not exclusive to just one side. And there are many ways of going about it.
At the same time, open source projects also have to compete for public interest, because it is voluntary.
And while this is great, that's also a challenge for Open Source development, as it is for anyone.
But it hits Open Source especially hard, because of its pronounced freedom, while limiting ownership.
This is not simply about greed. The question of ownership already starts with who directs the project which way.
And the often inconclusive answer to that has many difficult consequences.
The usual answer is forking development, so everyone can be happy in their own way.
But that too has caused many problems with splintered and weakened projects.
And that makes for weird contradictions. In theory, OS on average should be much more stable and save and service friendly, since anyone can look into it.
In practice it often isn't. Because not enough people are motivated to look into it, and there are big problems from a lack of accountable hierarchy structures.
So there have been several huge security holes that lasted more than a decade, and were a total embarrassment when discovered,
of a kind so bad you never saw happen on equivalent proprietary solutions in the first place.
Or terrible legacy constructs difficult to get rid of because of community politics.
The most important factors to good software is the combination of developer engagement with user feedback. That's the sort of Open that matters most.
And the idea of voluntary community service for the greater good is thousands of years old and was not invented by radical neckbeards on the internet.
Having said that, I'm glad these projects exist.