Yujian Fu

An approach to web services oriented modeling and validation

Web services provide a language-neutral, loosely-coupled, and platform independent way for linking applications within organizations or enterprises across the Internet. Web services communicate with each other via XML format messages. This paper presents a web service architecture model, Service-Oriented Software Architecture Model (SO-SAM), which is an extension of SAM (SoftwareArchitecture Model[16]) to the web service applications, as well as a validation of the model and a case study. SO-SAM is an executable architectural model incorporating Predicate Transition Nets with the style and understandability of component-based concepts. SO-SAM describes each web service in terms of component and service composition in terms of connector separately. We believe that SO-SAM facilitates the verification and monitoring of web services integrationsince SO-SAM fits the distributed nature of modern composite web services. In order to validate the model against system properties, we rewrite the SO-SAM into the XMLformat, and validate SO-SAM using a SAM support tool, SAM parser. Finally, a case study of the validation of the model is demonstrated.

Formalizing and validating UML architecture description of web systems

Web systems are self-descriptive software components which can automatically be discovered and engaged, together with other web components, to complete tasks over the Internet. Unified Modeling Language (UML), a widely accepted object-oriented system modeling and design language, and adapted for software architecture descriptions for several years, has been used for the web system description recently. However, it is hard to detect the system problems, such as correctness, consistency etc., of the integration of Web services without a formal semantics of web services architecture. In this paper, we proposed an approach to solving this issue by translating the UML web service architecture description into a formal modeling language - SO-SAM, and verify the correctness of the web system design using model checking techniques. We presented this approach through an imaging processing scenario in the distributed web application.

Modeling, validating and automating composition of web services

Current service architecture description language and composition approaches consider simplistic method invocation. They pay less attention to the formal semantics and verification of service composition in the design, and less support property specifications and architecture validation. This paper presents an executable web service architecture model, Service-Oriented Software Architecture Model (SO-SAM), which is an extension of SAM (Software Architecture Model [16]) to the web service applications, and verificationof web system properties in the design. SO-SAM describes each web service in terms of component and service composition in terms of connector separately. Furthermore, we validate SO-SAM model to prove that it facilitates the verification and monitoring of web services integration through translation to the Maude programming langauge, a high level language and high performance executable specification with the componentized and object-oriented design, as well as using model checking technique in the system design level. Finally, a case study of the validation of the model is demonstrated.

A TRANSLATOR OF SOFTWARE ARCHITECTURE DESIGN FROM SAM TO JAVA

A software architecture design has many benefits including aiding comprehension, supporting early analysis, and providing guidance for subsequent development activities. An additional major benefit is if a partial prototype implementation can be automatically generated from a given software architecture design. However, in the past decade less progress was made on automatically realizing software architecture designs. In this paper, we present a translator for automatically generating an implementation from a software architectural description. The implementation not only captures the functionality of the given architecture description, but also contains additional monitoring code for ensuring desirable behavior properties through runtime verification. Our method takes a software description written in SAM, a software architecture model integrating dual formal methods Petri nets and temporal logic, and generates ArchJava/Java/AspectJ code. More specifically, the structure of a SAM architecture description produces ArchJava code, the behavior models of components/connectors represented in Petri nets lead to plain Java code, and the property specifications defined in temporal logic generate AspectJ code; the above code segments are then integrated into Java code. An experimental result is provided.

A Method for Realizing Software Architecture Design

A software architecture design provides a high-level abstraction of system topology, functionality, and/or behavior; which provides the basis for early system understanding and analysis as well as the foundation for subsequent detailed design and implementation. However, research on software architecture in the past decade primarily focused on architecture description languages and their analysis techniques and less progress was made on automatically realizing software architecture designs. In this paper, we present a method for automatically generating an implementation from a software architectural description. The implementation not only captures the functionality of the given architecture description, but also contains additional monitoring code for ensuring desirable behavior properties through run-time verification. Our method takes a software description written in SAM, a software architecture model integrating dual formal methods Petri nets and temporal logic, and generates Java code. More specifically, the structure of a SAM architecture description produces Arch-Java code the behavior models of components/connectors represented in Petri nets lead to plain Java code, and the property specifications defined in temporal logic generates Aspect J code; the above code segments are then integrated into Java code

Automated runtime validation of software architecture design

The benefits of architecture description languages (ADLs) cannot be fully captured without a automated and validated realization of software architecture designs. In addition to the automated realization of software architecture designs, we validate the realization process by exploring the runtime verification technique and aspect-oriented programming. More specifically, system properties are not only verified against design models, but also verified during execution of the generated implementation of software architecture designs. All these can be done in an automated way. In this paper, we show that our methodology of automated realization of software architecture designs and validation of the implementation is viable through a case study.

A Framework for Developing Cyber Physical Systems.

Cyber physical systems (CPSs) are pervasive in our daily life from mobile phones to auto driving cars. CPSs are inherently complex due to their sophisticated behaviors and thus difficult to build. In this paper, we propose a framework to develop CPSs based on a model driven approach with quality assurance throughout the development process. An agent-oriented approach is used to model individual physical and computation processes using high level Petri nets, and an aspect-oriented approach is used to integrate individual models. The Petri net models are systematically mapped to classes and threads in Java, which are enhanced and extended with domain specific functionalities. Complementary quality assurance techniques are applied throughout system development and deployment, including simulation and model checking of design models, model checking of Java code, and run-time verification of Java executable. We demonstrate our framework using a car parking system.

A Framework for Developing Cyber-Physical Systems

Cyber-physical systems (CPSs) are pervasive in our daily life from mobile phones to auto-driving cars. CPSs are inherently complex due to their sophisticated behaviors and thus difficult to build. ...

Modeling and Analyzing Security Patterns Using High Level Petri Nets.

Security has become an essential and critical nonfunctional requirement of modern software systems, especially cyber physical systems. Security patterns aim at capturing security expertise in the worked solutions to recurring security design problems. This paper presents an approach to formally model and analyze six security patterns to detect potential incompleteness, inconsistency, and ambiguity in the textual descriptions; and to prevent their incorrect implementation. These patterns are modeled using high level Petri nets in our tool environment PIPE+. Simulation is used to analyze various security relevant properties. The validated formal models of individual security patterns serve as the building blocks for system design involving the composition of multiple security patterns.

Mapping Software Architecture Specification to Rewriting Logic (Short Paper)

In this paper we present a systematic translation algorithm that maps a software architecture model to rewriting logics. We consider a nowadays typical component-based software architecture model - SAM. SAM is a formal software architecture model that integrates two formalisms - Petri nets and temporal logic. Our goal is to effectively describe the component based software architecture model SAM using a rewriting based semantics. This algorithm is implemented in Maude, a high performance declarative programming language that supports membership and rewriting logics. The contribution of this paper is we defined the translation algorithm to rewriting logic to show an interleaving semantic matching between the behavior model Petri net and rewriting logic.