UML Design Models Research Articles

The Automatic Definition of the Intuitive Linguistic Heuristics Set to Recognize the Elements of UML Analysis and Design Models in English

The Automatic Definition of the Intuitive Linguistic Heuristics Set to Recognize the Elements of UML Analysis and Design Models in English

Transformation of UML Design Models of Information Security System into Agent-based Simulation Models

Transformation of UML Design Models of Information Security System into Agent-based Simulation Models

Automatic transformation tools of UML design models from virtual prototypes of multi-jointed robots

Most of robotic companies develop a control programming of multi-jointed robots, which spend too much time to manually adjust the moving functions of the robots. To solve this problem, we adapt the virtual prototyping (VP) to develop the control program of the robotic behaviors. For software engineers, in order for them to easily program this robot, we also apply metamodel mechanism to convert UML models with virtual prototyping model. We propose the automatic model transformation from the virtual prototyping model to UML models, which will then develop coding based on UML models. To prove our mechanism’s efficiency, we implement Robot to UML Translator (RUT) as our transformation rules with ATLAS transformational language. Lastly, we show experimental validation about the consistency of our proposed technique with an example of multi-joined robot prototype models.

Source-code comprehension tasks supported by UML design models: Results from a controlled experiment and a differentiated replication

Objective: The main objective is to investigate whether the comprehension of object-oriented source-code increases when it is added with UML class and sequence diagrams produced in the software design phase.Methods: We conducted a controlled experiment and a differentiated replication with young software maintainers. In particular, groups of Bachelor and Master students were involved.Results: The results show that more experienced participants better comprehend source-code when added with UML design models. An average improvement (or benefit) of circa 12% was achieved when the participants accomplished the comprehension task with UML class and sequence diagrams. The results of an analysis on the time to accomplish comprehension tasks showed that less experienced participants significantly spent more time when comprehending source-code with UML design models. This kind of participants spent on average 44.8% of the time to accomplish the same task with source-code alone.Implications: It is useless to give UML design models to comprehend source-code in case maintainers are not adequately experienced with the UML. Furthermore, the less the experience of participants, the more the time to accomplish a comprehension task with UML diagram is.

Research on Automated Software Test Case Generation

To improve the efficiencyof software testing, a model-driven method is proposed to automatically generatetest cases from UML design model. In it, PITCs (platform-independent testcases) are generated first from a UML design model. And then, according to thepredefined rules, a process is implemented to transform PITCs into thecorresponding PSTCs (platform-specific test cases). The experiment and comparisonhad showed that the method proposed in this paper was easier to be understoodand implemented by users to generate test cases than the ones existed.

Model transformation verification using similarity and graph comparison algorithm

Regarding the software development, MDA (Model Driven Architecture) of OMG can be regarded as the concept of making an independently-designed model according to the development environment and language and reusing it according to the desired development environment and language by expanding the reusable unit into the software model when developing software. The problem with these traditional research methods, but the first model, design model for checking the information with the model by defining a formal representation in the form of an abstract syntax tree, as you've shown how to perform validation of UML design model. Additional steps need to define more complex due to a software problem that is not the way to the model suitable for model transformation verification. In this paper, as defined in the verification based meta model for input and target model. And we also suggest how to perform model transformation verification using property matching based transformation similarity and graph comparison algorithm. This paper proposes model transformation verification using verification meta information and transformation similarity by property matching. In addition, in order to support verification of the target model generated from the source model, we define verification meta model for UML model, RDBMS model and RT-UML model. Recent researches from model-based architecture did partial tests focusing on phrase-correctness about the re-use in the perspective of converted software model. To overcome such limitations, this study suggests the ways to define transformation profiles using property information of system structure models as the test-based meta-model and transformation rules, improve graph comparison algorithm, and even supports the correctness of meanings. There were problems in existing methods of model transformation verification such as graph comparison or the one considering only syntax-correctness through pattern-matching. To remedy such problems, this study suggests a new verification method by defining the meta-model which has additional structural attributes and property information and the transformation profile, and using graph comparison algorithm which checks whether the information acquired from transformation is correct.

