Is the success of Linux directly proportional to its ability to integrate with existing proprietary systems like Windows? If so, should free software developers be spending more time integrating with it instead of building better software for free platforms?
Last week we took a look at proprietary software and how its integration might affect the Linux desktop. Is it good, bad, or somewhere in between?
There are several reasons why proprietary software might be useful to the Linux desktop. People are used to the way it works, it could support proprietary data formats better, it might simply work better.
Why is this an issue? Because if we want users to make the move to free software like the Linux desktop, then we should try and make it as easy as possible.
Linux is gaining in popularity every day. So is solid, open software its strength, or the ability to integrate into the existing Windows monopoly? Perhaps it’s a bit of both.
The importance of fitting in
This whole issue raises a valid point about Linux and free software in general. Should we try harder to fit into the Windows world?
On the one hand, we create free software to scratch an itch. We use it because we like it, not because we’re trying to take over the world (that will be a “completely unintentional side effect,” remember?).
That quote from Linus suggests that displacing Microsoft and gaining market share should not be a primary focus of open source software, although of course he doesn’t speak for everyone. Instead, we should focus on creating great software. As a result of great software and a better way of doing things, users will naturally migrate to Linux over time. However, does that mean that we should ignore the integration issue altogether?
Truly at the end of the day, the Linux desktop doesn’t have to do anything that its developers don’t want it to do. So your games don’t run on Linux. Too bad, it’s not Windows. If you want Windows, then run Windows! If you want a different, reliable operating system, then use Linux – you just might have to leave some of your software behind. We aren’t locked into a proprietary model and don’t have to be.
On the other hand, if Linux can inter-operate with Windows, then it will gain acceptance and adoption at a much faster rate. Like it or not, the world is mostly locked into proprietary software. Take Microsoft Office, for example. How can we expect businesses to switch to free software if they can’t read and write Microsoft formats? How can we expect users to switch to Linux if they cannot connect their iPods and listen to their music?
Various major computer manufacturers have started selling computers with Linux as an option, instead of Windows. If users who purchase these machines cannot use their software, can’t access their data and cannot use their devices, then does Linux really win?
Linux is king of the Internet and has conquered the super computer realm, yet it has hardly made a dent on the desktop. So perhaps in this arena fitting in is important, if we want to make a dent on the desktop market any time soon.
Kicking the habit
Some degree of interoperability is useful, but at what point does it become dangerous? Should Linux be able to play every file format people might use, should it synchronise with every mobile device, media player and palm pilot out there? Should it just work?
Today, we understand how much damage the prevailing vendor lock-in model has done to the computer industry. We know that proprietary data formats are bad for interoperability and ultimately hurt end users. Security expert Bruce Schneier agrees, writing:
“With enough lock-in, a company can protect its market share even as it reduces customer service, raises prices, refuses to innovate and otherwise abuses its customer base. It should be no surprise that this sounds like pretty much every experience you’ve had with IT companies: Once the industry discovered lock-in, everyone started figuring out how to get as much of it as they can.”
How then do we balance the support of the proprietary model with helping end users enjoy free computing. Is it even our call?
Perhaps we shouldn’t be dictating what formats people use at all and just let them make their own choices. Then by the same token, they shouldn’t be dictating what data formats we support. Should we be working to support patent encumbered proprietary data formats to make life easier for those who choose (or didn’t choose) to use them? Or should we aim for liberation through imitation? How many users, after successfully migrating to Linux, converted their entire music collection to a free file format such as Ogg Vorbis? Probably not a whole lot (after all, Linux can play MP3s so why bother, right?).
Personally, whether the Linux desktop integrates perfectly with the Windows world doesn’t make much difference to me. I only use free data formats and avoid products which would lock me into one particular vendor (like an iPhone). I realise however, that this is a luxury I have because I made a choice to be that way. I do recognise however, that it might make a big difference to others.
Where would Linux and free software be today, had we shunned existing markets and completely done our own thing? If Samba didn’t exist because Andrew Tridgell decided that he didn’t care about interoperability with Windows, would Linux have such a great market share on servers and network attached storage? Where will we be tomorrow if we don’t continue to integrate ourselves today?
The Samba project is a useful case study on the benefits of integration. It was written to scratch an itch, that is, to get Unix computers talking with Windows machines over a network. That’s a prime example of free software at work, the result of which is excellent communication between Unix and Windows, and indeed a robust replacement for Windows servers. In line with those words from Linus, Samba didn’t set out to destroy the Windows file server market, that would be a completely unintentional side effect. Then again, the very reason that Samba is successful is because it does integrate.
The Mono project has brought support for Microsoft’s .NET framework (which they are using to try to kill Java and dominate the programming space) to Linux. As a result, we are now seeing more free software applications written in various .NET languages like C#. How do we reconcile using and integrating proprietary platforms with pushing freedom from vendor lock-in? How do we make sure that we don’t shoot ourselves in the foot, long term?
How much should free and open source development focus on integration with proprietary software and platforms? Should Linux distros try harder to integrate into the world of Windows and how much should it do its own thing? On one level, free software must continue to follow its own path – scratch its own itches and innovate in its own right. On a higher level, if it can integrate with the proprietary world, then it will be much more attractive to those coming from that space.
Looking down from on high
Free software has come this far by just being itself. We use it because we like it. Should we be focusing more on integrating with Windows in order to increase market share, or should we just let nature take its course and those who want to switch will? In the end, a majority will “see the light.”
Then again, it’s easy to sit in our current position and ponder whether we should aim for greater integration with platforms like Windows. In truth, we already integrate quite well. We take for granted the fact that we buy a memory stick can actually access the data. Likewise, the ability to write to NTFS volumes, open Word documents, browse networked Windows shares, use calendars on Exchange and even authenticate to Active Directory.
Perhaps it’s time we took a page out of Microsoft’s book and started to “embrace, extend and extinguish” proprietary data formats and software. Integrate ourselves with them, and once we have the power, break them. Aside from the fact that this approach is horrible, nasty and completely unethical, the danger is whether in the end we would actually switch to totally free solutions, or continue to use those old familiar encumbered ones. We might have the market share, but then we’d have a whole new battle on our hands.
One thing is certain, however. Integration with existing systems has helped to rocket the popularity of Linux and make it much more attractive to business, education, government and even end users. If you’re a developer of free software, keep doing what you’re doing. Make great products and the users will come. Consider integrating with existing systems to make your software more attractive, but just don’t lose yourself along the way.
has been using Linux since 1999. In 2005 he created Kororaa Linux, which delivered the world's first Live CD showcasing 3D
desktop effects. He also founded the MakeTheMove
website, which introduces users to free software and encourages them to switch. In his spare time he enjoys writing articles on free software.