Software performance models from system scenarios

Software performance concerns begin at the very outset of a new project. The first definition of a software system may be in the form of Use Cases, which may be elaborated as scenarios: this work creates performance models from scenarios. The Use Case Maps notation captures the causal flow of intended execution in terms of responsibilities, which may be allocated to components, and which are annotated with expected resource demands. The SPT algorithm was developed to transform scenario models into performance models. The UCM2LQN tool implements SPT and converts UCM scenario models to layered queueing performance models, allowing rapid evaluation of an evolving scenario definition. The same reasoning can be applied to other scenario models such as Message Sequence Charts, UML Activity Graphs (or Collaboration Diagrams, or Sequence Diagrams), but UCMs are particularly powerful, in that they can combine interacting scenarios and show scenario interactions. Thus a solution for UCMs can be applied to multiple scenarios defined with other notations.KeywordsCredit CardSequence DiagramLoop BodyLogical ResourceMessage Sequence ChartThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

The Use Case Map (UCM) notation is part of the User Requirements Notation (URN), the most recent addition to ITU-T's family of languages. UCM models describe functional requirements and high-level designs with causal scenarios, superimposed on structures of components. It has been shown that UCMs can be transformed into more detailed MSC scenarios. However, UCMs are not executable as such. Early validation and exploration of requirements could benefit from a transformation to a formal, executable language. This paper presents the results of an experiment combining existing tool-supported techniques for the generation of MSCs from UCMs and for the synthesis of SDL from MSCs. In particular, this experiment provides useful results on the current interworking of such techniques and on requirements for future generations of tools. Through a simple case study, this paper also highlights questions and partial answers on the complementariness of these languages, on the usefulness of the resulting SDL models, and on potential improvements on the approach and on the languages themselves.

Technologies based on aspects and applied at the early stages of software development allow requirements engineers to better encapsulate crosscutting concerns in requirements models. The Aspect-oriented User Requirements Notation (AoURN) extends the User Requirements Notation (URN) with aspects and thus unifies goal-oriented, scenario-based, and aspect-oriented concepts in one framework. Minimal changes to URN ensure that requirements engineers can continue working with goal and scenario models expressed in a familiar notation. At the same time, concerns in goal and scenario models, regardless of whether these concerns crosscut or not, can be managed across model types. Typical concerns in URN are non-functional requirements (NFRs), use cases, and stakeholder goals. As AoURN expresses concern composition rules with URN itself, it is possible to describe rules in a highly flexible way that is not restricted by any specific composition language. Aspects can improve the modularity, reusability, scalability, and maintainability of URN models. Considering the strong overlap between NFRs and crosscutting concerns, aspects can help bridge the gap between goals and scenarios. On the other hand, Early Aspects (EA) research can benefit from a standardized way of modeling concerns with AoURN.

The Unified Modeling Language - UML - is the most used specification language, and the way the world models not only application structure, behavior, and architecture, but also business process and data structure. In this paper, we aim to demonstrate a system development methodology by generating the UML diagrams from the requirements of the Automatic Banking Machine (ABM) System and discuss their relationships, differences and suitability. The high-level requirements of the system are specified by using use-case diagram, activity diagram, state chart diagram, collaboration diagram, sequence diagram, and component diagram, and the low-level requirements of each component using class diagrams. We briefly introduce each diagram, their usage, their advantages and some limitations, and then we discuss the relationships and differences between two or more diagrams, and suitability for modeling the different parts of the system.

The interactive diagrams (ID) in the unified modeling language (UML) is consisted of object and the relation between objects, depicts the interaction relation and includes the information transferred between objects. As two interactive diagrams, the semantics of sequence diagrams (SD) and collaboration diagrams (CD) are equivalence in the unified modeling language, both diagrams can be converted with each other without the lost of information. But it is necessary that both diagrams coexist in the unified modeling language because their emphases are different in the course of interaction. Such study is instructive for practitioners to select both diagrams in real tasks.

