Really, I’m not out to destroy Microsoft. That will just be a completely unintentional side effect.
Linus Torvalds, 2003

wordpress html m5ecfd92
The Linux mascot, Tux, created by Larry Ewing

The kernel of an operating system (OS) is the central nervous system of a computer. It is the first piece of software that the computer executes, and it manages and mediates access to the hardware. Every piece of hardware needs a corresponding kernel device driver, and you need all of your drivers working before you can run any of your software. The kernel is the center of gravity of a software community, and the battle between free software and Windows is at its lowest level a battle between the Linux and Windows kernels. Microsoft has said that it has bet the company on Windows, and this is not an understatement! If the Windows kernel loses to Linux, then Windows, and Microsoft, is also lost.1

The Linux kernel is not popular on desktops yet, but it is widely used on servers and embedded devices because it supports thousands of devices and is reliable, clean, and fast. Those qualities are even more impressive when you consider its size: printing out the Linux kernel’s 8,000,000 lines of code would create a stack of paper 30 feet tall! The Linux kernel represents 4,000 man-years of engineering and 80 different companies, and 3,000 programmers have contributed to Linux over just the last couple of years.

That 30-foot stack of code is just the basic kernel. If you include a media player, web browser, word processor, etc., the amount of free software on a computer running Linux might be 10 times the kernel, requiring 40,000 man-years and a printout as tall as a 30-story building.

This 40 man-millennia even ignores the work of users reporting bugs, writing documentation, creating artwork, translating strings, and performing other non-coding tasks. The resulting Linux-based free software stack is an effort that is comparable in complexity to the Space Shuttle. We can argue about whether there are any motivations to write free software, but we can’t argue it already exists!

One of the primary reasons I joined Microsoft was I believed their Windows NT (New Technology) kernel, which is still alive in Windows Vista today, was going to dominate the brains of computers, and eventually even robots. One of Bill Gates’ greatest coups was recognizing that the original Microsoft DOS kernel, the source of most of its profits, and which became the Windows 9x kernel, was not a noteworthy engineering effort. In 1988, Gates recruited David Cutler from Digital Equipment Corporation, a veteran of ten operating systems, to design the product and lead the team to build the Windows NT kernel, that was released as I joined in 1993.

The kernel Cutler and his team developed looks like this:

wordpress html 44a39cc6
Windows NT kernel architecture block diagram. Cutler had a Windows 95 doormat outside his office; you were encouraged to wipe your feet thoroughly before entering.

Unfortunately for Microsoft, the original kernel lived on through Windows 95, Windows 98, and into Windows Me. (Microsoft also had Windows CE, a small kernel for embedded devices. Microsoft had three separate kernels for most of my tenure, whereas the same Linux kernel is used on small and big devices.)

Windows has become somewhat popular for servers and devices, but it never achieved the dominance it did on desktop PCs. Perhaps the biggest reason is that its code wasn’t available for others to extend and improve upon. The Linux kernel took off because there are people all over the world, from Sony to Cray, who tweaked it to get it to run on their hardware. If Windows NT had been free from the beginning, there would have been no reason to create Linux. However, now that there is the free and powerful Linux kernel, there is no longer any reason but inertia to use a proprietary kernel.

There are a number of reasons for the superiority of the Linux kernel. But first, I want to describe the software development process. When you understand how the Linux kernel is built, its technical achievements are both more impressive and completely logical.

Distributed Development

In Linux we reject lots of code, and that’s the only way to create a quality kernel. It’s a bit like evolutionary selection: breathtakingly wasteful and incredibly efficient at the same time.
—Ingo Molnar, Linux kernel developer

wordpress html m62e1158e
A portion of the speaker list for the 2006 Linux Kernel Symposium the author attended. Linux kernel development is a distributed effort, which greatly enhances its perspective.

Every 20th century management book I’ve read assumes that team members work in the same building and speak the same language. Microsoft’s corporate culture was based on the theory that software development was a collaborative effort that should be centralized so that people could work together. As a result, most Microsofties, especially the programmers, were based in Redmond because that was where all the other engineers were located.

Microsoft had a very open development model inside the company: developers would periodically switch teams, collaborate freely together on unreleased code, and join e-mail discussion groups with engineers in similar product roles. These resources of collaboration are some of the many which are unavailable to those outside.

A software program is basically a bunch of human-readable text files, compiled together into a machine-specific binary. When just one person is working on the codebase, things are easy to manage, but when you have multiple people, you need three more tools:

A source control system which records all changes, analogous to the History tab that exists at the top of every Wikipedia page. This provides many capabilities such as going back to find out when and why a code change was made.

A bug or issue tracker keeps a to-do list. This keeps track of the problems over time, and as people leave.

A communications mechanism (in-person, email, chat or forums) where programmers can discuss how to implement features, and work together to troubleshoot problems.

Larger teams have developed more formal processes to, for example, get consensus on when someone is given permission to make changes to source code, but the basic development process in the free software world is little different than what takes place at Microsoft.

The Internet, which was born when Microsoft was a mature company, has changed countless aspects of our lives, including the way software can be developed. Without the Internet, free software could never exist because the developers wouldn’t be able to work together. (Microsoft uses the Internet to do development in other places, although it is still primarily in Redmond.) Microsoft grew up before the birth of the web, and thus has yet to fully embrace this distributed process. For example, Microsoft’s bug databases aren’t available on the Internet. Microsoft isn’t taking the maximum benefit from the knowledge gained by its users because it doesn’t have as many feedback loops.

Linux has achieved enormous gains against Windows, even while, from a 20th century manager’s perspective, organizing the Linux kernel is a worst-case example for building a productive, prosperous organization. Where are the team-building exercises? The three-year planning retreats? It should be amazing that Linux releases anything at all, let alone dominates the supercomputer business.

Linux succeeds in spite of the cost of working remotely for several reasons. First, the distance between programmers forces people to formalize things, which helps quality: people get together at conferences like the Linux Kernel Symposium and present papers and get consensus and feedback on ideas from a wide variety of people. In addition, the ability to have anyone from around the world contribute is a greater benefit than the cost of putting people together. You couldn’t create a building large enough to host the millions of Wikipedia contributors, let alone the thousands of Linux kernel contributors.

Ingo Molnar’s quote above appears contradictory at first glance, but it is not. Linux receives lots of different ideas; many get rejected, but what remains incorporates the best of all the ideas. The Internet allows you to quickly evolve towards optimal solutions with feedback loops of discussions, tests, and bug reports. (Tests are very important because they give you objective numbers. If you want to see if the new disk cache code is faster, you can compile the kernel, which is a very disk-intensive task, and time the result.)

In the free software movement, the battles aren’t between empires, but rather between engineers fighting over technical details — testosterone-laden VIPs are irrelevant. The Linux kernel community has taken the idea of a meritocracy to the next level. All changes to the official Linux kernel must go through Linus, and his Lieutenant, Andrew Morton, and then the relevant subsystem maintainer — but first, the proposed change has to go through everyone else! All Linux changes are posted to a mailing list where anyone can comment and give opinions. Linus wrote:

The contributors for any given project are self-selected. Someone pointed out that contributions are received not from a random sample, but from people who are interested enough to use the software, learn about how it works, attempt to find solutions to problems they encounter, and actually produce an apparently reasonable fix. Anyone who passes all these filters is highly likely to have something useful to contribute.

Linus’ primary job is to provide technical expertise. He once said his job was to keep out bad code, and that might be enough. Let the varied users of Linux take it to new places, while he will make sure no one is screwing up the existing code along the way.

Linus was asked whether the unpolished nature of a large group of programmers, with disparate backgrounds, created a dreary situation that made him want to go back and work in private, and he said:

