Utility evaluation of models

Reliability growth models for hardware and software systems based on nonhomogeneous Poisson processes: A survey

The available state-based and path-based reliability models for the component-based software consume high computational cost and suffer from the evaluating complexity in the software evaluation. A SVM reliability evaluation model for component-based software systems (SVMREM) with a low complexity is presented in this paper. The component reliability SVM is performed to optimize the reliability evaluation time consumption. SVMREM has a low evaluation complexity and outperforms the state-based model and the path-based model of the reliability evaluation. Another advantage of SVMREM over the others is its software structure robustness. SVMREM only depends on the component historical reliabilities, which are independent from the software system structure. Based on the theory analysis and experiment results, it shows that the SVMREM reliability evaluating accuracy is acceptable when the software system structure is complex and the complexity of SVMREM is evidently lower than the contrast models.

Real-time process algebra (RTPA) is a denotational mathematical structure for denoting and manipulating system behavioral processes. RTPA is designed as a coherent algebraic system for intelligent and software system modeling, specification, refinement, and implementation. RTPA encompasses 17 metaprocesses and 17 relational process operations. RTPA can be used to describe both logical and physical models of software and intelligent systems. Logic views of system architectures and their physical platforms can be described using the same set of notations. When a system architecture is formally modeled, the static and dynamic behaviors performed on the architectural model can be specified by a three-level refinement scheme at the system, class, and object levels in a top-down approach. RTPA has been successfully applied in real-world system modeling and code generation for software systems, human cognitive processes, and intelligent systems.

In this paper we consider Markov analysis of models of complex software and hardware systems. A Markov analysis tool can be used during verification processes of models of avionics systems. In the introduction we enumerate main advantages and disadvantages of Markov analysis. For example, with Markov analysis, unlike other approaches, such as fault tree analysis and dependency diagram analysis, it is possible to analyze models of systems that are able to recovery. The main drawback of this approach is an exponential growth of models size with number of components in analyzed system. It makes Markov analysis barely used in practice. The other important problem is to develop a new algorithm for translating a model of a system to a model suitable for Markov analysis (Markov chain), since the existing solutions have significant limitations on the architecture of analyzed systems. Next we give a brief description of the context - AADL modeling language with Error Model Annex library, MASIW framework, and also give an explanation of Markov analysis method. In a main section we suggest an algorithm for translating a system model into a Markov chain, partially solving the problem of exponential growth of Markov chain. Then follows a description of further steps, and some heuristics that allow to extremely reduce running time of the algorithm. In this paper we also consider other Markov analysis tools and their features. As a result, we suggest a Markov analysis tool that can be effectively use in practice.

This paper summarizes our experiences while teaching the Models of Software Systems (MSS) course as part of the MSIT-SE master programme at Carnegie Mellon University (CMU), in Pittsburgh, PA, USA, and at Innopolis University (INNO), in Tatarstan, Russia. The MSS is a Formal Methods course taught to Software Engineers in the Fall of every year. The author was a visiting Faculty to CMU in the Fall of 2015, who then returned to Russia in the Fall of 2016 to replicate the same master course at INNO. The goal of the MSIT-SE master program at CMU as well as at INNO is to create software company leaders in the field of Software Engineering. The MSS course exposes students to several Formal Methods techniques and models, including first order logic, state machines, concurrency models and temporal logic. This paper reports our efforts to improve the quality of the MSS course by introducing the teaching of the Event-B language and its underlying software development methodology into the course programme. Our long time goal is to make Formal Methods (FM) and FM techniques more attractive to millennials and to demonstrate how they can effectively use those techniques to ensure reliability of the software systems employed by them in their IT companies.

Software Engineering principles and practices promote the reuse of existing elements to maximize the performance of development and maintenance processes.The core concepts of reusability are aligned with the FAIR (Findability, Accessibility, Interoperability, and Reusability) principles.From our perspective, FAIR principles are not only related to data in a software system, because there are other resources and parts of a system that are related to data indirectly or require data schemas and models for their description and management.Examples of these resources are services, business logic processes, contracts, security policies, architectures, components, deployment resources, execution rules, or interaction alternatives, among other possible examples.Actually, any resource in a system may need to be discovered either internally by a subprocess, or externally by any client that might be interested in finding, accessing, interoperating, or reusing it.This paper addresses a systematic literature review to analyze the current principles, paradigms, and technologies that can be applied to enable discovering and reusing mechanisms in modern software systems, and how traditional and outdated approaches have been adapted to support present issues.From this analysis, we outlined the challenges and open research lines that can be addressed to achieve a suitable reuse strategy.

Many buildings during their operational period incur damage of different origin: man-made, natural, operational, etc. Dynamic tests are performed for detailed assessment of the technical condition of buildings and structures in accordance with the regulatory documents for general analysis of the building damage state. In a large number of papers, the results of comparison of full-scale tests and numerical analysis using finite element method are presented. When analyzing the results, it can be concluded that the dynamic method is reliable, but has several limitations. The advantage of the dynamic method of building damage assessment is the possibility to adjust finite element models in software systems taking into account results obtained from in-situ tests, which allows to obtain more accurate results for the assessment of bearing capacity under seismic loading. To examine the effect of damage to buildings on their seismic resistance, an experiment with corrosiondamaged reinforced concrete columns was performed. The result of the first stage of the experiment is the assessment of the change in dynamic characteristics (eigenfrequency, vibration decrement, vibration damping coefficient, etc.) of reinforced concrete column specimens subjected to corrosion damage.

Software systems start small and grow in complexity and size. The larger a software system is, the more it is distributed over organizational and geographical confines. Thus, the modeling of software systems is necessary at a certain level of complexity because it can be used for communication, documentation, configuration and certification purposes. We came to the conclusion that several patterns of software modeling exist. The existence of such patterns is dependent on the history and the evolution of the system under consideration. We will show that a software system in its lifecycle has to face several crises. Such a crisis is a watershed in the application of new patterns. We provide an evolutionary view of software systems and models which helps understanding of current problems and prospective solutions.

