In most cases I agree with Ryan. Since anyone can read his text (or its Polish translation here) I won’t put my comments here. I would rather write something about the idea of comparing Linux to Windows or MacOS. According to Ryan, such comparisons are pointless. He tried to prove this, but I cannot agree with him in this area, so I decided to write this rebuttal.

I’d like also to bring up a much broader subject, which can be viewed as a software developing philosophy. In my opinion, it’s very important because of arguments I’ll try to present in the last part of this text.

How Ryan sees FLOSS

Ryan’s opinions on FLOSS aren’t original at all, and it’s nothing wrong with that. He thinks that FLOSS can make user active in the process of software development, while in the case of closed, proprietary software (or even freeware), user is only a spectator. Windows user can make use of this system, but he cannot modify it, and has very limited influence on the way this system behaves and works.

Of course, not only Ryan is of such opinion on FLOSS. Many people think this way. I have chosen Ryan only as an example, because I have translated his text into Polish. (Ryan, I hope you don’t mind me treating you this way!)

Ryan also points that FLOSS users shouldn’t be regarded as clients, since meeting clients needs is not what FLOSS is about. FLOSS focuses on the needs of tinkers and tweakers, who want to improve software.

Arch for its developers

A similar point of view can be found in a thread on the official Arch Linux forum. A few Arch Linux users (including myself, but the topic was closed after I posted my opinions; it might prove that I bring bad luck ;)) were complaining about the quality of some packages. Some other Arch Linux users explained that Arch Linux is available for free, no one pays them for working on this system, so people should get to work and fix the bugs themselves instead of making demands.

In the mentioned thread I have written a few words on the topic of relations between users and developers (I’m going to explain this idea in greater detail in this text), and I got some answers. I have found one of them, written by neotuli, especially interesting. Unfortunately, I wrote that post on June the 18th this year, and my PhD thesis exam was planned on June 25th… So, it took me some time to get ready to at least partly answer to this very interesting point of view of one of the Arch developers, but here you are!

The DIY (”do it yourself”) philosophy

Ryan, as well as the mentioned Arch developers, seems to follow a similar philosophy. I think I understand it, although I don’t follow it myself. I believe that it’s necessary to describe it very well, though, and I’m going to do it in this point.

I’m going to start with explaining the point of view of the Arch developers, and also of some of the official Arch forum users. The Arch Linux (as well as many other distributions - Arch is only an example!) is free software and an open project. Anyone can participate, anyone can take Arch and freely modify it. It means that I need no Arch developers’ “blessing” to do such changes - I can do it on my own, by myself! Of course, the Arch developers probably will ask me to join them, provided that I prove I’m good at it, and show that want to do it for free.

The rules can be applied to a vast majority of FLOSS projects, if not all of them. It is just like Ryan has written: you can pick it up and use it, provided you obey the GPL license.

The Arch developers are right when they point out that no one has any right to demand something from them, to treat them like commercial software vendors, since they aren’t paid for what they do, and they do the work for their own satisfaction (to gain some experience, learn something, or just for fun).

Well, I have to admit that I agree with this point of view. When I do something for my own satisfaction and someone wants to use my work, he has to realise that I won’t be available at his back and call. If there are some bugs in my software, which are a pain in the neck for its users, and I want to focus on implementing new features instead of fixing those bugs, I can always say: you don’t pay me for doing my work, but you have the sources, so make use of it and do it yourself! You have the right to do it, since it is free software!

This is what I call the “do it yourself” philosophy, seemed to be followed by so many people from the FLOSS community. I noticed a similar behaviour a few years ago, while reading posts written by people participating in the PLD distribution development. The distribution had a very good reputation then (perhaps it still has such a good reputation; I don’t know since I haven’t been looking for any news on this distribution for a long time) and thus many people were interested in it. Some of them were pointing out various bugs and saying that PLD is short on something. Those opinions had started many rants, most of which had the same conclusion: the PLD distribution is a distribution for the PLD distribution developers (since the casual users opinions just don’t matter…).

Of course, many names could be used for this philosophy. It could’ve been named “don’t spoil my fun”: I do what I do because it’s funny, so don’t spoil this fun. Don’t use it if you don’t like it, but don’t cry saying that it doesn’t work as expected! An alternative name, which also could’ve been used, is “I don’t care about you, user”. You don’t pay me for doing it, so why should I work for you, for free?

Those names are more adequate (at least in my opinion), since they make clear the rules that Ryan wrote about, to end user. They are also much more negative, though. Therefore I think it’s better to use the “do it yourself”, especially nowadays, when positive marketing messages count so much. It can be optionally extended to “if you don’t like it, or miss something, do it yourself”.

I think I have written enough about this way of FLOSS software development. It’s time to write something about its implications.

