How Linux is Built

While Linux is running our phones, friend requests, tweets, financial trades, ATMs and more, most of us don't know how it's actually built. This short video takes you inside the process by which the largest collaborative development project in the history of computing is organized. Based on the annual report "Who Writes Linux," this is a powerful and inspiring story of how Linux has become a volunteer-driven phenomenon.

You use Linux everyday whether you know it or not.

Over eight hundred fifty thousand Android phones running Linux are activated

every single day. Compare that to just thirty thousand Windows phones,

according to the latest reports.

That means one hundred Android devices have come online

just since you started watching this video.

Nearly seven hundred thousand televisions are sold in every day,

most of which are running Linux.

Eight out of ten financial trades are powered by Linux.

Nine out of ten of the world super computers run Linux.

Google, Twitter, Facebook and Amazon are all powered by Linux.

So, how is Linux developed to achieve all of this? Unlike other operating systems,

like Windows or iOS, Linux

is built collaboratively, across companies, geographies, and markets,

resulting in the largest collaborative development project in the history of

computing. Just since two thousand five about eight thousand developers

from almost eight hundred companies have contributed to the Linux kernel.

These contributions have resulted in fifteen million lines of code. One point five

million lines written in just the last couple of years.

Consider that Homer's epic "Ilead" is a mere fifteen thousand lines of text.

The novel "War and Peace" just five hundred sixty thousand words.

But it's not just about the sheer number of lines code,

it's also about how quickly Linux is developed and released.

For example, a major new kernel comes out every two to three months.

Compare this to years for competing operating systems.

This is made possible by a unique collaborative development process.

When submitting code to the Linux kernel, developers break changes into individual

units called patches.

The patch describes the lines that need to be changed, added, or removed from the

source code.

Each patch can add a new feature, new support for a device, fix a problem, improve

performance, or rework things to be more easily understood.

Developers post their patches to the relevant mailing lists where other developers can

reply with feedback.

When the patch is close to being release ready,

it is accepted by a senior Linux kernel developer, or maintainer, who manages

one or more of a one hundred different sections of the kernel.

While this is not a guarantee that it will go to the main line,

it is certainly a good sign.

Here it gets an even more extensive evaluation.

When the maintainer finishes their review, he or she will sign off on the

patch and send it on to Linux creator, and Linux Foundation Fellow, Linus Torvalds,

who has the ultimate authority on what is accepted into the next

release and what is not. Nearly ten thousand patches go into almost

every new release.

About six patches are applied to the kernel each hour.

Linux's rate of development is simply unmatched.

Today, Linux is dominating on mobile device, in the enterprise and web infrastructure,

data centers, supercomputing, and more.

What's next? Because together, we are ready.