Search

The development of systems with different features becomes increasingly challenging, given the actual context, implying on the search for new approaches for requirements elicitation. One of these approaches is design thinking (DT), a process of encouraging innovation used by designers, which presents itself as fundamental in the success of new products. This scenario motivates the importance of knowing DT concepts and their techniques, which can support requirements elicitation. In this context, the authors present DTA4RE (DT assistant for requirements elicitation), a tool that suggests DT techniques for requirements elicitation, which can be used by both students and professionals who would like to adopt DT in their projects. The DTA4RE is composed of a set of 27 techniques that could be suggested to the user through a recommendation questionnaire as well as an open repository with material to support the application of these techniques. Results from the authors' two empirical studies with software engineering undergraduate and graduate students and industry professionals indicate that DTA4RE has helped in the selection of and in the learning of DT techniques when considering real problems. Most participants considered the questions from the recommendation questionnaire easy to answer, and the techniques suggested by the tool useful. [ABSTRACT FROM AUTHOR]

Requirements prioritisation deals with the ranking or classification of user requirements based on their importance. This process is central to releasing a software product with features most favoured by users. While studies have explored the efforts that are dedicated to this cause, these tend to focus on a subset of the solutions that are available in the software engineering domain. Current techniques investigated in the software engineering domain do not consider the strengths inherent in requirements prioritisation techniques developed in other disciplines (e.g. product manufacturing), a gap that should be addressed. The authors thus conducted a comprehensive systematic mapping study and critical evaluation of studies that have provided implementations of requirements prioritisation techniques across multiple disciplines (including software engineering, product manufacturing, and engineering). Among their findings, they observed that while many solutions are targeted, quite often researchers have proposed solutions that were not evaluated. Most solutions were only validated as being operational, and the attributes studied had limited effects on performance outcomes. Their evidence suggests that new techniques may address the requirements prioritisation challenge if they are inspired by hybrid approaches developed across multiple disciplines. In addition, performance trade‐offs are to be expected of such techniques, depending on their performance targets. [ABSTRACT FROM AUTHOR]

In Punjab Pakistan, a river flood event is the most important natural disasters that every year causes high human casualties as well as heavy economic losses. A safety-critical system should be correct, reliable, complete, consistent, and unambiguous for accurate and precise flood monitoring, prediction, as well as emergency and rescue services during or after a flood event. System correctness must be ensured in every phase of the development of a safety-critical Flood Monitoring, Prediction, and Rescue (FMPR) system. Correctness is a functional property related to the behavior of the system having sub-properties of safety and liveness. These sub-properties must also be correct, complete, consistent, and unambiguous. Rigorous mathematical based software engineering methods like formal methods are suitable for the specification, design, modeling, verification, and validation of an FMPR safety-critical system. The proposed safety-critical system for FMPR is distributed as it is based on multi-agents. This system is specified, analyzed and designed by using Gaia multi-agent methodology, which is based on organizational abstractions. Gaia role model-based agent roles are specified, regular expression based liveness properties are specified, and first-order predicate calculus based safety properties are specified. Thus, safety and liveness properties are formally specified. After the detailed design phase, the system is formally modeled and verified by Hierarchical Coloured-Petri Nets (CP-Nets). As a result, a novel formal system for the specification, analysis, design, modeling, and verification of the FMPR system is proposed. This safety-critical system is distributed based on multi-agents.

Forests are an enduring component of the natural world and perform a vital role in protecting the environment. Forests are valuable resources to control global warming and provide oxygen for the survival of human life, including wood for households. Forest fires have recently emerged as a major threat to biological processes and the ecosystem. Unfortunately, almost every year, fire damages millions of hectares of forest land due to late and inefficient detection of fire. However, it is important to identify the forest fire at the initial level before it spreads to vast areas and destroys natural resources. In this paper, a formal model of the Internet of Things (IoT) and drone-based forest fire detection and counteraction system is presented. The proposed system comprises network maintenance. Sensor deployment is on trees, the ground, and animals in the form of subnets to transmit sensed data to the control room. All subnets are connected to the control room through gateway nodes. Alarms are being used to alert human beings and animals to save their lives, which will help to initially protect them from fire. The embedded sensors collect the information and transfer it to the gateways. Drones are being used for real-time visualization of fire-affected areas and to perform actions to control fires because they play a vital role in disasters. Graph theory is used to construct an efficient model and to show the connectivity of the network. To identify failures and develop recovery procedures, the algorithm is designed through the graph-based model. The model is developed by the Vienna Development Method-Specification Language (VDM-SL), and the correctness of the model is ensured using various VDM-SL toolbox facilities.

