Visual Formalism Research Articles

CUP: A Formalism for Expressing Cloud Usage Patterns for Experts and Non-Experts

The proliferation of cloud services, from infrastructure servers to software, has led to patterns in service deployment and provisioning practices, but not to standards for expressing and communicating such patterns to a broad-based audience. To enable the formal description and pattern classification of scenarios where cloud services are combined and provisioned to end-users, we propose a textual and visual formalism - the Cloud Usage Patterns (CUP) formalism. With CUP, both general users and cloud experts can express patterns. By expressing patterns seen in practice, we demonstrate that CUP is practically useful and makes the use of lengthy prose descriptions obsolete, which is currently common and often results in misunderstandings.

A visual programming environment for introducing distributed computing to secondary education

The paper introduces a visual programming language and corresponding web and cloud-based development environment called NetsBlox. NetsBlox is an extension of Snap! and builds upon its visual formalism as well as its open source code base. NetsBlox adds distributed programming capabilities by introducing two well-known abstractions to block-based programming: message passing and Remote Procedure Calls (RPC). Messages containing data can be exchanged by two or more NetsBlox programs running on different computers connected to the Internet. RPCs are called on a client program and are executed on the NetsBlox server. These two abstractions make it possible to create distributed programs such as multi-player games or client–server applications. We believe that NetsBlox not only teaches basic distributed programming concepts but also provides increased motivation for high-school students to become creators and not just consumers of technology.

The high level language for system specification: A model-driven approach to systems engineering

We present HiLLS (High Level Language for System Specification), a graphical formalism that allows to specify Discrete Event System (DES) models for analysis using methodologies like simulation, formal methods and enactment. HiLLS’ syntax is built from the integration of concepts from System Theory and Software Engineering aided by simple concrete notations to describe the structural and behavioral aspects of DESs. This paper provides the syntax of HiLLS and its simulation semantics which is based on the Discrete Event System Specification (DEVS) formalism. From DEVS-based Modeling and Simulation (M&S) perspective, HiLLS is a platform-independent visual language with generic expressions that can serve as a front-end for most existing DEVS-based simulation environments with the aid of Model-Driven Engineering (MDE) techniques. It also suggests ways to fill some gaps in existing DEVS-based visual formalisms that inhibit complete specification of the behavior of complex DESs. We provide a case study to illustrate the core features of the language.

A Visual Formalism for Interacting Systems

Interacting systems are increasingly common. Many examples pervade our everyday lives: automobiles, aircraft, defense systems, telephone switching systems, financial systems, national governments, and so on. Closer to computer science, embedded systems and Systems of Systems are further examples of interacting systems. Common to all of these is that some "whole" is made up of constituent parts, and these parts interact with each other. By design, these interactions are intentional, but it is the unintended interactions that are problematic. The Systems of Systems literature uses the terms "constituent systems" and "constituents" to refer to systems that interact with each other. That practice is followed here. This paper presents a visual formalism, Swim Lane Event-Driven Petri Nets, that is proposed as a basis for Model-Based Testing (MBT) of interacting systems. In the absence of available tools, this model can only support the offline form of Model-Based Testing.

Modular encoding of synchronous and asynchronous interactions using open Petri nets

The paper investigates the relationships between two well-known approaches to the modelling of concurrent and distributed systems, process calculi and Petri nets. A framework for the modular encoding of process calculi into Petri nets is proposed, which is based on a reactive variant of Petri nets. In particular, two exemplary calculi are considered: (asynchronous) CCS and CSP, representing alternative interaction paradigms, namely asynchronous and (broadcast) synchronous communication. The encoding is proved to preserve as well as to reflect the operational semantics. As a consequence, it is well-behaved with respect to the standard behavioural equivalences, a fact that is exploited to perform a “technology transfer” between the two formalisms, in terms of un/decidability results for classical properties such as reachability and deadlock-freedom.The encoding highlights the expressiveness of the proposed reactive variant of nets, as well as paving the way for a fruitful integration of tools and techniques between the visual formalism of nets and the algebraic framework of processes.

