# AdaCore Advocates Memory-Safe Programming for Enhanced Software Security

> As AI tools advance in their ability to identify software vulnerabilities, AdaCore advocates for a shift to languages like Ada and SPARK to enhance safety and security in high-integrity software systems.

**Source**: google.com | **Published**: 2026-08-14 | **Type**: article

## Key Facts

- AdaCore's shift to Ada/SPARK or Rust highlights a market demand for memory-safe programming.
- LLMs uncover defects in compiled binaries, revealing vulnerabilities in existing C/C++ systems.
- Transitioning to safer languages may incur retraining costs but reduces long-term risk exposure.
- Formal methods in Ada can prove absence of runtime errors, enhancing trust in software safety.
- Human review processes must evolve; deterministic AI tools can streamline functional safety compliance.

## Summary

AdaCore, a leader in high-integrity software development, is advocating for a shift in programming languages to enhance safety and security in software systems. This recommendation comes at a time when the automotive and aerospace industries are grappling with increasing demands for memory safety and functional integrity. The company’s head of technical marketing, Mark Hermeling, emphasizes the limitations of traditional languages like C and C++, which, despite their historical utility, pose significant risks due to memory safety issues such as buffer overruns and null pointer dereferences.

The urgency for change is underscored by the evolving landscape of software development, where the integration of artificial intelligence (AI) tools is becoming commonplace. Hermeling points out that large language models (LLMs) are now capable of identifying defects in compiled binaries, not just source code. This capability highlights a critical need for organizations to reassess their verification strategies and attack surfaces. As AI tools become more adept at uncovering vulnerabilities, relying solely on established programming practices may no longer suffice.

Adopting languages like Ada, SPARK, or Rust offers a proactive approach to mitigating these risks. These languages are designed to enforce memory safety through formal methods, allowing developers to prove the absence of runtime errors during the compilation process. This contrasts sharply with the MISRA standards, which, while helpful, do not guarantee complete safety. The transition to these more robust languages may involve retraining costs, but the long-term benefits include reduced engineering friction and increased trust in software quality.

The competitive dynamics in the automotive and aerospace sectors are shifting as companies recognize the necessity of integrating advanced programming methodologies. Organizations that embrace these changes may find themselves at a strategic advantage, particularly as regulatory bodies increasingly emphasize safety and security in software development. The push for compliance with ISO standards and the need for rigorous validation processes further amplify the importance of adopting safer programming practices.

As AI continues to evolve, its role in software development will only grow. Hermeling suggests that teams should rethink their methodologies, moving away from traditional practices that may no longer adequately address the complexities introduced by AI. The potential for AI to surface previously undetected vulnerabilities necessitates a shift towards programming languages that inherently reduce risk.

Looking ahead, the integration of formal verification methods alongside AI-generated code could redefine quality assurance processes. By enabling engineers to focus on aligning specifications with requirements rather than sifting through extensive lines of code, organizations can enhance their efficiency and reliability. As the industry adapts to these changes, companies that prioritize the adoption of memory-safe languages and formal verification methods will likely lead the way in delivering high-integrity software solutions, setting new benchmarks for safety and performance in the sector.

## Entities

- **Companies**: AdaCore, Toyota, Google
- **Products**: Ada, SPARK, Rust
- **Technologies**: LLMs, formal methods
- **People**: Mark Hermeling, Sebastian Blanco
- **Organizations**: SAE Automotive Engineering Magazine

## Key Concepts

AI in software development, Memory safety, Functional safety, MISRA standards, Formal verification, Human in the loop, Software development tools, High integrity software

## Definitions

- **Memory safety**: A programming language's ability to prevent common errors such as buffer overruns and null pointer dereferences.
- **Functional safety**: The part of the overall safety that ensures a system operates correctly in response to its inputs.
- **Formal methods**: Mathematical techniques used to prove the correctness of software and ensure it meets specified requirements.
- **LLMs**: Large Language Models that can analyze and generate code, identifying defects and undefined behaviors.
- **MISRA standards**: A set of guidelines for the safe use of the C and C++ programming languages in critical systems.

## Use Cases

- Switching from C/C++ to Ada/SPARK or Rust for safety-critical applications
- Using LLMs to identify defects in compiled binaries
- Implementing formal methods to ensure memory safety
- Enhancing software development processes in automotive and aerospace industries
- Reducing the burden of code reviews through automated verification
- Aligning validation strategies with ISO standards

## Frequently Asked Questions

**What are the benefits of using Ada or SPARK over C/C++?**

Ada and SPARK provide memory safety features that help prevent common programming errors found in C/C++. They also allow for formal verification, which can prove the absence of runtime errors.

**How can LLMs improve software quality?**

LLMs can analyze both source code and compiled binaries to identify defects and undefined behaviors. This capability helps teams uncover security vulnerabilities that may not be visible through traditional testing methods.

**What role do formal methods play in software development?**

Formal methods provide a rigorous way to verify that software meets its specifications and is free from certain types of errors. They can significantly reduce the need for extensive manual code reviews.

**Is it safe to use AI-generated code in critical systems?**

Yes, as long as the AI-generated code undergoes a thorough functional safety quality process. This ensures that the code meets safety requirements and is reliable.

**What challenges do teams face when transitioning to memory-safe languages?**

Teams may encounter retraining costs and the need to adapt their existing processes. However, the long-term benefits of improved safety and reduced errors often outweigh these initial challenges.

## Links

- [Read on Welcome.AI](https://welcome.ai/content/adacore-advocates-memory-safe-programming-for-enhanced-software-security)
- [Original source](https://www.google.com/url?rct=j&sa=t&url=https://www.techbriefs.com/component/content/article/55648-expert-insight-ai-risk-reduction-with-adacore&ct=ga&cd=CAIyGjBhYTY2NTYyNmEwMjY5ZjU6Y29tOmVuOlVT&usg=AOvVaw2R7Yvdg_FaTdul8vzFTIe0)
- [AdaCore](https://welcome.ai/company/adacore): Featured company

---

Source: Welcome.AI | https://welcome.ai/content/adacore-advocates-memory-safe-programming-for-enhanced-software-security