Specifying and Composing Non-functional Requirements in Model-Based Development

2009 ◽  
pp. 72-89 ◽  
Author(s):  
Ethan K. Jackson ◽  
Dirk Seifert ◽  
Markus Dahlweid ◽  
Thomas Santen ◽  
Nikolaj Bjørner ◽  
...  
Keyword(s):  
Functional Requirements ◽  
Model Based

Towards Test-Driven and Architecture Model-Based Security and Resilience Engineering

2013 ◽  
pp. 163-188
Author(s):  
Ayda Saidane ◽  
Nicolas Guelfi
Keyword(s):  
Software Systems ◽  
Critical Systems ◽  
Functional Requirements ◽  
Security Testing ◽  
Modeling Framework ◽  
Architecture Model ◽  
Model Based ◽  
Security Modeling

The quality of software systems depends strongly on their architecture. For this reason, taking into account non-functional requirements at architecture level is crucial for the success of the software development process. Early architecture model validation facilitates the detection and correction of design errors. In this research, the authors are interested in security critical systems, which require a reliable validation process. So far, they are missing security-testing approaches providing an appropriate compromise between software quality and development cost while satisfying certification and audit procedures requirements through automated and documented validation activities. In this chapter, the authors propose a novel test-driven and architecture model-based security engineering approach for resilient systems. It consists of a test-driven security modeling framework and a test based validation approach. The assessment of the security requirement satisfaction is based on the test traces analysis. Throughout this study, the authors illustrate the approach using a client server architecture case study.

Towards Test-Driven and Architecture Model-Based Security and Resilience Engineering

2014 ◽  
pp. 2072-2098
Author(s):  
Ayda Saidane ◽  
Nicolas Guelfi
Keyword(s):  
Software Systems ◽  
Critical Systems ◽  
Functional Requirements ◽  
Security Testing ◽  
Modeling Framework ◽  
Architecture Model ◽  
Model Based ◽  
Security Modeling

The quality of software systems depends strongly on their architecture. For this reason, taking into account non-functional requirements at architecture level is crucial for the success of the software development process. Early architecture model validation facilitates the detection and correction of design errors. In this research, the authors are interested in security critical systems, which require a reliable validation process. So far, they are missing security-testing approaches providing an appropriate compromise between software quality and development cost while satisfying certification and audit procedures requirements through automated and documented validation activities. In this chapter, the authors propose a novel test-driven and architecture model-based security engineering approach for resilient systems. It consists of a test-driven security modeling framework and a test based validation approach. The assessment of the security requirement satisfaction is based on the test traces analysis. Throughout this study, the authors illustrate the approach using a client server architecture case study.

A Model-Based Failure Identification and Propagation Framework for Conceptual Design of Complex Systems

2012 ◽  
Author(s):  
Hoda Mehrpouyan ◽  
David C. Jensen ◽  
Christopher Hoyle ◽  
Irem Y. Tumer ◽  
Tolga Kurtoglu
Keyword(s):  
System Architecture ◽  
Early Identification ◽  
Mitigation Strategies ◽  
Functional Requirements ◽  
Environmental Disturbances ◽  
Safety Issues ◽  
Model Based ◽  
Potential Safety ◽  
Failure Propagation ◽  
Failure Identification

In this paper, a model-based failure identification and propagation (MFIP) framework is introduced for early identification of potential safety issues caused by environmental disturbances and subsystem failures within a complex avionic system. The MFIP framework maps hazards and vulnerability modes to specific components in the system and analyzes failure propagation paths. Block definition diagrams (BDD) are used to represent system functional requirements in the form of demonstrating the relationships between various requirements, their associations, generalizations, as well as dependencies. These concept models help to identify hazardous factors and the relationships through which their detrimental effects are transferred through-out the proposed system architecture. As such, the approach provides the opportunity to reduce costs associated with redesign and provide important information on design viability. Using this technique, designers can examine the impacts of environmental and subsystem risks on the overall system during the early stages of design and develop hazard mitigation strategies.

Web Service QoS Matching Research Based on Ontology

2013 ◽  
Vol 385-386 ◽  
pp. 1679-1683
Author(s):  
Xin Bing Ma ◽  
Xiao Feng Zhou
Keyword(s):  
Web Service ◽  
Functional Requirements ◽  
Service Matching ◽  
Model Based ◽  
Ontology Model ◽  
Qos Parameters

In this article,take into account QoS characteristics comprehensively and build a reliable QoS ontology model. Based on the model,Web service QoS matching will be divided into three stages.Firstly,make a estimation of semantic comparability between QoS parameters of candidate services meeting the functional requirements and the QoS parameters of requirements in QoSIndependent ontology,find candidate services meeting users needs; Then,according to the critical QoS parameters between adjacent services constraints to further refine the matching between the candidate services;Finally choose the maximum service QoS value meeting the user requests in specific areas. So as to improve the efficiency and accuracy of service matching.

Separation of Concerns in Model-Based Development of Distributed Real-Time Systems

2010 ◽  
pp. 147-170
Author(s):  
Dionisio de Niz ◽  
Gaurav Bhatia ◽  
Raj Rajkumar
Keyword(s):  
Real Time ◽  
Fault Tolerant ◽  
Point Of View ◽  
Functional Structure ◽  
Real Time Systems ◽  
Functional Requirements ◽  
Model Based ◽  
Event Flow ◽  
Glue Code ◽  
Time Systems

