Modeling of Component Diagrams Using Petri Nets

With the growing use of UML diagrams for software design description and the importance of nonfunctional requirements evaluation at software development process, transforming these diagrams to executable models is considered to be significant. Nonfunctional requirements can not be evaluated directly by UML diagrams. Software designers are not usually familiar with non-functional requirement analysis and are not able to analyze such requirements easily. Therefore the designer should produce an executable model from software design description to be ready for analysis. usecase and sequence diagrams are the most important UML diagrams for software design description. In this paper, we propose new algorithms that enable a designer to transform usecase and sequence diagrams into executable models based on Petri nets and then we show how to use this Petri net models for simulation. Finally, to represent the usage of our proposed algorithms, we consider a case study as an example.

Are Forward Designed or Reverse-Engineered UML diagrams more helpful for code maintenance?: A family of experiments

A major cause of many complications in the field of software architectures is the lack of appropriate abstractions for separating, combining and encapsulating concerns of various kinds in architectural descriptions. Architectures of most complex software-intensive systems involve concerns that inherently crosscut the natural boundaries of the elements composing the architecture descriptions. Crosscutting concerns intersect the common modularity of systems as prescribed by their architecture descriptions, by traversing both the components and connectors, i.e., the relationships among the components. Crosscutting concerns are critical aspects of many architectural problems. However, architectural descriptions written in special-purpose languages (ADLs) like Wright, Darwin, Rapide and Acme should support descriptions of multiple structures, which include diagrams, models and views, that intentionally address different kinds of concerns. ADLs should show how various concerns affect each other in architectural designs; they should also allow one to identify, analyze and elaborate architectural concerns that cut across several software components, such as transactions, security, load balancing, synchronization, reuse, customization, scalability, etc.; they should, but they do not. This dissertation presents a new approach to software architecture that is suitable for supporting concern-oriented development and documentation of architectures for software-intensive systems. This approach allows for creating and documenting a multidimensional software structure that is referred to as concern-oriented software architecture; it provides new mechanisms for encapsulating individual concerns into independent architectural constructs. The ultimate goal of this new approach is to provide support for achieving design by concerns all through the development and description of software architectures. Moving towards this goal, we present a particular concern-oriented architectural framework called Perspectival Concern-Spaces (PCS). The PCS Framework offers a flexible and extensible means a) for supporting advanced separation of concerns in architectural design, and in the construction and evolution of software-intensive systems; and b) for filling the gap between architectural descriptions and modern software development artifacts. To show the feasibility of the proposed approach, we provide new modeling techniques that are used to describe and apply an aspect-oriented architectural pattern, called the On-demand Remodularization pattern. We give several examples of how the PCS Framework can be used to integrate concern-oriented architectural documentations with mainstream software development artifacts.

Nowadays, software effort estimation plays an important role in software project management due to its extensive use in industry to monitor progress, and performance, determine overall productivity and assist in project planning. After the success of methods such as IFPUG Function Point Analysis, MarkII Function Point Analysis, and COSMIC Full Function Points, several other extension methods have been introduced to be adopted in software projects. Despite the efficiency in measuring the software cost, software effort estimation, unfortunately, is facing several issues; it requires some knowledge, effort, and a significant amount of time to conduct the measurement, thus slightly ruining the advantages of this approach. This paper demonstrates a functional size measurement tool, named UML Point tool, that utilizes the concept of IFPUG Function Point Analysis directly to Unified Modeling Language (UML) model. The tool allows the UML eXchange Format (UXF) file to decode the UML model of mobile game requirement and extract the diagrams into component complexity, object interface complexity, and sequence diagram complexity, according to the defined measurement rules. UML Point tool then automatically compute the functional size, effort, time, human resources, and total development cost of mobile game. Besides, this paper also provides a simple case study to validate the tool. The initial results proved that the tool could be useful to improve estimation accuracy for mobile game application development and found to be reliable to be applied in the mobile game industry.