I actually like arguing (sometimes a bit too much), so the occasional flame-fest really does nothing but get me pumped up.

At the same time, I’m actually pretty good at just “letting it go”, once I’ve argued enough and am bored with the argument. Part of that is also having to occasionally just admit that you were wrong, and have the ability to send out a “mea culpa” e-mail just saying so.

I tend to care much more about improving the general development model than about the details of some particular subsystem. So that tends to make it easier for me to “let go.” I’ll state my opinions, but even if I’m convinced I’m right, if I’m not actually willing to write the code, in the end I’ll happily be overridden by the people who do write the code.

This is obviously very much a matter of personality.

There are things that I tend to worry about, and that can be really painful, but they are pretty rare. The classic example is the old “Linus doesn’t scale” argument, where it ended up being the case that I really had to fundamentally change the tools I use and how I work. And that was a lot more painful than worrying about the actual code.

Linux Kernel Superiority

Here are the reasons Linux is superior to the Windows kernel:

Refactored Code (Reliability)

Here is a diagram of the Linux kernel:

wordpress html mdabc9bc
Layers of the Linux kernel “onion”. The Linux kernel is 50% device drivers, and 25% CPU-specific code. The two inner layers are very generic.

Notice that it is built as an onion and is comprised of many discrete components. The outermost layer of the diagram is device drivers, which is 50% of the code, and more than 75% of its code is hardware-specific. The Microsoft Windows NT kernel diagram, shown several pages back, puts all the device drivers into a little box in the lower left-hand corner, illustrating the difference between theory and reality. In fact, if Microsoft had drawn the kernel mode drivers box as 50% of the Windows NT diagram, they might have understood how a kernel is mostly hardware-specific code, and reconsidered whether it was a business they wanted to get into.

Refactoring (smoothing, refining, simplifying, polishing) is done continuously in Linux. If many drivers have similar tasks, duplicate logic can be pulled out and put into a new subsystem that can then be used by all drivers. In many cases, it isn’t clear until a lot of code is written, that this new subsystem is even worthwhile. There are a number of components in the Linux kernel that evolved out of duplicate logic in multiple places. This flexible but practical approach to writing software has led Linus Torvalds to describe Linux as “Evolution, not Intelligent Design.”

One could argue that evolution is a sign of bad design, but evolution of Linux only happens when there is a need unmet by the current software. Linux initially supported only the Intel 80386 processor because that was what Linus owned. Linux evolved, via the work of many programmers, to support additional processors —more than Windows, and more than any other operating system ever has.

There is also a virtuous cycle here: the more code gets refactored, the less likely it is that a code change will cause a regression; the more code changes don’t cause regressions, the more code can be refactored. You can think about this virtuous cycle two different ways: clean code will lead to even cleaner code, and the cleaner the code, the easier it is for the system to evolve, yet still be stable. Andrew Morton has said that the Linux codebase is steadily improving in quality, even as it has tripled in size.

Greg Kroah-Hartman, maintainer of the USB subsystem in Linux, has told me that as USB hardware design has evolved from version 1.0 to 1.1 to 2.0 over the last decade, the device drivers and internal kernel architecture have also dramatically changed. Because all of the drivers live within the kernel, when the architecture is altered to support the new hardware requirements, the drivers can be adjusted at the same time.

Microsoft doesn’t have a single tree with all the device drivers. Because many hardware companies have their own drivers floating around, Microsoft is obligated to keep the old architecture around so that old code will still run. This increases the size and complexity of the Windows kernel, slows down its development, and in some cases reveals bugs or design flaws that can’t even be fixed. These backward compatibility constraints are one of the biggest reasons Windows takes years to ship. The problem exists not just at the driver layer, but up the entire software stack. When code isn’t freely available and in one place, it makes it hard to evolve. Microsoft has accumulated so much baggage over the years that it could be an airline.

While the internal logic of Linux has evolved a lot in the last ten years, the external programmer interfaces have remained constant. The key to a stable interface is incorporating the right abstractions. One of the best abstractions that Linux adopted from Unix is the file abstraction. In order to perform almost any function on a Linux computer, from reading a web page on a remote website to downloading a picture from a camera, it is necessary to simply use the standard file commands: open and close, read and write.

On my computer, in order to read the temperature of the CPU, I just need to open the (virtual) text file “/proc/acpi/thermal_zone/THM0/temperature” and the data I request is inside:2

temperature: 49 C

In essence, the Linux kernel is a bundle of device drivers that communicate with hardware and reveal themselves as a file system. As new features, security issues, hardware requirements and scenarios confront the Linux kernel, the internal design evolves and improves, but the file system abstraction allows code outside the kernel to remain unchanged over longer periods of time.

Here is a random sample of the change log of the Linux kernel from 2.6.14. As you can see, it is filled with all kinds of cleanup and bugfix work:

spinlock consolidation

fix numa caused compile warnings

ntfs build fix

i8042 – use kzalloc instead of kcalloc

clean up whitespace and formatting in drivers/char/keyboard.c


[SCSI] Fix SCSI module removal/device add race

[SCSI] qla2xxx: use wwn_to_u64() transport helper

[SPARC64]: Fix mask formation in tomatillo_wsync_handler()

[ARCNET]: Fix return value from arcnet_send_packet().

Many of the Linux kernel’s code changes are polish and cleanup. Clean code is more reliable and maintainable, and reflects the pride of the free software community.

If you look at the code changes required to make a bugfix, in the vast majority of cases all that is needed is a revision of a few lines of code in a small number of files. A general guideline Linux has for bugfixes is this: if you can’t look at the code change and prove to yourself that it fixes the problem, then perhaps the underlying code is confused, and this fix shouldn’t be added near the end of a release cycle.

According to Stanford University researchers
, the Linux kernel has 0.17 bugs per 1,000 lines of code, 150 times less than average commercial code containing 20-30 bugs per 1,000 lines.3
Microsoft’s Windows bug databases aren’t available on the Internet so it is impossible to make comparisons, but even if Linux isn’t more reliable already, it is setup to become so because the code is simple, well-factored, and all in one place.

Within the free software community, different teams are disparate entities, and so the idea of arbitrarily moving code from one part of the system to another can’t easily happen. Inside Microsoft there are no boundaries, and so code is moved around for short-term performance gains at the cost of extra complexity.

Here is a graph of all the function calls into the OS required to return a simple web request. These pictures demonstrate a visual difference in complexity that often exists between free and proprietary software:

wordpress html m2e72af43
System call graph in Microsoft’s proprietary web server, IIS.

wordpress html m1e9af381
System call graph to return a picture in the free web server Apache.

Uniform Codebase (Reliability, Maintainability, and Usability)

My job is to say “no”, to some extent. If you keep things clean enough and have some kind of requirement for what code can look like, you’re already ahead of the game. —Linus Torvalds

Linux engineers have found a way to run the same codebase on a wide variety of processors, on devices from cellphones to supercomputers, an unprecedented achievement. Linux has been tuned to first, run correctly, and then run efficiently on two, four, eight, and now 1,000 processor machines. Software has infinite malleability, so such a universal kernel has always been possible — it just took a bunch of different hardware companies working together to make it happen.

Putting everything into one codebase helps reliability. Running the Linux kernel on a 32-processor computer shakes out multi-threaded bugs far more quickly than on a two-processor laptop. Running on low-end machines keeps the code small and simple, which makes it run faster on desktops. Features that first appear on laptops and tablets eventually trickle their way down to even smaller devices where the code undergoes even more testing and enhancement. The many hardware and server developers who want extreme reliability ensure that the kernel on my PC is as reliable as Linux’s most demanding customer.

