Embracing a New Era of Productivity for Developers

The invention of computer programming languages kickstarted the software development industry by enabling creativity and providing developers with the ability to solve real-world problems. With time, however, developers’ focus shifted from simply solving real-world problems to solving them better and faster. As their employers demanded more solutions in less time, developers suddenly needed to maximize development time and be more productive.

As technology advanced, less-complex programming languages enabled faster development and increased productivity. This, however, changed little. Developers were still focused on writing more code in less time. Unfortunately, while “lines of code per day” can be a measure of productivity, the metric doesn’t account for quality. Recognizing this, successful developers today are embracing a new form of productivity—writing less code to achieve more.

This means that by flipping the script and focusing on writing less but higher-quality code, developers can maximize their time. With this approach, the benefit to everyone is cleaner and more functional software that’s easier to maintain over time.

In this article, we’ll discuss how writing less code creates better software and a new era of productivity. But before we do let’s take a step back and assess the state of the software development industry and what productivity means.

State of the Industry: How Long Can The Bloat Be Sustained?

The last ten years have seen massive improvements in productivity in the software development industry. This is mainly due to the development of more expressive programming languages, open-source software, common libraries, and easier access to information. These gains, however, are mired in complexity and bloat.

As developers face increasing pressure from marketing departments to deliver new solutions, features, and product versions faster, they sacrifice software efficiency for speed of delivery. This leads to higher levels of abstraction, like virtual machines or scripting engines. While the abstractions result in faster development cycles, they also introduce software complexity and bloat. (Read: DIving into Dev: The Software Development Lifecycle.)

In the 1970s, the early days of computer programming, developers emphasized conservation. This is because computer RAM and storage were in bytes. Effort focused on developing programs that could run quickly and smoothly on the limited hardware of the time. Achieving this fit was the highlight of creativity for software developers. Now, as modern developers disregard resource constraints, the strain on end-user hardware increases.

Pexels/Cottonbros

Fast forward to today. Now, we have unimaginably powerful hardware. Despite this, software feels the same, if not slower. We focus more on coding and deploying new features for marketing purposes than on conservation and quality. This is partly due to the huge increases in hardware processing and storage capacity we enjoy. According to Moore’s law, “Over the history of computing hardware, the number of transistors on integrated circuits doubles approximately every two years.”

In addition, there’s a wider adoption of technology at every level, both in our businesses and at home. As a result, the software industry is larger than ever. Today’s software development projects are often handled by teams. Each developer works on a piece of the whole. We don’t focus on developing high-quality software and conserving resources but on volume. The result is inefficient software.

Wirth’s law sums it all up. Wirth states that software speed decreases more quickly than hardware speed increases. In other words, even though modern CPUs are over a thousand times faster than earlier computers, our bloated applications still run slowly.

This begs the question:

Are we killing productivity gains with poor development tools that let us write more code faster, and ignoring quality, simplicity, efficiency, and conservation?

Look around: everything is annoyingly slow—far too slow if you remove the sheer brute force of modern hardware. A single web page can be as large as half a dozen megabytes. To put it into perspective, six modern web pages are heavier than the entirety of Windows 95 (30 MB). That’s just too much bloat. As if that were not enough, most web pages use hundreds of brittle JavaScript includes or libraries.

The problem can be seen everywhere. Desktop apps in Electron take up hundreds of megabytes of memory, even before you install them. What’s in there, an entire rendering engine for a simple Windows application? In one recent comparison, a simple Electron app took as much as 19.7 seconds to load over a network. A traditional native binary took only 2.4 seconds.

Releasing software for multiple devices adds even more complexity. Building and updating an application multiple times with different toolchains to support all of the major platforms out there (Windows, macOS, Linux, Android, iOS) is costly, complex, and brittle. (Read also: Is No-Code Development About to Go Mainstream?)

There is, however, a light at the end of the tunnel. That light involves tried and true technologies that deploy performant native code on multiple platforms. Embarcadero’s RAD Studio is one of those technologies, and it supercharges developer productivity.

What Does Productivity Mean in Software Development?

There are four aspects to software development productivity: developer productivity, business functionality, application flexibility, and product performance.

Developer Productivity

Of these four factors, technical debt is the largest stumbling block. It is a measure of how many typical development tasks a developer can complete based on specific metrics. These new-era productivity metrics also include finished tasks, documentation, and deployment. “Technical debt” refers to the implied costs developers have to work with as a result of prior shortcuts. To assess developer productivity, you need to account for the cost of technical debt against the other three metrics.

To reduce the impact of technical debt, developers can improve productivity by applying two techniques:

• Reducing coding requirements due to native libraries.

• Leveraging IDE tools like code completion and visual design.

IDEs with broader built-in libraries generally result in fewer lines of code per application. They reduce technical debt with clean, lean codebases and fewer opportunities for bugs or maintenance problems later in the product life cycle.