First of all, developer is the most important person. He’s the one who makes all the decisions about the directions that the software will be developed in. If a user doesn’t participate in the process of software development (e.g. by sending bug reports, testing, or sending patches), none will care about his opinions. Thus, the rules are simple: if you play, you can try to influence the game, but if you don’t, then sit down and shut up.

Such a situation should encourage people to take part in the game, at least in theory. If only players are allowed to speak up… In practise, many things might happen. Some people just get in the game, while others remain still spectators, and sometimes dare to say something (with various effects). There are also people who don’t want to play this game, and perhaps don’t get the rules. Those just leave the scene and go away looking for a better place for them. A place where they will be allowed to speak up, or they will think that they are.

The problem with FLOSS is that it’s not the game, but many different games. My text editor is a one of them, my terminal emulator is another one. There are many games, which are important for me, and even if I took a part in one of them, I wouldn’t have any significant position in the other ones.

I discovered LaTeX when I was writing my PhD thesis. Today I use Texmaker in order to edit my LaTeX source files, although I find it far from being a perfect tool. But it became a very important piece of software for me, so I decided to take the matter into my own hands and enhance it. I get in this game, but I use also the Arch Linux, which is a quite different game… And since I’m not a part of the Arch Linux game (because of lack of time and urge to be a part of it), my opinion isn’t important for the Arch Linux developers. This FLOSS is a lousy deal, isn’t it?

Despite all I have written above, it would be a mistake to think that this way of software development is wrong. Although I find the Arch Linux less and less suited for my needs, I still use it, just as I use a lot of other software, not participating in its development. Why am I doing it? Well, perhaps Arch is not perfect, but in my opinion other OSes are much, much further from this perfection. I will cite a phrase I found a long ago, while browsing the Mutt’s homepage: it sucks less. And don’t forget about the very attractive price of Arch!

Sometimes I obey to these rules myself, despite the fact I follow a different philosophy, which is described in the next point. As I have mentioned, I work on enhancing Texmaker. I have my own to-do list, and I don’t care about the other users, who might want to enhance Texmaker in some different way, but they can’t since they can’t do C++ programming. Well, my dear user, I don’t care about your needs. I do what I do because it’s something I need myself. If you have a problem… Well, it’s your own problem. I could’ve taken care of your problem only I you have paid me enough to do it (because my wages aren’t minimal).

Well, live is brutal. Even in the FLOSS world.

The free-market philosophy

Personally, I contrast the “do it yourself” philosophy with a different one. I call it a “free-market” philosophy. The name originates from the rules, which are similar to those on the free-market economy. Of course, the effects of applying those rules are also similar! I find the free-market philosophy the right one to follow.

For those, who don’t know the basics of economics, I can explain the rules of free-market economy. Everything is up to the consumer, sometimes called also a client: he’s the one who decides what he’s going to spend his money for. Producers have to compete for his choices. The best ones are successful, their businesses are profitable because consumers are happy with their products and services, and freely give them their money for those products and services. The other producers, who aren’t that good, don’t make such profitable businesses and are eventually made to get some other job. In such a system, consumers are offered better and better products and services again and again.

I hope Ryan won’t quiver with anger (because of using this awful business language) while reading it…

But more seriously: the same rules can be applied to the FLOSS software. Users will be more willing to use the software we develop, provided that we treat them as our customers. Of course, they will choose what they find the best for them, and they won’t hesitate telling us that our GUI sucks, and some feature is broken. And when they will upset us, and we ask them why they use our software at all, if it sucks, they will tell us that our software sucks, but it sucks less. Or that it has some feature that other software lacks.

The advantages of such a way of software development should be quite obvious. First of all, it’s easier to get some users for our software. If user thinks that his needs are important for developers, that he can speak up loud and developers will listen to him, that his opinion really matters, he will be happy to use the software. Such a user is a real gem: he will not only use our software, but also recommend it to his friends. And if our software is still not good enough, this user won’t forget our attitude and will be more willing to try it out later. A satisfied user is a satisfied consumer - it’s better than advertising campaign!

I doubt there is any need to explain not-marketing advantages of such a philosophy to someone who knows the famous words of Eric S. Raymond: “Given enough eyeballs, all bugs are shallow.”.

But the possibility to gain more users is not the only advantage of this “free-market” philosophy. While treating their users as their customers developers can get invaluable business experience, which might be very useful in their job, or while running their own business or startup. (And if the idea of making money makes you angry, please answer the question: who pays your internet bills and where comes this money from?)

This advantage can be bound with another one: it’s easier to switch to a different business model of software development. Yes, I’m talking about the possibility of setting up your own business (or startup), just like Trolltech does. Just think about it: wouldn’t it be great to be paid for doing something you like to do?

