One of the great charms of open-source software is that it’s free. Sort of.
As any real (read: employed) programmer working with open-source software can tell you, free software ain’t free. The minute you spend, well, one minute working on the code, you’ve spent your company’s money. And every additional minute costs more money—to say nothing of the lab time, bench instruments, software licenses, and other resources you and your colleagues devote to the effort. You get the idea.
Yet “free” open-source software exerts an irresistible attraction for many developers and their employers. Sometimes it’s the perceived freedom from tyrannical commercial RTOS companies. Sometimes it’s the flexibility to make changes or tweak code. Sometimes it’s motivated by the availability of talent. If all the cool kids are using open-source software, maybe we should, too.
But, as many developers discover, the do-it-yourself path can be an uphill one. Hacking out your own RTOS or compiler or middleware is fraught with travail, and, with open-source development, you’re kinda on your own.
You can smooth the trail by handing over development to a commercial entity, but this also defeats some of the purpose. Red Hat and MontaVista, for example, “commercialize” open-source Linux by offering tested code, full-time technical support, and all the other accouterments of a commercial operating system. They also charge real money, just like a commercial software company. In many ways, they offer the advantages of open-source code combined with professional support. But they also spoil some of the fun.
If that’s not what you’re after, there’s now a middle path. A group calling itself Linaro is collectively tweaking Linux for ARM processors and offering up its version for developers. Linaro isn’t a normal company, but neither is it a consortium or trade group. Instead, it’s a nonprofit group of 100+ programmers all working toward the same goal: making Linux work on ARM-based embedded systems.
What problem(s) are these guys trying to solve? Well, one of the good things about open-source software is that lots of people are working on it. But one of the bad things about open-source software is that lots of people are working on it. In other words, there’s no centralized authority; no go-to guy to make decisions about whether to implement interrupts this way or that way. Consequently, each independent developer comes up with his own solution, which is wasteful of everybody’s time and leads to incompatible solutions to the same problem. That’s okay if you don’t care what anyone else is doing, but it means you probably can’t borrow or share anyone else’s code, even if it’s nominally intended to solve your problem. The opposite of centralized authority is anarchy, and neither extreme really helps developers.
Linaro acts as a central authority on matters of Linux-on-ARM but without any commercial skin in the game. It’s a nonprofit organization, so it doesn’t sell anything or make money if you use (or ignore) its code. The group merely develops the most sensible solutions to common embedded-Linux problems,and offers its version to interested developers.
The Linaro seal of approval doesn’t guarantee eternal happiness or career success, but it does indicate that a group of 100 full-time programmers from around the world have thought this through and arrived at this particular solution. That’s useful in itself, because it means one less decision you have to worry about; they sweat the details so you don’t have to. It also means that each bit of Linaro-approved code should work with all the other Linaro-approved code. Hewing closely to the Linaro gospel means you’ll never walk alone.
So where does Linaro get all this talent? Does everyone contribute their time pro bono out of the goodness of their hearts? Hardly. Linaro’s programmers are all employed and well paid—just not by Linaro. Instead, the entire group is staffed by employees of other companies, such as IBM, Samsung, ARM, Texas Instruments, Freescale, and others. Everyone is a permanent full-time employee of their respective company; they just work all day for Linaro.
It’s an unusual business model: Freescale (for example) will pay a handful of its employees salaries and benefits but allow them to work full-time on Linaro business. These people work at Freescale and have Freescale cubicles, phone extensions, e-mail addresses, and ID badges, but they interact mostly with other Linaro “employees” around the world. (The group has members in 20 countries.) Freescale gets very little of their time or attention. Oh, and Freescale pays Linaro an annual membership fee, as well.
Why would any company agree to give away their employees and pay for the privilege? Because it actually works out in their favor. In exchange for donating 1–10 employees, the employer gets the benefit of all 100 Linaro programmers. Member companies get to contribute to and influence the work of the group, plus they get inside knowledge of what’s happening. They contribute their expertise and manpower; in return, they get the expertise of the 95% of Linaro programmers who aren’t theirs. Not such a bad deal.
The upshot for the industry is that Linux development for ARM chips proceeds more coherently than it otherwise might. That’s definitely in ARM’s best interest, but it’s also in the interest of any company that makes ARM processors (a large group, indeed). The easier it is to get Linux working on ARM-based embedded systems, the better for everyone involved in that business. Of course, rogue developers can still go it alone, ignoring Linaro’s input and contributions to the open-source pool. They may even produce superior solutions (for some definition of superior). But they’ll be out of the mainstream, forking from the development path that most Linux-on-ARM developers are likely to follow. If that kind of independence appeals to you, knock yourself out. If you’re willing to abdicate some autonomy in exchange for a collectively-developed solution, talk to Linaro.