211 research outputs found
Quo Vadis Abstract State Machines? J.UCS Special Issue
In introducing this special ASM issue of J.UCS we point out the particular role this Journal played in the short history of the ASM method and add some reflections on its current status
Ontology-based methodology for error detection in software design
Improving the quality of a software design with the goal of producing a high quality software product continues to grow in importance due to the costs that result from poorly designed software. It is commonly accepted that multiple design views are required in order to clearly specify the required functionality of software. There is universal agreement as to the importance of identifying inconsistencies early in the software design process, but the challenge is how to reconcile the representations of the diverse views to ensure consistency. To address the problem of inconsistencies that occur across multiple design views, this research introduces the Methodology for Objects to Agents (MOA). MOA utilizes a new ontology, the Ontology for Software Specification and Design (OSSD), as a common information model to integrate specification knowledge and design knowledge in order to facilitate the interoperability of formal requirements modeling tools and design tools, with the end goal of detecting inconsistency errors in a design. The methodology, which transforms designs represented using the Unified Modeling Language (UML) into representations written in formal agent-oriented modeling languages, integrates object-oriented concepts and agent-oriented concepts in order to take advantage of the benefits that both approaches can provide. The OSSD model is a hierarchical decomposition of software development concepts, including ontological constructs of objects, attributes, behavior, relations, states, transitions, goals, constraints, and plans. The methodology includes a consistency checking process that defines a consistency framework and an Inter-View Inconsistency Detection technique. MOA enhances software design quality by integrating multiple software design views, integrating object-oriented and agent-oriented concepts, and defining an error detection method that associates rules with ontological properties
Early aspects: aspect-oriented requirements engineering and architecture design
This paper reports on the third Early Aspects: Aspect-Oriented Requirements Engineering and Architecture Design Workshop, which has been held in Lancaster, UK, on March 21, 2004. The workshop included a presentation session and working sessions in which the particular topics on early aspects were discussed. The primary goal of the workshop was to focus on challenges to defining methodical software development processes for aspects from early on in the software life cycle and explore the potential of proposed methods and techniques to scale up to industrial applications
The Meaning of UML Models
The Unified Modelling Language (UML) is intended to express complex ideas in an intuitive and easily understood way. It is important because it is widely used in software engineering and other disciplines. Although an official definition document exists, there is much debate over the precise meaning of UML models. ¶ In response, the academic community have put forward many different proposals for formalising UML, but it is not at all obvious how to decide between them. Indeed, given that UML practitioners are inclined to reject formalisms as non-intuitive, it is not even obvious that the definition should be “formal” at all. Rather than searching for yet another formalisation of UML, our main aim is to determine what would constitute a good definition of UML. ¶ The first chapter sets the UML definition problem in a broad context, relating it to work in logic and the philosophy of science. ..
Quality of process modeling using BPMN: a model-driven approach
Dissertação para obtenção do Grau de Doutor em
Engenharia InformáticaContext: The BPMN 2.0 specification contains the rules regarding the correct usage of
the language’s constructs. Practitioners have also proposed best-practices for producing better BPMN models. However, those rules are expressed in natural language, yielding sometimes ambiguous interpretation, and therefore, flaws in produced BPMN models.
Objective: Ensuring the correctness of BPMN models is critical for the automation of
processes. Hence, errors in the BPMN models specification should be detected and
corrected at design time, since faults detected at latter stages of processes’ development can be more costly and hard to correct. So, we need to assess the quality of BPMN models in a rigorous and systematic way.
Method: We follow a model-driven approach for formalization and empirical validation
of BPMN well-formedness rules and BPMN measures for enhancing the quality of
BPMN models.
Results: The rule mining of BPMN specification, as well as recently published BPMN works, allowed the gathering of more than a hundred of BPMN well-formedness and
best-practices rules. Furthermore, we derived a set of BPMN measures aiming to provide information to process modelers regarding the correctness of BPMN models. Both BPMN rules, as well as BPMN measures were empirically validated through samples of
BPMN models.
Limitations: This work does not cover control-flow formal properties in BPMN models, since they were extensively discussed in other process modeling research works.
Conclusion: We intend to contribute for improving BPMN modeling tools, through the
formalization of well-formedness rules and BPMN measures to be incorporated in those
tools, in order to enhance the quality of process modeling outcomes
Model based test suite minimization using metaheuristics
Software testing is one of the most widely used methods for quality assurance and fault detection purposes. However, it is one of the most expensive, tedious and time consuming activities in software development life cycle. Code-based and specification-based testing has been going on for almost four decades. Model-based testing (MBT) is a relatively new approach to software testing where the software models as opposed to other artifacts (i.e. source code) are used as primary source of test cases. Models are simplified representation of a software system and are cheaper to execute than the original or deployed system. The main objective of the research presented in this thesis is the development of a framework for improving the efficiency and effectiveness of test suites generated from UML models. It focuses on three activities: transformation of Activity Diagram (AD) model into Colored Petri Net (CPN) model, generation and evaluation of AD based test suite and optimization of AD based test suite. Unified Modeling Language (UML) is a de facto standard for software system analysis and design. UML models can be categorized into structural and behavioral models. AD is a behavioral type of UML model and since major revision in UML version 2.x it has a new Petri Nets like semantics. It has wide application scope including embedded, workflow and web-service systems. For this reason this thesis concentrates on AD models. Informal semantics of UML generally and AD specially is a major challenge in the development of UML based verification and validation tools. One solution to this challenge is transforming a UML model into an executable formal model. In the thesis, a three step transformation methodology is proposed for resolving ambiguities in an AD model and then transforming it into a CPN representation which is a well known formal language with extensive tool support. Test case generation is one of the most critical and labor intensive activities in testing processes. The flow oriented semantic of AD suits modeling both sequential and concurrent systems. The thesis presented a novel technique to generate test cases from AD using a stochastic algorithm. In order to determine if the generated test suite is adequate, two test suite adequacy analysis techniques based on structural coverage and mutation have been proposed. In terms of structural coverage, two separate coverage criteria are also proposed to evaluate the adequacy of the test suite from both perspectives, sequential and concurrent. Mutation analysis is a fault-based technique to determine if the test suite is adequate for detecting particular types of faults. Four categories of mutation operators are defined to seed specific faults into the mutant model. Another focus of thesis is to improve the test suite efficiency without compromising its effectiveness. One way of achieving this is identifying and removing the redundant test cases. It has been shown that the test suite minimization by removing redundant test cases is a combinatorial optimization problem. An evolutionary computation based test suite minimization technique is developed to address the test suite minimization problem and its performance is empirically compared with other well known heuristic algorithms. Additionally, statistical analysis is performed to characterize the fitness landscape of test suite minimization problems. The proposed test suite minimization solution is extended to include multi-objective minimization. As the redundancy is contextual, different criteria and their combination can significantly change the solution test suite. Therefore, the last part of the thesis describes an investigation into multi-objective test suite minimization and optimization algorithms. The proposed framework is demonstrated and evaluated using prototype tools and case study models. Empirical results have shown that the techniques developed within the framework are effective in model based test suite generation and optimizatio
Action semantics of unified modeling language
The Uni ed Modeling Language or UML, as a visual and general purpose modeling
language, has been around for more than a decade, gaining increasingly wide application
and becoming the de-facto industrial standard for modeling software systems. However,
the dynamic semantics of UML behaviours are only described in natural languages.
Speci cation in natural languages inevitably involves vagueness, lacks reasonability and
discourages mechanical language implementation. Such semi-formality of UML causes
wide concern for researchers, including us.
The formal semantics of UML demands more readability and extensibility due to its
fast evolution and a wider range of users. Therefore we adopt Action Semantics (AS),
mainly created by Peter Mosses, to formalize the dynamic semantics of UML, because
AS can satisfy these needs advantageously compared to other frameworks.
Instead of de ning UML directly, we design an action language, called ALx, and
use it as the intermediary between a typical executable UML and its action semantics.
ALx is highly heterogeneous, combining the features of Object Oriented Programming
Languages, Object Query Languages, Model Description Languages and more complex
behaviours like state machines. Adopting AS to formalize such a heterogeneous language
is in turn of signi cance in exploring the adequacy and applicability of AS.
In order to give assurance of the validity of the action semantics of ALx, a prototype
ALx-to-Java translator is implemented, underpinned by our formal semantic description
of the action language and using the Model Driven Approach (MDA). We argue that
MDA is a feasible way of implementing this source-to-source language translator because
the cornerstone of MDA, UML, is adequate to specify the static aspect of programming
languages, and MDA provides executable transformation languages to model mapping
rules between languages.
We also construct a translator using a commonly-used conventional approach, in
i
which a tool is employed to generate the lexical scanner and the parser, and then
other components including the type checker, symbol table constructor, intermediate
representation producer and code generator, are coded manually. Then we compare the
conventional approach with the MDA. The result shows that MDA has advantages over
the conventional method in the aspect of code quality but is inferior to the latter in
terms of system performance
Model Transformation Languages with Modular Information Hiding
Model transformations, together with models, form the principal artifacts in model-driven software development. Industrial practitioners report that transformations on larger models quickly get sufficiently large and complex themselves. To alleviate entailed maintenance efforts, this thesis presents a modularity concept with explicit interfaces, complemented by software visualization and clustering techniques. All three approaches are tailored to the specific needs of the transformation domain
- …