Situation-awareness is a desirable feature of application software systems in mobile computing environments. In this paper, we present an extended finite state machine model for the situation-aware mobile application software systems. In this model, each state represents an impromptu condition that a system is presented, and the state is characterized by the historical context record and the internal action record. Each state transition in the model represents a context input. The whole finite state machine models the dynamicity of the situation-aware application software system that adjusts its own behavior according to the situation changes. The situation-aware requirement is application-specific, and each situation-aware requirement is corresponding to an FSM. This model is useful in the mobile application software development: it can be used to verify the validness of the situation-aware requirement; it can be used to generate test cases that represent the situation changes a system may experience in a mobile environment.

Despite it being an established area of research and development, embedded system does not own a dedicated development methodology that developers can adhere to. Being an inter-disciplinary activity, a cross of software and hardware, it brings challenge to developer to construct a development methodology for embedded system. This paper proposes a new development model for embedded system by the hybrid of selected development methodologies in software engineering and systems engineering, considering they are both essential in embedded system. The model is harmonized with embedded system design vital tasks and also non-functional properties following the ISO/IEC9126.

The paper examined the problem of modeling and design of software computer systems. The article briefly describes the content aspects of the various stages of the implementation of software complexes and systems. The methodology of research and analysis of systems, which uses the method of computer simulation modeling, is given. The aim of the work is to create a new universal approach to the design and implementation of software systems of various levels of complexity. During the study, the following general scientific methods were used: system analysis, synthesis, formalization, modeling, decomposition, structuring, description, comparison. The materials used in the study were: computers and software development tools. As a result of the study proposed a universal agent-module approach to the design and implementation of software systems based on simulation agent-based modeling. The study presents the processes of modeling and designing software systems, their stages, and the possibility of their integration within the described approach. Examples of formal model and structure of the software system under design based on the agent-module approach are presented. The proposed approach can be used in the process of software development at the initial stages related to modeling and designing of software systems. Integration of modeling and design stages in the proposed approach will significantly reduce software development time and simplify the design process by making it clearer and more formalized. Materials of the article are of scientific and practical value for a wide range of specialists interested in system analysis, modeling, design and implementation of software systems.

Many legacy systems are still essential. They run efficiently and accurately in legacy hardware and software environments. Therefore, it is necessary to migrate legacy hardware and software to modern platforms. One of the directions of migration is to service-oriented architectures. In this case, side effects are possible. Therefore, it is necessary to use the software system model. This model is used to assess the migration process of legacy software systems. An approach for building network models from the ground up is proposed in this research. Time-dependent Petri nets are used to explain the traces of events in the simulated network. A user may create a network workload model that can be utilized for network planning purposes using this technique. A method must be established to determine whether or not the created model is suitable. An example is used to determine the suitability of the Markov model for the behavior of a system with discrete states in terms of precision. An example is used to build a model for the operation of a basic software system. Providing the executable network model of the migrating system to the service identification approach input is preferred.

The success of modern ICT systems is not just about the technology. The human and social dimensions are also critical – especially in terms of understanding the context and environment within which the systems operate. This is true also about the environment in which the system is developed. Although much effort has been expended on building and analysing formal models of software systems, little has been done in terms of how software development teams work and how this might be studied in a formally-based way. This research looks at one of the fundamental aspects involved in collaborative teams working in projects – the transactive memory system (TMS). This, well established, concept in psychology is an approach to how the different people in a team regard the capabilities (knowledge and abilities) of each other as it changes over time. These capabilities are the basis for decision making in software projects about who does what, and when.
\n
\nUsing a formal model of the TMS of a team, based on agent-based modelling, simulations were made of how teams might operate under different circumstances. The initial model was validated against published data. The model was then investigated in terms of how different types of project management affected the TMS of a team and on the team’s performance. In particular, a comparison was made between a traditional, plan-based approach against an agile method using pair programming. The result demonstrates strong benefits in terms of performance and learning with the agile approach.

This tutorial presents techniques for self-adaptive software systems that use performance models in order to achieve desired quality-of-service objectives. Main hindrances with the state of the art are the assumption of a steady-state regime to be able to use analytical solutions and the explosion of the state space which occurs when modeling software systems with stochastic processes such as Markov chains. This makes their online use difficult because the system under consideration may be in a transient regime, and the typically large cost of the analysis does not permit fast tracking of performance dynamics. We will introduce fluid models based on nonlinear ordinary differential equations as a key enabling technique to effectively approximate large-scale stochastic processes. This representation makes it possible to employ online optimization methods based on model-predictive control in order to find an assignment of the values of tunable parameters of the model steering the system toward a given performance goal. We will also show how, dually, the same techniques can be used for the online estimation of software service demands. In this tutorial we will focus on software performance models based on queuing networks, with applications to runtime auto-scaling in virtualized environments.

In this paper, we present a Fluid Stochastic Petri Net (FSPN) based model which captures the behavior of aging software systems with checkpointing, rejuvenation and self-restoration, three well known techniques of software fault tolerance. The proposed FSPN based modeling framework is novel in many aspects. First, the FSPN formalism itself is extended by adding flush-out arcs. Second, the three techniques are simultaneously captured in a single model for the first time. Third, the formalism enables modeling dependencies of the three techniques on various system features such as failure, load and time in the same framework. Further, our base FSPN model can be viewed as a generalization of most previous models in the literature. We show that these FSPNs can not only mimic previously published models but can also extend them. For one FSPN model, we present numerical results to illustrate their usage in deriving measures of interest.