This study presents a formal description and verification method of the ontology transformation process of the distribution network information model based on the meta-model theory. By defining the dynamic change structures and model mapping constraints of the ontology transformation process of distribution network, a formalised specification for describing the key attributes of model updating and model mapping processes was constructed. The model updating and model mapping instances were specified using model checking verification tool SPIN. The method fundamentally guarantees the standardisation and reliability of the model ontology transformation process achieved by the meta-model.

Sequencing constraints are restrictions on the order of operations (statements, methods, or calls) during program execution. They trigger software failures if sequencing constraints are violated during software execution; this is a common defect in software systems. Sequencing constraint defects are difficult to find because they are specification-related. To resolve this issue, we propose a defect detection approach based on static analysis. In our approach, first, we formalize the sequencing constraints as regular expressions extracted from software specification, and define regular expression of defect patterns that violate sequencing constraints. Then, the software is converted into a control flow graph (CFG), and the CFG is labeled by the constraint information to generate a sequencing-constraint control flow graph (SC-CFG) that is converted into a path expression using algebraic representation. Finally, a suspiciousness defect report is outputted by pattern matching, which compares defect patterns with string patterns extracted by the path expression. The experiments are performed to validate the effectiveness of our approach. The evaluation results show that our approach is effective at detecting sequencing constraint defects before software testing. [ABSTRACT FROM AUTHOR]

Requirement prioritisation and selection is an essential activity in modern‐day large software development. Optimal prioritisation process is critical for successful implementation and release planning in a software development project. Requirement prioritisation becomes more challenging in projects having large sets of requirements and stakeholders, having diverse perspectives resulting in irrelevancy and ambiguity during features extraction. This study aims to improve requirement prioritisation process using text mining and clustering techniques for accurate extraction of features and requirement prioritisation in multi‐stakeholder context. The proposed framework developed to avoid incompleteness in requirements and disagreement among development teams and stakeholders. Thus, the proposed framework compared with other requirement prioritisation techniques (i.e. Analytical Heretical Process, Commutative Voting and Wiegers) to highlight the significance of the proposed framework while conducting an experimental study. The results show that the proposed framework outperformed the traditional techniques and enhanced the prioritisation process with complete semantic information of extracted features and taking into account the diverse perspective of stakeholders. [ABSTRACT FROM AUTHOR]

Autonomous robotic systems are complex, hybrid, and often safety critical; this makes their formal specification and verification uniquely challenging. Though commonly used, testing and simulation alone are insufficient to ensure the correctness of, or provide sufficient evidence for the certification of, autonomous robotics. Formal methods for autonomous robotics have received some attention in the literature, but no resource provides a current overview. This article systematically surveys the state of the art in formal speci- fication and verification for autonomous robotics. Specially, it identifies and categorizes the challenges posed by, the formalisms aimed at, and the formal approaches for the specification and verification of autonomous robotics. [ABSTRACT FROM AUTHOR]

In this paper, we study the problem of formal verification for Answer Set Programming (ASP), namely, obtaining a formal proof showing that the answer sets of a given (non-ground) logic program P correctly correspond to the solutions to the problem encoded by P, regardless of the problem instance. To this aim, we use a formal specification language based on ASP modules, so that each module can be proved to capture some informal aspect of the problem in an isolated way. This specification language relies on a novel definition of (possibly nested, first order) program modules that may incorporate local hidden atoms at different levels. Then, verifying the logic program P amounts to prove some kind of equivalence between P and its modular specification. [ABSTRACT FROM AUTHOR]

There is a significant need to give careful consideration to the Capability Maturity Model Integration (CMMI) level 2 specific practices (i.e. SP 1.1 'understand requirements' and SP 1.2 'obtain commitment to requirements'), especially in the context of small‐ and medium‐sized software development organisations, in order to assist such organisations in effectively managing their requirements engineering processes. In this study, the authors propose an abstract‐level model for each of these two specific practices as well as cover the initial evaluation of the models. In addition, necessary templates and checklists are also provided for each proposed model. The proposed models are based on a significant amount of research in software process improvement, CMMI and requirements engineering. The initial evaluation of the proposed models was executed using an expert panel review process. The results showed that the proposed models provide ease of learning and ease of use, provide stakeholder satisfaction and can be applied to small‐and medium‐sized software development organisations. It is important to highlight that this study contributes not only to the implementation of SP 1.1 and SP 1.2 of REQM process area in the context of small‐ and medium‐sized software development organisations but also to the body of knowledge on REQM. [ABSTRACT FROM AUTHOR]

