software toolchain

What is a software toolchain?

A software toolchain is a set of software development tools used simultaneously to complete complex software development tasks or to deliver a software product. Each tool in the chain is itself a piece of software that serves a different function and is optimized to work together with other tools in the chain. Example programs in a software toolchain are an assembler, linker and debugger.

Companies can customize software toolchains to suit their software needs. Some software vendors also offer their own toolchains. One of the main benefits of using a software toolchain instead of a disparate set of tools is the consistent programming environment throughout the development process and the smooth transition between tools as development progresses.

What is the purpose of a toolchain?

The purpose of a software toolchain is to have a group of linked software tools that are optimized for a specific programming process. The output generated by one tool in the chain is used by the next tool as the input.

By integrating tools together, the toolchain considers the various tool dependencies and, as a result, streamlines the software development process. For example, a programming language such as C++ may require language-specific tools, like a debugger or compiler. A development team that knows C++ can integrate one of these tools into their chain to avoid bottlenecks in the development process.

What should a toolchain include?

Toolchains may vary depending on the team using them and the product being delivered. However, basic toolchains often include the following components:

• Assembler -- converts assembly language into code.
• Linker -- links a set of program files together into a single program.
• Debugger -- used to test and debug programs.
• Compiler -- used to generate executable code from the source code of a program.
• Runtime libraries -- used to interface with an operating system (OS). It enables the program to reference external functions and resources. An API is an example of this.

Developers will often write a script that links these tools together and automates some of the process.

Complex software products will likely require more tools than this, but this basic assortment is generally involved in any software toolchain in some form, regardless of the product being delivered.

Some coding languages and platforms offer their own toolchains and enable customization within the integrated development environment platform. Apple's Xcode is one example of this.

Benefits of using toolchains

The main benefit of using a software toolchain is that it streamlines the development lifecycle. To a degree, the software development process can be automated, which is especially useful for DevOps implementations. In DevOps implementations, teams often employ a continuous delivery strategy and need all tools working simultaneously to be as efficient as possible.

Additionally, using a pre-built toolchain from a third party allows development teams to bypass the step of building a toolchain from scratch, which can be difficult and time consuming. Developers can use these preexisting toolchains and then customize them to the specific use case.

Using toolchains can also help expedite handoffs between teams that use different software tools by increasing visibility, security and productivity.

Notable toolchain examples

One unique example of a toolchain is the Verified Software Toolchain. The Verified Software toolchain is a collection of verification tools for the C programming language.

More specifically, it is a project from Princeton that assures with machine-checked proofs that assertions claimed at the top of a toolchain hold in the machine-language program and function correctly in the OS. The toolchain does this with static analyzers, compilers, OSes and libraries to ensure that code is consistent as it gets translated into machine code.

The Verified Software Toolchain is designed for software products that need to be reliable, easy to use and consistently functional. This includes security-critical applications and safety-critical applications -- or in other words, applications in which a hacker is deliberately searching for a bug, or in which a software bug could cause actual physical harm to the user.

Recently, with the increasing popularity of DevOps and Agile software development, there has been a move towards open source toolchains. Some examples of toolchains consisting of open source tools are:

• Gradle -- for building application components;
• Jenkins -- for integrating separate code components; and
• Selenium -- for automated application testing.

While open source doesn't come in a pre-configured toolchain, it creates flexibility that suits DevOps organizations well.

Software toolchains vs. DevOps toolchains

A close relative of the term "software toolchain" is the term "DevOps toolchain." Both terms refer to collections of software used together, but DevOps toolchain more specifically describes a toolchain used by an organization that practices DevOps. It implies that the tools in the chain will be mapped to the stages of the DevOps process, from planning to monitoring.

The steps of a DevOps toolchain usually include:

• Plan -- involves defining purpose, expectations and requirements for a software product.
• Create -- involves designing and building the software.
• Test -- involves testing the product in various ways, such as providing a public beta for users and other developers to test.
• Release -- involves scheduling and deploying the software.
• Monitor -- involves evaluating metrics and user feedback to fix bugs or update the software with more features.

Software toolchain is a broader term that includes DevOps toolchain but extends beyond that to include tools used in a more traditional software development methodology. It also applies more directly to programming, whereas DevOps toolchains are geared toward other parts of the overall delivery process.