Linux is more flexible than the Windows NT kernel, though both are very clean and flexible. For example, the National Security Agency (NSA) has created a free software component called SELinux (Security Enhancements to Linux) that adds a strong security enforcement mechanism known as Mandatory Access Control.4
Making these mechanisms public helps ensure there are no back doors to the NSA’s computers. I will discuss in a later chapter why governments can adopt free software, even for high-security scenarios, but it appears the NSA already understands this concept.

Throughout the Linux world, one has many more choices for just the right tool to do the job. Some might argue that too much choice is a bad thing, but creating many components forces clear boundaries, and survival of the fittest whittles down the inferior choices over time.

Frequent Ship Cycles (Maintainability and Usability)

Microsoft had a motto: “Ship early, ship often.” This philosophy is wise for software development because it forces teams to maintain a high-quality product every day, and the earlier you release, the sooner you can receive and incorporate feedback.

However, this philosophy only works when adopted. Unfortunately, Microsoft’s two biggest products, Windows and Office, do not follow this philosophy. Of course, paying $240 every year for the latest upgrade to Windows “Ultimate” wouldn’t be acceptable either!

The Linux kernel ships every three months. For a product of its size and complexity, Linux’s rate of shipment is unprecedented. This pace has allowed the Linux kernel to ship drivers before Windows, and even before the hardware itself has shipped. Linux supported USB 3.0 before Microsoft, which did not include it in Windows 7. Because Linux is constantly near shipping, you can take any random build from Linus’ computer, put it into a rocket and feel quite confident that it won’t crash.

A big part of the Department of Justice lawsuit against Microsoft focused on the company’s bundling of many software components with their operating system. The government accused Microsoft of excluding third-party software developers and stifling competition. But Microsoft’s tying has been both a blessing and a curse.

The blessing is that by having the pieces work together, they can reuse code and be more integrated. The curse is that Microsoft has created a situation whereby it revises and adds new features to all of its interdependent components at the same time. As a consequence, its components take years to stabilize, and you can’t ship until the last component is ready.5

By contrast, in a free OS, software components depend only on released versions. Every team doesn’t try to ship on the same day, so the OS contains the latest versions of all released components.6 Separate development organizations have enforced boundaries that have simplified dependencies, and allows everyone to move ahead at whatever pace they choose.

Many users wonder whether free software will ever be as good as proprietary software because presumably the free software guys can’t afford things like usability studies. Having watched usability studies at Microsoft, grabbing people off the street to give their bits of feedback in a room with two-way mirrors is not necessary. The Internet, and all its communications mechanisms, provides a continuous and richer feedback mechanism than you can get with any usability study. In addition, usability studies don’t matter if you can’t incorporate the changes quickly and easily. With clean codebases and frequent ship cycles, usability will happen automatically. I’ve spent a lot of time using Linux and find many applications are perfectly usable.

Shipping a new platform every five years in theory provides Microsoft’s partners a stable platform upon which to build. However, in reality, its results have flaws. For instance, I wasn’t able to install an HP Photodesk 7960 printer driver on Windows Server 2003, although the driver installed perfectly on XP. The subtle and unintentionally undocumented differences between those operating systems, which shipped two years apart, has created compatibility headaches even on Microsoft’s supposedly uniform platform.

Lower Development Costs (Maintainability)

It is much less expensive for hardware vendors to support Linux. If you want to build a device driver, a great place to start is by looking at existing shipping device drivers, an opportunity that Linux offers to everyone. A proprietary “Device Driver Toolkit” with its sample code is never as good as production code. Those expensive kits contain documentation, but not source code — so you sometimes have to guess at what is happening down below.

We find in Windows today that hardware manufacturers have duplicated a bunch of the functionality Windows provides but doesn’t quite fit their needs. For example, IBM includes its own applet and status icon for wireless Internet, so Windows XP on IBM hardware has two. Presumably they weren’t satisfied with the features Windows provided, and weren’t able to fix them. And so they had to build new applets from scratch! This is also what gives Windows a feeling of a jumble of components slapped together.

Here are five of the 100 applets IBM adds to Windows:

wordpress html 664c43b0
Windows XP with 5 of IBM’s 100 extra applets. Notice the large number of status icons on this almost-virgin installation.

Building all of these applets, designing multilingual user interfaces, providing the means to install and configure, etc. is ten times more work than merely writing the device driver, leveraging other shipping drivers, and uploading it to the official codebase.

My Photodesk 7960 printer worked on Windows XP, but didn’t work on Windows Server 2003 because the installation code crashed — which HP shouldn’t be forced to bother with in the first place.

Security (Reliability and Maintainability)

To mess up a Linux box, you need to work at it; to mess up your Windows box, you just need to work on it. Scott Granneman

Attempting to compare the security of operating systems is a complicated endeavor because there are an infinite number of risks. It is like asking whether one car is safer than another. Against what: Getting hit from the front? Rolling over? Having the gas tank pierced? Its ability to brake?

Furthermore, neither Windows nor Linux are perfectly secure operating systems; both are prone to buffer-overrun viruses, an issue I will discuss in the tools chapter. Furthermore, new threats appear over time, and so each nefarious advancement requires new logic to defend against it. Given these caveats, it is still possible to make some comparisons.

Some of the previous advantages of Linux, such as its simplicity, modularity, support for SELinux, etc. all help with its security. In addition, the nature of how Linux is developed also helps. A document commissioned by the US Military said:

Open source software is potentially subject to scrutiny by many eyes Therefore bugs, security flaws, and poor design cannot hide for long, at least when the software has a community of programmers to support it. And since fixing the code doesn’t depend on a single vendor, patches are often distributed much more rapidly than patches to closed source software.
Can increase code quality and security With closed source software, it’s often difficult to evaluate the quality and security of the code. In addition, closed source software companies have an incentive to delay announcing security flaws or bugs in their product. Often this means that their customers don’t learn of security flaws until weeks or months after the security exploit was known internally. Open Technology Development Roadmap

Another big difference between Linux and Windows is that Linux was adapted from Unix, which had a multiuser design right from the beginning. In Windows, users have historically had full Administrator access to the machine, including the ability to overwrite system files. When the computer is attacked by a virus, the virus can gain the same capabilities as the user and thereby hide itself inside system files, which make it very difficult to remove. On Linux, I can write only to my own files and have read-only access to all others. Linux’s multiuser nature, and therefore its focus on minimal permissions, minimizes any damage.

One study found that there are about 60,000 known viruses for Windows, and only about 40 for Linux. Another study by Evans Data showed that 8% of Linux developers say their machines have been infected by malicious code, compared to 60% of Windows machines.

Brian Krebs of the Washington Post found that code to exploit flaws in Internet Explorer 6 existed for 284 days in 2006, while Firefox was at risk for just 9. Computer security expert Bruce Schneier recommended in December 2004 that people not run Internet Explorer. Some argue that Linux and Firefox have fewer viruses because they have fewer users, but Apache is well-respected for its security.

For most of my tenure at Microsoft, we worried about features, reliability, and performance, not security. Microsoft’s Chief Research and Strategy Officer, Craig Mundie, said in 2002:

Many of the products we designed in the past have been less secure than they could have been because we were designing with features in mind rather than security.

Microsoft has greatly increased its focus on security in the past few years, and I am sure the security of every product improves with every release, but the baggage of their codebases serve as an ongoing impediment.