Various robots are playing critical roles in many areas such as industrial manufacturing, disaster rescuing, unmanned vehicle, and science exploration. Because of the uncertain environment, changed resource, or dynamic system structure at runtime, traditional methods such as testing, model checking, and static analysis used in the development stage are not enough to ensure that the executions of robot control software satisfy specified properties. In this paper, we propose a runtime verification approach called Robots Monitor on Multilayer (RMoM) based on robot operating system (ROS) for monitoring whether the running of a robot swarm violates given temporal properties. To monitor robot system in a comprehensive manner over multiple layers, RMoM unifies resource, communication, robot, and swarm properties into a systemic, hierarchical monitoring framework. A discrete-time Metric Temporal Logic (MTL $_3$) RMoM is proposed for specifying properties with timed and parameterized characteristics in robot swarms. Then, the corresponding three-valued semantics is defined for MTL $_3$ -RMoM to generate impartial and anticipatory monitors. Moreover, a hierarchical monitoring specification language high-level specification language (HSL)-RMoM and a series of monitor construction algorithms are proposed to automatically generate monitors for MTL $_3$ -RMoM properties on ROS platform. The experiments show that the method can automatically generate the monitors for detecting properties of robot swarms. [ABSTRACT FROM AUTHOR]

This paper reports on the development of a formal model for the Hybrid ERTMS/ETCS Level 3 concept in Electrum, a lightweight formal specification language that extends Alloy with mutable relations and temporal logic operators. We show how Electrum and its Analyzer can be used to perform scenario exploration to validate this model, namely to check that all the operational scenarios described in the reference document are admissible, and to reason about expected safety properties, which can be easily specified and model checked for arbitrary track configurations. We also show how the Analyzer can be used to depict scenarios (and counter-examples) in a graphical notation that is logic-agnostic, making them understandable by stakeholders without expertise in formal specification. [ABSTRACT FROM AUTHOR]

In order to handle undesirable failures of a multicopter, which occurs in either the pre-flight process or the in-flight process, a failsafe mechanism design method based on supervisory control theory (SCT) is proposed for the semi-autonomous control mode. The failsafe mechanism is a control logic that guides what subsequent actions the multicopter should take, by taking account of real-time information from guidance, attitude control, diagnosis and other low-level subsystems. In order to design a failsafe mechanism for the multicopters, safety issues of the multicopters are introduced. Then, user requirements including functional requirements and safety requirements are textually described, where functional requirements guide the modelling of a general multicopter plant, and safety requirements cover the failsafe measures dealing with the presented safety issues. Based on these requirements, several multicopter modes and events are defined. On this basis, the multicopter plant and control specifications are modelled by automata. Then, a supervisor is synthesized by using SCT. In addition, the authors present three examples to demonstrate the potential conflicting phenomena due to the inappropriate design of control specifications. Finally, based on the obtained supervisor, an implementation method suitable for multicopters is presented, in which the supervisor is transformed into decision-making codes.

The assurance of required quality properties is one of the major challenges in self-adaptive systems (SASs). SASs have the capability to adapt their dynamic behavior autonomously at runtime due to uncertain changes in the environment. In general, an SAS is much difficult to specify and verify, because of its highly complex internal behavior and especially when time constraints are involved. In this research, we use modal μ-calculus (Mμ) for the specification and verification of colored Petri nets-based self-adaptive concurrent systems. We propose self-adaptive multi-agent concurrent system (SMACS) framework that is specifically designed for complex architectures. The internal structure of SMACS framework is based on MAPE-K feedback loop. Each phase of the feedback loop works as an internal agent (Int-Agent) known as Monitor Int-Agent, Analyzer Int-Agent, Planer Int-Agent, and Executer Int-Agent. The decentralized approach is being used in this research, and due to this approach, all agents intelligently adapt their behavior in the environment and send updates to other agents. For verification of internal properties like liveness, safeness, and deadlock-freedom of each agent, the TAPA model checker is being used. For the implementation of SMACS framework, traffic monitoring system is chosen as a case study.

Formal verification of information flow security with dynamic policies of security-critical systems is a grand challenge. This paper presents the first effort to formally specify and verify a capability-based system model with dynamic information flow policies. We build a generic security model with dynamic security policies. In the security model, we define a set of information flow security properties and provide an inference framework for them. Based on the security model, we propose a system model for capability-based secure systems. The system model specifies critical events including system initialization, inter-domain communication, and capability management. We prove information flow security of the capability-based model by an unwinding theorem. Formal specification and security proof are carried out in the Isabelle/HOL theorem prover and could be applied to formally develop and verify the security of capability-based secure systems, such as separation kernels and secure hypervisors. To our knowledge, this is the first machine-checked proof of capability-based information security with dynamic policies.

