166,934 research outputs found
Approach for model-based requirements engineering for the planning of engineering generations in the agile development of mechatronic systems
The crucial factor for a successful usage of modeling approaches of systems engineering is the interaction of language, method, and tool. For this, specific challenges arise for the application of MBSE in agile requirements engineering. From observations in agile development practice at a machine tool manufacturer, the challenges for model-based requirements engineering are described and each is assigned to its critical aspect of modeling: The language must formally represent the requirements data model, especially for planning engineering generations. The tool must support collaborative, interdisciplinary cooperation, and consider the dynamics of the requirements model during the development process. The method must individually support the requirements engineering activities, which are carried out several times in a sprint during the development process and must enable a target-oriented process for bundling the requirements into engineering generations. Taking these demands into account, an approach is then presented providing activity-based views in conjunction with activity steps based on a consistent ontology for the description of product requirements and verification activities. The activity steps are composed in activity patterns and support the user in making use of the views for modeling requirements for the engineering generations. The approach is implemented in the software JIRA at a machine tool manufacturer. The subsequent evaluation shows that the approach is used in development practice and offers the potential to plan engineering generation systematically and comprehensibly and to ensure a regular review of the implemented requirements
Proceedings of the First NASA Formal Methods Symposium
Topics covered include: Model Checking - My 27-Year Quest to Overcome the State Explosion Problem; Applying Formal Methods to NASA Projects: Transition from Research to Practice; TLA+: Whence, Wherefore, and Whither; Formal Methods Applications in Air Transportation; Theorem Proving in Intel Hardware Design; Building a Formal Model of a Human-Interactive System: Insights into the Integration of Formal Methods and Human Factors Engineering; Model Checking for Autonomic Systems Specified with ASSL; A Game-Theoretic Approach to Branching Time Abstract-Check-Refine Process; Software Model Checking Without Source Code; Generalized Abstract Symbolic Summaries; A Comparative Study of Randomized Constraint Solvers for Random-Symbolic Testing; Component-Oriented Behavior Extraction for Autonomic System Design; Automated Verification of Design Patterns with LePUS3; A Module Language for Typing by Contracts; From Goal-Oriented Requirements to Event-B Specifications; Introduction of Virtualization Technology to Multi-Process Model Checking; Comparing Techniques for Certified Static Analysis; Towards a Framework for Generating Tests to Satisfy Complex Code Coverage in Java Pathfinder; jFuzz: A Concolic Whitebox Fuzzer for Java; Machine-Checkable Timed CSP; Stochastic Formal Correctness of Numerical Algorithms; Deductive Verification of Cryptographic Software; Coloured Petri Net Refinement Specification and Correctness Proof with Coq; Modeling Guidelines for Code Generation in the Railway Signaling Context; Tactical Synthesis Of Efficient Global Search Algorithms; Towards Co-Engineering Communicating Autonomous Cyber-Physical Systems; and Formal Methods for Automated Diagnosis of Autosub 6000
A Petri Net Approach to Verify and Debug Simulation Models
Verification and Simulation share many issues, one is that simulation
models require validation and verification. In the context of simulation,
verification is understood as the task to ensure that an executable simulation model
matches its conceptual counterpart while validation is the task to ensure that a simulation
model represents the system under study well enough with respect to the goals of the simulation study.
Both, validation and verification, are treated in the
literature at a rather high level and seem to be more an art than
engineering. This paper considers discrete event simulation of
stochastic models that are formulated in a process-oriented language.
The ProC/B paradigm is used as a particular example of a class of
simulation languages which follow the common process interaction
approach and show common concepts used in performance modeling,
namely a) layered systems of virtual machines that contain resources and
provide services and b) concurrent processes that interact by
message passing and shared memory.
We describe how Petri net analysis
techniques help to verify and debug a large and detailed simulation model of
airport logistics. We automatically derive a Petri net that models the control
flow of a Proc/B model and we make use of invariant analysis and modelchecking to shed
light on the allocation of resources, constraints among entities and
causes for deadlocks
Business Modeling with the Support of Multiple Notations in Requirements Engineering
Requirements specification should not be concerned only with the software specification, but should also be able to integrate with the organizational models describing the environment in which the system will function. Agentāoriented conceptual modeling notations such as i* represents an interesting approach for modeling early phase requirements which includes organizational contexts, stakeholder intentions and rationale. Business Process Modeling notations such as BPMN are used to effectively conceptualize and communicate important process characteristics to relevant stakeholders. On the other hand, Unified Modeling Language (UML) is suitable for later phases of requirement capture which usually focus on completeness, consistency, and automated verification of functional requirements for the new system. In this paper, we illustrate the use of a methodology that facilitate and support the combined use of notation for modeling requirement engineering process in a synergistic fashion in a complex project for a large government Department. The notations we used were i*, BPMN and UML Use Case
A Framework for Analyzing Composition of Security Aspects
The methodology of aspect-oriented software engineering has
been proposed to factor out concerns that are orthogonal to the core
functionality of a system. In particular, this is a useful approach to handling
the difficulties of integrating non-functional requirements such as
security into complex software systems. Doing so correctly and securely,
however, still remains a non-trivial task. For example, one has to make
sure that the "weaving" process actually enforces the aspects needed.
This is highly non-obvious especially in the case of security, since different
security aspects may actually contradict each other, in which case
they cannot be woven in a sequential way without destroying each other.
To address these problems, this paper introduces a framework for the
aspect-oriented development of secure software using composition filters
at the model level. Using an underlying foundation based on streamprocessing
functions, we explore under which conditions security properties
are preserved when composed as filters. Thanks to this foundation
we may also rely on model level verification tools and on code and model
weaving to remedy security failures. Our approach is explained using as
case-studies a web banking application developed by a major German
bank and a webstore design
A Logical Verification Methodology for Service-Oriented Computing
We introduce a logical verification methodology for checking behavioural properties of service-oriented computing systems. Service properties are described by means of SocL, a branching-time temporal logic that we have specifically designed to express in an effective way distinctive aspects of services, such as, e.g., acceptance of a request, provision of a response, and correlation among service requests and responses. Our approach allows service properties to be expressed in such a way that
they can be independent of service domains and specifications. We show an instantiation of our general methodology that uses the formal language COWS to conveniently specify services and the expressly developed software tool CMC to assist the user in the task of verifying SocL formulae over service specifications. We demonstrate feasibility and effectiveness of our methodology by means of the specification and the analysis of a case study in the automotive domain
- ā¦