Having browsed through the sources to a number of Linux applications, one can say the free codebases are typically cleaner than their Windows counterparts, which makes them easier to secure. The default server-oriented Debian 4.0 Linux distribution requires a mere 170MB of disk space, whereas Windows Server 2003 requires 3 GB. All other things being equal, the fact that Debian is 17 times smaller means it will be more secure. The free database MySQL is a mere 26MB download; the code is clean and small, and therefore much more likely to be reliable and secure.

Another advantage of Linux is that all the applications in a Linux operating system receive security updates. In the Microsoft world, only Microsoft’s code is protected by Windows Update.

While Linux is free to acquire, it can also be cheaper to run and maintain than Windows because of its better security. The city of Manchester in England spent $2 million in 2009 to remove the Conficker worm from their computers.

Linux has learned from Windows

While the Windows NT kernel was state of the art at the time it was released in 1993, most of its good ideas have been learned well and absorbed, in spite of the fact that the code has never been released.

For example, the Linux kernel supports asynchronous I/O (input/output), an innovative way to do reads and writes without tying up “thread” resources. This was an innovation first made widespread in Windows NT.

The ability to load code dynamically is another important feature the Linux kernel adopted from NT and others. Plug and play and suspend and hibernate was a collaboration between Microsoft and hardware companies in the 1990s, and Linux now supports this feature.

Throughout the free software stack, developers have incorporated good ideas from the outside world. There is no Not Invented Here syndrome in free software; a good idea is a good idea, and existing code is even better. In software today, the biggest impediment to sharing ideas is not ego, but license agreements.

The Linux kernel has even learned from Microsoft’s mistakes. For example, one feature added to the Windows NT 4.0 kernel was to put the code that draws widgets into the kernel itself. While this can improve graphics performance, it also means that a bug in the code of a button has the capacity to crash the entire system. The best way to keep a system secure and reliable is to keep as much code as possible in user mode above the kernel, and Linux follows this strategy.7

The Feature Race

One of Microsoft’s best arguments against free software over the years has been to tout their new features and use that as “proof” that free software will always be behind proprietary software. The moment a Microsoft product comes out, it always offers features that no one else has. However, most of the features are in fact ones that others do have, and Microsoft is catching up. Nearly every new feature is an evolutionary step forward in a place that Microsoft felt needed work.

But like Microsoft, each team in the free software community is improving their code every day. In fact, because Microsoft takes so long to ship, the free software community has often added features before Microsoft. The website displays the latest list of the Linux features added since the previous release 3-4 months before, and it is typically 15 pages long! For example, here is just the list of driver features added to the 2.6.26 version of the Linux kernel, which had a 3-month dev cycle.

Linus 2.6.26 driver workitems



Add warm-plug support for IDE devices

Mark “idebus=” kernel parameter as obsoleted (take 2)

Remove ide=reverse IDE core

Add “vlb|pci_clock=” parameter

Add “noacpi” / “acpigtf” / “acpionboot” parameters

Add “cdrom=” and “chs=” parameters

Add “nodma|noflush|noprobe|nowerr=” parameters

Add Intel SCH PATA driver

Add ide-4drives host driver (take 3)

gayle: add “doubler” parameter

Remove the broken ETRAX_IDE driver


sata_inic162x: add cardbus support

libata: prefer hardreset

ata: SWNCQ should be enabled by default

Make SFF support optional

libata: make PMP support optional

sata_mv: disable hotplug for now, enable NCQ on SOC, add basic port multiplier support

sata_fsl: Fix broken driver, add port multiplier (PMP) support

4.2. Networking

ssb: add a new Gigabit Ethernet driver to the ssb core

Add new qeth device driver,

Add new ctcm driver that reemplaces the old ctc one,

New driver “sfc” for Solarstorm SFC4000 controller.

Driver for IXP4xx built-in Ethernet ports

Add support the Korina (IDT RC32434) Ethernet MAC

iwlwifi: Support the HT (802.11n) improvements,,,, add default WEP key host command, add 1X HW WEP support, add default WEP HW encryption, use HW acceleration decryption by default, hook iwlwifi with Linux rfkill, add TX/RX statistics to driver, add debugfs to iwl core, enables HW TKIP encryption, add led support, enables RX TKIP decryption in HW, remove IWL{4965,3945}_QOS

ath5k: Add RF2413 srev values, add RF2413 initial settings, identify RF2413 and deal with PHY_SPENDING, more RF2413 stuff, port to new bitrate/channel API, use software encryption for now

pasemi_mac: jumbo frame support, enable GSO by default, basic ethtool support, netpoll support

rt2x00: Add per-interface structure, enable master and adhoc mode again, enable LED class support for rt2500usb/rt73usb

e1000e: Add interrupt moderation run-time ethtool interface, add support for BM PHYs on ICH9

niu: Add support for Neptune FEM/NEM cards for C10 server blades, add Support for Sun ATCA Blade Server.

gianfar: Support NAPI for TX Frames

ehea: Add DLPAR memory remove support

sfc: Add TSO support

b43: Add QOS support, add HostFlags HI support, use SSB block-I/O to do PIO

S2io: Multiqueue network device support implementation,, enable multi ring support, added napi support when MSIX is enabled.

ixgbe: Introduce MSI-X queue vector code, introduce Multiqueue TX, add optional DCA infrastructure, introduce adaptive interrupt moderation

uli526x: add support for netpoll

fmvj18x_cs: add NextCom NC5310 rev B support

zd1211rw: support for mesh interface and beaconing

libertas: implement SSID scanning for SIOCSIWSCAN

ethtool: Add support for large eeproms

The scheduled bcm43xx removal

The scheduled ieee80211 softmac removal

The scheduled rc80211-simple.c removal

Remove obsolete driver sk98lin

Remove the obsolete xircom_tulip_cb driver

4.3. Graphics

radeon: Initial r500 support,,

intel_agp: Add support for Intel 4 series chipsets

i915: Add support for Intel series 4 chipsets

Add support for Radeon Mobility 9000 chipset

fb: add support for foreign endianness

pxafb: preliminary smart panel interface support,

Driver for Freescale 8610 and 5121 DIU

intelfb: add support for the Intel Integrated Graphics Controller 965G/965GM

Add support for Blackfin/Linux logo for framebuffer console

4.4. Sound

hda-codec – Allow multiple SPDIF devices, add SI HDMI codec support, add support for the OQO Model 2, add support of Zepto laptops, support RV7xx HDMI Audio, add model=mobile for AD1884A & co, add support of AD1883/1884A/1984A/1984B, add model for cx20549 to support laptop HP530, add model for alc883 to support FUJITSU Pi2515, add support for Toshiba Equium L30, Map 3stack-6ch-dig ALC662 model for Asus P5GC-MX, support of Lenovo Thinkpad X300, add Quanta IL1 ALC267 model, add support of AD1989A/AD1989B, add model for alc262 to support Lenovo 3000, add model for ASUS P5K-E/WIFI-AP, added support for Foxconn P35AX-S mainboard, add drivers for the Texas Instruments OMAP processors, add support of Medion RIM 2150, support IDT 92HD206 codec

ice1724 – Enable AK4114 support for Audiophile192

ice1712: Added support for Delta1010E (newer revisions of Delta1010), added support for M-Audio Delta 66E, add Terrasoniq TS88 support

Davinci ASoC support

intel8x0 – Add support of 8 channel sound

ASoC: WM9713 driver

Emagic Audiowerk 2 ALSA driver.

Add PC-speaker sound driver

oxygen: add monitor controls

virtuoso: add Xonar DX support

soc – Support PXA3xx AC97

pxa2xx-ac97: Support PXA3xx AC97

4.5. Input

Add support for WM97xx family touchscreens

WM97xx – add chip driver for WM9705 touchscreen, add chip driver for WM9712 touchscreen, add chip driver for WM97123 touchscreen, add support for streaming mode on Mainstone