Using the cloud for companies can have a positive impact on business process construction because it gives the ability to perceive resources such as unlimited. However, this construction in the cloud still has a lot of problems with resource issues in elasticity, especially after over time, this can be costly expensive for companies when services of business process aren't optimised in resource consumption. Hence, resources perspectives have become important to optimise the business process construction by selecting similar services that have low consumption for each activity. Concretely, the aim of this work is to ensure the consistency feature in resource perspective by using a Petri Nets to verify the right execution of business process with initial allocated resources based on some properties and to select a path of similar services that has a low consumption to minimise cloud elasticity anytime for companies. [ABSTRACT FROM AUTHOR]

Many of the software development projects are not successfully finished. In many cases, this is because the software requirements were not correctly identified. One of the factors that affect the elicitation of requirements is the proper selection of requirements elicitation techniques. Even when there is a lot of literature that proposes several requirements elicitation techniques, there is no reference process model that indicates the techniques that must be applied by a requirement's engineer to elicit the requirements of a mobile application for e‐commerce. This gap covers both the elicitation of functional and non‐functional requirements. Therefore, the authors propose a new model called reference process model for requirements elicitation for e‐commerce mobile applications development (RPM‐REFEMAD), which allows the elicitation of requirements based on the use of four elicitation techniques combined in ten steps. The proposed model was applied in the requirements elicitation of two e‐commerce mobile applications in different scenarios. To visualise the results of the model, a survey was designed and applied to users/stakeholders who participated in the reference process model evaluation. The survey results indicated that RPM‐REFEMAD model helps to elicit more quality and quantity functional and non‐functional requirements, in comparison with the use of traditional requirements elicitation techniques. [ABSTRACT FROM AUTHOR]

Formal methods have become a recommended practice in safety-critical software engineering. To be formally verified, a system should be specified with a specific formalism such as Petri nets, automata and process algebras, which requires a formal expertise and may become complex especially with large systems. In this paper, we report our experience in the formal verification of safety-critical real-time systems. We propose a formal mapping for a real-time task model using the LNT language, and we describe how it is used for the integration of a formal verification phase in an AADL model-based development process. We focus on real-time systems with event-driven tasks, asynchronous communication and preemptive fixed-priority scheduling. We provide a complete tool-chain for the automatic model transformation and formal verification of AADL models. Experimentation illustrates our results with the Flight control system and Line follower robot case studies. [ABSTRACT FROM AUTHOR]

A software formal specification is useful if and only if it is consistent or non-conflictive. However, checking the correctness or consistency of a formal specification is a difficult task. This paper proposes a method to prove its consistency or correctness by generating relevant theorem proofs. Checking the correctness and consistency of Object-Z formal specification is the main goal, which can make the specifier to get confident. Because Object-Z has inheritance property, this paper discusses it from different aspects, and focuses on the reuse of theorem proof. Finally, theorem prover Z/EVES is used to analyze and verify the Object-Z theorem proofs (semi-)automatically. [ABSTRACT FROM AUTHOR]

In the context of file systems like those of Unix, path resolution is the operation that given a character string denoting an access path, determines the target object (a file, a directory, etc.) designated by this path. This operation is not trivial because of the presence of symbolic links. Indeed, the presence of such links may induce infinite loops. We consider a path resolution algorithm that always terminate, detecting if it enters an infinite loop and reports a resolution failure in such a case. We propose a formal specification of path resolution and we formally prove that our algorithm terminates on any input, and is correct and complete with respect to our formal specification.

Requirements elicitation is one of the essential steps towards software design and construction. Business analysts and stakeholders often face challenges in gathering or conveying key software requirements. There are many methods and tools designed by researchers and practitioners but with the persistent development of new technologies, there is a need to make requirements gathering and design‐rationale process more efficient and adaptable. Storytelling is an emerging concept and researchers are witnessing its effectiveness in education, community building, information system, and requirement elicitation. Objectives of this study are to devise a method for requirements elicitation and improving design‐rationales using story‐based techniques and evaluate the effectiveness of the proposed activity. To answer the research objectives, the authors have conducted open‐ended interviews to get feedback on the proposed method; the authors have case requirement from a running project to map how this method can be useful; and performed empirical evaluation of the proposed card‐based activity. The estimated regression model, in our study, has shown that participants' perception about the simplicity/easiness and the joy of playing the game has an eventual positive effect on requirements elicitation through enhancing user's desire to play the game, which in turn increases the collaborative learning outcomes of the game. [ABSTRACT FROM AUTHOR]

