Writing Software Right the First Time

Developing high-quality software isn’t an easy task nor is it cheap. Still, fixing bugs in the field is a lot more expensive with the cost of fixing these issues rising exponentially as it moves through quality assurance to deployment in the field. Add to the mix the rise of generative artificial intelligence (GenAI) and its ability to identify bugs in software, which only elevates the need for high-quality software from the start.

Programming languages like Ada/SPARK and Rust aim to improve things with or without AI assistance. Developers may want to take a closer look at these even while turning to AI to enhance their productivity.

While a definitive accounting of bug fix costs hasn’t really taken place, it’s true that the impact of a bug is more significant as it moves from the design stage to deployment for a variety of reasons. First, the number of systems involved. Second is how they can be updated in the field, and, finally, whether addressing the bug actually fixes the issue and doesn’t cause other problems.

Even with over-the-air (OTA) updates, there’s a significant cost in fixing a bug. OTA doesn’t guarantee that all instances where a bug occurs will be fixed in a timely manner. Another issue concerns which systems will be fixed using OTA even if the option is available, because changes are often device-specific and vendors may not provide updates for legacy devices.

Getting it Right the First Time

Getting the job done right the first time is of course the end goal for most developers (see figure). The challenge is achieving that goal while meeting deadlines and productivity requirements.

These are many aspects that come into play in creating good software:

• Choice of programming language
• Formal specifications
• Version-control systems
• Bug tracking
• Good coding practices
• Peer/code reviews
• Unit and systems testing
• Documentation
• Software bill of materials (SBOM)

AI can assist with many of these even without generating code, such as doing code reviews, generating unit tests, and even writing documentation. AI code generation and agentic AI are areas we’ll leave to another article.

Why the Programming Language Makes a Difference for High-Quality Software

Programming languages can range from very strict and concise to less precise and even undefined characteristics. Rust, Ada, and SPARK are on the strict side, while C is closer to the other end of the spectrum. Essentially, the stricter approaches put the specifications in the programmer’s hands but the checking is done by the compiler. For example, Ada can specify a variable that has a range from −10 to 25 with checking to make this the case, while C integers are specified by the number of bits with no checking by the compiler.

Similar compiler checking is done by Rust when it comes to memory management. Again, C puts the onus on the programmer, while Rust makes sure that the programmer’s specifications are met.

Contracts are a feature that allows programmers to specify preconditions, postconditions, and invariants for functions and code. At least one Rust crate supports contracts, and contracts are inherent in Ada 2012 and SPARK. C++ contracts are part of the C++26 standard. SPARK takes support to the extreme — it’s able to prove that the program meets the specifications at compile time, allowing for removal of most runtime checks.

Though many tout the freedom and efficiency of programming languages like C, these tend to be the ones that cause the most problems when it comes to bugs. That’s because the programmer must check for bugs rather than the compiler.

It’s true that the compiler can’t address a lot of bugs. However, having the compiler check on as many areas as possible allows developers to focus on those areas that the compiler can’t handle alone.

Will AI Help Create High-Quality Software?

When it comes to AI helping with software creation and maintenance, your mileage will vary. For many seasoned developers, it’s made repetitive chores easier. And many new or non-developers have been able to create applications without understanding the underlying code.

In some cases, AI-generated code has been good and bug-free while it’s added major bugs and security issues to applications in others. The field is still new and constantly changing, making it difficult to know where the results of AI and developers will work together in this wide spectrum.

I know that many will task AI with complete application creation and deployment. However, I hope that it will be used more to configure and manage tools like compilers and formal specifications. And that they will be overseen by people who can understand the implications of the system while using, say, compilers to implement the details in a consistent and repeatable fashion.

Check out the results of a few polls we’ve conducted related to software development:

I also gave a talk a while back on Creating Bug-Free Embedded Software.

Here are some videos on Certifiable Rust and Embeddable Rust that you might find interesting.