Design of MDA Based Model Transformation Profile for Model Verification

Validation of existing software design models and transformed target models for the study, mainly checking (Model Checking) with a code-based software designed to define in the abstract syntax tree or on the models generated using refactoring on design models for refinery operations and define how to perform. The problem with these traditional research methods, but the first model, design model for checking the information with the model by defining a formal representation in the form of an abstract syntax tree, as you've shown how to perform validation of UML design model. Additional steps need to define more complex due to a software problem that is not the way to the model suitable for model transformation verification. In this paper, as defined in the MDA based model transformation studies of a graph based mode transformation, and how to perform model transformation verification through improving graph comparison algorithm and model property information.

Using Aspects for Platform-Independent to Platform-Dependent Model Transformations

This paper presents an aspect-based approach for realizing a transformation from platform-independent to platform-dependent models in the context of a model transformation chain that generates queueing-based performance models from UML design models of serviceoriented applications. The purpose of generating such performance models is to evaluate the performance of the system under development in the early software lifecycle phases, in order to insure that it will meet the performance requirements. The paper presents the model transformation chain PUMA4SOA, which transforms automatically a UML model of a service-oriented architecture (SOA) system extended with MARTE performance annotations into an intermediate model, Core Scenario Model (CSM), which in turn is used to generate a Layered Queueing Network (LQN) performance model. Aspect-oriented modeling is used to represent different services offered by the underlying SOA platform to the SOA application. The paper discusses and compares different alternatives for composing the platform aspect models with the platform-independent model (PIM) of the application throughout the model transformation chain.

Specification of Products and Product Lines

The study of variability in software development has become increasingly important in recent years. A common mechanism to represent the variability in a product line is by means of feature models. However, the relationship between these models and UML design models is not straightforward. UML statecharts are extended introducing variability in their main components, so that the behavior of product lines can be specified. The contribution of this work is the proposal of a rule-based approach that defines a transformation strategy from extended statecharts to concrete UML statecharts. This is accomplished via the use of feature models, in order to describe the common and variant components, in such a way that, starting from different feature configurations and applying the rule-based method, concrete state machines corresponding to different products of a line can be obtained.

Eliciting security requirements and tracing them to design: an integration of Common Criteria, heuristics, and UMLsec

Building secure systems is difficult for many reasons. This paper deals with two of the main challenges: (i) the lack of security expertise in development teams and (ii) the inadequacy of existing methodologies to support developers who are not security experts. The security standard ISO 14508 Common Criteria (CC) together with secure design techniques such as UMLsec can provide the security expertise, knowledge, and guidelines that are needed. However, security expertise and guidelines are not stated explicitly in the CC. They are rather phrased in security domain terminology and difficult to understand for developers. This means that some general security and secure design expertise are required to fully take advantage of the CC and UMLsec. In addition, there is the problem of tracing security requirements and objectives into solution design, which is needed for proof of requirements fulfilment. This paper describes a security requirements engineering methodology called SecReq. SecReq combines three techniques: the CC, the heuristic requirements editor HeRA, and UMLsec. SecReq makes systematic use of the security engineering knowledge contained in the CC and UMLsec, as well as security-related heuristics in the HeRA tool. The integrated SecReq method supports early detection of security-related issues (HeRA), their systematic refinement guided by the CC, and the ability to trace security requirements into UML design models. A feedback loop helps reusing experience within SecReq and turns the approach into an iterative process for the secure system life-cycle, also in the presence of system evolution.

TESTING ASPECT-ORIENTED PROGRAMS WITH UML DESIGN MODELS

