TechBeacon, November 2, 2015
By Eyal Maor
Click here to read the article in TechBeacon
“Our build times are too long.” I hear that age-old complaint all the time from developers, but most recently I heard it at LinuxCon. There’s a good reason for this: Linux has its own unique issues in this regard.
Software developers frequently discuss long builds as though they’re the natural order of things and nothing can be done about them. However, while developers can put successful continuous integration (CI) and agile processes in place, the headaches of long builds will continue if they haven’t optimized each step to achieve faster processing times.
The problem with Linux
Here’s the crux of the problem with Linux: Unlike Windows, the operating system has no unified management because of all the different customizations, the flexibility, diversity of tools, and configuration options. Then there are all the different Linux distributions, such as Ubuntu, Red Hat Enterprise Linux, and CentOS. Each distribution is almost its own distinct operating system, which means that instead of developers having to only support one version, they must support all distributions. Software engineers aren’t always spared, either, because many companies run mixed distributions. That means multiple build processes, since each distribution requires its own separate build—and more time spent getting software out the door.
The variety of development tools and lack of consistency available to Linux developers contribute to Linux’s complexity. While this gives software engineers more tool and process options from which to choose, it also adds a layer of complication.
Another challenge for developers using Linux is an inherent inability to see how their builds are progressing. When developers can visualize a build, they can analyze build processes, detect errors, and identify bottlenecks. Traditionally, however, much of Linux development takes place by way of a text-only terminal or low-level development environment. While the terminal provides impressive customization and enhanced flexibility, it’s difficult to sort through long textual output or huge log files. This is especially true for a developer on deadline. It’s hard for a software engineer to see that the code written by a team member in another office could have broken the build or inserted a dependency that slowed development. When developers have the time to drill down, textual output can be valuable. However, this lack of visualization often means that software engineers are unable to identify bottlenecks or have clarity in the build process.
If developers wanted to speed up their builds, they’ve had to spend significant time muddling with complex configurations as well as optimizing every tool they use. Many organizations don’t have the resources to spend so much time on expensive professional services. Others require that teams change their toolchains and use proprietary tools rather than sticking with existing development tools. Developers who want to accelerate their builds should be able to use the same tooling and workflow that they were already using, and install a build acceleration tool on their network within a few minutes. Linux lets you do that.
While Linux isn’t a perfect OS and has some disadvantages, it’s increasingly becoming the OS of choice, especially in the Android world. Many back-end web servers and other critical technology infrastructures run on Linux. In addition, some developers prefer Linux as their primary development platform because they’re developing code to be deployed on Linux (such as Android kernel developers developing with Linux or back-end developers developing complex SaaS software deployed on Linux servers).
Linux already has an extensive developer toolchain built in—no need to install third-party applications. What’s more, the number of customization options, from keyboard shortcuts to virtual desktop support, are virtually unlimited.
A key benefit of Linux for many developers is gaining a sense of control over the entire chain of production, from development to testing, to deployment, to long-term maintenance. Developers feel a greater sense of stability due to the customization options available.
The world of Linux development is also changing, and for the better. Current trends include:
- The growth of Linux both on the desktop and embedded devices. While Linux desktop deployment is still small in technical environments, Linux on the desktop is increasingly common. Many development teams, from those in small startups to enterprises, use Ubuntu or Red Hat-based distributions. Linux powers everything from web servers, to Internet of Things devices, to Android devices. The global analyst firm VDC Research projects that Linux-based embedded devices will rise from a 56.2 percent market share in 2012 to 64.7 percent in 2017.
- Performance increases. As Linux gains in popularity as a development platform, making an investment in performance improvements becomes essential. You need better tooling as well as good development practices and procedures, such as refactoring, automated testing, and continuous integration, instead of overnight builds. With incremental releases and a greater emphasis on quality and security, organizations are breaking the paradigm of long builds.
- Flexibility without jeopardizing performance. One major benefit of Linux is its flexibility and customizability, but this has also led to performance hits. In the future, expect to see less tolerance for performance hits in the name of flexibility, such as the ability to run multiple build configurations simultaneously when compiling your software.
- Increased visibility. Expect greater visualization and the ability to see what happens under the hood without needing to devote hours to do so. Both individual software engineers and managers need high-level visibility. This greater visibility will also make management more receptive to Linux adoption. In addition, you’ll have many ways to view what’s under the hood, rather than relying solely on long textual outputs on a terminal.
- Faster CI. Enabling parallel execution of build tasks shortens CI, allowing organizations to make their CI truly continuous, instead of only relying on lunchtime and overnight builds.
With the growth of Linux development, we should develop intolerance for long build times. By simplifying and accelerating development, we’ll see an even greater explosion of Linux as a core development platform.