wacom: add support for Cintiq 20WSX

xpad: add support for wireless xbox360 controllers

Add PS/2 serio driver for AVR32 devices

aiptek: add support for Genius G-PEN 560 tablet

Add Zhen Hua driver

HID: force feedback driver for Logitech Rumblepad 2, Logitech diNovo Mini pad support

4.6. Video

V4L2 soc_camera driver for PXA270,,

Add support for the MT9M001 camera

Add support for the MT9V022 camera

Add support for the ISL6405 dual LNB supply chip

Initial DVB-S support for MD8800 /CTX948

cx23885: Add support for the Hauppauge HVR1400, add generic cx23417 hardware encoder support

Add mxl5505s driver for MaxiLinear 5505 chipsets, basic digital support.

4.6. Video

cx88: Add support for the Dvico PCI Nano, add xc2028/3028 boards, add support for tuner-xc3028

saa7134: add support for the MSI TV@nywhere A/D v1.1 card, add support for the Creatix CTX953_V.1.4.3 Hybrid

saa717x: add new audio/video decoder i2c driver

Support DVB-T tuning on the DViCO FusionHDTV DVB-T Pro

Add support for xc3028-based boards

ivtv: add support for Japanese variant of the Adaptec AVC-2410

Add basic support for Prolink Pixelview MPEG 8000GT

bttv: added support for Kozumi KTV-01C card

Add support for Kworld ATSC 120

CX24123: preparing support for CX24113 tuner

Added support for Terratec Cinergy T USB XXS

budget: Add support for Fujitsu Siemens DVB-T Activy Budget

Support for DVB-S demod PN1010 (clone of S5H1420) added

Added support for SkyStar2 rev2.7 and ITD1000 DVB-S tuner

em28xx-dvb: Add support for HVR950, add support for the HVR-900

Add support for Hauppauge HVR950Q/HVR850/FusioHDTV7-USB

HVR950Q Hauppauge eeprom support

Adding support for the NXP TDA10048HN DVB OFDM demodulator

Add support for the Hauppauge HVR-1200

pvrusb2-dvb: add DVB-T support for Hauppauge pvrusb2 model 73xxx

Add support for Beholder BeholdTV H6

cx18: new driver for the Conexant CX23418 MPEG encoder chip

s5h1411: Adding support for this ATSC/QAM demodulator

4.7. SCSI

zfcp: Add trace records for recovery thread and its queues, add traces for state changes., trace all triggers of error recovery activity,register new recovery trace., remove obsolete erp_dbf trace, add trace records for recovery actions.

qla2xxx: Add support for host supported speeds FC transport attribute., add FC-transport Asynchronous Event Notification support., add hardware trace-logging support., add Flash Descriptor Table layout support., add ISP84XX support., add midlayer target/device reset support.

iscsi: extended cdb support, bidi support at the generic libiscsi level, bidi support for iscsi_tcp

scsi_debug: support large non-fake virtual disk

gdth: convert to PCI hotplug API

st: add option to use SILI in variable block reads

megaraid_sas: Add the new controller(1078DE) support to the driver

m68k: new mac_esp scsi driver

bsg: add large command support

Add support for variable length extended commands

aacraid: Add Power Management support

dpt_i2o: 64 bit support, sysfs

Firmware: add iSCSI iBFT Support


Add a watchdog driver based on the CS5535/CS5536 MFGPT timers

Add ICH9DO into the iTCO_wdt.c driver

4.9. HWMON

thermal: add hwmon sysfs I/F

ibmaem: new driver for power/energy/temp meters in IBM System X hardware

i5k_amb: support Intel 5400 chipset

4.10. USB

ISP1760 HCD driver

pxa27x_udc driver

CDC WDM driver

Add Cypress c67x00 OTG controller core driver,,

Add HP hs2300 Broadband Wireless Module to sierra.c

Partial USB embedded host support

Add usb-serial spcp8x5 driver

r8a66597-hcd: Add support for SH7366 USB host

Add Zoom Telephonics Model 3095F V.92 USB Mini External modem to cdc-acm

Support for the ET502HS HDSPA modem

atmel_usba_udc: Add support for AT91CAP9 UDPHS

4.11. FireWire

release notes at linux1394-user

4.12. Infiniband

IPoIB: Use checksum offload support if available, add LSO support, add basic ethtool support, support modifying IPoIB CQ event moderation, handle 4K IB MTU for UD (datagram) mode

ipath: Enable 4KB MTU, add code to support multiple link speeds and widths, EEPROM support for 7220 devices, robustness improvements, cleanup, add support for IBTA 1.2 Heartbeat

Add support for IBA7220,,,,,,,,,

mthca: Add checksum offload support

mlx4: Add checksum offload support, add IPoIB LSO support to mlx4,

RDMA/cxgb3: Support peer-2-peer connection setup

4.13. ACPI and Power Management

ACPICA: Disassembler support for new ACPI tables

eeepc-laptop: add base driver, add backlight, add hwmon fan control

thinkpad-acpi: add sysfs led class support for thinklight (v3.1), add sysfs led class support to thinkpad leds (v3.2)

Remove legacy PM

4.14. MTD

m25p80: add FAST_READ access support to M25Pxx, add Support for ATMEL AT25DF641 64-Megabit SPI Flash

JEDEC: add support for the ST M29W400DB flash chip

NAND: support for pxa3xx

NOR: Add JEDEC support for the SST 36VF3203 flash chip


AR7 mtd partition map

NAND: S3C2410 Large page NAND support

NAND: Hardware ECC controller on at91sam9263 / at91sam9260

4.15. I2C

Add support for device alias names

Convert most new-style drivers to use module aliasing

Renesas SH7760 I2C master driver

New driver for the SuperH Mobile I2C bus controller

Convert remaining new-style drivers to use module aliasing

4.16. Various

MMC: OMAP: Add back cover switch support

MMC: OMAP: Introduce new multislot structure and change driver to use it

mmc: mmc host test driver

4981/1: [KS8695] Simple LED driver

leds: Add mail LED support for “Clevo D400P”

leds: Add support to leds with readable status

leds: Add new driver for the LEDs on the Freecom FSG-3


Add RapidIO multi mport support

Add OF-tree support to RapidIO controller driver

Add serial RapidIO controller support, which includes MPC8548, MPC8641

edac: new support for Intel 3100 chipset

Basic braille screen reader support

ntp: support for TAI

RTC: Ramtron FM3130 RTC support

Don’t worry if you don’t understand what these things mean as I don’t either. It is just important to understand that even the hardware of computers are too big and complicated for one company to oversee the development of.

This is just a portion of the code changes for that version of Linux, and doesn’t include work in the file systems, networking, performance, architecture-specific work, and so forth.

Free software has added countless features before Microsoft. However, many of these features are so obscure that your eyes would glaze over reading the list. Anyone who focuses on the highly-touted features in Microsoft’s latest release is missing the larger picture: even when these features are compelling, they often make you more deeply tied into the proprietary world and make it harder to migrate away.

Microsoft’s new software always has new features, but usually only one piece of code for a scenario. Linux supports 60 file systems, including several clustering solutions, that allow a seamless scale-out of disk storage amongst a group of servers. Microsoft supports just one, which is tied very tightly to its system, which in turn limits its flexibility. Free software also approaches solutions from different directions. There are several ways to attack virtualization and Linux is working on them in parallel and finding what is common between them.8

Linux is Inexorably Winning

The fact that the Linux kernel has these many advantages over Windows means two things. First, the argument that free software engineers are unable to innovate and only copy the work of others is not true.

