The Impact of Code Reuse on Productivity

Introduction

A great development experience is on every CIO’s mind, as numerous business development experts agree that IT has become the driving force in building a successful modern business. Whereas developers, team leads, and organisations want tools and processes to be fast, secure and reliable, so professionals can gain higher levels of job satisfaction and autonomy and increase their speed of delivery.

In this report, we will review whether frictionless code reuse can make developers more productive while maintaining the quality and security of code. Code reuse has become a popular practice within enterprise development teams, and for good reason. In principle, reusing a piece of code means you don’t need to create it from scratch. Therefore, your developers can save time on duplicated efforts.

But for code reuse to work, that code needs to be high-quality, safe, and reliable. This report will examine the pros and cons of code reuse, and whether there is a limit to the value it can bring to enterprise business.

Abstract

Improving developer productivity comes with all kinds of business benefits. Your company builds better code, which helps create high-quality products, giving you a competitive advantage in your market. In addition, you benefit from faster time to market, improved collaboration, and a preferable workplace culture.

Your development team’s productivity impacts many areas of business and is something you should continually strive to improve. But is code reuse the answer?

In this report, BlueOptima analyses over 80 million source-code revisions across its BlueOptima Global Benchmark™ to establish the impact of code reuse on developer teams’ productivity. In addition, we will examine the risks and advantages that come with code reuse. We look at how it can reduce cost and speed up delivery, but also how too much reuse can have negative impacts on developer productivity.

Understanding Code Reuse

To understand code reuse, we need to understand software components. A software component is a specific part of a larger program or construction. Often, a component provides a unique function or group of functions within the program. By making components reusable, developers can save time and effort in recreating code that provides the same functionality.

Code reuse can solve a number of commercial and technical challenges. In an ideal world, developers would be able to access a code library, adapt any piece of code for reuse and be assured that it is free from error, reliable and safe to deploy for a new application. However, oftentimes developers find that only a tiny fraction of the code they wish to change is alterable. So, they have to resort to building a new component from scratch.

What Makes a Component “Reusable”?

Developing for reuse is an art in itself. It is often difficult to make a component reusable, and it becomes harder if your organisation has many product components and development teams distributed across several locations.

Some of the key barriers to code reuse include the following:

Project managers must plan for additional resources upfront.
More time is required as code must be tested more thoroughly than if it were for a single project.
To be reused, code needs to be secure, reliable and efficient, which requires more time, resources and testing in the project development process.

What Makes a Good Reusable Component?

For code to be reusable, it must be created with a designated use in mind. For example, components in your program may need to be altered to provide additional services at a later stage.

A well-designed reusable component will anticipate future alterations and provide hooks that allow developers to extend or alter functionality without modifying the internal structure of the component. In addition, an ideal piece of reusable code would be short (under 300 lines), follow standardised and intuitive naming conventions for functions and variables, allowing for developers to make changes from a single place. Or, it would include comments that inform developers of the intended use cases and any modifications made at a later date.

However, according to Fred Brooks’ book, Mythical Man Month, this type of ideal-fit reusable component costs around three times more to develop than single-use code.

Benefits of Code Reuse

Enterprise leaders want the quality and performance of their software to be the best, without errors. Creating high-quality code like this takes time, and while it is an important factor to consider, business leaders must also weigh up quality against resource constraints, expected delivery dates, and profitability.

Accelerated Development

Time to market is an essential metric and is always at the forefront of a CIOs mind. As long as the quality of the software is high enough, products and services that are brought to market early are typically of more value to your organisation. Code reuse often speeds up system production by reducing development time which makes both stakeholders and customers happy.

Effective Use of Specialists

Rather than duplicating efforts by redoing the same work over and over again, your specialists can develop reusable software that makes the best use of your human capital. Developers with specialist knowledge can create reusable components. By using your top developers to build high-quality reusable components, other developers without the same level of knowledge can participate in the project by using those components.

Increased Dependability

Reused code is more dependable than new code because it has been thoroughly tested. Within your code reuse framework, you should ensure code is reliable and secure across all of your program layers. Its design and implementation faults should have been found and fixed before it became a reusable component which makes it dependable.

Lower Development Costs

Development costs are proportional to the size and complexity of the software being developed. Code reuse means you have fewer developers churning code to complete the project. By recycling large software components like subsets, you can considerably reduce workloads.

Reduced Process Risk

The cost of using an existing component is already known, whereas developing a new component is unknown. With reusable code, you reduce the margin of error in your estimation, especially when relatively large software components such as subsystems are reused.

Standards Compliance

Some standards, such as user interface standards, can be created as a set of reusable components. This ensures all applications present the same menu formats to your users, making the interface familiar and dependable.

Ease of Maintenance

Reusable code makes it easy to change and update the implementation without affecting other parts of the system.

The Impact of Code Reuse on Productivity

BlueOptima’s study, which includes over 80 million source code revisions, shows that internal component reuse impacts developer productivity. However, increases in productivity are not linear. Some reuse is always better for productivity than none at all but a moderate amount of reuse is the best for optimising the productivity of an application.

‍

‍Caption: Figure 1: Depicts the level of productivity based on the volume of component reuse within an application.

Code Reuse Categories and Productivity

Our study broke down code reuse into four categories:

No reuse: 0 components reused
Low reuse: 1-3 components reused
Moderate reuse: 4-10 components reused
High reuse: More than 10 components reused

The greatest impact on productivity can be found in the comparison to applications with zero code reuse. The productivity of applications with moderate reuse is 27% more than that of the group with no reuse. Those who give high reuse are less productive than those who reuse a moderate amount but are still more productive than applications that reuse no code at all.

The peak region for code reuse, as it affects productivity, is between 4-10 reused components. If you added between 4-10 reusable components to an application with no reuse, it is equivalent to hiring 27 new developers for a team of 100.

Code Reuse Best Practices

While there are positive impacts on productivity, there is such a thing as too much code reuse. When applications start to use more than ten reusable components, their productivity begins to decline.

Balancing Cost, Risk, and Reward

Risks for development teams that reuse internal components include:

Dependencies: Too many dependencies can slow you down; relying on other teams can make integration slower.
Complexity: Developers may find it complex to find the right component and documentation if correct processes are not in place.
Factory Syndrome: Developers may resist a shift in status from "master craftsman" to "factory drone" if reuse programs are perceived as too rigid.
Not-Invented-Here (NIH) Syndrome: Developers may value their own ideas above those conceived outside their group, highlighting the need for a collaborative culture.

Mitigation Strategies

Track and Adapt: Track which components are being reused heavily and ensure they are adapted to scale across the organisation with proper documentation and support.
Realisation Strategy: Evolve the reusable asset over multiple iterations rather than building all requisite features on the first iteration to avoid creating irrelevant components and scheduling risks.

BlueOptima’s Code Insights

Code Insights provides objective insights into a development team’s source code so they can accurately identify and more easily eliminate risks. It also helps minimise the impact on technical debt incurred from shift-left initiatives.

Who are BlueOptima?

We provide a SaaS technology that objectively measures software development efficiency. Our core metrics for productivity and code maintainability allow executives to make data driven decisions related to talent optimization, vendor management, location strategy and much more.

‍