There are also some disadvantages, of course. The most important one of them is moving developer aside, as the result of making consumer the most important person. If consumer’s needs are the most important thing, then the developer’s role is to serve consumers. The software should be developed in the direction set by the consumer, not by the developer. And what if the developer thinks of something different? What if he is interested in something else? Well… If he doesn’t have enough of perseverance, he might lose all interest in further development of the software. In the extreme case it might lead to stopping whole development. Well, it happens - if it’s not funny and no one pays me for doing it, my motivation to work further might drop…

To sum it up: on the one hand the project might gain more users, and on the other hand it might lose its developers, resulting in development freeze, which leads to lose its users who will likely choose something else. It’s a lousy deal, isn’t it?

In my opinion, a good solution to this problem is… the human nature. We just like to be admired and famous. The project is good enough? It has many users? Its developers are getting bored with it and are leaving it? So I can have my chance. I am a young lion, seeking for a chance to gain the fame. I’ll take this project over, or join the developers team (provided there is still some team to join), and then I’ll develop it further, maintain it, gain all the users gratitude, and have something to write in my CV…

And now the conclusions

Although the two ways of software development have been described as an opposing ones, they shouldn’t be viewed as such. They are colliding just in one aspect: in treating the end user. “Do it yourself” promotes only those users who join the group of people working on the software development. The “free-market” promotes the end users only, making their needs the most important factor.

Of course, you can have a different point of view on this problem. Ryan and the Arch developers probably have… I prefer the way I have just described, because first of all I am a user. Although I can write code for myself, although I try to enhance existing software written by other people, I’m still just a user in 99% of cases. A spectator, who just watches the played games and tries to choose the most interesting ones.

I believe we can make the best use of our computers when we want them just to work, in the way we want them to work, or at least in the way we can accept it. It’s similar to all other things we use: cars, TVs, refrigerators… Personally, I don’t care about the way my car, my TV, or my refrigerator works, all I want is all these things just work! And that’s what I want from my computer - it should just work, make my work easier. I’m not happy when it’s not.

However, there is one, essential difference between Linux and a TV or a car. I have paid for my TV much more than I have paid for my Linux. Yet I still have similar demands from these things, though… It all should just work.

But is it logical to expect that as a user of my OS, that I got for free, I’ll be treated like a customer, who bought a TV or a car? Haven’t I lost my mind?

In my opinion, I haven’t.

And it is because of one reason: competition. This is competition between TVs and cars producers, and this is competition between free (and freeware) software developers as well. Because of this competition there are products which are chosen more often that the others, and producers (including developers) have to continuously make their offer better and better, in order to stay in the market.

This competition is also present in the Linux world: Vim versus Emacs, or KDE versus GNOME are only two examples. If we took a broader look at the IT world, we could notice that the development of various OSes is full of competition: while Windows was gaining more and more ground, Linux desktop was being made better and better. The truth is that many features present in various Windows versions were just copied from MacOS (which is, in my opinion, better than the OS made by Microsoft)…

Competition is the driving force behind this progress, whether we like it or not. In the business world we compete in order to gain more customers and make our profits higher and our markets bigger. In the FLOSS world we compete in order to gain more users and more advocates for our solutions. This competition really exists, and it’s something good for us, regardless of what the reasons of this competition are.

Because of this competition, you can have influence on the software development even if you don’t participate actively in this process. I used to use Firefox, KMail, I used to burn CDs and DVDs with growisofs (I think), using a terminal emulator. Nowadays I use Opera and burn CDs and DVDs with k3b. The applications from KDE have been slowly replacing those from GNOME, and IceWM have replaced FluxBox. Perhaps Ubuntu will have replaced Arch in the future?

Nothing lasts forever, we can be sure of that. If I use the application X today, I might switch to its competitor Y tomorrow, and the developers of X, who are telling me to shut up because I don’t actively participate in the development of X, should realise that. They might lose a user, who could report some bug in the future. The more a user used to a program is, the more motivation to act like this he has. But he has to be encouraged to try and use this program first!

Why you can compare Linux to Windows and MacOS?

Now I got to the point where I can start my polemics with Ryan again, on the topic of comparing Linux (I avoid the GNU/Linux form, popular in the FLOSS world; I’m going to explain it later) to Windows or MacOS. According to Ryan, they are two different games: a commercial (Windows and MacOS), and FLOSS (Linux), two different goals, and you cannot measure the success of Linux in the term of meeting (common) users needs because Linux doesn’t even try to meet them.

It seems to be right: how could you measure the success of Linux in the term of gaining larger user base, or larger market share, if the Linux developers don’t even try to satisfy these goals? It would be like judging a soccer team by the way how good they are at playing volleyball, and judging a volleyball team by the way how good they are at playing soccer. It’s pointless, of course.