The head of Windows Server recently said
that free software, “by its very nature, does not allow intellectual property to be built.” This statement is factually incorrect: the Linux kernel is doing many things no kernel has ever done before, just as Wikipedia is doing things no encyclopedia has ever done before.

Second, even if Microsoft gave away the source code to the Windows kernel, the existing free software community would dismiss it. A worldwide community has pounded Linux into the shape it should be. Linus calls Windows “witchcraft”, so why work on an inferior codebase whose details up till now have been opaque?

Charging for an OS

A Linux operating system is an entirely different beast compared to a Microsoft operating system. Microsoft was constantly torn about how much value to invest in Windows, and how much to set aside for extra licensing revenue in other products. Windows Vista has five different versions, (originally they announced eight!), each with basically the same code, but with dramatically different prices:

Windows Vista Ultimate$243$350
Windows Vista Business$176$260
Windows Vista Home Premium$140$219
Windows Vista Home Basic$85$157
Windows Vista EnterpriseCustom volume license

Microsoft charges $85 to $350 for Windows Vista, but the code in each version is 99% the same.

Microsoft’s natural goal is to put as many new and compelling features into high-end, high-profit versions even though the prices are not correlated to the work required to build the various Vista versions.

Creating multiple versions is tricky because if third-party applications depend on features that aren’t in a particular version of Windows, then the applications won’t run, and the Windows brand is weakened. Therefore, Microsoft would sometimes add logic to cripple the performance of high-end features on low-end versions. In the free software world, no one deliberately cripples their own creation.

When I worked at Microsoft, there were numerous turf wars. For example, the Word team fought with the Windows team over whether WordPad, a tiny Windows applet, should have the ability to read Word’s DOC files. The Windows team wanted to create an operating system that had the ability to display the hundreds of millions of DOC files, but the Word team didn’t want to create a reason for people not to purchase Word. There were also running battles between the teams responsible for Outlook and Outlook Express, Exchange and SQL, Works and Word, FoxPro and Access, Access and VB, SQL Server and Access, PC and XBox. Each team was paranoid about another team adding functionality that would discourage someone from buying their product.

Microsoft also was torn between bundling important features in the operating system, like they did with web browsers, instant messaging and multimedia, and leaving features out in order to reap more money later. Windows doesn’t ship with a dictionary because Office has one. Windows doesn’t come with development tools because those are part of Microsoft’s Visual Studio business. With Linux, anything free is welcomed into the operating system.

In addition to Microsoft’s strategic decisions to exclude certain features, there are also cases of benign neglect. The Sound Recorder in Windows XP lets you only record for 1 minute, a limitation that exists from the days of 16-bit Windows that no one bothered to fix. Microsoft’s official solution is for the customer to purchase Office OneNote.

Applets, command-line tools, and many other important but unsexy parts of an operating system were always allocated very limited resources. Ask Steve Ballmer for resources for the unimportant Sound Recorder, and you would receive a dirty, polystyrene fork hurtling in your direction. In the free software model, anyone, on their time frame, can improve a piece of code that is useful or interesting to them, whether “strategic” or not. Eric Raymond calls this phenomenon a developer “scratching their own itch.” Wikipedia is built almost entirely from this mechanism, and only free software can capture every little advancement.

Complexity of License Agreements

It would be possible to fund the construction of all roads with tolls. This would entail having toll booths at all street corners. Such a system would provide a great incentive to improve roads. It would also have the virtue of causing the users of any given road to pay for that road. However, a toll booth is an artificial obstruction to smooth driving—artificial, because it is not a consequence of how roads or cars work.
—Richard Stallman

Even if you believe it is perfectly okay to charge for software, it is hard to know what to charge consumers for software. Microsoft used to charge a fixed amount for a server product. However, one day they realized that customers who had 10 users connected to a server should be paying less than those who had 100. This observation resulted in the creation of client access licenses (CALs); a concept that required payment for each individual user of server software, but which is an additional burden on the customer. If you have 1,000 employees accessing 1,000 servers, you need to fill out a lot of paperwork.

This was all before the invention of the Internet whereby the number of users of a server could easily be in the thousands and which made many usages of CALs expensive and unsustainable. Therefore, Microsoft moved towards a model where the cost was based on the number of processors in the computer so that little boxes would cost less than big boxes.

This model worked until Intel introduced the concept of “hyperthreading”, which fools a computer into thinking there are two processors inside the computer, but which adds only 15-30% more performance. Microsoft’s customers would of course be unhappy at the thought of purchasing a bunch of new licenses for such a small performance improvement, so Microsoft ended up giving free licenses for hyperthreaded processors.

Then, virtualization was created:

wordpress html m3f4cb3ed
Intel virtualization marketing diagram: Virtualization allows the ability to run multiple operating systems on one computer: each instance thinks it controls the machine. The best uses for virtualization are web hosting, inside corporate data centers, and for software developers.

Virtualization allows different applications to be fully isolated from each other inside different complete instances of an operating system, but at the same time share the CPU and other hardware resources. Isolation is important because even within a single company’s data center, different departments don’t want to run their code on the same machine. If Hotmail went down, they didn’t want it to be the fault of the Microsoft Bob web page.

I was told that inside the cavernous datacenters of a Fortune 500 company, the computers used on average only 15% of their CPU’s capacity. The different departments all maintained their own hardware, which they’d built out to handle the maximum possible load; this is an idea as silly as utilizing only 15% of an office building.

Virtualization gives you software isolation but allows you to share hardware. However, when you install more proprietary software, licensing issues arise. If I put three copies of a database server in separate virtualization instances on a four-processor computer, under many of Microsoft’s licensing models I would have to purchase enough licenses for 12 processors — even though the computer only has four. Like hyperthreading, virtualization is another technology that wasn’t conceived of when Microsoft created their per-processor licensing model.

In a free software environment, you can add new hardware and add or remove applications without paying or keeping track of anything. I will write more about economic aspects later, but for now it is only important to understand that free software sidesteps these hassles, which are often very onerous for enterprises.

An interesting moral dilemma for proprietary software vendors is whether to allow pirated copies to receive security updates.

Free Software Only Costs PCs

Creating a unified industrial software base built around free software will not only make PCs more powerful, but it will also allow us to push their intelligence everywhere, from cars to medical equipment. Free software will be built because it is so valuable to businesses; everyone else will come along for the ride and get it for free.

The proprietary software model has hurt many of the smaller software markets. In fact, except for gaming business which is as much about artistry as software, Microsoft is nearly the last proprietary software company standing. When I was at Microsoft, our biggest competitors were companies such as Borland, WordPerfect, Corel, Lotus, Netscape and Sybase — names you never hear anymore.

There is no Microsoft of educational software selling products used in every school. There are several companies selling proprietary products, perhaps receiving enough revenue to stay in business, but the proprietary software model has prevented them from achieving critical mass.

Recently, I saw an ad for a trivial software applet capable of converting a DVD to the iPod video format. Microsoft managed to convince everybody that each little software product is worth selling. Now you see why Stallman’s analogy of proprietary software as tollbooths is apt — they serve as permanent, pervasive obstacles holding up progress for software that was written years earlier. Free software flows with much less friction. In fact, in the free software world, the definition of a PC operating system completely changes.

A Free Operating System

Our most potent operating system competitor is Linux and the phenomena around open source and free software. The same phenomena fuels competitors to all of our products. The ease of picking up Linux to learn it or to modify some piece of it is very attractive. The academic community, start-up companies, foreign governments and many other constituencies are putting their best work into Linux.
—Bill Gates

wordpress html m30bba2e9
The One Laptop Per Child has as much CPU power as a workstation of 1991, but it would be just a shiny box without free software and content.