The unified modeling language (UML) designs come in a variety of different notations. UML designs can be quite large and interactions between various notations and the models they define can be difficult to assess. During the design phase, and between successive releases of systems, designs change. The impact of such changes and the resulting effect on behavior can be non-obvious and difficult to assess. This survey article explores techniques for such re-evaluation that can be classified as regression testing and suggests regression testing criteria for designs. These might vary depending on testing objectives and include both selective and regenerative regression testing approaches. The article provides a concise overview of regression testing approaches related to various UML design notations including use cases, class diagrams, sequence diagrams, activity diagrams, and statecharts, as well as combinations of these models. It discusses UML-related techniques involving cost and prioritization during selective regression testing. Finally, it evaluates these techniques with respect to inclusiveness, precision, efficiency, generality, accountability, and safety. An example is used throughout to illustrate how the techniques work. Copyright © 2009 John Wiley & Sons, Ltd. This survey article explores techniques for regression testing with UML designs and suggests regression testing criteria for designs. These might vary depending on testing objectives and include both selective and regenerative regression testing approaches. The article provides a concise overview of regression testing approaches related to various UML design notations including use cases, class diagrams, sequence diagrams, activity diagrams, and statecharts, as well as combinations of these models. Copyright © 2009 John Wiley & Sons, Ltd.

Dependability aspects, such as availability and security, are critical in the design and implementation of distributed real-time systems. As a result, it is becoming crucial to model and analyze dependability requirements at the early stages of system development life-cycle. The Service Availability Forum (SA Forum) has developed a set of standard API specifications to standardize high-availability platforms. Among these specifications, the Availability Management Framework (AMF) is the service responsible for managing the availability of the application services by handling application redundant components, dynamically shifting a workload of a faulty component to a healthy component. To manage service availability, AMF requires a configuration of the application it manages. This configuration consists of a logical view of the organization of the application’s services and components. Recognizing the need to plan for availability aspects at the early stages of system development life-cycle, this paper proposes an approach to map high level availability requirements into AMF configurations. The early availability requirements are expressed in terms of the Use Case Maps (UCM) language, part of the ITU-T User Requirements Notation (URN) standard. Our approach allows for the early reasoning about availability aspects and promotes the portability and the reusability of the developed systems across different platforms.

Non-functional requirements such as availability, reliability, and security are often crucial in designing and implementing distributed real-time systems. As a result, such non-functional requirements should be addressed as early as possible in the system development life-cycle. The widespread interest in dependability modeling and analysis techniques at the requirements elicitation and analysis stage provides the major motivation for this research. This paper presents a novel approach to describe high-level availability requirements using the Aspect-oriented Use Case Maps (AoUCM) language. AoUCM adds aspects-oriented concepts to the Use Case Maps (UCM) language, part of the ITU-T User Requirements Notation (URN) standard. The proposed approach relies on a mapping of availability architectural tactics to reusable AoUCM models, allowing availability tactics to be encapsulated early in the software development life-cylce. Initial tool support for the resulting availability extensions, is provided by the jUCMNav tool. We demonstrate the applicability of our approach using a case study of Lawful Intercept (LI), an IP router feature.

Semi-formal software techniques have been very successful in industry, government institutions and other areas such as academia. Arguably, they owe a large part of their success to their graphical notation, which is more human-oriented than their counterpart text-based and formal notation techniques. However, ensuring the consistency between two or more models is one of the known challenges of these techniques. This work looks closely at the specific case of the User Requirements Notation (URN) technique. Although the abstract model of URN provides for link elements to ensure the consistency between its two main components, namely, Goal-Oriented Requirement Language (GRL) and Use Case Maps (UCM), the effective implementation of such links is yet to be fully addressed. This paper performs a detailed analysis of the existing URN models construction process and proposes an improved process with some guidelines to ensure, by construction, the correctness and consistency of the GRL and UCM models. A case study is used throughout the paper to illustrate the suggested solution.