Software is increasingly being used to enable new features in systems in multiple domains. These domains include automotive, avionics, telecomunication, and industrial automation. Because the user of these systems is not aware of the presence of the software, this type of software is known as embedded software. More importantly, such a software, and the whole system in general, must satisfy not only logical functional requirements but also parafunctional (a.k.a. nonfunctional) properties such as timeliness, security, and reliability. Traditional development languages and tools provide powerful abstractions such as functions, classes, and objects to build a functional structure that reduces complexity and enables software reuse. However, the software elements responsible for the parafunctional behaviors are frequently scattered across the functional structure. This scattering prevents the easy identification of these elements and their independent manipulation/reuse to achieve a specific parafunctional behavior. As a result, the complexity of parafunctional behaviors cannot be reduced and even worse, the construction of those behaviors can corrupt the functional structure of the software. In this chapter, we propose a model-based framework for designing embedded real-time systems to enable a decomposition structure that reduces the complexity of both functional and parafunctional aspects of the software. This decomposition enables the separation of the functional and parafunctional aspects of the system into semantic dimensions (e.g., event-flow, timing, deployment, fault-tolerant) that can be represented, manipulated, and modified independent of one another from an end-user point of view. The realizations of these dimensions, however, do interact on the target platform since they consume common resources and impose constraints. These interactions can be captured during model construction and resource demands mediated during platform deployment. The use of semantic dimensions results in three significant benefits. First of all, it preserves the independence of the functional structure from parafunctional behaviors. Secondly, it enables the user to manipulate different parafunctional concerns (e.g., timeliness, reliability) independent of one another. Lastly, it enables the reuse of compositions along any dimension from other systems. The second core abstraction in our modeling approach is an entity called a coupler. A coupler expresses a particular relationship between two or more components, and can also be used recursively. Couplers enable the hierarchical decomposition of functional as well as parafunctional aspects. Aided by semantic dimensions and multiple coupler types, our framework enables the auto-generation of glue code to produce a fully deployable system. Our framework can also construct a detailed timing and resource model. This model in turn is used to optimize the usage of a given hardware configuration, or synthesize a configuration to suit a given software model. Our framework is implemented in a tool (de Niz, Bhatia & Rajkumar 2006) called SysWeaver that had been used to generate glue code and analyze the timing behavior of avionics, automotive, and software-radio pilot systems.

Engineering Model-Based Software Testing of WIMP Interactive Applications

2021 ◽  
Vol 5 (EICS) ◽  
pp. 1-30
Author(s):  
Alexandre Canny ◽  
Célia Martinie ◽  
David Navarre ◽  
Philippe Palanque ◽  
Eric Barboni ◽  
...  
Keyword(s):  
Software Testing ◽  
Formal Model ◽  
Interactive Software ◽  
User Centered Design ◽  
Functional Requirements ◽  
Interactive Applications ◽  
Model Based ◽  
Threats To Validity ◽  
Interactive Application ◽  
And Performance

The goal of software testing is to detect defects with the objective of removing them at a later stage in the development process. Interactive software development follows the User Centered Design approach that promotes continuous involvement of users both at design and evaluation phases. This process is meant to produce usable interactive software by gathering functional and non-functional requirements related to both user needs and context of use. However, taking into account these potentially very-complex-to-implement requirements increases the complexity of the software that is likely, without appropriate methods and tools, to encompass a large number of defects. One of the limitations of UCD approaches is that it provides no guidance on the engineering of the interactive application, which thus usually embeds numerous defects resulting in failures at the origin of user frustrations and performance drops. Even though a classification of interactive application defects has been proposed, interactive application testers remain only superficially supported in detecting them. This paper defines a model-based approach to engineer the testing activity for interactive applications. It proposes a process that bridges the gap between UCD artefacts and interactive software implementation by the production of a dedicated formal model exploited for testing purposes only. The application of the process is demonstrated on an interactive cockpit WIMP application. Finally, threats to validity (capability of the approach to detect defects and to ensure an acceptable coverage testing of the interactive application) are addressed by a longitudinal study on 61 variants of a simple application developed by 61 different developers. ?

scholarly journals A model-based software development method for automotive cyber-physical systems

2011 ◽  
Vol 8 (4) ◽  
pp. 1277-1301 ◽  
Author(s):  
Zhigang Gao ◽  
Haixia Xia ◽  
Guojun Dai
Keyword(s):  
Software Development ◽  
Code Generation ◽  
Physical Environment ◽  
Source Code ◽  
Cyber Physical Systems ◽  
Functional Requirements ◽  
Development Method ◽  
Physical Systems ◽  
Implementation Model ◽  
Model Based

The development of automotive cyber-physical systems (CPS) software needs to consider not only functional requirements, but also non-functional requirements and the interaction with physical environment. In this paper, a model-based software development method for automotive CPS (MoBDAC) is presented. The main contributions of this paper are threefold. First, MoBDAC covers the whole development workflow of automotive CPS software from modeling and simulation to code generation. Automatic tools are used to improve the development efficiency. Second, MoBDAC extracts nonfunctional requirements and deals with them in the implementation model level and source code level, which helps to correctly manage and meet non-functional requirements. Third, MoBDAC defines three kinds of relations between uncertain physical environment events and software internal actions in automotive CPS, and uses Model Modifier to integrate the interaction with physical environment. Moreover, we illustrate the development workflow of MoBDAC by an example of a power window development.

Sign in / Sign up

Export Citation Format

Share Document