Business Functionality

Simply put, business functionality means choosing the right framework. It refers to a framework’s business suitability and impact on your long-term plans. Excellent functionality allows companies to easily build custom tools or extensions, develop on any platform they choose, and protect their source code from exploitation. Perhaps most importantly, high business functionality gives enterprises confidence that they will be able to maintain their new applications for decades.

Application Flexibility

Application flexibility assesses the scope of the tasks you can perform with a framework. While IDEs and frameworks are supposed to be Turing-complete and technically infinitely flexible, some are better suited to a task than others. Flexible frameworks allow businesses to target a broad audience, build software for every application tier, and access operating system functions and consumer hardware.

Product Performance

Consumers judge applications in part by how they perform. Businesses that choose a framework with superior performance avoid customer dissatisfaction by minimizing wait times and resource use on slow machines.

Software Productivity Through a Business Lens

Pexels/fauxels

Since productivity directly impacts the bottom line, it’s only fair that we look at software development productivity through the lens of economics. In standard economic terms, productivity is the ratio between the total deliverables (goods and/or services) and the total cost of producing them (effort and time inclusive).

To define productivity in software development, one must first establish a definition for software development deliverables. Basically, this includes software products like web, mobile, or desktop applications—any features that contain lines of code. It is a fair definition, but “lines of code” alone are not deliverables. Your users don’t see or care about your code. They buy applications because of what they can do.

For this reason software development deliverables are defined by the value they offer and the tasks they fulfill. That means software development productivity is a matter of total value (from an end-user perspective) versus total development costs (effort and time inclusive). Software development costs include both the cost of your developers and the tools they use to build your software. If you take both the cost of time and tools into account, toolchains that are “free” but time consuming are not free. Finally, in addition to development time, future maintenance, ease of testing, and an application’s ability to fulfill its purpose are all hidden productivity costs.

How To Improve Software Development Productivity?

The answer is quite straightforward: by providing value. Build applications that are scalable and flexible on platforms that simplify deployment and increase productivity.

To achieve this, you need to choose the right software development framework. There are plenty of different frameworks out there. Many of them, however, focus on generating more lines of code faster. What you need to focus on is frameworks and libraries that enhance productivity with performance as a goal—for example, Delphi’s VCL and FMX frameworks. The road to productivity is integrated software development toolchains like Embarcadero’s RAD Studio that increase developer productivity, reduce code complexity, fulfill business requirements, provide application flexibility, and solidify product performance—in other words, toolchains that provide both immediate and lasting value.

Does Writing Less Code Create Better Software?

According to IBM, “Software development refers to a set of computer science activities dedicated to the process of creating, designing, deploying, and supporting software.”

Software developers are technologically creative individuals with the ability to generate solutions to real-world problems.

Now, glance through that description again, looking for the words “write code.” Nowhere does it say that.

While code is obviously the means developers use to build solutions, it is not the end goal. Today, however, we have become code happy. We have forgotten that the purpose of software development is to provide value, ease of maintenance, and scalability. When we forget that purpose, the result is complex, bloated, and difficult-to-maintain software.

When it comes to creating better software, less code is the way to go. The chances of a project failing increase with the number of lines of code. Successful developers know this, and they also know that time is money and less code is more productive to produce. That’s why they’re embracing this new era of productivity and working to provide value with less code.

Here are two more reasons less code creates better software:

• Less code is easier to understand. Code everyone on your team understands is easier to reuse.

• Less code is easier to test and maintain. Simplified testing and maintenance costs you less over time.

Developers can ramp up their productivity by embracing simplicity and avoiding complexity. They can do this with easy-to-read, -write, and -learn languages; low-code technologies; and robust toolchains.(Read: How Low-Code Development Will Bring Data Science to the Masses.)

Toolchains like Embarcadero’s RAD Studio allow you to develop business solutions in the productivity sweet spot. The combined productivity gains of integrated toolchains; low-code technologies like those available in Delphi; and multiplatform deployment on Android, iOS, macOS, Windows, and Linux can supercharge developer productivity up to 5X.

Are You Ready to Embrace a New Era of Productivity?

With organizations looking to reduce technical debt, speed up time to market, and also develop real-world solutions to business problems in real time, software development needs to be more productive than ever. But productivity in software development doesn’t mean winning the race for the most lines of code per day. On the contrary, productivity is all about conserving resources and eliminating software bloat.

Writing less code is the new era of software productivity. Successful developers write only as much code as they need to build scalable, easy-to-maintain solutions. Successful organizations combine easy-to-read, -learn, and -write languages with toolchains like Delphi that focus on performance. They also use powerful low-code technologies to write less code and ultimately provide greater end-user value.

Are you ready to embrace a new era of productivity? Create software that does more with less code, free from needless inefficiencies.