Using the Unified Modeling Language (UML), static aspects at conceptual level are represented in structural diagrams such as class diagrams, while dynamic aspects are represented in behavioral diagrams such as state chart diagram, activity diagram, sequence diagrams and collaboration diagrams. And metric measures for those, improves the quality of design. The earlier work focuses on metrics for class diagrams. The main goal of this paper is to focus on the definition of mea -sures that applied to guarantee the validity of design through {NEntryA, NExitA, NA, NT, NS} State chart diagrams, {NM} Inter-action diagrams, and {NOA, NOUC, NOUCA}Use-Case diagrams. This measure of metric validates intrinsic understandability of all behavioral UML diagrams.KeywordsSoftware metricsUML behavioral diagramscomplexity metricstheoretical validation

Designing information systems in social context: a goal and scenario modelling approach

Test is important part of every industrial flow. Therefore preparation of it is in the early phase of development. An effective method is to use User Requirements Notation (URN) for it. It contains two parts: Goal‐oriented Requirement Language (GRL) and Use Case Maps (UCM). It can give the test goals with the help of and GRL and it can provide exact formal description for test generation with the help of UCM. Finally it can link to other mathematical formal models like Communicating Sequential Processes (CSP) or Control Signal CSP (CSCSP). A test system that is described by CSP, a modified CSP that is called CSCSP and a test aspect of URN is combined in this paper. The whole method becomes more useful with the combination of these three solutions, because it can be used in the area of test from the beginning to the end.

The Unified Modeling Language (UML) does not fully address the needs of some important modeling domains, including goals and non-functional requirements (NFR). However, UML can be extended and tailored through the definition of profiles. In this paper, we propose a UML profile for the Goal-oriented Requirement Language (GRL), the goal/NFR notation of the User Requirements Notation (URN), recently standardized by ITU-T as Recommendation Z.151. Our profile is based on the abstract metamodel of GRL defined in accordance with ITU-T Recommendation Z.111 (meta-metamodel). This GRL metamodel has already been successfully tested and implemented in the jUCMNav Eclipse plug-in (a URN modeling tool). The profiling approach used in this paper adheres to the guidelines for UML profile design defined in ITU-T Recommendation Z.119. The resulting profile has been implemented in a UML 2 tool, namely IBM Rational Tau 4.0, and validated with case studies. Our experience and lessons learned are also discussed.KeywordsGoal-oriented Requirement LanguageMetamodelTau G2UML ProfileUser Requirements Notation

Recently, interest in performance modeling of out-come-based regulations has grown in the regulatory community. In this context, performance modeling refers to the measuring of important business aspects in a coordinated manner and the use of these measurements for improved decision making. Goal modeling techniques have shown to be beneficial when expressing and analyzing performance models. Since most regulations are still written in natural language, support for the transformation of regulatory text into performance models is needed. This allows regulators and regulated parties to keep working with familiar natural language regulations and to use goal models indirectly while avoiding a potentially significant learning curve for goal-modeling techniques. In this paper, we present such a tool-supported transformation to goal models expressed with the User Requirements Notation that enables reasoning about outcome-based regulations via widely available evaluation mechanism for goal models. The transformation is implemented in the jUCM-Nav goal modeling tool and illustrated with an example from the banking domain.

Unified Modeling Language (UML) provides various diagrams to depict system characteristics and complex environment from different viewpoints and different application layers. It also contains a lot of standard elements with vague and sparse semantics. Researching how to combine Unified Modeling Language (UML) with formal method in order to improve UML semantic accuracy is a hotspot of researches in software engineering because of the half formal characteristic of UML. This paper defines Syntax Domains, Abstract Syntax, Semantic Domains, Semantic Functions of UML sequence diagram using Denotational Semantics, formally depicts sequence diagram on the function of the each syntax object of sequence diagram. It provides the foundation for accuracy and consistency validation of UML sequence diagram.