Concurrency cannot be observed, asynchronously

The paper is devoted to an analysis of the concurrent features of asynchronous systems. A preliminary step is represented by the introduction of a non-interleaving extension of barbed equivalence. This notion is then exploited in order to prove thatconcurrency cannot be observedthrough asynchronous interactions, i.e., that the interleaving and concurrent versions of a suitable asynchronous weak equivalence actually coincide. The theory is validated on some case studies, related to nominal calculi (π-calculus) and visual specification formalisms (Petri nets). Additionally, we prove that a class of systems which is deemed (output-buffered) asynchronous, according to a characterization that was previously proposed in the literature, falls into our theory.

Modular Design of Urban Traffic-Light Control Systems Based on Synchronized Timed Petri Nets

Timed Petri nets (TPNs) have been utilized as visual formalism for the modeling of complex discrete-event dynamic systems. They illuminate the features in describing the properties of causality and concurrency. Moreover, it is well known that a synchronized TPN (STPN) allows us to present all of the concurrent states in a complex TPN. In this paper, we propose a new methodology to design and analyze an urban traffic network control system by using the STPN. In addition, the applications of the STPN to eight-phase, six-phase, and two-phase traffic-light control systems are modularized. The advantage of the proposed approach is the clear presentation of the behaviors of traffic lights in terms of the conditions and events that cause phase alternations. Moreover, the size of the urban traffic network control system can be easily extended with our proposed modular technique. An analysis of the control models is performed via a reachability graph method to demonstrate how the models enforce the transitions of the traffic lights.

Online Collaborative Environment for Designing Complex Computational Systems

Developers of information systems have always utilized various visual formalisms during the design process, albeit in an informal manner. Architecture diagrams, finite state machines, and signal flow graphs are just a few examples. Model Integrated Computing (MIC) is an approach that considers these design artifacts as first class models and uses them to generate the system or subsystems automatically. Moreover, the same models can be used to analyze the system and generate test cases and documentation. MIC advocates the formal definition of these formalisms, called domain-specific modeling languages (DSML), via metamodeling and the automatic configuration of modeling tools from the metamodels. However, current MIC infrastructures are based on desktop applications that support a limited number of platforms, discourage concurrent design collaboration and are not scalable. This paper presents WebGME, a cloud- and web-based cyberinfrastructure to support the collaborative modeling, analysis, and synthesis of complex, large-scale scientific and engineering information systems. It facilitates interfacing with existing external tools, such as simulators and analysis tools, it provides custom domain-specific visualization support and enables the creation of automatic code generators.

A visual formalism for weights satisfying reverse inequalities

In this expository article we introduce a diagrammatic scheme to represent reverse classes of weights and some of their properties.

Dynamical and Mechanistic Reconstructive Approaches of T Lymphocyte Dynamics: Using Visual Modeling Languages to Bridge the Gap between Immunologists, Theoreticians, and Programmers

Dynamic modeling of lymphocyte behavior has primarily been based on populations based differential equations or on cellular agents moving in space and interacting each other. The final steps of this modeling effort are expressed in a code written in a programing language. On account of the complete lack of standardization of the different steps to proceed, we have to deplore poor communication and sharing between experimentalists, theoreticians and programmers. The adoption of diagrammatic visual computer language should however greatly help the immunologists to better communicate, to more easily identify the models similarities and facilitate the reuse and extension of existing software models. Since immunologists often conceptualize the dynamical evolution of immune systems in terms of “state-transitions” of biological objects, we promote the use of unified modeling language (UML) state-transition diagram. To demonstrate the feasibility of this approach, we present a UML refactoring of two published models on thymocyte differentiation. Originally built with different modeling strategies, a mathematical ordinary differential equation-based model and a cellular automata model, the two models are now in the same visual formalism and can be compared.

Symbolic Message Sequence Charts

