Patterns of Software Modeling

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.

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.

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.

This paper introduces an approach to uniform modeling and testing of hardware and software systems and their faults. As an example, for hardware under consideration, designs at a behavioral level will be used, implemented in Hardware Description Language (HDL). For software, an example will be borrowed from a graphical user interface design. Both examples will be modeled by finite state machines. The mutation of these models leads to lucid hardware and software fault models, respectively. Original models and their mutants will then be used to generate test cases for positive testing and negative testing, respectively, forming a holistic test strategy. A positive test is supposed to validate the system under legal (expected, regular) circumstances, whereas a negative test checks the behavior of the system under illegal (unexpected, irregular) situations. Non-trivial examples are used to validate and analyze the approach with respect to uniform modeling and testing capability.

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

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.

Welcome to the CoSS2006, Workshop on Conceptual modeling of Service-oriented software Systems, held in conjunction with the 25th International Conference on Conceptual Modeling ER2006. The workshop focuses on different facets of conceptual modeling and design of service-oriented systems, a recent development paradigm that has the potential to transform current business software systems and applications from an archipelago of isolated entities that barely talk to one another, into a seamless organism that transcends physical and organizational boundaries, and creates new opportunities for interoperability and integration.

Software-hardware co-design enabled with co-simulation is useful for building embedded computing systems. Indispensable to design is developing hardware and software simulation models at appropriate abstraction levels. Toward this goal, this paper presents a study of combined Register-Transfer-Level (RTL) and software system modeling. Specifically, composition of hardware and software models is proposed and a co-simulation environment to simulate the models is developed. The hardware and software parts of a prototypical Network on Chip (NoC) system are modeled and simulated. The hardware part is specified at RTL level using the DEVS Suite Simulator and the software part defined as a MATLAB script. A Functional Mock-up Interface (FMI) is developed for the DEVS-Suite Simulator to support hardware and software model coupling and co-simulation. This study details a modular development of hardware and software models executing on disparate environments instead of employing a monolithic modeling method supported with a monolithic simulation engine.

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.

Although modern software engineering paradigms (e.g. model-driven development, aspect-oriented development, product-line engineering etc.) use different types and combinations of abstraction techniques to decompose descriptions of software systems into human-tractable pieces, they all dramatically increase the number of different views that human engineers have to work with. This presents several fundamental challenges for modeling complex software systems, including the need to develop better technologies for operationally managing the many views of software systems and keeping them all synchronized, and developing better metaphors for software engineers to develop, evolve and navigate around the views of systems as projects evolve. Key questions are how to reconcile traditional views of software systems dominated by the notion of source code and traditional notions of software evolution such as refinement and round-trip-engineering with the ideas emerging in model-driven, aspect-oriented and product-line focused approaches. The goals of this workshop are to clarify these challenges, discuss ideas for addressing them, and map out a vision for the view-oriented software engineering metaphors of the future.

Formal inference processes in all kinds of engineering designs are based on the cognitive process and means of abstraction. This paper presents a formal treatment of system design. It first discusses the differences of system designs in abstract and concrete systems. A hierarchical abstraction model of system descriptivity (HAMSD) is developed that explains the abstract levels of entities and artifacts in both the concrete world and the abstract world. The HAMSD model classifies the design of a system at five levels known as the levels of (1) analogue objects, (2) diagrams, (3) natural languages, (4) professional notations, and (5) mathematics from the bottom up. According to the HAMSD model, an architectural, functional, or behavioral design of a system should adopt a higher-level abstract means to describe the system at a given abstract level, in order to obtain more powerful descriptivity and higher accuracy. Therefore, a mechanical system may be designed by using diagrams; while an information or software system can not be precisely described by diagrams. The reason is that the former is at an abstract level lower than the descriptive means of diagrams, but not so is the latter. Applications of the above findings in dealing with complicated problems in large-scale software system designs are discussed in the context of software engineering. Real-time process algebra (RTPA) is adopted as a highly abstract means in case studies on formal methodologies of software system design and modeling for software objects and design patterns.

Coordinated Atomic Actions is a conceptual framework used to increase the reliability (by fault tolerance) of concurrent object-oriented software systems. An extension of this conceptual framework to support the modelling of real-time software systems has been proposed. In this work we present our proposal for improvements of this extension focusing on recovery process optimisation, non-determinism reduction and time-related constructs extension.

Modeling and verification issues of software systems have a significant place in the study of the mathematical theory of programming. This is mostly due to the importance of establishing a theoretical basis for the creation of dependable software. This page describes in depth Model Checking, the most used method for modeling and verifying software 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.

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.