The biggest difference between Windows and Linux is that free software contains thousands of applications, installable with one click, and managed as one set. A Linux operating system includes all the obvious stuff like a spreadsheet, web browser, and instant messaging, but it also includes tools for making pictures and music, children’s applications, server software, the Bible, development tools, and much more.

Audacity is the most popular free audio editor on Linux. It doesn’t have a talking paper clip: “It looks like you’re trying to add echo. Would you like some help?” But it does provide a well-rounded set of features, and has many effects for the manipulation of sound.

wordpress html m345c7259
A rich and reliable free audio manipulation tool

Audacity, of course, doesn’t have a one-minute limitation on its ability to record as Windows XP does. Its most important feature is its plugins for import, export, and effects — extensibility is one of free software’s best features.

Audacity Audio Editor Feature List
    • Audacity can record live audio through a microphone or mixer, or digitize recordings from cassette tapes, vinyl records, or minidiscs. With some sound cards, it can also capture streaming audio.

Record from microphone, line input, or other sources.

Dub over existing tracks to create multi-track recordings.

Record up to 16 channels at once (requires multi-channel hardware).

Level meters can monitor volume levels before, during, and after recording.

Import and Export
    • Import sound files, edit them, and combine them with other files or new recordings. Export your recordings in several common file formats.

Import and export WAV, AIFF, AU, and Ogg Vorbis

Import MPEG audio (including MP2 and MP3 files) with libmad

Export MP3s with the optional LAME encoder library.

Create WAV or AIFF files suitable for burning to CD.

Open raw (headerless) audio files using the “Import Raw” command.

Note: Audacity does not currently support WMA, AAC, or most other proprietary or restricted file formats.

    • Easy editing with Cut, Copy, Paste, and Delete.

Use unlimited Undo (and Redo) to go back any number of steps.

Very fast editing of large files.

Edit and mix an unlimited number of tracks.

Use the Drawing tool to alter individual sample points.

Fade the volume up or down smoothly with the Envelope tool.

        • Echo




Change the pitch without altering the tempo, or vice-versa.

Remove static, hiss, hum, or other constant background noises.

Alter frequencies with Equalization, FFT Filter, and Bass Boost effects.

Adjust volumes with Compressor, Amplify, and Normalize effects.

Other built-in effects include:

Sound Quality
    • Record and edit 16-bit, 24-bit, and 32-bit (floating point) samples.

Record at up to 96 KHz.

Sample rates and formats are converted using high-quality resampling and dithering.

Mix tracks with different sample rates or formats, and Audacity will convert them automatically in real time.

    • Add new effects with

LADSPA plugins

    • .

Audacity includes some sample plugins by Steve Harris

Load VST plugins for Windows and Mac, with the optional VST Enabler

Write new effects with the built-in Nyquist
programming language.

    • Spectrogram mode for visualizing frequencies.

“Plot Spectrum” command for detailed frequency analysis.

Free and Cross-Platform
    • Licensed under the

GNU General Public License (GPL)

    • .

Runs on Mac OS X, Windows, and GNU/Linux.

Developers of free software applications tend to build extensibility plugins as a fundamental way of writing their software because they know their tool will never by itself be able to do all the things people will want. A plugin provides a boundary between things that manage data, and things that manipulate it. The most popular plugins eventually become a part of the base system, but by being built separately, they have forced clean boundaries and modularity.9

Every application that Linux has that Windows doesn’t is a feature Windows is missing:

wordpress html m41cb5490
Richard Stallman’s free software vision realized: A free Linux operating system contains an entire store of free applications available with one click, and built to work together. Having so many tools at your disposal makes computers more personal, powerful, productive, and enjoyable. Your computing experience becomes limited only by your creativity.

A free operating system is where Metcalfe’s law meets software: the more people using free software, the more applications will be built for it. Just one piece of free software isn’t useful, but with an entire stack, we can enter a shining age.

Going from today’s 20 million Linux users to the anticipated one billion means the potential for 50 times more resources. The free software stack has several challenges I will discuss throughout this book, but it is important to mention here that few of the applications in the dialog box are as polished or reliable as Firefox. However, many are very powerful, and more than good enough to depend on in a business.

While Linux still needs work, Windows is no day at the beach. Here is an email from Bill Gates’ describing his experience of installing Microsoft MovieMaker on Windows:

From: Bill Gates
Sent: Wednesday, January 15, 2003 10:05 AM
To: Jim Allchin
Cc: Chris Jones (WINDOWS); Bharat Shah (NT); Joe Peterson; Will Poole; Brian Valentine; Anoop Gupta (RESEARCH)

Subject: Windows Usability degradation flame

I am quite disappointed at how Windows Usability has been going backwards and the program management groups don’t drive usability issues.

Let me give you my experience from yesterday.

I decided to download (Moviemaker) and buy the Digital Plus pack … so I went to They have a download place so I went there.

The first 5 times I used the site it timed out while trying to bring up the download page. Then after an 8 second delay I got it to come up.

This site is so slow it is unusable.

It wasn’t in the top 5 so I expanded the other 45. These 45 names are totally confusing. These names make stuff like: C:\Documents and Settings\billg\My Documents\My Pictures seem clear.

They are not filtered by the system … and so many of the things are strange. I tried scoping to Media stuff. Still no moviemaker. I typed in movie. Nothing. I typed in movie maker. Nothing.

So I gave up and sent mail to Amir saying – where is this Moviemaker download? Does it exist? So they told me that using the download page to download something was not something they anticipated. They told me to go to the main page search button and type movie maker (not moviemaker!)

I tried that. The site was pathetically slow but after 6 seconds of waiting up it came. I thought for sure now I would see a button to just go do the download. In fact it is more like a puzzle that you get to solve. It told me to go to Windows Update and do a bunch of incantations.

This struck me as completely odd. Why should I have to go somewhere else and do a scan to download moviemaker? So I went to Windows update. Windows Update decides I need to download a bunch of controls. (Not) just once but multiple times where I get to see weird dialog boxes. Doesn’t Windows update know some key to talk to Windows?

Then I did the scan. This took quite some time and I was told it was critical for me to download 17megs of stuff. This is after I was told we were doing delta patches to things but instead just to get 6 things that are labeled in the SCARIEST possible way I had to download 17meg. So I did the download. That part was fast. Then it wanted to do an install. This took 6 minutes and the machine was so slow I couldn’t use it for anything else during this time. What the heck is going on during those 6 minutes? That is crazy. This is after the download was finished.

Then it told me to reboot my machine. Why should I do that? I reboot every night — why should I reboot at that time? So I did the reboot because it INSISTED on it. Of course that meant completely getting rid of all my Outlook state.

So I got back up and running and went to Windows Update again. I forgot why I was in Windows Update at all since all I wanted was to get Moviemaker. So I went back to and looked at the instructions. I have to click on a folder called WindowsXP. Why should I do that? Windows Update knows I am on Windows XP. What does it mean to have to click on that folder?

So I get a bunch of confusing stuff but sure enough one of them is Moviemaker. So I do the download. The download is fast but the Install takes many minutes. Amazing how slow this thing is. At some point I get told I need to go get Windows Media Series 9 to download.

So I decide I will go do that. This time I get dialogs saying things like “Open” or “Save”. No guidance in the instructions which to do. I have no clue which to do.

The download is fast and the install takes 7 minutes for this thing.

So now I think I am going to have Moviemaker. I go to my add/remove programs place to make sure it is there. It is not there.

What is there? The following garbage is there. Microsoft Autoupdate Exclusive test package, Microsoft Autoupdate Reboot test package, Microsoft Autoupdate testpackage1. Microsoft AUtoupdate testpackage2, Microsoft Autoupdate Test package3.