Uncertainty and imprecision play an important role in the specification and analysis of complex systems. Therefore, it is important to provide methodologies and tools to support the correct development of these systems. In this paper we present a new formalism, based on fuzzy automata, to facilitate the different phases involved in the development of a system where information is fuzzy. The formal syntax and semantics of our formalism are based on previous work, which has been adapted to be easily implemented and automated. We introduce a methodology to analyze systems modelled with one of our fuzzy automata. Finally, we show how our framework can be used to define a model of the heart based on electrocardiograms (ECGs) and use this model to analyze data of real patients. [ABSTRACT FROM AUTHOR]

Uncertainty and imprecision play an important role in the specification and analysis of complex systems. Therefore, it is important to provide methodologies and tools to support the correct development of these systems. In this paper we present a new formalism, based on fuzzy automata, to facilitate the different phases involved in the development of a system where information is fuzzy. The formal syntax and semantics of our formalism are based on previous work, which has been adapted to be easily implemented and automated. We introduce a methodology to analyze systems modelled with one of our fuzzy automata. Finally, we show how our framework can be used to define a model of the heart based on electrocardiograms (ECGs) and use this model to analyze data of real patients. [ABSTRACT FROM AUTHOR]

The benefits offered by software architectures include providing an improved understanding of high-level relationships amongst systems components and facilitating in making principled decisions between alternatives. A vast majority of architectural decisions are focused on realising functional requirements and often ignore the non-functional requirements (quality attributes) altogether or include them as an afterthought. This has a negative impact on the overall acceptance of the software system by its intended users. Moreover, these architectures are specified using diagrammatic notations such as boxes and lines as connectors between them. As a result, such semi-formal representations lack precision in their definitions and may lead to misinterpretations of the architecture resulting in errors being introduced at later stages of development. Although several Architectural Description Languages (ADLs) exist for the formalisation of systems architectures, few are designed for formalising non- functional requirements. Since ADLs concentrate on component-level representations and not on the system as a whole, their support of non-functional requirements is limited. Additionally, as each ADL normally supports one quality attribute, multiple ADLs are required to cater for various quality attributes. This articles aims to address the challenges of inadequacies of specifying quality attributes in software systems in a manner that is both formal and applicable to a wider range of quality attributes. To achieve this goal, this paper present a process model that assists in formalising the non-functional requirements of a service-based software system and eliminates the need for multiple ADLs. It demonstrates the practicability of the proposed model by applying it to one quality attribute, namely "availability", using the general purpose Z specification language. [ABSTRACT FROM AUTHOR]

In automobile industry, it is a common approach to develop automobile real-time operating systems under some standards. For instance, OSEK/VDX is a world-wide adopted open standard. Traditional workflow is to first understand the standard, design and develop a system, then test its conformance to the standard, and finally deploy. There are several issues with the traditional workflow, e.g., ambiguities in standards may lead to incorrect design and implementation of real-world systems; the conformance of real-world systems to standards is difficult to check; and bug fixing after implementation is costly. To remedy the situation, in this paper, we present a unified executable formal automobile kernel under OSEK/VDX standard by defining the operational semantics of the system services in the standard using a rewrite-based executable semantic framework called $\mathbb {K}$. The formal kernel is unified in that it serves multiple purposes such as: 1) formal modeling of the OSEK/VDX standard helps detect ambiguities in the standard; 2) the executable kernel is essentially a formal model of the standard, which can be used to verify the correctness of automobile applications; and 3) verified applications can be used as test cases to check the conformance of a real-world automobile operating system against the OSEK/VDX standard. Using the formal kernel, we identify several ambiguities in the OSEK/VDX standard and a potential deadlock vulnerability in an industrial automobile application. [ABSTRACT FROM AUTHOR]

Unified Modeling Language (UML) is the effective standard for modeling object-oriented software systems. However, the ambiguity of semantics and the absence of consistency among UML diagrams lead to lack of precisely defining the requirements of a system. On the other hand, formal methods are techniques and tools use the mathematical notations, and they involve the precise syntax and semantics of the unambiguous software requirements specification. It applied in early stages of Software Development Life Cycle (SDLC). Therefore, an integrated between UML specification and formal specification is required to reduce the requirements' ambiguity and error, and to improve the quality and security of software systems. This paper proposes an approach involves the combining UML use-case diagram and activity diagrams with Z language for formalization of Library Management System (LMS). The focus of this paper is on consistency between the UML diagrams to Z Schema, and then verified by using the Z / EVEs tool. [ABSTRACT FROM AUTHOR]