It’s not so simple, though. I think that it’s all about the point of view. There are people in the soccer team, who are good soccer players and poor volleyball players. In the volleyball team the situation is opposite, but all of these people are sportspersons and thus we can compare their individual achievements and sporting conduct… It’s not pointless anymore, is it?

In the same way you can compare Linux to Windows or MacOS. These OSes developers have different goals, but regardless of those goals these OSes are being used by various users. The end user doesn’t have to share the same goal, he just sees these products and compares them according to his own needs. The end user judges the products by his own terms!

I have done this myself. I have never liked Windows. I have never understood this system, I have never been able to control it. My story with Linux is quite different. At the beginning, I didn’t understand this system as well, but I had a documentation which I started to study. I have learned how this system works (in rather narrow scope; I haven’t needed more knowledge on this topic), I can control it - and I like it. Working under Windows, I feel lost, so the choice is quite obvious for me.

The arguments that Linux is not ready for desktop, because it can’t play MP3s, OGGs and AVIs out-of-the-box, are ridiculous, of course. Windows also can’t play OGGs and AVIs out-of-the-box, and nobody says it’s not ready for desktop!

The idea of comparing Linux and Windows is not a bad one, or ridiculous, though. On the contrary, it might be very stimulating and enlightening! For example, you might find out why Linux is less popular and has opinion of more difficult and complex system than Windows (although, in my personal opinion, it’s otherwise).

Ryan (I still use this poor man as an example ;)) consistently uses the name GNU/Linux. I know what it means, of course, but the end user doesn’t understand this weird name: what’s this GNU? And don’t somebody dare to explain it to him, because things will get much more complicated then…

Explaining a common user the difference between operating system’s kernel and its basic software is pointless, just as is explaining a common driver how many pistons there are in his car’s engine, and which kind of pistons they are. What are those pistons? I don’t know, and I don’t care. My car is supposed just to work, you know. And so is my computer. So stop talking about this GNU/Linux, because Linux is all I want!

If gaining more users of Linux (which might take more active part in FLOSS software development in the future) is what we want, then let’s simplify. Let’s leave this GNU/Linux for the techies and fanatics like RMS. For me, my Linux is just a Linux. It’s hard enough to explain that other Linuxes might differ in the way they look and behave…

(It’s just like with this preaching that FLOSS is better than closed software. End users just don’t care! Most of them want their software to work, they don’t need it to be “open”, they don’t make any use of sources!)

But let’s get back to the idea of comparing Linux to Windows. My argument is simple: they can be compared, when we look at it from end user’s point of view. If you can do something under Windows, and you can do the same thing under Linux, you can compare these two solutions. And it won’t be comparing of apples and air. Get it?

The final conclusion

In the end, I’d like to write something about this treating a viewer like a client, a cash machine. I have no doubts this is rather a common procedure. In opposite to Ryan, I don’t see it as something wrong. Personally I like to be treated like a client, because it makes me the one who makes the rules. If I won’t like the way I’m treated, I’ll choose another producer. The cost of my internet connection has been the same for years, while its parameters were getting better and better, and it’s all due to the fact, that I’m a client (this cash machine) of my internet provider. In another words: my life is getting better and better!

But let’s forget about my personal opinions and views. It’s all about a perspective, about a point of view on the whole situation. Companies might treat their clients like cash machines, or in any way they want to treat them, it’s all up to them. The most important thing is that the clients themselves don’t have to care about it at all! A client don’t have to care about a producer’s or a service provider’s goals, he has his own goals and needs, and he might choose a product or a service for quite different reasons that those producers and service providers think!

In fact, this is my case. I don’t like my internet service provider, yet I’m their client, because those bastards are simply the best in my vicinity.

And people use software in the same way. They don’t care about the fact, that a software producer treat them like a cash machine. Everything is all right, as long as they can have the software they need, for the price they accept (and they accept the price, since they buy the software!).

And it’s the same in the FLOSS world. I am an end user, and I don’t care about the developers’ goals. I use the software because it’s good, or because it’s better (or because it sucks less). I don’t care about the access to the source code, about the freedom of modifying and redistribution of the software… I’m not a software producer! I’m a software user and all I want is to have a working application. As long, as it works, I use it and I’m happy.

Of course, you can say that there’s Linux on one hand, and there are Windows and MacOS on the other hand, and that they’re not in the same game. And you’re right! But don’t forget that all these games are being watched by the same people. Those people have their own needs, regardless of the way we see them (as clients, or as people). And you can compare Linux, Windows and MacOS as long, as those people will use all of them to meet their needs.

Of course, you should compare those OSes in a proper way, because complaining that AVIs don’t play out-of-the-box is ridiculous

With thanks to Ryan Cartwright for his great, insightful text (read it here: Don’t compare GNU/Linux with Windows or MacOS - they are not in the same game),
With thanks to Arch Linux developers for their great operating system I have been using for many years,

Tomasz Primke