An approach is presented for generating a performance prediction model so that both qualitative (logical correctness) and quantitative (timeliness) properties of a real‐time system can be evaluated. The architecture of a system is layered into a functional layer and a physical one. Both architectural layers are developed as executable models: the executable functional model is a Petri net and the executable physical model is a queuing net. The two‐layered executable models are then connected to develop a performance prediction model. A message‐passing pattern is generated from the Petri net using a state space analysis technique. Then, the queuing net model processes these messages preserving the pattern. Once the network delays are obtained from the queuing model, their values are inserted back into the Petri net model. Since the communication service demands are isolated from the executable functional model, the communications network can be specified independently at any preferred level of detail. This enables the executable functional model to be invariant with respect to the executable physical model resulting in additional flexibility in designing a large‐scale information system. This property, together with the synthesis technique, enables both formal and simulation methods to be used together, when each one utilizes a different self‐contained commercial‐off‐the‐shelf software application. © 2002 Wiley Periodicals, Inc. Syst Eng 6: 1–18, 2003

Department of Defence Architecture Framework(DoDAF) is an important method to ensure the quality of system design. One way for DoD architecture validation and assess is to transform the DoD architecture products into executable models, then the performance of DoD architecture can be tested through analyzing model execution process and result. Based on the different advantage of UML(Unified Modelling Language) and Petri nets, the paper applies some kinds of views in UML to describe the relative DoD architecture products. Considering the relationship among the products, the UML views for products are transformed into ECPN (Extended Colored Petri Nets) simulation models according to the transformation rules. So the dynamic behavior of system can be displayed by those simulation model, and whether the time-order relation, information flow and system interface is reasonable, or the system function satisfies the military requirement, and the change of system state is correct, can be checked evidently. At last, the paper gives a case in the air defense system using simulation validation method proposed by it.

Software performance based on performance models can be applied at early phases of the software development cycle to characterize the quantitative behavior of software systems. We propose an approach based on queueing networks models for performance prediction of software systems at the software architecture level, specified by UML. Starting from annotated UML Use Case, Activity and Deployment diagrams we derive a performance models based on multichain and multiclass Queueing Networks (QN). The UML model is annotated according to the UML Profile for Schedulability, Performance and Time Specification. The proposed algorithm translates the annotated UML specification into QN performance models, which can then be analyzed using standard solution techniques. Performance results are reported back at the software architecture level in the UML diagrams. As our approach can be fully automated and uses standard UML annotations, it can be integrated with other performance modeling approaches. Specifically, we discuss how this QN-based approach can be integrated with an existing simulation-based performance modeling tool.

The emergence of Unified Modeling Language (UML) as a standard for modeling systems has encouraged the use of automated software tools that facilitate the development process from analysis through coding. The UML state machine diagram is used for modeling the dynamic aspects of systems and includes many concepts that are not present in most popular programming languages, like Java or C++. There exists a gap between high level modeling language and a programming language. This paper proposes an approach to narrow the gap between multiple UML models and an implemented system. The narrowing of gap is achieved by generating compact and efficient Java code directly from UML state machine having sequential and concurrent substates. The code generation is achieved by creating a mapping between UML behavior and the Java programming language. Our model can work as a basis for automatic code generation for object-oriented systems.

This position paper examines current practices and challenges for tracing non-functional requirements (NFRs). Anecdotal evidence suggests that many organizations do not effectively trace NFRs and that functional changes are often implemented with very little understanding as to how system qualities such as safety, security, and performance will be impacted. The tendency for NFRs to have broad ranging impact upon a software system, and the strong interdependencies and tradeoffs that exist between NFRs and the software architecture leave typical existing traceability methods insufficient for tracing NFRs. This paper focuses on post-requirements traceability of NFRs. It first identifies three critical areas in which NFRs require traceability support, it then evaluates existing traceability methods, and finally proposes a more holistic traceability environment named Goal Centric Traceability that supports impact analysis of NFRs within the context of the software architecture in which they are deployed.