Message sequence charts (MSCs) are a widely used visual formalism for scenario-based specifications of distributed reactive systems. In its conventional usage, an MSC captures an interaction snippet between concrete objects in the system. This leads to voluminous specifications when the system contains several objects that are behaviorally similar. MSCs also play an important role in the model-based testing of reactive systems, where they may be used for specifying (partial) system behaviors, describing test generation criteria, or representing test cases. However, since the number of processes in a MSC specification are fixed, model-based testing of systems consisting of process classes may involve a significant amount of rework: for example, reconstructing system models, or regenerating test cases for systems differing only in the number of processes of various types. In this article we propose a scenario-based notation, called symbolic message sequence charts (SMSCs), for modeling, simulation, and testing of process classes. SMSCs are a lightweight syntactic and semantic extension of MSCs where, unlike MSCs, a SMSC lifeline can denote some/all objects from a collection. Our extensions give us substantially more modeling power. Moreover, we present an abstract execution semantics for (structured collections of) SMSCs. This allows us to validate MSC-based system models capturing interactions between large, or even unbounded, number of objects. Finally, we describe a SMSC-based testing methodology for process classes, which allows generation of test cases for new object configurations with minimal rework. Since our SMSC extensions are only concerned with MSC lifelines, we believe that they can be integrated into existing standards such as UML 2.0. We illustrate our SMSC-based framework for modeling, simulation, and testing of process classes using a weather-update controller case-study from NASA.

Re-tooling Code Structure Based Analysis with Model-Driven Program Slicing for Software Maintenance

Static code analysis is a methodology of detecting errors in program code based on the programmer's reviewing the code in areas within the program text where errors are likely to be found and since the process considers all syntactic program paths; there is the need for a model-based approach with slicing. This paper presented a model of high-level abstraction of code structure analysis for a large component based software system. The work leveraged on the most important advantage of static code structure analysis in re-tooling software maintenance for a developing economy. A program slicing technique was defined and deployed to partition the source text to manageable fragments to aid in the analysis and statecharts were deployed as visual formalism for viewing the dynamic slices. The resulting model was a high-tech static analysis process aimed at determining and confirming the expected behaviour of a software system using slices of the source text presented in the statecharts.

Multi-modal scenarios revisited: A net-based representation

Live sequence charts (LSC) is a visual formalism that can be used to model reactive systems. In terms of LSC, a system model is a set of charts, each of which may be referred to as a multi-modalscenario. In this paper, we revisit the scenarios of the UML2-compliant dialect of LSC. We abstract from their concrete visual representation, and show how to capture multi-modal scenarios in a flexible, yet conservative, way. For this, we use the building blocks of Petri nets; i.e., places and transitions, extended with modalities and interpreted in accordance with the semantics of LSC. This results in what we refer to as LSC nets. LSC nets can express a variety of advanced constructs of LSC, as well as several semantic variations suggested in the literature, with just a few primitive notions. At the same time, the net corresponding to an LSC involves rather superficial, technical, changes in presentation. As a result, LSC nets form a rigorous basis to present, discuss, and investigate the language as a whole, or interesting fragments thereof.

Modeling and Designing of Urban Traffic Control Systems by Statecharts

Statechart has been utilized as a visual formalism for the modeling of complex systems. It illuminates the features on describing properties of causality, concurrency and synchronization. The reachability structure is used to represented dynamic model by a Boolean function. In this paper, we try to describe State invariant method and equation function for hierarchical tree diagram. Finally, we used them to analyze the urban traffic control systems which are modeled by using Statecharts. Their formalism provides a concept of propositional logic for presenting control strategy.

Based on Synchronized Timed Petri Nets for Emergency Vehicle Preemption Systems

Timed Petri net (TPN) has been utilized as a visual formalism for the modeling of complex discrete event dynamic systems. It illuminates the features on describing properties of causality and concurrency. Moreover, it is well-known that synchronized timed Petri net (STPN) allows us to present all of the concurrent states in complex TPN. In this paper, we propose a new methodology to design, analyze and implement an urban emergency vehicle preemption control system by using STPN. The applications of STPN to two-phase traffic lights and emergency vehicle preemption are illustrated. The advantage of the proposed approach is the clear presentation of traffic lights’ behaviors in terms of conditions and events that cause the preemption phases alternations. Finally, a two-phase traffic lights control system with emergency vehicle preemption will be realized by using STPN. To our knowledge, this is the first work that employs STPN to model a two-phase traffic lights control system with emergency vehicle preemption system.