Someone decided to trash the one part of Windows that was usable? The file system is no longer usable. The registry is not usable. This program listing was one sane place but now it is all crapped up.

But that is just the start of the crap. Later I have listed things like Windows XP Hotfix see Q329048 for more information. What is Q329048? Why are these series of patches listed here? Some of the patches just things like Q810655 instead of saying see Q329048 for more information.

What an absolute mess. Moviemaker is just not there at all. So I give up on Moviemaker and decide to download the Digital Plus Package.

I get told I need to go enter a bunch of information about myself.

I enter it all in and because it decides I have mistyped something I have to try again. Of course it has cleared out most of what I typed.

I try (typing) the right stuff in 5 times and it just keeps clearing things out for me to type them in again.

So after more than an hour of craziness and making my programs list garbage and being scared and seeing that is a terrible website I haven’t run Moviemaker and I haven’t got the plus package.

The lack of attention to usability represented by these experiences blows my mind. I thought we had reached a low with Windows Network places or the messages I get when I try to use 802.11. (don’t you just love that root certificate message?) When I really get to use the stuff I am sure I will have more feedback.

Linux Distributions

With Linux, each OS distribution carves out a niche to meet its users’ needs. There are specialized versions of Linux containing educational software, tools for musicians, versions dedicated to embedded or low-end hardware, and regional versions of Linux produced in places like Spain and China.

The various distributions have much in common, including the Linux kernel, but use different free software and installation mechanisms. One distribution called Gentoo downloads only one binary, a bootstrapping compiler. The rest of its deliverables are the source code to the components they offer. This gives the user the ability to build a system highly optimized for his hardware.

Some distributions are optimized to run well on old hardware and fit on CDs the size of a credit card:

wordpress html 2ef4001a
Damn Small Linux is the most popular Linux for old computers and ships on 80×60 mm CDs.

Linux is very popular on servers, which require an additional focus on performance, reliability, and security. One of the simplest ways to decrease bloat and security risks is to remove the graphical interface:

top – 12:54:17 up 62 days, 20:14, 2 users, load average: 0.16, 0.42, 0.43
Tasks: 127 total, 1 running, 126 sleeping, 0 stopped, 0 zombie
Cpu(s): 0.2% us, 0.3% sy, 0.0% ni, 98.5% id, 0.2% wa, 0.7% hi, 0.2% si
Mem: 514248k total, 489360k used, 24888k free, 79128k buffers
Swap: 1020088k total, 18416k used, 1001672k free, 177528k cached

2041 root 10 -5 0 0 0 S 0 0.0 0:11.74 usb-storage
1 root 16 0 1564 528 460 S 0 0.1 0:01.09 init
2 root RT 0 0 0 0 S 0 0.0 0:00.01 migration/0
3 root 34 19 0 0 0 S 0 0.0 0:14.63 ksoftirqd/0
4 root RT 0 0 0 0 S 0 0.0 0:00.00 watchdog/0

Screenshot of a text-based Linux process viewer. Just because a computer displays only text doesn’t mean there isn’t a modern, rock-solid operating system underneath.

It is as hard to write a graphical user interface (GUI) for a server as it is to write the server itself: every new feature in the server needs a corresponding improvement in the administration interface. If your server can generate 1,000 records per second, then your user interface had better be able to handle that without choking.10

While most devices do not need a GUI, desktop users do, and like everything in the free software world today, there are several good choices.

The following map shows the Debian branch of the Linux distribution family tree; they derive from each other, just like in a biological ecosystem:

wordpress html md634a1
A portion of the Linux family tree showing the Debian branch, the biggest free software distribution.

Here is a chart showing the relative popularity of Linux distros:

wordpress html m69a1ebbe
Linux distributions, sorted by popularity. The line shows the divide between both halves of the popularity curve.

What you see here is an almost perfectly smooth curve that illustrates a relatively new idea called the “Long Tail.” One way to think about this idea is to look at the English language. Words like “the” are used with great frequency, but many more words like “teabag” are used infrequently. There is a long tail of infrequently used English words, and to just ignore them would be to throw away much of what makes our language so special.

The lesson of the long tail in business is the importance of catering to customers with special interests. The long tail of Linux distributions means that the creation of a free software ecosystem doesn’t mean the end of the free market, or of competition.

Wikipedia and the Linux kernel are two of the best examples of the fact that free software and the free exchange of ideas can create superior products without licensing fees. The mere existence of these premier products, without a gigantic company behind them, is proof that the proprietary development model is doomed.

1 While cloud computing, the movement of increasing number of applications and services provided over the Internet, is one of the hot topics of today, it is unrelated to the Windows vs. Macintosh vs. Linux war that is going on. Even in a future where applications like word-processing are done over the Internet, you still need a kernel, a web browser, a media player, and so forth.

2 This should arguably be expressed as XML, but because there is common code that reads these values and provides them to applications, and because each file contains only one value, this problem isn’t very significant; the kernel’s configuration information will never be a part of a web mashup.

3 These studies have limited value because their tools usually analyze just a few types of coding errors. Then, they make the IT news, and get fixed quickly because of the publicity, which then makes the study meaningless. However, these tools do allow for comparisons between codebases. I believe the best analysis of the number of Linux bugs is the 1,400 bugs in its bug database, which for 8.2 million lines of code is .17 bugs per 1,000 lines of code. This is a tiny number, though it could easily be another 100 times smaller. Here is a link to the Linux kernel’s active bugs:

4 This is a way to add additional security because the operating system can say, for example: Because a media player has no reason to write files to disk, the system can take away this permission. Before the kernel tries to do anything interesting, it will ask the Mandatory Access System (MAC) whether such an operation is allowed. The security checks in most other operating systems simply ask if the person is allowed to do something.
Creating a default policy adds additional work for application writers, and by itself doesn’t entirely solve the problem. A word processor needs complete read and write access, so how do you solve the problem of a virus in a document macro opening all of your files and writing junk? SELinux doesn’t deal with this situation because it doesn’t have this information. In garbage-collected programming languages, it is possible to walk the stack and determine more information about whether a macro, or the word processor itself, is asking to open a file.

5 The alternative is for each component to use the previous version of all of its dependent components, which means that the features in the latest Internet Explorer wouldn’t show up in various places that are using the old version. However, does the Help system need the latest version?

6 Some components contain multiple versions to allow for a transition period.

7 In Windows Vista, Microsoft moved some of the device drivers to user mode but they should have kept the device drivers small, simple, and in the kernel and instead moved the widgets and fluff to user mode.

8 Two of the biggest differences in strategy is User Mode Linux (UML) which changes Linux to run as an application on top of another instance of Linux, and the standard virtualization, which runs the guest OS in kernel mode, though it doesn’t actually talk to the hardware. The Linux kernel is evolving towards figuring out the architecture, and what is shared between the different strategies.

9 I argue in another place in the book that software has no clear boundaries. What I meant was that one never really knows precisely what the interface between manager and manipulator should be. For audio files, the boundary seems clear: here is some audio data, chew on it. However even there you must ask: what DSP APIs are available to the plugins? Otherwise, each plugin will need lots of duplicate code that the manager already likely has! It is the new hardware capabilities that create a need for a change at this boundary. The lesson here is to keep your boundaries simple, but assume you may need to change them.

10 Many embedded scenarios don’t include a GUI because there is no standard one yet. Most GUIs are too complicated and slow for embedded scenarios: the brand-new cash register at my local Starbucks has a touch display with a text interface.


Leave a comment

Your email address will not be published. Required fields are marked *