The article presents a method for detecting errors in the design of virtual environments, which involves the use of UML diagrams, and the mathematical apparatus of Petri Nets. The analysis of the features of the use of UML diagrams in the design of mechanics of virtual environments, as well as Petri Nets for their static analysis and dynamic modeling have been carried out. The work of this method is demonstrated on the example of the design of the mechanics of the game “Snake”.

A key aspect of the design of any software system is its architecture. An architecture description, from a runtime perspective, should provide a formal model of the architecture in terms of components and connectors, their ports and behaviours, and how they are composed together. The Unified Modelling Language (UML) is widely used in the design of software systems and has recently been extended to better support software architecture description. This paper presents the UML 2.0 Profile for π-ADL, a novel ADL that has been designed in the ArchWare European Project. It briefly presents π-ADL and its UML 2.0 Profile, then it illustrates through a case study how the UML 2.0 Profile for π-ADL can be used for formally modelling software architectures. The toolset for supporting the UML 2.0 Profile for π-ADL is outlined: it supports architecture modelling, architectural behaviour animation, and model checking of architectural properties.

To solve the identification and comprehension problem of crosscutting concerns in existing legacy software system, a framework of aspects-oriented software reverse engineering was proposed. An approach on re-modularizing traversal features of legacy system was presented, which based on various Unified Modeling Language (UML) diagrams. While modeling crosscutting concerns in UML use case diagrams, the non-functional requirements that affect several use case modules can be enveloped into aspects modules with stereotype mechanism. The recurring message transmission patterns can be re-modularized as aspects in UML sequence diagrams with UML collaborations. Standard UML activity diagram notations were extended and modified by nodes fusion and addition, which support the graphical composition operation between crosscutting behaviors and primary business rules of concurrent system. The case study indicates traversal features of software system can be extracted and re-modularized from various perspectives in aspects-oriented reverse engineering, which improves the comprehensibility and maintainability of legacy system.

To keep our software products and cross-product software components maintainable, an approach to software architecture management with a long-term perspective is required. One-time modeling of the intended software architecture is not sufficient. Instead, it must be maintained throughout the whole life-cycle of the software system. Tool support is required to monitor the actual physical software architecture. Deviations must be resolved by modifying the software system or the software architecture description. All software architectures are required to follow a consistent architectural style, which is defined in a technology-neutral way and mapped to all technologies we use in development. In order to support this multi-technology landscape, the architectural style, and our use cases, we developed a tool suite, the BTC RevEngTools.

The resolution of conflicts among non-functional requirements are difficult problem during the analysis of non-functional requirements. To mitigate the problem, the weighted softgoal is proposed based on the Softgoal Interdependency Graphs (SIG) that help engineers resolve conflicts among non-functional requirements. It is also shown evaluation results of the weighted SIG applications to develop non-functional requirements and choose alternative design decisions.

To most in the software community, "modeling" is drawing pictures, something much different than "coding". While programming languages must be specified precisely enough to be executable, this has not necessarily been the case for modeling languages. Indeed, the well-known Unified Modeling Language (UML) has for years had a specification that is far from precise. However, precise models are quite common in other engineering disciplines, and there has been a minority even in software engineering that have created models that are precise enough to be, themselves, executable. Over the last decade, the UML community has more generally come to realize the benefits of having at least a subset of UML specified with precise execution semantics. While not all models need to be executable, executable models can support early testing and analysis of the design of critical software systems, as well as supporting simulation for communities using UML for modeling beyond just software (such as SysML for systems engineering). As a result, there has been a great deal of work in recent years toward the standardization of precise, executable semantics for UML models - the "meaning" behind the pictures: Foundational UML (fUML), the Action Language for fUML (Alf) and the recently completed Precise Semantics for UML Composite Structures. These new specifications provide the promise of widespread support for executable modeling across the many UML tools now on the market.