Jump to main navigation, main content

Archived entry | Matt Wilcox .net

Why Open Source is the future for large applications

Earlier this week a friend of mine tried out Ubuntu to see what all the fuss was about. He didn’t get on with it, and cited some problems he had with the software. Then he stunned me with a conclusion that Open Source can’t work well for end-users and that Commercial software was the only way to get the majority of Average Joe’s to use a program. The discussion ended up developing into an ‘Open Source Development vs Commercial Development’, and the arguments raised by numerous people interested me enough to condense it all into a blog post. For the record, I’m strongly of the belief that Open Source is a very good thing, that it’s impact is already global, and that it has become the only viable solution to developing large applications. Here’s why.

What Open Source is, and how is it different to Commercial development

For those who may not know, Open Source is an umbrella term which is most often understood to mean that the source code of a program is freely available for anyone to look at, alter, use, and re-distribute. There are various derivatives of Open Source license, but that’s essentially what the term means. So, when a program is ‘Open Source’, it’s available for free (no cost) and you can do with it whatever you want. The vast majority of Open Source software is made by volunteers who contribute their spare-time to the software project by coding for it or helping out however they are able. These people are not financially reimbursed for doing this. Because anyone can see the source files and anyone can contribute to the program it’s often the case that Open Source projects of any substantial size develop and improve very quickly. They are usually extremely robust and reliable, and receive bug-fixes and updates at rapid and regular rates.

In contrast, Commercial development is done by a company, which is a closed entity. The source files are kept hidden and no one else can have input of any sort into the project (that isn’t solicited by the Company itself). The people that do the programming are paid for it, because it’s their job. The entire project from start to finish is ‘closed’. When bugs arise they are assessed by the company, and fixed by the company. Commercial programs are most often not free (because they were not free to develop, and because the objective of a company is to make money, which is done mainly through selling a product).

Throughout this article we will be thinking in terms of how these developmental strategies work with regard to large projects. Specifically, how they work when someone tries to make complex software such as an Operating System.

Why developing large applications is hard for companies, but easy for Open Source.

Large applications take a lot of effort, money, and time to build. Windows Vista has a host of criticisms including being three years overdue, it lacking a number of ‘major’ features that had been planned for it, and how it cost a staggering $10 billion in employee salaries alone. The sheer size of modern applications make them hugely expensive to build, and in combination with the time it takes to do so, large projects are a massive gamble for companies. Even now, no one is sure how Vista is doing in the market place, though there are unhappy rumbles, and voiced opinions that this will be the last of its kind. It’s easy to see why - closed source environments are too monolithic to cope with projects of this size. Developing such complex software requires a development process that is agile, heavily tested, and incremental. Taking five years to make one program is five years where you’ve stood still and competitors haven’t. It’s building software while working on the assumptions and ‘best guesses’ made five years ago. Hugely risky. Making matters worse, applications are getting larger and more complex over time as users demand better features, and more of them. This means the time, difficulty, and cost of development can only increase.

In contrast, the Open Source model is much more agile, thorough, and rapid. Ubuntu has major releases every six months, and any number of incremental updates in between. It costs nothing to develop, because everyone contributing is a volunteer. The code itself is of higher quality because it’s exposed to inspection by any number of people. That’s why Linux (which Ubuntu is one distribution of) has such a strong reputation for stability, security, and reliability. The code is more tested. The features Ubuntu gets are the ones that are needed the most at the time of development, not features based on the best guesses of some specification from five years ago when the project was started. The open source model is far less risky.

An example of a smaller project that reaps similar Open Source benefits is Mozilla’s Firefox. This browser is almost single-handedly responsible for Microsoft resurrecting the Internet Explorer development team. Firefox innovated and improved upon a competitor browser that had stood still for five years. The quality of Firefox forced Microsoft out of it’s complacency and into action. IE7 was Microsoft’s answer to Firefox 1, but by the time IE7 managed to stumble out of the starting blocks, Firefox 2.0 had already been released. Even companies with Microsoft’s resources find it hard to keep up with an Open Source development strategy.

How Open Source is economically viable

If Open Source is free to use, and costs nothing to develop - how will this model work for companies? It’s a good question. Microsoft and other commercial software developers currently make money by selling their programs. Open Source development is a system which exists largely without the troubles of money. It’s not designed to make anyone rich, but simply to make the world a better place. Which is a noble thing worth supporting in an of itself. But, if the commercial model of software development can’t cope with projects the size of Operating Systems any more, how will those companies remain profitable? By selling support and services relating to the free products. It’s a model that allows Conanaical to make a profit from Ubuntu, despite the fact that Ubuntu is totally free (as in speech, and as in beer).

