Minor nitpick: we have become a support community for free software running on any OS, however the page titles still say "Nuxified GNU/Linux Help Forums".
Yeah, I'm aware of it.. It's mostly left for gaining some search traffic for "Linux help". I might remove it at some point once we solidify a new marketing strategy..
I need to make my peace, so I hope no one gets angry.
I want to remind people that Linux was created for a reason. You don't have real open source on Windows. To run any Windows app (including pseudo open source stuff like Firefox on Windows) you need to rely on what Microsoft provides underneath, and this stuff they provide is not open source in any shape or fashion. It is completely and exclusively under their control, and it is the HEART of any application on Windows (eg, to do things like accessing files and memory reliably). There is NOTHING freedomware about it. It's how they have made their living for 2+ decades eliminating as competition all who relied on this platform they control completely and share not one bit (in the freedomware sense).
For those that care about FOSS/freedomware, porting to Windows *usually* has the effect of extending the life of Windows and keeping it closed (less pressure on Microsoft to open up). This doesn't help Linux or Windows users in general. For a while now, it's been very easy to gain access to Linux and FOSS through LiveCDs, and hard drives and storage is very inexpensive nowadays.
In summary, the guts of any pseudo open source Windows app are the low-level system calls, and NONE of these are open source. That's why Linux and a bunch of other open source platforms exist. You don't have open source without the HEART being open source and free.
I mention this for awareness and not in any serious attempt to try and fight decisions about nuxified since this isn't my website, but it is a shame to see a good thing go.
This guy has it right: http://lxer.com/module/newswire/view/98648/index.html
PS: If people want Windows and "open source" apps, that's not my business. I'm just calling it like it is. In those cases, the product isn't FOSS because only the top layer is trustworthy and free. It's hard to call something safe and free when the platform underneath is shifty and out of your control, and worse when it is to the controllers' clear benefit (as a market share owning monopolist) to keep shifting it around to affect negatively everything above that isn't owned by them .. Again, my intention is not to get anyone upset. Carry on.
Noone will get angry, don't worry.
In a way I'm actually glad you brought this up. Even if I don't entirely agree there may be a need to sooner or later somewhere discuss exactly the pros and cons of marketing GNU/Linux specifically or Freedomware in general - and as well supporting it on Nuxified one or the other way.
As for where I disagree I think it mostly comes down to semantics. I believe that Freedomware even on proprietary platforms is still Freedomware. That particular piece of code is free and you can adapt it to better run even on a totally proprietary platform if you so wish. I understand what you mean by that people still aren't fully in freedom when they use freedomware on a proprietary bottom, like the Windows OS. But the same can be said for using proprietary graphics drivers on an otherwise fully free system, right?
What you're basically saying is similar to what RMS says as that as long as the system isn't 100% Free Software you don't have complete freedom, and whether it is only 50% or 99% it doesn't matter - as long as it's not 100%. While I believe this to be quite true if you get really precise about it I think Freedomware on proprietary platforms can help alleviate some of the usual prejudices that people have for it, like that because it is free it can't be good quality. Once they realize just how good Freedomware can be, taste the bit of freedom even while they are still in a shall we say totalitarian's territory, they are more likely to consider going steps further and ultimately switching to a Free OS like GNU/Linux.
All this said, why did Nuxified switch to supporting all Freedomware? Because we wanted to shift away attention from promoting only an alternative operating system, where people end up switching while having absolutely no idea about the whole freedom philosophy that made it happen. In fact "Linux" becomes just a buzzword for a let's say "Windows killer", not a buzzword for a "free as in freedom OS". When all one cares is propagation of "Linux" no matter what, then the freedom becomes much less relevant. If putting totally redundant proprietary software on top of it is gonna get us more adoption they'll do it. And I don't agree with that.
Instead we want the goal to be the propagation of Freedomware in general - let it be everywhere and in every form until there is so much of it that proprietary software as such completely loses its relevance and power. The OS doesn't matter to this bigger picture. It can be any of the GNU/Linux distros, any of the BSD distros, any of the OpenSolaris distros - it doesn't matter as long as it's freedomware.
This is also a good way to stop the mentality that creates what you know as "distro wars". When we know what is common to us, and how important that is, we are less likely to have such petty fights.
Therefore Nuxified.org stands as a place in which we don't discriminate. We will help you with Freedomware, no matter what it is and where it runs. Mind you, we do encourage people to switch wholesale to a Free platform, and we are fully aware that GNU/Linux is in probably over 90% of cases the best Free OS solution. So it's not like this shift means somehow forgetting GNU/Linux or ceasing to promote it. In a contrary. The more people know about Freedomware the more people will be genuinely interested in GNU/Linux for what it is - and it is NOT just another ordinary OS. There is something special about it - it is Freedomware.
Geez this took long.
Btw, thanks for that interview link. It was awesome.
I understand your perspective (mostly I think), and you have some good points. It's a good thing we don't all think identically or the world would be pretty boring.
>> If putting totally redundant proprietary software on top of it is gonna get us more adoption they'll do it. And I don't agree with that.
Closed source at the higher levels is less dangerous. You can live without it (just don't run the app or plugin), and it is more limited in what it can do. On Windows, there isn't a single piece of 100% FOSS because **everything** requires closed source Windows to run. You can't run on Windows and bypass Windows. Also, all the more important things are at the OS level.
>> let it be everywhere and in every form until there is so much of it that proprietary software as such completely loses its relevance and power
The "embrace" is followed by "extend" is followed by "extinguish" for a reason. The real power for carrying that out is in controlling the lowest layers possible and being closed source. The monopolist benefits when FOSS brakes. Imagine Firefox (on Windows) getting a virus because the hole was patched for IE internal API calls but not for regular 3rd party API calls. Imagine PHP appearing less stable and slower than ASP. Who will want to switch then? But the real effect is when enough people code for PHP on Windows or write plugins for Firefox on Windows and these don't work on Linux. Remember that Windows is closed source. Microsoft can add a lot of effects and these are not ported over to Linux nearly as easily as FOSS is ported over to Windows.
This has been how Microsoft has operated in the past (makes perfect business sense for them and it would be foolish for them to contemplate doing otherwise as long as they are a monopolist). Over time, it is not worthwhile to develop for Linux at all. Eventually, the FOSS apps stop being of any quality... Sure, this is much more difficult to happen with FOSS because of all the people that will always code FOSS even if they lost their job. Microsoft may not be able to ever "beat" Linux completely, but every dollar to Microsoft is 50 cents of aggravation and delay for Linux as Microsoft puts it to work anti-competitively (to please shareholders).
Anyway, speaking only for myself as a developer, I am insulted by the way Microsoft runs the show. I don't do business with "partners" under those circumstances. When Microsoft allows us to see all their source and build it ourselves, only then will I consider writing code on their platform where I show them the code (this is a personal view and is general.. there are always exceptions). Why voluntarily let them have the upper hand over you? Thanks, but no thanks. Linux is lovely, delicious, and nutritious.
>> thanks for that interview link. It was awesome.
It's a bit long, but I did think you were mentioned. Also the link within the link is good (about the "shades").
>> I believe that Freedomware even on proprietary platforms is still Freedomware.
I am repeating myself, but this quote allows me to be clear. On Linux, you can run this and that completely free. You can do 100% or some smaller percent as you choose. Linux kernel is all free(dom) but an app may not be all free so you get partial free in the worst case and you can easily be 100% free (just don't run the particular closed app).
On Windows you **cannot** get anywhere near 100% free. Everything is filtered by Microsoft. **Everything** And Business 101 dictates that a monopolist that has shareholders (especially if these run the company) benefits when 3rd party apps look bad in comparison. There are many bugs that can be introduced/left behind very easily so that only 3rd party apps look bad.
>> What you're basically saying is similar to what RMS says as that as long as the system isn't 100% Free Software you don't have complete freedom, and whether it is only 50% or 99% it doesn't matter
Do you see that I have a particular beef about not running "platform" and "infrastructure level" code that is not free if it can at all be avoided? This is more true when we are talking about what a monopolist produces, especially one that has had the inclination and skill to embrace, extend, and extinguish the way Microsoft has.
This is not to say that EEE is only possible from below, but it is more difficult from above and without established monopolies to lean on.
Also, in the short run, Microsoft needs Vista to be interesting to buyers. FOSS is a way to quickly make Vista interesting (and keep Windows interesting). FOSS doesn't stop growing, and Microsoft can't keep up by themselves (they kill off other closed source app competitors so that pool is running dry). Remember that Vista is more serious software than is Windows. We are talking about really losing control of any form of privacy and control and confidence. Also, Microsoft can back patch through the Internet automatically no matter what you want. In this way, they can change software you already lease/use so that it behaves differently than in the past.
I just don't do business with a company like Microsoft if it can at all be avoided (which thankfully has been pretty easy to do for me for a while now).
And as I said, I like to give my perspective, but I don't want any war. You have an understandable pov that many share (even other developers). There are many ways to fight a war, but I do think the approach helios takes is a good one of focusing in on a FOSS OS.
If you run Windows, can you really every understand freedom? I don't think so. You have to go to Linux and try it out for yourself to see what the fuss is about.
>> Once they realize just how good Freedomware can be, taste the bit of freedom ..
Let's hope they don't end up with a bad taste. As stated above, on Windows **everything** is subject to Microsoft Windows "bugs," instabilities, and absence of control.
>> When all one cares is propagation of "Linux" no matter what, then the freedom becomes much less relevant. If putting totally redundant proprietary software on top of it is gonna get us more adoption they'll do it. And I don't agree with that.
As stated above, on Windows there is zero that is 100% free. On Linux, including proprietary apps, the majority is 100% free. That's quite a difference (most or all being 100% free vs. nothing being 100% free).
Also, the tendency for companies is to open up on Linux because that works well in that environment but to keep things closed on Windows oftentimes.
Thanks for the opportunity to vent. I know this can be a touchy subject for various reasons.
I should add that it is easy and natural for Microsoft to fix bugs in (eg) IE but not have the effects work on other 3rd party apps. There are many code paths. Microsoft is clear that they "integrate." It is worthwhile to stay up night after night to fix a bug on IE if you are a Microsoft employee/stockholder. But don't expect them to hunt bugs with the same intensity and dedication for code paths set up for third parties (the Windows/Vista/etc "public" APIs that are not integrated like the code used by MS apps). Even if Microsoft employees/execs were outstanding citizens, it wouldn't happen because they are human and every bug they found which helped the competition would be many fewer dollars in their bank accounts (and less security about their future, less time with the family, etc).
In FOSS, everyone can see everything, so all interested parties can look after what is maximally relevant to themselves. It all works out. Also, because everything is open, it might be considered pretty embarrassing to be sloppy and neglectful. And we don't have anywhere near the same control and dollars flowing as flow to Redmond. Linus looks good if everything works maximally well for the most users possible. That is completely different from the Microsoft lead developer scenario.
If Microsoft was not working from a monopolist position then the story would change since mistakes around their software might mean their software gets the boot. Rather, with the wide market share they hold, the natural choice is to dump the 3rd party app and just stick with all MS since that will work better (ie, you can't dump Windows for Adobe Windows since Adobe doesn't produce Adobe Windows, so you dump misbehaving Adobe apps for new and improved comparable MS apps, especially if you would get deep discounts for making the switch (monopolists are very wealthy)).
And I want to also repeat that there are many techniques and situations. The whole story doesn't play out on the OS only.
An "API" just means that an application would have instructions in the program defer control to provided "API" code in order to get some effect. Since Microsoft controls the OS, all applications have to rely on code provided by Microsoft (in general terms an OS is not bypassable).
Windows/Vista will never be free of conflicts of interests at least until Microsoft leaves the application business (to do only OS). Ditto for clients and servers and any other mutually dependent software categories. You can't presume to provide a fair playing field when you compete on each side of the communication channel. It's just natural to integrate the competitors out of the show.
Also, to a large degree, by "Linux" I also mean other FOSS OS.
To be honest I personally agree that staying completely away from Windows and any non-free OS is the best way and wouldn't, if I were a coder, do my programs for Windows. If nothing then out of spite.
I am also not very passionate about either side of the argument when it comes to the question of whether to port applications to Windows or not. You could say, most of the time I'm on the fence, seeing that both have their pros and cons.
This is why I don't find this to be a "touchy subject" for me personally at all. I just don't care so much which of the two sides are right.
What led me to make Nuxified.org so open towards all Freedomware regardless of the platform it runs on comes from a different direction, which doesn't have much to do with the question of coding Freedomware for proprietary platforms. It has a lot to do with the question of which idea to we give more attention to, the idea of "Linux OS - The great free Windows Killer" or the idea of "Freedomware - The proprietary software killer".
The former is specific to one operating system, GNU/Linux, and yet it is only a portion of what is considered as Freedomware. It is an OS vs. OS thing.
The latter is about all Freedomware. It is a paradigm vs. paradigm thing. It is freedom vs. non-freedom. Hence by focusing on the latter I give more attention to the idea of freedom than to the idea of just having a Windows killer.
Why? Because Windows is not the only thing we want to kill. We want to kill all proprietary software, everywhere. At least that's what I believe.
So basically that this means offering help and support to people running Freedomware even on Windows is more of a side-effect of having such an attitude, than something I actually desire. What Nuxified.org does is by no means encouraging people to port apps to Windows. We merely offer people to help them with apps that already are ported. Basically, the least we can do now that these pieces of freedomware are on the freedom-deprived land is help them through, at least gain community ties with them and then ultimately, by being friendly rather than isolationist, win them over to GNU/Linux or other free platforms completely.
A positive perspective is what counts because that shows through regardless of the approach or contribution, and not all cats are skinnable the same way.
Meanwhile, we really need to keep forging away at these distros and apps.
Sorry for appearing a bit aggressive. I warned about that. I still think it's a touchy subject. Hopefully the value proposition for FOSS will continue to appeal to a growing number of people. It may be though that no major chunk of Jacks and Jills will buy into it enough until FOSS is hands down better in most respects. It's with this mentality that I think I would take great satisfaction if I found out that developers across the board were abandoning Windows to focus on making Linux and friends hands down the best.
Meanwhile, the slow march continues.
The most important reason for supporting freedomware on an enslaved OS is as follows: There still are people locked in to such OSes because they absolutely need a certain app or feature which nobody who is capable can be bothered to recreate in freedomware. Should anyone who is unfortunate enough to be locked in not have the possibility to at least be as free as possible?
Of course the time invested in porting freedomware apps to enslaved operating systems would be better spent implementing whatever the show-stopper features are in freedomware. But if no developer who knows how wants to do it, and no freedomware company thinks it would be good ROI, then the best solution to the problem just ain't gonna happen.
The good news is: with virtualization one can run freedomware and slaveware on the same computer without mixing them.
The bad news is: slaveware vendors will allow only the most expensive versions of their software to be run that way.
I am guided a bit by the idea that there is *almost* no situation where a LiveCD can't provide a better solution than Windows pseudo-FOSS apps. For do-it-yourself, it's easier to download a Windows app if you are on Windows, but for helping someone, I think the LiveCD is preferable in most cases and only slightly more complex. A vid demoing how to install a LiveCD to hard drive would be very useful (hard drives are fairly cheap).
And I do think there is a long term loss for a slight short term gain (in most cases?) by opting out for the Windows solution.
Anyway, the message I am posting is a bit more focused towards developers.
For the motivated, check out freegeek.org as well as the examples provided in the interview link above.
Okay, so there's this MS Windows-only or MacOS-only app, which, whatever it is, is a showstopper for moving to a freedomware OS. Since it's important, it will probably run most of the time. Then using a LiveCD will mean more reboots than a Windows ME which has been infected with every bit of malware and junkware known to man. (excuse me for the colourful metaphor)
The better solution is two computers and a network. And why not, Linux PCs are dirt cheap nowadays.
A related article and some more comments: http://www.linuxtoday.com/infrastructure/2008012900226OPDTSW . [I post as Jose_X on LT.]
Some new additions to this conversation would be that (a) porting detracts from time that could be spent doing more useful work, (b) porting code adds to what must be maintained consequently making the whole less maintainable, (c) FOSS developers and consultants can't provide support for Windows (only Microsoft can and maybe a few special "partners"), and (d) if Microsoft share decreases significantly any time soon, the effort would have proved to be wasted to a large extent (for many) and the code would be a lot of excess code that would not likely be maintained that well and might be considered extra bloat by many (since Windows without a huge market share really isn't that appealing as a platform to many FOSS coders.. I am guessing).
The author brought up as a major point that abandoning Windows is missing out on opportunities to grow application market share and revenue. I think both of those will certainly attract some developers (especially if they like Windows and are comfortable with it), but not me. I see the advice as short-sighted. I am much happier helping Linux grow, dealing with that growth, and making applications better on Linux, than jumping on the Microsoft treadmill to waste many extra brain cells trying to play their game continuously. This time period for me is the sweat equity investment time period. The "business" will be much better off later on with a solid foundation and not cutting corners.
One could write ones software using a cross-platform framework, making porting cost no time at all. It doesn't cause much bloat either. However it's still helping MS/Apple... and helping everyone stuck on Windows/MacOS by not forcing them to use a proprietary alternative to ones software that would also try to lock them in. Tough decision!
>> One could write ones software using a cross-platform framework, making porting cost no time at all.
I am not sure I know what framework you are talking about that "just works," allows you to use the features you want, works efficiently, OR doesn't require testing across multiple platforms. Besides for a hello world app.
Some are better than others, but if porting was not an issue would we be having this conversation? [Alright, maybe, but let's look closer.]
I thought about some supposed X-platform frameworks I was aware of (and my experience is limited), and all have significant issues in practice. For example, some of the better ones simply lack the feature set you need. They are X-platform because they are limited in scope. Or they have features, but a bunch of the features only really work on one platform or don't work quite the same way. Keep in mind that there is a large system outside your code which you must interface with (eg, basic OS functionality and services provided by the environment). Windows and Linux are not the same. They have different capabilities and models. They are controlled by different entities so they evolve differently over time. And yes, they each keep evolving. Also, the X-platform tools themselves must map to the specific platforms underneath. There are a different set of bugs for each platform map. And there is the cost of getting the tools to work, eg, costs to the PHP, perl, Qt, Java, etc people, but that doesn't affect the typical application developers except indirectly since there is less time to advance the capabilities of those platforms on Linux.
And I'm not even looking at gratuitous changes or changes done for business purposes to break competing apps or get them to spend more and more time on your platform instead of other platforms or instead of improving the core software.
This doesn't mean there aren't X-platform techniques and tools to help out, but one point was that there are real costs maintaining a port properly.
This guy said it best http://www.computerworld.com.au/index.php/id;444282619;pp;2 :
>> For me personally, that is completely uninteresting because why would I want to run Windows on my Linux machine?
Of course it does depend on what your app does whether or not there is a suitable cross platform framework for it.
For many things Java with a Swing GUI is just fine. That really shouldn't have any platform specific issues, and if it does, shame on Sun. I know Java is not a very programmer friendly language, but there are other languages that can use the Java libs and be compiled to Java bytecode. Jython is pretty neat.
If you want to do multimedia, the new KDE frameworks look interesting.
And what about LINA? I don't know if that has much platform specific bugs, but just like Java it shouldn't.
Another link on Microsoft and standards http://www.linux.com/feature/125630 . It involves the topic of cross-platform as well as same platform interoperability for office suite applications ("cross" or "same" depending on whether you are looking strictly at the OS or at the whole stack all the way up to the competiting applications that manipulate the file formats).
It makes business sense for Microsoft to keep changing the rules of the game when you play in their sand box. That is costly to developers and means they are always vulnerable. And by the nature of the integration between operating system platform and applications that are each produced by Microsoft, third parties start and play the game in a lopsided playing field.
As much as we want to believe that quality is not as important as freedom, this is likely not the case in the minds of many. It could become so, but it might then mean that those that do understand this have to pay the price of an inferior computing experience. For that reason, although I think freedom is what we need to sell/communicate the most as it is really what is valuable, I am very conscientious of trying to keep the quality of FOSS products competitive if not outright superior. Seeing that "FOSS on Windows" is inferior to proprietary and MS apps may mean that many may not try or give a Linux LiveCD a fighting chance (remember there is a learning curve time period that extends beyond the first trial).
And the issue of quality means that you necessarily have to put effort to make the app perform well on Linux. Cross-platform tools sacrifice performance at least to some degree to gain their ability to (sort of) work across different platforms.
[An example of cross platform is C99 (the latest ISO version of the C language). Yet, you can't do very much that is interesting if you limit yourself to the standard libraries. There are many libraries you may want to use that are not cross-platform. Furthermore, C compilers don't really implement the standard correctly (at least many don't). You also have that for Windows, the preferred set of tools is visual studio which has it's own special things. You might worry about producing X-platform, but the tools on Windows don't help you achieve that. The result is that you have to go through extra effort that would not be necessary if this wasn't a monopolist business we were talking about. Monopolies gain by breaking standards and keeping secrets, because when things don't work, it's always the other guy that has to get the boot.]
Java is a noble effort to create a cross-platform tool. It is very comprehensive. Now that it is mostly all open source, it should continue to improve in quality, but don't kid yourself that there aren't bugs and that there aren't platform differences that cannot be bridged naturally but require specific knowledge of the platform and work arounds. So we have the problem that not all platforms work in a way that can be abstracted easily into one general cookie cutter, and we have the problem that each implementation of the JVM or of any of the tools has it's own set of bugs that are specific to the individual platforms. The more complex the application, the harder it is to get it to work across platforms consistently and reliably. [In the case of Windows, it stands out as not being very POSIX-y compared to most *nix which makes finding a cross-platform compromise that much more difficult.. but yes Java has set a decent standard for what it means to be a comprehensive cross-platform tool.]
Please don't tell me that you don't think bugs exist in essentially all non trivial software? [Some bugs depend on what a user finds unsatisfying, so some bugs are subjective, but many are not.] http://www.linuxtoday.com/infrastructure/2008013000226OPMRMS .
Also, for various reasons, Java may not be the tool a particular team decides to use to build their application, so even if Java was ideal for cross-platform use, the reality is that a whole lot besides Java is being used and those developers porting those apps must still deal with those troubles.
land0 may post his view on why FOSS ports to Windows are a good thing. In anticipation, I will take a stab at some (at least one) reasons. However, I want to clarify/augment what I have been saying when I say I am against porting apps to Windows. I've thought about this before, and certainly some amount of ports help and likely are even necessary. The cautions are for the general case.
There is a lot that can be argued without certainty either way because an important element of some of the arguments is subjective (possibly backed by research). Do the chances increase or decrease that Jack/Jill will move to Linux (or help get Windows to open up) with more FOSS ported over to ubiquitous Windows? Some aspect of this has to do with the mindset of Jack/Jill. Are they more or less predisposed?
The main reason I see why porting might be a good thing is with the assumption (and it's a decent one) that Jack/Jill gravitate towards what is free(dom) all else being similar enough. In that case, ports help make them aware and help them become comfortable with the software. In time, they might prefer to move over.
I think the main problem "in time" will be the neverending series of hurdles Microsoft will throw. Business dictates (to preserve their lucrative and powerful monopoly) that they continue making it more painful for users of their past products to migrate away to competitors. Sometimes, you need a certain amount of pain to make it less painful to move. While getting used to FOSS apps lowers some pains of migrating and increases curiosity to have more FOSS (if the experience is positive!), it also helps ease the pain of being on Windows AND/WHICH gives Microsoft more time to add more hurdles.
Also, denying something entirely but talking about its virtues really helps create curiosity and demand. This desire to move over is deminished significantly if the user gets a sample whenever they want right where they are. And if the sample is not that good to begin with, all the more reason exists not to want to bother to move to the extent it is perceived that nothing special lies over the rainbow. [See also the comment below about free samples that are bad.] A different end result (that would justify porting over apps mediocrely) would be that the user imagines it gets better if they move and staying will mean second best. The risk here is that if already something similar exists where they are (**competition among FOSS ports**) or if the so-so sample is "good enough" then the stimulation to move to Linux disappears. Really, what do Jack and Jill think? [wish I knew]
As for developers that want to port, consider this. Porting to Windows is not a stable thing, and you are always dependent on exactly how much Microsoft will be willing to give you tomorrow. You are giving up to them important decisions over how your application runs and when it runs that way. You lack certain information that can help your application be competitive. You also necessarily have to immerse yourself into their way of doing things [which is a real issue for almost any dev when they are starting over with new API's and procedures as might be the case with Vista]. In short, it is time consuming and costly in brain cells and will lead to mediocre results. The mediocre results may hurt the impression of FOSS (lessen the curiosity and perceived pay-off in trying to move over).
There will also be a tendency to want to exploit what you (as a dev) learned later on again. This creates tension between one set of tools and procedures and another, so this detracts from Linux development (less so the more cross-platform are the tools you use).
[Thinking about this now..] I actually think that perhaps a major benefit of FOSS on Windows is to get developers used to the code and coding FOSS. For these "users," the stimulation and potential of source code is large even if the app doesn't work well. In fact, it's greater if the app doesn't work well. And these users may in fact realize that supporting in detail two very distinct platforms is a drag, so as their skills increase, they may likely dump the inferior developer environment that is Windows. [See the discussion of bridges below.]
Additionally, to some extent my views towards porting are similar to towards patents. When the other person doesn't want to play well, and even worse, when there are laws giving them certain rights (so that allowing yourself to be influenced by them can possibly hurt you), then I much prefer simply not to play.
That is my mindset, but I know it is not typical of Jack/Jill. I quickly saw the value of freeware because I was looking already for those sorts of qualities (as a dev mostly) when I came across Linux. In practice, I don't know how far those ideas will go with Jack/Jill, so I necessarily have to try and put myself into a state of mind that is not typical for me (or which I didn't experience at the time I was introduced to Linux).
I think Jack/Jill will "see the light" but we have to get the word out to them through a medium where they will hear it. And you don't need access to that much FOSS to buy into the message of freedom. Let me repeat, ** you don't need access to that much FOSS to buy into the message of freedom **. You just need a proof-of-concept to show you that it is real.
Now for some general comments.
An argument for cross-platform tools:
.. is that it allows those confined to Windows to leverage their skills to code in a way that helps Linux. In this case, we have a bridge that can be used to travel out of Monopolyland.
I agree with this. The "problem" with bridges though is that they can be used to move the other way to. So we'd have to look at particular bridges to see how they are being maintained and traveled.
Giving away free samples:
Usually this is a very good idea. Free samples can be through a LiveCD where perhaps not everything works ideally. It can also be through ports to Windows. My preference by far is for the former, but there are certainly cases where the latter would be the most effective.
Openoffice is a case where not only does Jack/Jill sample goods, they also can rely on these goods to a large extent to save a lot of money that would otherwise be helping to prop the closed platform monopolies. Most FOSS products aren't like OO in having a significant and immediate negative impact to the money flowing to sustain the closed source monopolies.
AND do companies give away free samples that have expired or do they give you a sampling of the best? LinuxLiveCD's come close to giving away the best FOSS offers. Windows ports are near the other end where the samples are stale. If you can't ever truly give great samples on Windows but can surely waste a lot of precious time trying, should you really try?
I think one of the difficulties experienced with the LiveCD path is that a LiveCD is not as good as a pre-load. There are bound to be issues (a pain hurdle), and if help is not there right away to fix the problem, they may abandon the idea. To this end, you want to make sure you can provide help but also that you help Jack or Jill become motivated enough to stick with it ("I can't wait to get this to work"). Execution is important.
Supporting Windows users of FOSS:
I don't know how well I could avoid dealing with people on Windows that were having trouble. There is a tendency to want to help that user if you were already willing to help another and if you "support" the platform. But keep in mind that you really can't deal with Windows that well because it is closed source and the documentation that does exist isn't necessarily accurate (you can't debug the documentation without the source code to the product.. to Windows).
Man, I hate these kinds of arguments because they are so subjective ("he thinks/ she thinks"). Everyone is different and is motivated differently. I guess my main view is that people should realize that porting has a number of negatives that could very well greatly outnumber the positives under many scenarios. And porting is not free by any means. It is costly in developer time, time that could be spent otherwise. Also, improving LiveCDs and execution in using this medium to introduce FOSS continue to be important.
But you can't hold back ports as long as someone is willing to make them (assuming it was a bad thing). The really most important thing is to try and communicate the value in freedomware and this would include *the OS platform* as well as the upper layers.
FWIW, this is a short description of one particular migration:
Here is another migration: http://www.itbusiness.ca/it/client/en/home/News.asp?id=46692
>> "During the migration although there were no issues, like all new things, it faced resistance. But once people started using it, they saw benefits and became fond of it. We won't go back, this is an irreversible process," says P.R.Krishnamoorthy, senior business development manager at Elcot.
Notice that Linux is not that hard to get used to (though in this case there may have been other motivations and not a lot of hard core dependency on Windows for all I know). What is required is to dive into the water (and not waste too much time with toes) and have someone there to help for the initial period.
This may also be useful: http://www.itwire.com/content/view/16376/1090/ . It's about what an Intel rep thinks FOSS devs should do wrt to FOSS drivers. The argument I think boils down to us not working too hard ("bend over backwards") to help out vendors that don't cooperate. When we reverse-engineer a driver, we help the vendor, and the vendor has less pressure to open up. The devs do it for the challenge in part I think.
In summary, no matter from what direction you look at it, MS Windows is a pain in the rear, and it's difficult to figure out who (if anyone) should be helped by providing ports and support, and who simply should try harder to switch to a free OS.
But I didn't start this thread to talk about MS Windows:
Minor nitpick: we have become a support community for free software running on any OS, however the page titles still say "Nuxified GNU/Linux Help Forums".
So why don't we have BSD and OpenSolaris and whatnot in the title?
And yes, some of our members will try to support freedomware ported to MS Windows as well, but don't tell anyone .
Jose I think you got the general point across, that there are disadvantages to porting Freedomware to Windows, and I agree. But while I'm not very passionate for either side of the argument I can see that there are also some positives in porting.
First of all, even for those who port I believe GNU/Linux is definitely a priority if it is the native platform for which they initially developed the software.
If they want to port over to Windows, this means that they are sufficiently motivated and have sufficient time and resources to do this. What motivates them may often be to simply expand the user base and hence general perceived usefulness of their application. Many of them don't act based on some general strategy for spreading Freedomware or GNU/Linux. They have their own motives.
Another point to make is that Freedomware is Freedomware which means that even though Microsoft is able to change the rules, it is not necessarily the original developer which has to strike back with adaptations. It may very well be someone who is a programmer on Windows, within the userbase of the windows port, who will make sure to adapt the program. In other words, while MS has the advantage of being able to change the rules, Freedomware on Windows have the advantage of allowing anyone to modify it and adapt. This could very well make any effort by MS to change the rules fairly futile. Besides I haven't heard of many cases of that happening anyway.
As for how it helps people switch over.. Well, the worst thing for most people is change. When they switch over from Windows without any of the GNU/Linux-specific applications on it they will have to completely change their experience. But with such applications available on Windows they can first start getting used to the whole eco-system of GNU/Linux applications while on Windows and then after they did, it is just a matter of switching the base, Windows out, GNU/Linux in. And when they arrive, they find that they can use all of those free applications now, natively, even better performing and even better looking, but it wouldn't feel that foreign and new, because they've already used those same applications for a while.
Imagine someone using KDE with various other Free Software applications on top of Windows, they'd barely know they're using Windows. So what effort is it for them to switch once they get used to this? Next logical step is to just remove the Windows core and get something like Kubuntu. Interface-wise they wont see a difference, yet the system will run more beautifully.
So they use these free applications while on Windows and get fairly familiar with the GNU/Linux-like way of computing, but they still have an incentive to finally go all the way because they know, now that they've gotten used to it, running all of it native will make it run even smoother and faster. If they don't know this, well, we shall tell them, right here.
Well, this could be added.. not a bad idea.. There's no big hurry though. I'll be rethinking Libervis Network in general these days, including Nuxified.org and keep marketing especially in mind. So when changes get going this too will be fixed.
I'll let what I wrote stand for the most part (I got the message, too, ), but let me add a little bit more here.
People have different motivations and some will in fact eventually get tired while others will not. I am not trying to control anyone, just make it easier for them to become aware of the shortcomings as I see them.
The most important point is as you have stated all along to get people to see the value in freedomware. I would (repeat) add an emphasis that the operating system and all the invisible stuff are a big part of actually having freedom (software is much more adaptable than hardware or else I would be making a bigger deal about the hardware too). It may not be sexy and visible, but the low level stuff holds all the keys because of how frequently the apps that lie above it make calls to it and depend on it. They depend on it totally actually (again, you use Windows calls to access things as basic as files.. and the OS can actually stop you in mid action to analyze what you are doing and also automatically intercepts certain processor instructions.. or all of them if it really wanted to). There are plenty of inefficiencies, "bugs", and other nuissances that would be effected on your program all in the name of security or whatever else happens to be in vogue. At least with Linux (BSD, etc) you know Linus is on your side and you can verify it for yourself.
>> ..while MS has the advantage of being able to change the rules, Freedomware on Windows have the advantage of allowing anyone to modify it and adapt. This could very well make any effort by MS to change the rules fairly futile. Besides I haven't heard of many cases of that happening anyway.
Remember this is Windows we are talking about. It is closed source. It is very difficult to know exactly why software is "misbehaving" when a significant chunk of the software is closed. To diagnose an app you have to be able to diagnose everything all the way down since the error/bug could happen anywhere.
*Even without bad intentions*, any time Microsoft adjusts their code and issues an update, something almost certainly breaks, even if they fixed more bugs than created new ones (which is the case only some of the time) In fact, long established bugs become a part of the definition of library function calls. If you "fix" a bug without warning (or with warning) you break code that had already factored in that behavior.
These things happen with FOSS, too. The difference is that you can become a sleuth and track an error (or change) in software that is not from your project but which you depend on (all the way down to the actual kernel if necessary). On Windows, we hit a brick wall. Microsoft likely tests their own application software very thoroughly with any changes they make to underlying libraries and system code, but beyond these apps or theirs that they test thoroughly ... I'll leave to your imagination.
And notice I didn't even consider Microsoft "bad intentions" for which there is plenty of precedent, documented in court recordings or not (if the companies settled).
Microsoft likely tests their own application software very thoroughly with any changes they make to underlying libraries and system code, but beyond these apps or theirs that they test thoroughly ... I'll leave to your imagination.
I think MS's main beef is with GNU/Linux, not so much with Freedomware in general. If it runs on Windows they are fine because, just as you do, they perceive it as an advantage to Windows. It is applications, after all, that gives most market value to an operating system and it is largely what keeps Windows dominant. I'm not sure Microsoft would like to see their changes badly affect third party applications, even if those are cross platform Freedomware. Chances are, if they want to make sure Adobe programs, many popular "shareware" programs and other things which are popularly used on Windows, work, they would largely make most Freedomware work too, which is depending on the same base as these other applications.
So, not only that I doubt that would do it intentionally, but I think it may be in their own self interest not to meddle that much. And again, I don't actually quite remember hearing about many (or at all) cases where such meddling really happened and really hurt Freedomware.
Look at Firefox for example. Some say it works even better on Windows than on GNU/Linux. This is one case where MS in fact has every motive to somehow make life harder on Firefox, but it didn't seem like they went that far.
And besides, wouldn't any such meddling just earn them more anti-trust legal issues?
[Updated several times within the first 45 minutes of posting]
You have good points, but I have something of a reply. **Roughly** each paragraph (or pair) addresses a unique part of your comment. I did not quote you specifically, but I can go back and do so if you can't figure out what I an addressing.
The anti-trust thing sounds good on the surface, but Microsoft has not stopped. They have been charged and convicted multiple times. They are constantly settling out of court. The EU is after them again just weeks after having finished off a nine year ordeal (not sure about precise time periods). The EU is going slow because that is their nature, but there is material to have gone after them multiple times in parallel.
It's very difficult to be in Microsoft's position and not violate the law. They don't separate the divisions (with a firewall) that work on potentially inter-related software (all software can potentially be inter-related). It's virtually impossible for them not to leverage a monopoly to give a struggling or new product a significant lift. They integrate as much as they can since this increases their value proposition. Gates has sworn up and down about how Microsoft could not be any other way (iirc). Microsoft touts tight integration as a feature.
And as for attempting to keep anti-trust authorities somewhat satisfied, they have deals with Novell and others, but this is a smoke screen. Novell cannot second source Microsoft as long as Microsoft controls the source that goes into Microsoft products, keeping at least some (and likely a whole lot) of source code away from the eyes of Novell engineers.
In the FOSS world, projects constantly discover bugs upstream or in related projects. Now replace these components with closed source and the system breaks down even when everyone is trying to be nice.
In theory you can accomplish some cross help, but it's like working in a team blind-folded. The opportunities to cover your teammates' backs is missing. So all help and reconciliation is slowed down to a crawl, and time is crucial in a highly competitive situation. MS has their bugs under control while we run around like headless chickens trying to meet up with their busy engineers. AND all of this encumberance assuming the best of times, that Microsoft is one of the gang and cooperates as fully as they reasonably can.
If you create a major update to your software (and even a minor update sometimes), it's difficult to imagine that it won't impact others. Microsoft can and will fix their own things, but they can't really fix others' software. Look at how they rushed Vista. They are rushing. Their resources are strained. Let's not make them out to be supermen or clairvoyant.
Their Q&A is clearly suffering (and it was never near perfect). Assuming the best intentions, they are breaking things [Vista was horrendous from what I hear; tons of apps broke.] Does anyone think there is a good chance that things will get much easier for them in the future? I think their focus is on stomping bugs and not on going back to study their public interfaces and find bug fixes they could *undo* just so that test suites that are almost surely much more incomplete than desireable pass with flying colors.
And when they do extend a hand, you have to be very naive to think they would go as far with 3rd parties as they go with their internal subdivisions. In fact, the proof they are not going as far is that they are still hiding the source code. No amount of explanation or documentation (even assuming they do a much much better job than their OOXML documentation) substitutes for the actual source code. They have the source code. We don't. Advantage Microsoft. .. and it does *further* place into doubt their sincerity if they at all try to pass that they are providing a fair playing field.
Microsoft wants 3rd party apps BUT they don't want them to look better than their own when they already have an offering. On the other hand, they DO PREFER to have FOSS devs code for Windows than for Linux. Thus the FOSS apps don't have to be as good as they should/could be, just good enough to keep the devs busy working on them.
Microsoft has targeted Adobe recently. Since I don't use Windows, I don't know what is going on there today. As for the past, I am fairly sure that Adobe has had close deals with Microsoft and has seen much more of their source code than others. Yes, Adobe may have been specifically given an advantage while Microsoft did not have a comparable offering in order to keep Adobe as loyal as possible (eg, with Adobe putting a lot more emphasis on Windows than on Linux).
As for Firefox, I am not one of those saying it runs better on Windows, mostly because I don't use Windows and can't really test it; however, keep in mind that it isn't just Windows that directly affects the comparison. Google and Mozilla have a history of trying to provide superior support for the Windows platform. Am I right or am I right? [This is especially true historically about Google, and they recently gave many millions to Mozilla.] In fact, this is one of the things I would like to have avoided, FOSS devs spending a whole lot of time on the Windows port and neglecting Linux. In fact, *any* time spent on Windows detracts from Linux. [This is an approximation since some devs work on Windows code but would not ever under any circumstances work on Linux code.. and yes, it is their choice.. but I can still vent and plan accordingly, right?]
Finally, Microsoft platform issues tend to happen at strategic moments. At least in the past this was documented. You are correct that Microsoft is probably trying to keep things safe now more than ever. The term bait and switch comes to mind (though it may not apply exactly).
Another note on Microsoft. They learn from mistakes. Shortly after the latest USDOJ trial was over, they developed software and policies to purge internal emails. They were even selling this functionality to other companies. Yeah, this speaks volume. Contrast that with FOSS where every single thing anyone ever said is archived if possible.
So if you haven't heard much recently, you aren't the only one.
[I think I did a decent job in this post of giving Microsoft the benefit of the doubt in many scenarios. The reality is that they can in fact do anything, and we can't know it (except mostly in a limited way and based on fortune). The fact is that their business, pulling in extreme profits enabled by their monopolies, dictates that they be sloppy, secretive, uncooperative, and anything else they can get away with when dealing with 3rd parties when the third party apps compete with any of their offerings. Don't expect me to put my faith and trust in them. It's not happening. I don't even really put it in Linus, but I can see the Linux source and build the software myself and use that. I won't go easy on the Monopolist when I'd hardly give my friends a break. Tit4Tat not Tit4nothing.]
There's no question about not going easy on Microsoft. Of course, when all is said and done the mere fact that they have control of the Windows source code and nobody else gives them an upper hand and us a reason to be wary.
But I think many people who code or port Freedomware for Windows are aware of the risks. They have their motives for doing it. And sometimes those motives do involve the spread of Freedomware, despite all the disagreement about that being a good strategy.
You mentioned bait and switch, well that what they're hoping for nevertheless, despite all the risks. It may just happen to work fine enough for long enough for people to become familiar of the applications and hence more resistant to switching wholesale to GNU/Linux where such applications are native.
And so, again, while there is of course a risk to be recognized, the fact is that even in all these years (decade and more) there have always been small freeware and shareware software coders on the Windows platform. There is an abundance of such software. They are not big companies, often just one man shows, definitely not big enough to have favourable deals with Microsoft, but they did fairly well and were recognized and used by a lot of people. A freeware image viewer I distinctively remember as an example from back in my windows days is Irfan View. An awesome little app at the time, lightning fast and functional - and naturally very popular too.
So if third party software breaks due to the risk of not having access to windows source, all software from small third party providers will then break, not just Freedomware. And if it really did break then something tells me this is just the standard that windows users have come to expect. Besides, blue screens of death aren't so infamous for nothing. In other words, if Freedomware will perform sub-optimally, it's not like it would make a huge amount of difference compared to a lot of other third party software - providing users little or no incentive to conclude that Freedomware is especially worse than other software while still leaving Freedomware enough room to prove itself for its usefulness.
That said.. to each his own. If I were a coder I probably wouldn't bother with Windows myself, unless perhaps I wanted to do a business of support and needed the biggest user base possible while recognizing potential if not assured benefits of porting. As I am, I don't see neither of the ways as perfect within this imperfect context, but not porting is a default. Perfect would be if GNU/Linux became dominant and the whole discussion of porting would become moot - but we're not there yet.
...here is my 0.00 cents worth. Which coincidently is exactly the price I had to pay for my Freedomware OS.
I work with small to medium sized businesses we provide what we call technology consulting. In essence we help them integrate Freedomware solutions whether web based or otherwise, to increase their productivity and streamline their work flow. We connect them with their clientÃ¨le via the web. Pretty fancy huh.
So as you can assume we come across a lot of locked in frustrated even infuriated clients. They do not know of any other way to do things. The bleed squad and their smaller counter parts do not really assist these businesses it is not in their best interest. So they are not only locked in but are being slowly bled by those that they look to for help. It is a very sad state of affairs indeed.
So why do I respectfully disagree with the idea that Freedomware should cease to be developed to work on proprietary OS's? Quite simply I am seeing first hand what happens when I am able to provide relief to these people via Freedomware solutions that run on M$ and Appl$. In most every case there are specific applications that the businesses need to be able to manage their billing or other core piece of their business. I am not talking about Quickcrooks which in most cases is possible to be replaced with GNUcash or SQLedger or..______________. Or made to run in wine or crossover office. Which I have yet to have a reliable experience with. Most of these businesses are truly and completely locked in. Sure there are various emulation and virtua...blah blah blah which is exactly what my clients hear. They just need to get their work done so they can spend more time doing what they really want to do.
Whenever possible I do upgrade them to a Freedomware based OS. These cross platform applications are at the very heart of how we can in good conscience refer to them as Freedomware. These applications that can run most anywhere and on most anything enable us to be ambassadors. They enable us to relieve some if not most of the stress. They provide a means for all of us to build trust with the people around us that are stressed out and frustrated with their computing experience.
There you have it.
This may be a valuable technique/approach:
Apps sell themselves for their functionality and cost savings.
The kernel and other plumbing aren't sold as easily, at least not in the same sexy way; however, the "freedomware" philosophy can be used to help the sell. The customers may not fully appreciate the value of having freedomware working behind the scenes, but they can buy into the idea that the plumbing can possibly be even more important for achieving a break from vendor lock-in. Remember that **all** "FOSS" apps on Windows have a large portion of their functionality (let's say 50% to make things simple) controlled and achieved by closed source Windows.
In the same way that Microsoft may encourage customers to buy all their products even when the (alleged) value is not readily apparent, so too can we try and guide the customer that wants freedom and control to make the move fully to Linux&friends. The dividends come further on down the road. Once you escape, you are free indeed and not subject to some future breakage or change in the rules and costs.
And maybe some of the material presented in (eg) this thread can be useful for arguing the importance of a platform like Linux&Co over Windows (which is closed source).
Remember that what made all of this freedomware with which we're in contact possible were the invisible GNU tools, the invisible kernels, invisible X, invisible standards, and the work of many working on the invisible stuff. Without these, the FOSS we *see* today (KDE and GNOME apps) would not exist. On Windows there was freeware (not freedomware) and this was not leverageable and generally did not keep up with the endless changes in the platform. An apple that is rotten at the core (including seeds) is not really an apple that will take you far. It will take you a bit somewhere, but not too far [The analogy police will be hearing about this one.]
[Also keep in mind that because of the closed protocols, file formats, API's, etc, of many of the surrounding services, freedomware on Windows will require many more closed/lock-in dependencies than if the apps were on Linux&Co in order to achieve comparable functionality.]
Microsoft can do whatever they want. They hold the keys that all applications need and the gates through which they must pass (for apps that run on Windows). But how much do/can they *really* do and get away with?
Let me provide a little bit more discussion on this topic.
From http://www.linuxtoday.com/it_management/2008020601826OSBZSV I'll quote a comment
Subject: Windows best platform for running FOSS
>> Windows Server 2008 as the best platform for running open source applications.
..if you are Microsoft.
As the gatekeeper to all applications that run over Windows, Microsoft particularly likes FOSS for a reason that has nothing to do with the quality FOSS brings.
It's the fact that it is easier to know what a FOSS application is doing than what a third-party closed-source application is doing. Microsoft is in a position to control any application it wants or to gather as much data from them as it wants, but the task is much easier and cost effective when you are dealing with FOSS.
Imagine standard MS certified Firefox binaries. MS would know exactly what was going on because they would have pinned down the particular compilation of an open source product. Then every time you go to Google and Google gets a little information about you, Microsoft will have actually gotten a lot more even when you use Firefox and not IE.
We can even imagine a day where for security reasons most of the conversations are encrypted and "have to rely" on proxy servers. That day, it will be just too easy for Microsoft to harvest data and potentially build more humongous databases than whatever Google would ever be capable of building... well, at least if they preserve their desktop monopoly.
Some of the things Microsoft can do with closed source applications become impractical to do during the course of the user using the desktop. These can span from logging information at some high level (keeping a trail of the major details of what the user does) to actually modifying instructions as the application is run (think of an interactive debugger that allows you to adjust instructions midstream but much faster and automated).
To some degree they already do these sorts of things (logging and filtering instructions), just as Linux does in part with the help of hardware for security reasons (among other reasons).
They can do quite a lot in real-time if they have already pre-analyzed the software. The analyses can happen at their research centers or right inside the PC perhaps while you sleep or are not using the PC and are keeping it mostly idle. Regardless of how they approach this, it is much easier for them to dissect an application that is a specific compilation of a body of source code to which they have access than it is for them to deal with some arbitrary binary (especially if they don't perceive an immediate threat or opportunity).
This isn't sci-fi. Debuggers and many tools and theories have existed for ages. The Java Virtual Machine and other virtual machines work this way. The main difference now and into the future is that the hardware that can do crazy things in real-time or near real time gets cheaper and is possibly available right inside the very PC you buy. The more powerful the hardware, the more that can be done realistically. And the more open the application, the more that can be done by a long shot.
Though the sky may not fall down tomorrow or the next day or the next if you use FOSS or MS apps on Windows, it's probably better to be informed about the possibilities when planning future courses of actions. Some customers may care in some cases but not in others.
Keep in mind 3 things.
1 -- Their past has showed them to be willing to break or twist the law. This is especially true the more they felt they were in a tough bind or the greater the opportunity they sensed. Microsoft is run by humans (in a very privileged position) after all.
2 -- Legally, they might believe they can record/analyze/use/sell/etc virtually any data on you and even alter any data. Their EULA says things to that effect I believe.
3 -- Whenever you hear someone talking about all the horrendous things that Google does or might do, just remember that those possibilities are open to Microsoft just the same and then some. Everything that flows towards or is clicked in Googleland passes through Redmondland first if you use closed source Microsoft software (like Windows XP and especially like Vista which seems to be more tuned to doing things behind your back than is XP).
I don't know.
Fortunately, I have many reasons to stay off Windows.
I really like the fact that everything is just saner and less risky, so that I don't have to worry too much about whether I mind having this or that action spilled out onto the ether or kept in some vault for potential abuse later on.
This privacy concern however may do the trick for customer A or B. This should be particularly useful to government buyers. Take voting software for example. We all know that some voting results are worth millions, even at a smaller scale than "President of the US". The abuse can be in drops over prolonged periods of time, can be done by external agents (if the "holes" exist), and may be much cheaper and more effective than "raising" millions for political campaigns. Sometimes it doesn't take that large a "bug" to gain the needed 1%.
Other customers that may be interested are those that worry they might be caught doing something "improper" (legal or illegal). Who likes to be black mailed?
Remember, Microsoft builds in the holes ("bugs") as they code up the software, but anyone can take advantage. It's all closed source, which means that those that know about the bugs will likely be black hats not white hats.
This post, taken with the earlier comments, helps further clarify the distinction between "platforms" and "apps" as I see it. If there is some inconsistency with what I wrote earlier, please point it out since I am always trying to refine my understanding of the problems FOSS faces and am trying to work out consistent plans.
The subject heading should be "Brian!" If it isn't (Linux Today changes links every so often) then look for such a comment here: http://www.linuxtoday.com/infrastructure/2008020801826OPDTKE
The argument is basically that KDE/Qt over Windows is a good idea (as would be KOffice). I contrast that with porting a Linux app over in a way where the port is bound tightly to other MS platforms and services. With KDE ported... well, read the post.
OK. I'll quote the main relevant portion of it here (since I wrote it anyway).
I see positives to KDE/Qt running on Windows. But that is only part of what it takes to run an app; otherwise, we would not be talking about "porting" KOffice over.
With KDE at least "we" are setting the direction and not trying to keep up with MS GUI "standards."
It's *much* better that people would code for KDE/Qt than for Windows GUI even though there would still many hooks that would be specific to Windows environment.
As for Linux, it has going for it at least that it is a neutral playing ground (you have to like that all else being similar) and is an effort to do something of high quality with no business overhead to deal with.
Maybe KDE over Windows will not run amazingly, but the key would be to get Windows devs to see potential enough to start sampling it. You would have someone not Microsoft setting the tempo and in a way that is transparent and that FOSS would not be whipped off the horse. If enough former Windows devs grow to like KDE while it still works OK on Windows, then Microsoft will have a difficult time getting nasty later on. Also, the pressure is already on MS not to use heavy DRM in order to be able to keep up with Linux efficiency and lightness (MS may not have been told the pressure is on since they keep pushing DRM).
KOffice provides another way to divert revenue from MSOffice.
Anything that helps break the monopolies is good.
Trolltech bought by someone large that wasn't Microsoft may work well.
I think that all infrastructure ports of Linux/FOSS platforms to Windows XP (?) and other old Monopoly platforms is good if that means people will not be pressured to upgrade to new closed source would-be Monopoly platforms. Windows XP is still vulnerable to MS updates which is not good since these change the platform from underneath.
The key I think is to build code that is not specific to Windows if possible. Thus the larger of a layer we can put over Windows and have people be able to code to that exclusively (eg, the comprehensive Java platform), the better off Linux, BSD, etc are.
Comparing Windows XP to Vista: Windows XP is already a monopoly platform pretty much. Also, MS seems to want to abandon it. If it stays fairly static, we have to expect that most "bridges" will have more people leave that ship than go into it (since most are already there). Vista is the opposite in that regard. It holds more surprises and secrets from FOSS and is not established yet.. and is a larger potential future revenue source for the Monopolist than is Windows XP (I would think). We rescue people from the platforms they are already on, before they feel a need to "upgrade" to a worse ship.
Microsoft still has Visual Studio. Through that they can hook applications to Vista or other MS specific technologies in a way that doesn't port. Here KDevelop, Eclipse, NetBeans, etc would be very helpful.
It's important (so that MS has pressure to be good and compete by being fair) that these platforms (KDE, Java, etc) perform well on Linux. If not, Windows devs will tire of the platform layer since it will seem inferior to the MS alternative. If it does work well on Linux, then it not working on Windows will be a bad reflection on Microsoft to some extent.
Poster Adam Williamson said that it might be difficult to get Windows devs to give KDE a shot. Well, Windows devs can be tempted. They can be tempted through knowledge of the benefits of "freedomware," through knowledge of other interesting things that run only or best on Linux, if they find KDevelop and other tools appealing, etc.
KDevelop and other IDE's would need to be easy to use and help the user with as many needs as possible. Nokia may be able to help out here by making it easy to develop for mobiles using Trolltech tools. Another benefit is that using KDevelop and similar tools makes it easier to hedge with Linux for the day MS becomes unbearable to that dev or company.