The new constructs in aspect-oriented programming bring new types of programming faults with respect to crosscutting concerns, such as incorrect pointcuts and advice. This paper presents a UML-based approach to testing whether or not an aspect-oriented program conforms to its expected crosscutting behavior. We explore aspect-oriented UML design models to derive tests for exercising interactions between aspects and classes. Each aspect-oriented model consists of class diagrams, aspect diagrams, and sequence diagrams. For a method under test, we weave the sequence diagrams of the advice on the method into the method's sequence diagram. Based on the woven sequence diagram and class/aspect diagrams, we then generate an AOF (Aspect-Object Flow) tree by applying coverage criteria such as condition coverage, polymorphic coverage, and loop coverage to woven sequence diagrams. In the AOF tree, each path from the root to a leaf is an abstract message sequence, indicating a template of test cases. A concrete test case is obtained by creating objects that satisfy the collective constraints in the template. Our empirical study shows that the model-based testing approach is capable of revealing several types of aspect-specific faults, including incorrect advice type, incorrect (weaker or stronger) pointcut strengths, and incorrect aspect precedence.

Architecture-Driven Service Discovery for Service Centric Systems

Service discovery has been recognized as an important aspect in the development of service-centric systems, i.e., software systems which deploy Web services. To develop such systems, it is necessary to identify services that can be combined in order to fulfill the functionality and achieve quality criteria of the system being developed. In this paper, we present a framework supporting architecture-driven service discovery (ASD)—that is the discovery of services that can provide functionalities and satisfy properties and constraints of systems as specified during the design phase of the development lifecycle based on detailed system design models. Our framework assumes an iterative design process and allows for the (re-)formulation of design models of service-centric systems based on the discovered services. The framework is composed of a query extractor, which derives queries from behavioral and structural UML design models of service-centric systems, and a query execution engine that executes these queries against service registries based on graph matching techniques. The article describes a prototype tool that we have developed to demonstrate and evaluate our framework and the results of a set of preliminary experiments that we have conducted to evaluate it.

Testing UML designs

Early detection and correction of faults in the software design phase can reduce total cost and time to market of a software product. In this paper we describe an approach for testing UML design models to uncover inconsistencies. Our approach uses behavioral views such as Sequence Diagrams to simulate state change in an aggregate model. The aggregate model is the artifact of merging information from behavioral and structural UML views. OCL pre-conditions, post-conditions and invariants are used as a test oracle.

Using patterns for the refinement and translationof UML models: A controlled experiment

This paper presents a controlled experiment, conducted at the University of Kaiserslautern which evaluates an approach known as SORT, for the systematic refinement and translation of UML Diagrams. Specifically, the experiment investigates the effects of SORT, with respect to the mapping of object-oriented UML design models to source code, by comparing the effects of different approaches to such mappings (SORT and ad-hoc1) on the quality attributes understandability, verifiability, and effort (time). The experimental results demonstrate that OO systems developed by applying SORT are more understandable and verifiable. In summary, SORT can help to improve the quality of software systems, but its application alone does not guarantee quality.

Model-based testing with UML applied to a roaming algorithm for Bluetooth devices

In late 2001, the Object Management Group issued a Request for Proposal to develop a testing profile for UML 2.0. In June 2003, the work on the UML 2.0 Testing Profile was finally adopted by the OMG. Since March 2004, it has become an official standard of the OMG. The UML 2.0 Testing Profile provides support for UML based model-driven testing. This paper introduces a methodology on how to use the testing profile in order to modify and extend an existing UML design model for test issues. The application of the methodology will be explained by applying it to an existing UML Model for a Bluetooth device.

A Pattern-Based Framework for Software Anomaly Detection

This paper presents a pattern-based framework for developing tool support to detect software anomalies. The use of a pattern-based approach is important because it provides the flexibility needed to address domain-specific needs, with respect to the types of problems the tools detect and the strategies used to inspect and adapt the code. Patterns can be used to detect a variety of problems, ranging from simple syntactic issues to difficult semantic problems requiring global analysis. Patterns can also be used to describe transformations of the software, used to rectify problems detected through software inspection, and to support interactive inspection and adaptation when full automation is impractical. This paper describes a part of the Knowledge Centric Software (KCS) framework that embodies the pattern-based approach and provides capabilities for addressing different languages and different application domains. While only the part of the framework relevant to code inspections is addressed in this paper, in future, we also expect to address UML analysis and design models. As an application of the research, we present an overview of an inspection tool being developed for high assurance software for avionics systems.