“Our construction times are too long.” I hear this age-old complaint from developers all the time, but more recently I heard it at LinuxCon. There’s a good reason for this: Linux has its own issues in this regard.
Software developers often discuss long versions as if this is the natural order of things and nothing can be done about them. However, while developers can successfully implement continuous integration (CI) and agile processes, the headaches of long releases will continue if they haven’t optimized every step for faster turnaround times.
The problem with Linux
Here’s the crux of the matter with Linux: Unlike Windows, the operating system lacks unified management due to all the different customizations, flexibility, variety of tools, and configuration options. Then there are all the different Linux distributions, such as Ubuntu, Red Hat Enterprise Linux, and CentOS. Each distro is almost its own separate operating system, which means that instead of developers having to support only one version, they have to support all distributions. Software engineers aren’t always spared either, as many companies use mixed distributions. This means multiple build processes, as each distro requires its own separate build and more time spent releasing the software.
The variety of development tools and the lack of consistency available to Linux developers contribute to the complexity of Linux. While this gives software engineers more tool and process options to choose from, it also adds a layer of complication.
Another challenge for developers using Linux is an inherent inability to see how their versions are progressing. When developers can view a build, they can analyze build processes, detect errors, and identify bottlenecks. Traditionally, however, much of Linux development has taken place using a text-only terminal or low-level development environment. Although the terminal offers impressive customization and improved flexibility, it is difficult to sort long texts or huge log files. This is especially true for a developer on the deadline. It’s hard for a software engineer to see that code written by a team member in another office might have broken build or inserted a dependency that slowed down development. When developers have time to dig deeper, textual output can be invaluable. 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 had to spend a lot of time messing around with complex setups and optimizing every tool they use. Many organizations do not have the resources to spend so much time on expensive professional services. Others require teams to change their toolchains and use proprietary tools rather than sticking to existing development tools. Developers who want to speed up their builds should be able to use the same tools and workflows they were already using, and install a build acceleration tool on their network within minutes. Linux allows you to do this.
Although Linux is not a perfect operating system and has some drawbacks, it is increasingly becoming the operating system of choice, especially in the Android world. Many back-end web servers and other critical technology infrastructures run on Linux. Additionally, some developers prefer Linux as the primary development platform because they develop code to deploy 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 integrated development toolchain – no need to install third-party applications. Plus, the number of customization options, from keyboard shortcuts to virtual desktop support, is virtually unlimited.
A key benefit of Linux for many developers is to gain a sense of control over the entire production chain, from development to testing, deployment and long-term maintenance. Developers feel a greater sense of stability with the customization options available.
The world of Linux development is changing too, and for the better. Current trends include:
- The growth of Linux on both desktops and embedded devices. While Linux desktop deployment is still small in technical environments, desktop Linux is increasingly common. Many development teams, from small startups to businesses, use distributions based on Ubuntu or Red Hat. Linux powers everything from web servers and Internet of Things devices to Android devices. Global analyst firm VDC Research predicts Linux-based embedded devices grow from a market share of 56.2% in 2012 to 64.7% in 2017.
- Performance increases. As Linux grows in popularity as a development platform, investing in improving performance becomes essential. You need better tools along with good development practices and procedures, such as refactoring, automated testing, and continuous integration, instead of overnight builds. With incremental releases and an increased focus on quality and safety, organizations are breaking the long release paradigm.
- Flexibility without compromising performance. One of the main advantages of Linux is its flexibility and customization, but this has also resulted in performance degradation. Going forward, expect to see less tolerance for performance issues in the name of flexibility, such as the ability to run multiple build configurations simultaneously when compiling your software.
- Increased visibility. Expect better viewing and the ability to see what’s going on under the hood without having to spend hours doing it. Software engineers and individual managers need high level visibility. This greater visibility will also make management more receptive to Linux adoption. Plus, you’ll have plenty of ways to see what’s hiding under the hood, rather than relying solely on long text outputs on a terminal.
- Faster CI. Allowing build jobs to run in parallel shortens the CI, allowing organizations to make their CIs truly continuous, instead of relying only on lunchtime and overnight builds.
With the growth of Linux development, we should develop an intolerance for long build times. By simplifying and speeding up development, we will see an even greater explosion of Linux as a core development platform.