Case Study: Enforcing DO-178C and Architecture Control in Aerospace Software Development

Case Study: Enforcing DO-178C and Architecture Control in Aerospace Software Development

Industry: Aerospace & DefenseClient Profile: Global aerospace contractor (undisclosed)Domain: Avionics software for flight control and navigation systemsTeam Size: 100+ engineers in distributed locationsLanguages: C and C++Key Standards: DO-178C, MISRA C/C++, JSF++ AV

The Challenge

A leading aerospace technology company was developing embedded software for next-generation avionics. The software had to comply with DO-178C Level A safety standards — the highest assurance level for airborne systems — along with strict internal coding guidelines and industry standards like MISRA C and JSF++ AV.

Despite a highly qualified team and a rigorous V&V process, they faced the following recurring challenges:

• Lack of architectural visibility: Teams struggled to validate design-layering policies and detect unintended dependencies across modules.
• Manual compliance overhead: Code reviews for standards like MISRA were lengthy and error-prone, especially in legacy modules.
• Audit complexity: Preparing evidence for DO-178C objectives (especially A-5, A-6, A-7) required manual effort and lacked traceability.
• Long software lifecycle: Changes made in current projects had to remain maintainable and safe for at least 15–20 years.

They needed a scalable, automated solution to monitor architectural consistency, ensure coding standard adherence, and streamline documentation for certification.

The Solution: CppDepend

CppDepend was selected after an internal pilot with three candidate tools. The deciding factors were:

• Ability to customize rules using CQLinq to match JSF++ AV and MISRA interpretations
• Visual dependency graphs to monitor architecture across teams and time
• Support for long-term maintainability tracking (technical debt, code churn, metric trends)
• CI/CD integration that allowed enforcement without slowing productivity

CppDepend was positioned as the central analysis engine in their Verification and Validation (V&V) strategy, particularly for structural coverage and design rule enforcement.

Implementation

Phase 1 – Pilot (4 weeks)

• Analyzed a legacy avionics subsystem (~400k LOC) used in flight stabilization
• Detected 1,200+ rule violations (many from hidden include chains and unintended cross-layer calls)
• Created baseline architecture diagrams and dashboards

Phase 2 – Policy Definition (6 weeks)

• Defined ~80 custom CQLinq rules representing internal architecture and JSF++ AV constraints
• Created alerts for unsafe type casting, dynamic memory use, and layering breaches
• Tailored reports to match DO-178C documentation structure (SOI-2 / SOI-3)

Phase 3 – CI Integration & Team Enablement (8 weeks)

• CppDepend integrated into Jenkins-based CI pipeline
• All builds generated compliance reports and technical debt metrics
• Developers received real-time feedback on code violations within pull requests

Results After 3 Months

Outcomes & Benefits

• DO-178C Support: CppDepend helped meet objectives A-5 (Design), A-6 (Implementation), and A-7 (Code Standards) by automating verification of coding standards, control flow complexity, and architectural structure.
• Long-Term Code Health: By continuously tracking metrics such as code churn, coupling, and debt, the team could better plan refactors without jeopardizing certification.
• Reduced Audit Burden: Reports generated by CppDepend were used directly in SOI-2 and SOI-3 documentation, eliminating days of manual work.
• Improved Development Velocity: With quality gates in place, developers could focus on functionality while ensuring compliance in the background.

Why CppDepend?

CppDepend stood out not only for its static analysis power, but also for its extensibility and visualization tools. In a safety-critical domain where every change requires documentation, traceability, and justification, CppDepend became an integral part of the software engineering workflow.

Conclusion

CppDepend gave this aerospace team a scalable and automated way to enforce architectural policies, track code quality over time, and reduce certification overhead. By shifting code analysis left — and making structure and standards visible at every step — they were able to build safer, cleaner, and more certifiable avionics software.

← Back to Aerospace & Defense overview