A Case Study: Logical Operators and Statecharts for Level Crossing Traffic Control Systems

Statechart has been utilized as a visual formalism for the modeling of complex systems. It illuminates the features on describing properties of causality, concurrency and synchronization. In this paper, we try to describe a behavioral logical operations language by using Statecharts. The logical operation is a data structure that is used to represent by a Boolean function. This paper used them to analyze the models which are modeled by using Statecharts. Their formalism provides a concept of propositional logic for presenting control strategy. Finally, an example of level crossing traffic control systems is examined successfully.

Decidable Race Condition and Open Coregions in HMSC

Message Sequence Charts (MSCs) is a visual formalism for the descrip- tion of communication behaviour of distributed systems. An MSC specifies relations between communication events with partial orders. A situation when two visually ordered events may occur in any order during an execution of an MSC is called a race and is usually considered as a design error. While there is a quadratic time al- gorithm detecting races in a finite communication behaviours called Basic Message Sequence Charts (BMSCs), the race detection problem is undecidable for High-level Message Sequence Charts (HMSCs), an MSC formalism describing potentially infi- nite sets of potentially unbounded behaviours. To improve this negative situation for HMSCs, we introduce two new notions: a new concept of race called trace-race and an extension of the HMSC formalism with open coregions, i.e. coregions that can extend over more than one BMSC. We present three arguments showing benefits of our notions over the standard notions of race and HMSC. First, every trace-race-free HMSC is also race-free. Second, every race-free HMSC can be equivalently ex- pressed as a trace-race-free HMSC with open coregions. Last, the trace-race detec- tion problem for HMSC with open coregions is decidable and PSPACE-complete. Finally, the proposed extension of coregions allows to represent in a visual fash- ion whether an arbitrary number of racing events in the usual MSC formalism are concurrent or not.

A Logic of Traffic Light Controller Modelled and Analyzed by Statecharts

Statechart has been utilized as a visual formalism for the modeling of complex systems. It illuminates the features on describing properties of causality, concurrency and synchronization. In this paper, we try to describe the behavioral of the traffic lights by using Statecharts. We use Boolean function to make the traffic light controller behavior in a certain way. This paper used Boolean function to analyze the models which are modeled by using Statecharts. Their formalism provides a clear means for presenting control logic. Finally, an example of traffic light controller system is examined successfully.

Statechart-based Controllers Synthesis in FPGA Structures with Embedded Array Blocks

Statechart-based Controllers Synthesis in FPGA Structures with Embedded Array BlocksStatechart diagrams, in general, are visual formalism for description of complex systems behaiour. Digital controllers, which act as reactive systems, can be very conveniently modeled with statecharts and efficiently synthesized in modern programmable devices. The paper presents in details syntax and semantics of statecharts and new implementation scheme. The issue of statecharts synthesis is not still ultimately solved. Main feature of the presented approach is the transformation of statechart diagrams into Finite State Machine, and through KISS format, functional decomposition and mapping into Embedded Memory Blocks. Embedded Memory are part of the modern programmable devices.

Modelling and analysis of air traffic control systems using hierarchical timed coloured Petri nets

Hierarchical timed coloured Petri net (HTCPN) models have been utilized as a visual formalism for the modelling of complex reactive systems. They brighten the features on describing properties of causality, concurrency and synchronization. This paper focuses on the use of HTCPNs to model and analyse a dynamic procedure of an air traffic control (ATC) system. The advantage of the proposed approach is the clear presentation of the aircraft behaviour in terms of conditions and events. To our knowledge, this is the first work that employs HTCPNs to obtain models of ATC systems.