English • 中文
在这篇文章中，我将用"Linux"表示GNU/Linux操作系统和各种FOSS（译注：自由、开源的软件，Free / Open Source Software）项目，这样读起来会顺畅些。
- 1 !=
- 1.1 问题一：Linux 和 Windows 根本不一样
- 1.2 问题二 : Linux 和Windows 太不一样了
- 1.3 问题三: 文化冲击
- 1.4 Subproblem #3a: There is a culture
- 1.5 Subproblem #3b: New vs. Old
- 1.6 Problem #4: Designed for the designer
- 1.7 问题 #4 为设计者而设计
如果你跳转到了这个页面，那么十有八九你是一个Linux 的新用户，你正遇到许许多多的麻烦关于如何由Windows 转向Linux，这篇文章的目的正是向新手解释这个问题。由于这个大问题衍生出许多枝节，下面我将对此逐一进行讨论。
问题一：Linux 和 Windows 根本不一样
你一定会惊讶于有这么多人对Linux 发出相似的抱怨，他们奔向Linux，盘算着找到一个免费的，开源版的Windows。通常，这正是那些狂热的Linux 使用者所告诉他们去期待的状况。然而这却是个似是而非的期待。
人们尝试Linux 的原因不尽相同，但所有的原因都可以归结为一：他们希望linux 会比windows 更优秀。正是出于这一点，linux的小成本、更广泛的选择权、高性能和高安全性——当然，还有许多其它的方面——被作为与windows 比较时的衡量标准。往往每一个开始尝试Linux 的Windows 用户都是如此。
太多的人都忽略了这样一个事实：从逻辑上讲，在保持某样东西与被比较体完全相同的前提下，将其做得更好是绝无可能的。正如一个完美的复制品将与它的母版毫无差异，但是它不可能会超越原版。所以当你怀抱着linux 的使用该和windows 差不多的观念而尝试linux ，并希望它能够做的更好，你便会无可避免的发现他们之间的不同，并且把这些不同之处看作是Linux 的缺陷。
举一个简单的例子，让我们来想一想驱动程序的升级吧：通常的情况下，倘若我们要在windows 下升级某个硬件的驱动，我们需要去硬件制造商的网站上，找到并下载新的驱动；然而在Linux 下，我们只是简单的升级内核即可。
这意味着在Linux 下，仅仅一次下载和升级便能提供所有适用的最新驱动，然而在Windows 下我们却不得不浏览多个网站并分别下载升级程序。这是一个不同的过程。并且显然，这决不会是一种糟糕的体验。然而却有很多人对此抱怨不停，只因为这不是他们习惯的方式。
或者从另一个更经常接触到的例子来看，想一想Firefox ——开源软件伟大成功故事中的一个、一个席卷全球的浏览器。它是通过模仿IE ，那个“最流行的浏览器”而取得成功的吗？
不，它的成功是因为它比IE 更好 ， 它之所以 更好 正是因为它 不同. 它有标签式浏览，实时书签，内建搜索条，PNG支持，adblock扩展，以及其他美妙的东西。"查找"工具条显示在底部的工具栏中，它能够查找你键入的内容并且以红色标识表示没有相匹配的内容。而IE没有标签页浏览，没有RSS功能，搜索条只能通过第三方扩展实现，它的查找对话框还得通过点击 "确认"按钮开始查找，而且还要再点击一次"确认"才能清除"未发现" 的错误提示。它明白无疑地证明了一个开源应用程序通过“不同”而做到了“更好”，依靠“更好”进而取得了成功。如果FF是一个IE的克隆，它必然早已微不足道地消逝在了IE的阴影之下。如果Linux 是一个Windows的克隆，同样的事情也会发生在Linux身上。
因此，解决这个问题的方案在于：记住Linux 中那些对于你的使用习惯来说熟悉或相同的部分，Linux 不是 新版的 或 改进版的Windows。 积极地迎接那些不同之处，因为只有不同，Linux才真正拥有闪耀出其光彩的机会。
问题二 : Linux 和Windows 太不一样了
当人们期待着linux 有所特色的时候，又一个问题接踵而至。Linux 和Windows 实在是太不一样了，一些差异简直难以习惯。也许最典型的例子就是可供linux 用户选择的东西实在是太多了。对于一个刚上手的windows 用户，他拥有一个经典 或 XP风格的桌面主题、写字板程序、IE浏览器，Outlook Express；然而对于一个初用linux 的家伙，他面前有上百种发行版供以挑选，此后，是Gnome 或者KDE 或者Fluxbox，Vi 或者emacs 或者kate，Konqueror 或者Opera 或者Firefox 或者Mozilla 或者其他随便什么带来的一系列选择，如此等等不一而足。
Linux 真的 和Windows 有那么大的区别吗？不管怎么说，它们都是操作系统。它们都做同样的工作：操作你的计算机，让你有个东西运行你的应用程序，自然它们多少都有些共通的地方吧？
但是从windows 切换到Linux 就象从开汽车切换到骑摩托车。他们都是 操作系统/道路车辆。他们可能都使用同样的 硬件/道路。他们可能都提供一个运行应用程序的 环境/把你从A处运到B处 。但他们使用本质不同的两种方法达到目的。
Linux/汽车 从根本上用于多用户/乘客. Windows/摩托车 用于单用户/乘客。每个 Windows 用户/摩托车驾驶员每时每刻都要习惯集中精力控制他的 计算机/车辆 . 而一个 Linux 用户/汽车乘客 只要在以根用户登录/坐在驾驶座上时才要习惯去控制他的 计算机/车辆.
通过两种不同的方法来达成同样的目标，他们各有长处和缺陷： 当载上一整个家庭的成员和大包小包的货物从A至B时，一辆车显然是明智的选择： 它有充裕座位以及足够的储存空间。而在单人从A地到B地的旅程中，摩托车则是更好的伴侣：它不怎么会遇上堵塞，消耗的燃油也更少。
一个开摩托人的如果试图通过转移重心来拐弯，很快就会陷入一堆麻烦中。同样的，一个Windows 用户如果认为自己的经验可以直接派上用场，结果也会因为相同的原因而徒劳无获。事实上，较之电脑新手，一个Windows 高级用户在Linux 的使用过程中常遇上更多麻烦。那些根深蒂固的Windows 经验用户在面对问题时如果无法解决，常会觉得“如果我这么有知识的都搞不定，那新手就更不别想了”，因而得出的“Linux离桌面应用还有十万八千里呢”想法也便大错特错。
Subproblem #3a: There is a culture
Windows users are more or less in a customer-supplier relationship: They pay for software, for warranties, for support, and so on. They expect software to have a certain level of usability. They are therefore used to having rights with their software: They have paid for technical support and have every right to demand that they receive it. They are also used to dealing with entities rather than people: Their contracts are with a company, not with a person.
Linux users are in more of a community. They don't have to buy the software, they don't have to pay for technical support. They download software for free & use Instant Messaging and web-based forums to get help. They deal with people, not corporations.
A Windows user will not endear himself by bringing his habitual attitudes over to Linux, to put it mildly.
The biggest cause of friction tends to be in the online interactions: A "3a" user new to Linux asks for help with a problem he's having. When he doesn't get that help at what he considers an acceptable rate, he starts complaining and demanding more help. Because that's what he's used to doing with paid-for tech support. The problem is that this isn't paid-for support. This is a bunch of volunteers who are willing to help people with problems out of the goodness of their hearts. The new user has no right to demand anything from them, any more than somebody collecting for charity can demand larger donations from contributors.
In much the same way, a Windows user is used to using commercial software. Companies don't release software until it's reliable, functional, and user-friendly enough. So this is what a Windows user tends to expect from software: It starts at version 1.0. Linux software, however, tends to get released almost as soon as it's written: It starts at version 0.1. This way, people who really need the functionality can get it ASAP; interested developers can get involved in helping improve the code; and the community as a whole stays aware of what's going on.
If a "3a" user runs into trouble with Linux, he'll complain: The software hasn't met his standards, and he thinks he has a right to expect that standard. His mood won't be improved when he gets sarcastic replies like "I'd demand a refund if I were you"
or the people online who provide the tech support. They don't owe you
Subproblem #3b: New vs. Old
Linux pretty much started out life as a hacker's hobby. It grew as it attracted more hobbyist hackers. It was quite some time before anybody but a geek stood a chance of getting a useable Linux installation working easily. Linux started out "By geeks, for geeks." And even today, the majority of established Linux users are self-confessed geeks.
And that's a pretty good thing: If you've got a problem with hardware or software, having a large number of geeks available to work on the solution is a definite plus.
But Linux has grown up quite a bit since its early days. There are distros that almost anybody can install, even distros that live on CDs and detect all your hardware for you without any intervention. It's become attractive to non-hobbyist users who are just interested in it because it's virus-free and cheap to upgrade. It's not uncommon for there to be friction between the two camps. It's important to bear in mind, however, that there's no real malice on either side: It's lack of understanding that causes the problems.
Firstly, you get the hard-core geeks who still assume that everybody using Linux is a fellow geek. This means they expect a high level of knowledge, and often leads to accusations of arrogance, elitism, and rudeness. And in truth, sometimes that's what it is. But quite often, it's not: It's elitist to say "Everybody ought to know this". It's not elitist to say "Everybody knows this" - quite the opposite.
Secondly, you get the new users who're trying to make the switch after a lifetime of using commercial OSes. These users are used to software that anybody can sit down & use, out-of-the-box.
The issues arise because group 1 is made up of people who enjoy being able to tear their OS apart and rebuild it the way they like it, while group 2 tends to be indifferent to the way the OS works, so long as it does work.
A parallel situation that can emphasize the problems is Lego. Picture the following:
New: I wanted a new toy car, and everybody's raving about how great Lego cars can be. So I bought some Lego, but when I got home, I just had a load of bricks and cogs and stuff in the box. Where's my car??
Old: You have to build the car out of the bricks. That's the whole point of Lego.
New: What?? I don't know how to build a car. I'm not a mechanic. How am I supposed to know how to put it all together??
Old: There's a leaflet that came in the box. It tells you exactly how to put the bricks together to get a toy car. You don't need to know how, you just need to follow the instructions.
New: Okay, I found the instructions. It's going to take me hours! Why can't they just sell it as a toy car, instead of making you have to build it??
Old: Because not everybody wants to make a toy car with Lego. It can be made into anything we like. That's the whole point.
New: I still don't see why they can't supply it as a car so people who want a car have got one, and other people can take it apart if they want to. Anyway, I finally got it put together, but some bits come off occasionally. What do I do about this? Can I glue it?
Old: It's Lego. It's designed to come apart. That's the whole point.
New: But I don't want it to come apart. I just want a toy car!
Old: Then why on Earth did you buy a box of Lego??
It's clear to just about anybody that Lego is not really aimed at people who just want a toy car. You don't get conversations like the above in real life. The whole point of Lego is that you have fun building it and you can make anything you like with it. If you've no interest in building anything, Lego's not for you. This is quite obvious.
As far as the long-time Linux user is concerned, the same holds true for Linux: It's an open-source, fully-customizeable set of software. That's the whole point. If you don't want to hack the components a bit, why bother to use it?
But there's been a lot of effort lately to make Linux more suitable for the non-hackers, a situation that's not a million miles away from selling pre-assembled Lego kits, in order to make it appeal to a wider audience. Hence you get conversations that aren't far away from the ones above: Newcomers complain about the existence of what the established users consider to be fundamental features, and resent having the read a manual to get something working. But complaining that there are too many distros; or that software has too many configuration options; or that it doesn't work perfectly out-of-the-box; is like complaining that Lego can be made into too many models, and not liking the fact that it can be broken down into bricks and built into many other things.
So, to avoid problem #3b: Just remember that what Linux seems to be now is not what Linux was in the past. The largest and most necessary part of the Linux community, the hackers and the developers, like Linux because they can fit it together the way they like; they don't like it in spite of having to do all the assembly before they can use it.
子问题 #3b：新用户 vs. 老用户
Problem #4: Designed for the designer
In the car industry, you'll very rarely find that the person who designed the engine also designed the car interior: It calls for totally different skills. Nobody wants an engine that only looks like it can go fast, and nobody wants an interior that works superbly but is cramped and ugly. And in the same way, in the software industry, the user interface (UI) is not usually created by the people who wrote the software.
In the Linux world, however, this is not so much the case: Projects frequently start out as one man's toy. He does everything himself, and therefore the interface has no need of any kind of "user friendly" features: The user knows everything there is to know about the software, he doesn't need help. Vi is a good example of software deliberately created for a user who already knows how it works: It's not unheard of for new users to reboot their computers because they couldn't figure out how else to get out of vi.
However, there is an important difference between a FOSS programmer and most commercial software writers: The software a FOSS programmer creates is software that he intends to use. So whilst the end result might not be as 'comfortable' for the novice user, they can draw some comfort in knowing that the software is designed by somebody who knows what the end-users needs are: He too is an end-user. This is very different from commercial software writers, who are making software for other people to use: They are not knowledgeable end-users.
So whilst vi has an interface that is hideously unfriendly to new users, it is still in use today because it is such a superb interface once you know how it works. Firefox was created by people who regularly browse the Web. The Gimp was built by people who use it to manipulate graphics files. And so on.
So Linux interfaces are frequently a bit of a minefield for the novice: Despite its popularity, vi should never be considered by a new user who just wants to quickly make a few changes to a file. And if you're using software early in its lifecycle, a polished, user-friendly interface is something you're likely to find only in the "ToDo" list: Functionality comes first. Nobody designs a killer interface and then tries to add functionality bit by bit. They create functionality, and then improve the interface bit by bit.
So to avoid #4 issues: Look for software that's specifically aimed at being easy for new users to use, or accept that some software that has a steeper learning curve than you're used to. To complain that vi isn't friendly enough for new users is to be laughed at for missing the point.
问题 #4 为设计者而设计
Problem #5: The myth of "user-friendly"
This is a big one. It's a very big term in the computing world, "user-friendly". It's even the name of a particularly good webcomic. But it's a bad term.
The basic concept is good: That software be designed with the needs of the user in mind. But it's always addressed as a single concept, which it isn't.
If you spend your entire life processing text files, your ideal
software will be fast and powerful, enabling you to do the maximum
amount of work for the minimum amount of effort. Simple keyboard
shortcuts and mouseless operation will be of vital importance.
But if you very rarely edit text files, and you just want to write an occasional letter, the last thing you want is to struggle with learning keyboard shortcuts. Well-organized menus and clear icons in toolbars will be your ideal.
Clearly, software designed around the needs of the first user will not be suitable for the second, and vice versa. So how can any software be called "user-friendly", if we all have different needs?
The simple answer: User-friendly is a misnomer, and one that makes a complex situation seem simple.
What does "user-friendly" really mean? Well, in the context in which it is used, "user friendly" software means "Software that can be used to a reasonable level of competence by a user with no previous experience of the software." This has the unfortunate effect of making lousy-but-familiar interfaces fall into the category of "user-friendly".
Subproblem #5a: Familiar is friendly
So it is that in most "user-friendly" text editors & word processors, you Cut and Paste by using Ctrl-X and Ctrl-V. Totally unintuitive, but everybody's used to these combinations, so they count as a "friendly" combination.
So when somebody comes to vi and finds that it's "d" to cut, and "p" to paste, it's not considered friendly: It's not what anybody is used to.
Is it superior? Well, actually, yes.
With the Ctrl-X approach, how do you cut a word from the document you're currently in? (No using the mouse!)
From the start of the word, Ctrl-Shift-Right
to select the word.
Then Ctrl-X to cut it.
The vi approach? dw deletes the word.
How about cutting five words with a Ctrl-X application?
From the start of the words, Ctrl-Shift-Right
And with vi?
The vi approach is far more versatile and actually more intuitive: "X" and "V" are not obvious or memorable "Cut" and "Paste" commands, whereas "dw" to delete a word, and "p" to put it back is perfectly straightforward. But "X" and "V" are what we all know, so whilst vi is clearly superior, it's unfamiliar. Ergo, it is considered unfriendly. On no other basis, pure familiarity makes a Windows-like interface seem friendly. And as we learned in problem #1, Linux is necessarily different to Windows. Inescapably, Linux always appears less "user-friendly" than Windows.
To avoid #5a problems, all you can really do is try and remember that "user-friendly" doesn't mean "What I'm used to": Try doing things your usual way, and if it doesn't work, try and work out what a total novice would do.
Subproblem #5b: Inefficient is friendly
This is a sad but inescapable fact. Paradoxically, the harder you make it to access an application's functionality, the friendlier it can seem to be.
This is because friendliness is added to an interface by using simple, visible 'clues' - the more, the better. After all, if a complete novice to computers is put in front of a WYSIWYG word processor and asked to make a bit of text bold, which is more likely:
- He'll guess that "Ctrl-B" is the usual standard
- He'll look for clues, and try clicking on the "Edit" menu. Unsuccessful, he'll try the next likely one along the row of menus: "Format". The new menu has a "Font" option, which seems promising. And Hey! There's our "Bold" option. Success!
Next time you do any processing, try doing every job via the menus: No shortcut keys, and no toolbar icons. Menus all the way. You'll find you slow to a crawl, as every task suddenly demands a multitude of keystrokes/mouseclicks.
Making software "user-friendly" in this fashion is like putting training wheels on a bicycle: It lets you get up & running immediately, without any skill or experience needed. It's perfect for a beginner. But nobody out there thinks that all bicycles should be sold with training wheels: If you were given such a bicycle today, I'll wager the first thing you'd do is remove them for being unnecessary encumbrances: Once you know how to ride a bike, training wheels are unnecessary.
And in the same way, a great deal of Linux software is designed without "training wheels" - it's designed for users who already have some basic skills in place. After all, nobody's a permanent novice: Ignorance is short-lived, and knowledge is forever. So the software is designed with the majority in mind.
This might seem an excuse: After all, MS Word has all the friendly menus, and it has toolbar buttons, and it has shortcut keys. . . Best of all worlds, surely? Friendly and efficient.
However, this has to be put into perspective: Firstly, the practicalities: having menus and toolbars and shortcuts and all would mean a lot of coding, and it's not like Linux developers all get paid for their time. Secondly, it still doesn't really take into account serious power-users: Very few professional wordsmiths use MS Word. Ever meet a coder who used MS Word? Compare that to how many use emacs & vi.
Why is this? Firstly, because some "friendly" behaviour rules out efficient behaviour: See the "Cut&Copy" example above. And secondly, because most of Word's functionality is buried in menus that you have to use: Only the most common functionality has those handy little buttons in toolbars at the top. The less-used functions that are still vital for serious users just take too long to access.
Something to bear in mind, however, is that "training wheels" are often available as "optional extras" for Linux software: They might not be obvious, but frequently they're available.
Take mplayer. You use it to play a video file by typing mplayer filename in a terminal. You fastforward & rewind using the arrow keys and the PageUp & PageDown keys. This is not overly "user-friendly". However, if you instead type gmplayer filename, you'll get the graphical frontend, with all its nice, friendly , familiar buttons.
Take ripping a CD to MP3 (or Ogg): Using the command-line, you need to use cdparanoia to rip the files to disc. Then you need an encoder. . . It's a hassle, even if you know exactly how to use the packages (imho). So download & install something like Grip. This is an easy-to-use graphical frontend that uses cdparanoia and encoders behind-the-scenes to make it really easy to rip CDs, and even has CDDB support to name the files automatically for you.
The same goes for ripping DVDs: The number of options to pass to transcode is a bit of a nightmare. But using dvd::rip to talk to transcode for you makes the whole thing a simple, GUI-based process which anybody can do.
So to avoid #5b issues: Remember that "training wheels" tend to be bolt-on extras in Linux, rather than being automatically supplied with the main product. And sometimes, "training wheels" just can't be part of the design.
Problem #6: Imitation vs. Convergence
An argument people often make when they find that Linux isn't the Windows clone they wanted is to insist that this is what Linux has been (or should have been) attempting to be since it was created, and that people who don't recognise this and help to make Linux more Windows-like are in the wrong. They draw on many arguments for this:
Linux has gone from Command-Line- to Graphics-based interfaces, a clear attempt to copy Windows
Nice theory, but false: The original X windowing system was released in 1984, as the successor to the W windowing system ported to Unix in 1983. Windows 1.0 was released in 1985. Windows didn't really make it big until version 3, released in 1990 - by which time, X windows had for years been at the X11 stage we use today. Linux itself was only started in 1991. So Linux didn't create a GUI to copy Windows: It simply made use of a GUI that existed long before Windows.
Windows 3 gave way to Windows 95 - making a huge level of changes to the UI that Microsoft has never equalled since. It had many new & innovative features: Drag & drop functionality; taskbars, and so on. All of which have since been copied by Linux, of course.
Actually. . . no. All the above existed prior to Microsoft making use of them. NeXTSTeP in particular was a hugely advanced (for the time) GUI, and it predated Win95 significantly - version 1 released in 1989, and the final version in 1995.
Okay, okay, so Microsoft didn't think up the individual features that we think of as the Windows Look-and-Feel. But it still created a Look-and-Feel, and Linux has been trying to imitate that ever since.
To debunk this, one must discuss the concept of convergent evolution. This is where two completely different and independent systems evolve over time to become very similar. It happens all the time in biology. For example, sharks and dolphins. Both are (typically) fish-eating marine organisms of about the same size. Both have dorsal fins, pectoral fins, tail fins, and similar, streamlined shapes.
However, sharks evolved from fish, while dolphins evolved from a land-based quadrupedal mammal of some sort. The reason they have very similar overall appearances is that they both evolved to be as efficient as possible at living within a marine environment. At no stage did pre-dolphins (the relative newcomers) look at sharks and think "Wow, look at those fins. They work really well. I'll try and evolve some myself!"
Similarly, it's perfectly true to look at early Linux desktops and see FVWM and TWM and a lot of other simplistic GUIs. And then look at modern Linux desktops, and see Gnome & KDE with their taskbars and menus and eye-candy. And yes, it's true to say that they're a lot more like Windows than they used to be.
But then, so is Windows: Windows 3.0 had no taskbar that I remember. And the Start menu? What Start menu?
Linux didn't have a desktop anything like modern Windows. Microsoft didn't either. Now they both do. What does this tell us?
It tells us that developers in both camps looked for ways of improving the GUI, and because there are only a limited number of solutions to a problem, they often used very similar methods. Similarity does not in any way prove or imply imitation. Remembering that will help you avoid straying into problem #6 territory.
Problem #7: That FOSS thing.
Oh, this causes problems. Not intrinsically: The software being free and open-source is a wonderful and immensely important part of the whole thing. But understanding just how different FOSS is from proprietary software can be too big an adjustment for some people to make.
I've already mentioned some instances of this: People thinking they can demand technical support and the like. But it goes far beyond that.
Microsoft's Mission Statement is "A computer on every desktop" - with the unspoken rider that each computer should be running Windows. Microsoft and Apple both sell operating systems, and both do their utmost to make sure their products get used by the largest number of people: They're businesses, out to make money.
And then there is FOSS. Which, even today, is almost entirely non-commercial.
Before you reach for your email client to tell me about Red Hat, Suse, Linspire and all: Yes, I know they "sell" Linux. I know they'd all love Linux to be adopted universally, especially their own flavour of it. But don't confuse the suppliers with the manufacturers. The Linux kernel was not created by a company, and is not maintained by people out to make a profit with it. The GNU tools were not created by a company, and are not maintained by people out to make a profit with them. The X11 windowing system. . . well, the most popular implementation is xorg right now, and the ".org" part should tell you all you need to know. Desktop software: Well, you might be able to make a case for KDE being commercial, since it's Qt-based. But Gnome, Fluxbox, Enlightenment, etc. are all non-profit. There are people out to sell Linux, but they are very much the minority.
Increasing the number of end-users of proprietary software leads to a direct financial benefit to the company that makes it. This is simply not the case for FOSS: There is no direct benefit to any FOSS developer in increasing the userbase. Indirect benefits, yes: Personal pride; an increased potential for finding bugs; more likelihood of attracting new developers; possibly a chance of a good job offer; and so on.
But Linus Torvalds doesn't make money from increased Linux usage. Richard Stallman doesn't get money from increased GNU usage. All those servers running OpenBSD and OpenSSH don't put a penny into the OpenBSD project's pockets. And so we come to the biggest problem of all when it comes to new users and Linux:
They find out they're not wanted.
New users come to Linux after spending their lives using an OS where the end-user's needs are paramount, and "user friendly" and "customer focus" are considered veritable Holy Grails. And they suddenly find themselves using an OS that still relies on 'man' files, the command-line, hand-edited configuration files, and Google. And when they complain, they don't get coddled or promised better things: They get bluntly shown the door.
That's an exaggeration, of course. But it is how a lot of potential Linux converts perceived things when they tried and failed to make the switch.
In an odd way, FOSS is actually a very selfish development method: People only work on what they want to work on, when they want to work on it. Most people don't see any need to make Linux more attractive to inexperienced end-users: It already does what they want it to do, why should they care if it doesn't work for other people?
FOSS has many parallels with the Internet itself: You don't pay the writer of a webpage/the software to download and read/install it. Ubiquitous broadband/User-friendly interfaces are of no great interest to somebody who already has broadband/knows how to use the software. Bloggers/developers don't need to have lots of readers/users to justify blogging/coding. There are lots of people making lots of money off it, but it's not by the old-fashioned "I own this and you have to pay me if you want some of it" method that most businesses are so enamoured of; it's by providing services like tech-support/e-commerce.
Linux is not interested in market share. Linux does not have customers. Linux does not have shareholders, or a responsibility to the bottom line. Linux was not created to make money. Linux does not have the goal of being the most popular and widespread OS on the planet.
All the Linux community wants is to create a really good, fully-featured, free operating system. If that results in Linux becoming a hugely popular OS, then that's great. If that results in Linux having the most intuitive, user-friendly interface ever created, then that's great. If that results in Linux becoming the basis of a multi-billion dollar industry, then that's great.
It's great, but it's not the point. The point is to make Linux the best OS that the community is capable of making. Not for other people: For itself. The oh-so-common threats of "Linux will never take over the desktop unless it does such-and-such" are simply irrelevant: The Linux community isn't trying to take over the desktop. They really don't care if it gets good enough to make it onto your desktop, so long as it stays good enough to remain on theirs. The highly-vocal MS-haters, pro-Linux zealots, and money-making FOSS purveyors might be loud, but they're still minorities.
That's what the Linux community wants: an OS that can be installed by whoever really wants it. So if you're considering switching to Linux, first ask yourself what you really want.
If you want an OS that doesn't chauffeur you around, but hands you the keys, puts you in the driver's seat, and expects you to know what to do: Get Linux. You'll have to devote some time to learning how to use it, but once you've done so, you'll have an OS that you can make sit up and dance.
If you really just want Windows without the malware and security issues: Read up on good security practices; install a good firewall, malware-detector, and anti-virus; replace IE with a more secure browser; and keep yourself up-to-date with security updates. There are people out there (myself included) who've used Windows since 3.1 days right through to XP without ever being infected with a virus or malware: you can do it too. Don't get Linux: It will fail miserably at being what you want it to be.
If you really want the security and performance of a Unix-based OS but with a customer-focussed attitude and an world-renowned interface: Buy an Apple Mac. OS X is great. But don't get Linux: It will not do what you want it to do.
It's not just about "Why should I want Linux?". It's also about "Why should Linux want me?"