Nor need all the programmers lose their jobs - they would still be needed in order to facilitate support, others would be able to work on smaller programs which are better suited to the commercial model, and others would perhaps be employed to donate their code to Open Source projects that Microsoft would sell support for. The latter example is actually something that Conanical already do; employing people to develop code which is then donated to Ubuntu.

Current problems with Open Source projects

Many Open Source projects are tremendously successful. PHP and MySQL are industry standards. Linux is an Open Source Operating System and you will find it used all over the world. It dominates the web server arena (besting Microsoft’s Windows in fact), it’s in smart fridges and cookers, video players, DVD recorders, set-top boxes, mobile phones, palm-tops, printers, airports terminals, and all sorts of unexpected places. It’s there because it suits the requirements better than commercially available software. What you will notice missing from this list is ‘desktop computers’. One of the major problems with Open Source has been it’s level of entry. For the vast majority of instances, Open Source projects are built by expert nerds, for other expert nerds. And that’s a problem for Open Source projects that want popular user acceptance.

Poor documentation

By nature, many Open Source projects are built by experts to address a very specific issue. That expert knows his system because he’s the one that built it - and so it’s very often the case that there is little to no documentation, and no consideration at all for design aesthetics or end-user requirements. For the majority of smaller projects, this will almost always be the case, though this is less so in larger projects. Only the really major projects seem to be well documented (PHP being the only example that springs readily to mind).

If anyone wants their software to be successful, it has to be thoroughly documented, and done so in language that the end user will understand. Not just some techno-babble and an unstated assumption that the user will know that by “edit /usr/file.txt and change the value of Y”, you actually mean “Open up a Terminal by clicking Application > Accessories > Terminal and type ’sudo gedit /usr/file.txt’, then scroll to the bottom of the file and change the value of Y to X”.

Non-existent or out-dated tutorials

For the very same reason that documentation is poor, tutorials are also often missing entirely or fall far below the standard set by corporate offerings. People learn by doing, and while documentation can be enough for some projects, it is not enough for Joe Public. They may require a step-by-step walk-through of how to do a task, not just a terse explanation of a particular program function.

It’s too complex or lacking good user-orientated design

Another problem stemming from the root of ‘expert nerds doing everything’ is that expert nerds are highly unlikely to appreciate how a non-expert nerd would like to use a program. As an example, The GIMP is a very powerful piece of software that is a rough equivalent of Photoshop. It’s a very capable program, but the interface is at best ‘poor’, and more akin to some torture induced nightmare for anyone used to using Photoshop.

Larger projects, and especially ones that are not aimed at fellow experts and programmers, need to be designed, not just built. They need to cater for the end user, and not the guy doing the building, or what the guy doing the building thinks might be logical, because he’s probably not the right guy to make those decisions.

Problems with the image of Open Source

Open source has a poor image with the general public. It’s a term that often lacks any meaning, and even where there is vague recognition of the term there are usually incorrect perceptions about what that means. Some of those perceptions are justified, and some are not, but they all need addressing if Open Source projects are to get major market share in arenas where Joe Average is the end user.

The following are some of the arguments I’ve heard made against Open Source. I think it fair to say that the people I’ve heard making these arguments are experienced computer users, but have not delved too deeply into Open Source as a whole. Their opinions are likely to be reflective of ‘normal’ users, which is something that makes them more interesting and important.

Most open source software seems to rip off paid-for software and present it in a moral way. That is fine - but it doesn’t push anything. […] It seems like most of the people [developing for Open Source projects] never even meet - let alone sit together and think up ideas. It’s real human interaction that makes these things happen - there’s no substitute.

In the early days of computing, this was likely the case. Commercial programs that were nice and small could be ‘copied’ by Open Source coders, often one or two people working from their bedrooms. The free version would be very similar to the commercial one, and because the projects were small they didn’t necessarily innovate. Now that the industry as a whole is much larger, it is rarely the case that Open Source projects are near direct copies of existing commercial software. It’s also the case that there are steering comities and a lot of face-to-face meetings and user-research in large Open Source projects. Conanical takes care of this for Ubuntu, Mozilla does the same for Firefox. It’s a trend that’s spreading as Open Source projects become more complex.

