#include <iostream>
#include <memory>
#include <string>
// Abstract base class: Request
class Request {
public:
virtual void execute() = 0; // Pure virtual function
virtual ~Request() = default;
};
// Concrete class: ResetRequest
class ResetRequest : public Request {
public:
void execute() override {
std::cout << "Executing Reset Request" << std::endl;
}
};
// Concrete class: ClearDTCRequest
class ClearDTCRequest : public Request {
public:
void execute() override {
std::cout << "Executing Clear DTC Request" << std::endl;
}
};
// Factory Class: RequestFactory
class RequestFactory {
public:
static std::unique_ptr<Request> create(const std::string& data) {
if (data == "Reset") {
return std::make_unique<ResetRequest>();
} else if (data == "ClearDTC") {
return std::make_unique<ClearDTCRequest>();
} else {
return nullptr;
}
}
};
// Class: Service
class Service {
public:
bool validateData(const std::string& data) {
return !data.empty(); // Simple validation logic
}
void OnNewMessage(const std::string& data) {
if (validateData(data)) {
auto request = RequestFactory::create(data);
if (request) {
request->execute();
} else {
std::cout << "Invalid Request Type" << std::endl;
}
}
}
};
// Class: Connection
class Connection {
public:
void setOnMessageHandler(Service& service) {
// Simulate receiving messages
service.OnNewMessage("Reset");
service.OnNewMessage("ClearDTC");
service.OnNewMessage("InvalidRequest");
}
};
int main() {
Connection connection;
Service service;
connection.setOnMessageHandler(service);
return 0;
}
Poorly defined requirements are among the leading causes of project failures, driving up costs and delaying timelines. A study by the Project Management Institute revealed that inaccurate requirements are responsible for over 47% of project failures. This issue is especially critical in engineering, as defective requirements can lead to costly rework, operational inefficiencies, and even safety risks in regulated industries.
Requirements engineering is a complex discipline involving the identification, documentation, and verification of a system’s requirements. Traditionally, this process has relied heavily on manual effort, which is prone to errors such as ambiguity, inconsistency, and omissions.
Manual reviews are labor-intensive and subject to human bias, often missing subtle defects that later escalate into major project risks. Moreover, ensuring compliance with stringent guidelines like INCOSE, ISO 26262 (functional safety), and ASPICE (software process improvement) further complicates the process.
Generative AI offers a breakthrough solution to these challenges. Organizations can streamline the requirements verification process by leveraging advanced AI models like ChatGPT, making it faster, more accurate, and scalable. This article explores how AI-powered tools are revolutionizing engineering requirements reviews, aligning them with standards like INCOSE, ISO 26262, and ASPICE.
AI-powered tools like large language models (LLM) bring unparalleled efficiency and precision to requirements verification. These models evaluate requirements against industry guidelines, ensuring they are clear, complete, and technically accurate.
Unlike traditional methods, generative AI quickly processes large datasets, identifies defects, and provides real-time actionable insights. For example, ChatGPT-4, trained on INCOSE guidelines, can review requirements for completeness, ambiguity, and traceability while drawing on domain knowledge to evaluate technical accuracy.
The International Council on Systems Engineering (INCOSE) outlines six key characteristics of effective requirements, often called the “6Cs” to ensure that requirements are actionable and aligned with project goals:
| Characteristic | Definition | Example |
|---|---|---|
| Comprehensive | Addressing all aspects of the system's lifecycle, ensuring thorough consideration from conception to decommissioning. | Includes requirements for system operation, maintenance, and disposal, e.g., "The system shall operate under -20 °C to +80 °C and support remote diagnostics." |
| Collaborative | Promoting teamwork to integrate diverse perspectives. | Captures input from engineers, designers, and users, ensuring needs are met, e.g., "Requirements reviewed and approved by safety, usability, and compliance teams." |
| Consistent | Applying uniform processes and standards to maintain quality and reliability across projects. | Ensures no contradictions, e.g., "Speed shall be measured every second and logged consistently across all modules." |
| Communicative | Ensuring clear and effective information exchange among all parties involved | Requirements are easy to understand and avoid ambiguity, e.g., "The system shall alert within 10 ms if speed exceeds 2000 RPM." |
| Creative | Encouraging innovative problem-solving approaches to tackle complex challenges. | Emphasizes flexibility, e.g., "The system shall leverage modular architecture to adapt to future technology upgrades." |
| Critical | Engaging in thorough analysis and evaluation to make informed, effective decisions. | Requires detailed validation, e.g., "Each requirement must be verified through simulation and testing before approval." |
Defective requirements often exhibit the following red flags:
AI-powered tools for requirements verification offer several compelling advantages including:
Consider the following set of requirements for a motor monitoring system:
| Requirement ID | Description | Defect | Suggestion |
|---|---|---|---|
| R1 | "The system shall continuously measure motor speed." | Ambiguity: "Continuously" is vague. | Specify a sampling rate (e.g., every 1 second). |
| R3 | "The system shall provide alerts in acceptable time." | Unverifiable: "Acceptable time" lacks a clear definition. | Define "acceptable time" with measurable criteria (e.g., within 10 milliseconds). |
| R6 | "The system shall support real-time diagnostics." | Ambiguity: "Real time" is not defined. | Specify latency thresholds (e.g., less than 100 ms). |
Using generative AI, these defects were identified within seconds, along with clear recommendations to resolve them. This automation dramatically reduces review times while ensuring adherence to standards.
Generative AI tools extend their utility beyond INCOSE by aligning with other industry frameworks like ISO 26262 and ASPICE. For example, ISO 26262 ensures functional safety in automotive systems by verifying that requirements mitigate risks, while ASPICE focuses on process quality, ensuring traceability and compliance with software development best practices.
AI models can integrate these guidelines into their reviews, offering holistic verification across multiple frameworks.
Automated requirements verification is no longer a luxury; it’s a necessity in today’s fast-paced engineering landscape. By leveraging AI-powered tools like ChatGPT, organizations can streamline their review processes, ensuring that requirements are accurate, complete, and compliant with industry standards.
Generative AI not only reduces manual effort but also enhances scalability and accuracy, making it an invaluable asset for modern engineering teams.
Ready to revolutionize your requirements review process? Explore our AI-powered requirement review tools today and experience the benefits firsthand. Book a meeting today to learn more!
Other Articles
AI-powered requirement review tools simplify engineering verification, ensuring accuracy, efficiency, and compliance with INCOSE guidelines. Learn more about it here.
Managing and optimizing thread overhead is important for safety-critical and embedded systems. Learn more about the C++ multithread common myths here.
Managing and optimizing thread overhead is important for safety-critical and embedded systems. Learn more about the C++ multithread common myths here.
Discover the critical role of effective interface management in complex systems. Learn how centralized tools, AI-powered solutions, and well-defined processes can prevent errors, enhance collaboration, and ensure safety in industries like automotive and aerospace.
The system requirements analysis process under ASPICE and ISO26262 frameworks shapes automotive system architecture design for enhanced safety, reliability, and compliance. Learn more about it here.
Compliance with ASPICE and ISO26262 standards provides a significant impact on automotive software development. Learn more about it here.
AI technologies like ChatGPT-4 are revolutionizing requirements engineering by improving accuracy, consistency, and efficiency. Learn about the role of AI in refining, validating, and managing project requirements here.
Model-Based Systems Engineering (MBSE) offers a robust framework to streamline the entire engineering process, from design to validation. Learn more about it here.
Data-Oriented Design (DOD) can revolutionize automotive software development by enhancing performance, reducing costs, and minimizing hardware requirements. Learn more about it here.
Explore the evolution of functional safety, its growing importance in industries like automotive, and the critical role of Fault Tolerant Time Interval (FTTI) in ensuring system reliability. Learn how FTTI, along with Malfunctioning Behavior Manifestation Time (MBMT) and Hazard Manifestation Time (HMT), contributes to robust safety designs, preventing hazards in safety-related systems such as ADAS and autonomous vehicles. Discover the impact of ISO 26262 standards on the development of effective fault detection and reaction mechanisms in automotive safety.
While ISO 26262 primarily addresses functional safety, SOTIF extends the scope to focus on potential hazards arising from system behaviour, even when the system functions as intended. Learn more about it here.
Discover the risks of reinterpret_cast in safety-critical software and explore safe alternatives like polymorphism and templates for robust, efficient code.
In a rapidly evolving technological landscape, the demand for systems that can not only withstand errors but also adapt to them is paramount. This article delves into the world of Fault-Tolerant (FT) systems, emphasizing their significance in maintaining the functionality and safety of critical operations across various sectors. It explores the latest advancements in FT technology, underscoring the importance of resilience and adaptability in ensuring uninterrupted service and safeguarding against potential failures.
In a rapidly evolving technological landscape, the demand for systems that can not only withstand errors but also adapt to them is paramount. This article delves into the world of Fault-Tolerant (FT) systems, emphasizing their significance in maintaining the functionality and safety of critical operations across various sectors. It explores the latest advancements in FT technology, underscoring the importance of resilience and adaptability in ensuring uninterrupted service and safeguarding against potential failures.
Discover the transformative impact of Software-Defined Networking (SDN) and Multicast Addressing on automotive embedded systems. Explore how these technologies enhance communication efficiency, safety, and performance in the automotive industry, leading to cost-effective, scalable, and eco-friendly solutions. Dive into the technical advantages and practical applications for modern vehicles and infrastructure.
Discover how ChatGPT revolutionizes engineering with AI, accelerating learning, enhancing safety, and boosting productivity.
Defect Escape Reduction Rate and feedback loop elevate testing. Learn more about them here.
ASPICE and ISO26262 frameworks improve system development in the automotive industry, ensuring safety, compliance, and high-quality standards.
Conducting software FMEA, FTA, and compliance with ISO 26262 helps developers create software that meets stringent safety requirements. Learn more about it here.
Explore the challenges of dynamic memory allocation in critical software, learn how to mitigate failures, and ensure the reliability of safety-critical systems. Real-life failures and practical solutions are discussed.
Strong types are a key concept in C++ programming for functional safety. Learn how strong types can reduce errors in critical systems with C++.
Unit testing is an essential part of the software development process. Learn more about it here.
Learn about categorizing requirements, including functional, non-functional, performance, interface etc for effective system management and development.
Writing clear and unambiguous requirements for the automotive industry is important to avoid potential safety risks. Learn more about it here.