The belief quoted above is that Open Source projects do not innovate, but rather steal ideas. This is wrong. Firefox is a good example of an Open Source project which has innovated far above it’s commercial counterpart (Internet Explorer 6, at that time), offering new functionality and new user experiences. Later on it could be thought that IE7 ’stole’ some of Firefox’s ideas (tabbed browsing being the most obvious). Of course, thinking of it as ’stealing’ or ‘ripping’ would be wrong. Tabbed browsing is a brilliant idea and a rather fundamental one. There are not many ways to handle what Tabbed Browsing achieves except by tabbed browsing itself. Another example of ‘ripping’ is the 3D desktop and file-browser Windows Vista now use. Both were used years before in Linux, and also by Mac OSX. The entire issue of ‘who came up with the idea first’ is rather pointless. The fact of the matter is that good ideas become universal, no matter who first came up with the idea. ‘Ripping’ works both ways, from commercial product to Open Source, and from Open Source to commercial products.

Group meetings, good planning, and innovation all happen in Open Source - but because Open Source’s profile is so low to Joe Public, the impression is often that Open Source rips all its ideas from commercial software.

[…] people have to get paid to do something and those imitating others efforts for free can be undermining the whole industry

To me this shows a lack of understanding of how the Open Source model works, and how it can be profitable. If this view is to be changed then people need to understand how Open Source works from a commercial point of view. After all, this is how the majority of people are used to thinking about this stuff, and many people quickly become suspicious of things that seem too good to be true. Open Source can often seem too good to be true (free software that claims to do everything my commercial software does, that volunteers make, and no one gets paid for it … it does sound odd)

All this rubbish about it being more secure is a load of tosh too - virus writers and hackers can hack anything given enough time. Why don’t they hack Linux et al? Partly because it is geek-o-matic and they love it - and partly because nobody uses it. Why would you try and hack a program 1% of people use - when you can hack something 90% of people use. It’s the same thing with Macs.

Plus - it’s Open Source! Don’t you think hacking something like that would be just a little easy?

Clearly this person has not read any studies into Open Source security, and that will be the case for a large number of potential users too. Such people will be ignorant of why large Open Source projects are often better quality applications than commercial counterparts. I can refute the claims in the above comment with some conviction. As throughout the article, the focus is on large-scale applications, for which I use Operating Systems as representatives. Specifically, Linux for the Open Source development model, and Windows for the commercial development model.

Open Source projects are more secure. Fact. And not because Linux less popular than commercial alternatives either. To prove that point lets observe that Linux and Apache makes up the majority of web-servers, and many sites that require heavy security use Open Source. Going by the logic claimed above, Open Source servers should be the greater target of hacker attention, and ought to be compromised far more than comercial software. But in fact hackers fail more often against Open Source servers than they do against commercial servers. So, Open Source is more secure even in an environment where it is a far bigger target than the commercial competitors.

Linux in particular is also more secure against viruses, not because it’s un-popular, but because it actually is more secure.

While there is most definitely some validity in the claim that people can hack anything given enough motivation, this is meaningless to the argument. The argument raised is ‘which is demonstrably more secure and why, Linux or Windows?’. In report after report, Linux is more secure, because of it’s open source nature and superior programming and code quality. I’ll take a moment to provide a semi-humorous graphic that might explain it visually. Or try a different tack and show why Windows is so insecure.

Why I believe Open Source will succeed

Despite the above mentioned problems, Open Source is constantly developing. Three years ago Linux was almost impossible to use unless you were a total computer tech-head. Today, even I can use it. That’s because of the rapid adoption of user-orientated design in Open Source projects. Next year a total computer virgin will be able to use it. In three years anyone raised on a Windows or OSX machine will be able to use it intuitively without getting frustrated at it.

The great success story, and an indicator of the future for Open Source is, of course, Firefox. It’s something that started with the tech-heads, became adopted by web developers, and has now become accepted in the land of the average user. It’s well documented, powerful, flexible, easy to use, and better than any commercial competition in almost every area. And the best bit is Joe Public doesn’t know or care that it is an Open Source project. Which is the largest indicator of it’s success you could have.

From the archives

Other enteries filed under:

My Two Cents

Site information

Built with valid XHTML and CSS, designed with web standards and accessibility in mind. Best viewed in a modern browser [Firefox, Safari, Opera]

This domain and all content is a copy of my old website, for historical purposes only.