Tihamér Levendovszky received his M.Sc. in Electrcal engineering and Ph.D. in Computer Science from the Budapest University of Technology and Economics. His main research area is graphical modeling languages and applied performance analysis of software systems. He is working for Institute for Software-Integrated Systems at Vanderbilt University, Nashville, TN as a research assistant professor.
Abstract: Performance metrics can be predicted with appropriate performance models and
evaluation algorithms. The goal of ourwork is to adapt theMean-Value Analysis evaluation
algorithm to model the behavior of the thread pool. The computation time and the
computational complexity of the proposed algorithm have been provided. The limit of
the response time and the throughput sequences computed by the novel algorithm has
been determined. It has been shown that the proposed algorithm can be applied to
performance prediction of web-based software systems in ASP.NET environment. The
proposed algorithmhas been validated and the correctness of performance prediction with
the novel algorithm has been verified with performance measurements. Error analysis has
been performed to verify the correctness of performance prediction.
Abstract: Verification of model processing programs, where only the definitions of the program and the languages of the models to be transformed are analyzed, has become a fundamental issue in model-based software engineering. This analysis may become very complex, but it is performed only once and the results are independent from concrete input models. The formal background of verification methods for graph rewriting-based model transformations has become a subject of research recently. In previous work, we have provided fundamental formal and algorithmic background of a (semi-)automated verification approach for graph transformations. This work concludes these components and put them together to introduce the implementation of a verification system fully integrated into a model transformation framework, VMTS. The strong points of our approach is its usability, its implementation in an existing tool, and its extendibility, which are demonstrated on a case study in the application domain of mobile centric social networks. Our results show that the verification of graph rewriting-based model transformations can be largely automated.
Abstract: Metamodeling is a widely applied technique in the field of graphical language engineering. Environments supporting metamodeling aid rapid and flexible domain-specific modeling language (DSML) definition and utilization. In software engineering, design patterns are efficient solutions for recurring problems. With the proliferation of DSMLs, there is a need for domain-specific design patterns to offer solutions to problems recurring in different domains. The aim of this paper is to illustrate a concept that integrates modeling patterns into a metamodeling environment. The introduced approach utilizes the modeling functionalities of the environment; a visual design pattern metamodel, a system architectural metamodel extended with textual constraints are introduced. Furthermore, design patterns are validated against relaxed constraints defined in the metamodel to only allow the creation of patterns that can be extended to valid instance models.
Abstract: Model-based development is one of the most promising solutions for several problems of industrial software engineering. Graph transformation is a proven method for processing domain-specific models. However, in order to be used by domain experts without graph transformation experts, it must be fast even if not tweaked for speed manually based on knowledge available only to the implementers of the transformation system. In this paper, we compare the performance of such manual optimizations with a solution using automated optimization based on sharing of matches between overlapping left-hand-sides of sequentially independent rules. This yields a 11% improvement in our scenario, although our prototypical implementation only exploits overlapping between, at most, two rules, and the analyzed benchmark does not contain many cases where the optimization is applicable.
Abstract: Tool support for design patterns is a critically important
area of computer-aided software engineering. With the proliferation
of Domain-Specific Modeling Languages (DSMLs), the adaptation of the
notion of design patterns appears to be a promising direction of
research. This paper introduces a new approach to DSML patterns,
namely, the Active Model Pattern infrastructure. In this framework,
not only the traditional insertion of predefined partial models is
supported, but interactive, localized design-time manipulation of
models. Optionally, the infrastructure can be adapted to handling
transactional tracing information as well as transactional undo and
redo operations. Possible realizations of the framework are also
discussed and compared
Abstract: Using XML as a data representation format is a common choice when integrating software systems on different platforms. The serialization of in-memory object instances of a class into corresponding XML documents heavily influences the performance of the XML-based communication, even if we send the XML over HTTP as in the case of SOAP-based XML Web Services, or with asynchronous messaging such as Java Message Service (JMS), or simply saving it into a file. Several studies have been published analyzing the performance impact of XML serialization on different platforms. No models or measurement methodologies have been proposed however, to establish a relationship between the serialization cost of primitive types (e.g. int, double, string), and the serialization cost of composite types. Such a model can be very useful when the type of the XML messages exchanged during the communication are known a priori, recorded in an interface definition, similarly to the Web Services Description Language (WSDL) in case of XML Web Services. This paper introduces a model that is validated with measurements on .NET and Java platform. The opposite direction, deserialization is covered as well. The main mathematical tool used is linear regression, but cases are also shown and explained where linearity is compromised.
Abstract: Metamodeling is a widely applied technique in
the field of graphical languages to create highly configurable
modeling environments. These environments support the
rapid development of domain-specific modeling languages
(DSMLs). Design patterns are efficient solutions for recurring
problems. With the proliferation of DSMLs, there is
a need for domain-specific design patterns to offer solutions
to problems recurring in different domains. The aim of
this paper is to provide theoretical and practical foundations
to support domain-specific model patterns in metamodeling
environments. In order to support the treatment of premature
model parts, we weaken the instantiation relationship. We
provide constructs relaxing the instantiation rules, and we
show that these constructs are appropriate and sufficient to
express patterns. We provide the necessary modifications in
metamodeling tools for supporting patterns.With the contributed
results, a well-founded domain-specific model pattern
support can be realized in metamodeling tools.
Abstract: The performance of web-based software systems is one of the most important and complicated consideration. With the help of a proper performance model and an appropriate evaluation algorithm, performance metrics can be predicted. The goal of our work is to introduce and verify an improved multi-tier queueing network model for web-based software systems. In our work, an evaluation and prediction technique applying dominant factors in point of response time and throughput performance metrics has been established and investigated. The Mean-Value Analysis algorithm has been improved to model the behavior of the thread pool. The proposed algorithm can be used for performance prediction. The convergence and limit of the algorithm have been analyzed. The validity of the proposed algorithm and the correctness of the performance prediction have been proven with performance measurements.
Abstract: Verification of the transformations is a fundamental issue for applying
them in real world solutions. We have previously proposed a formalization to declaratively
describe model transformations and proposed an approach for the verification.
Our approach consists of a reasoning system that works on the formal transformation
description and deduction rules for the system. The reasoning system can
automatically generate the proof of some properties. In this paper, we present a case
study, to demonstrate our approach of automated verification of model transformations
in a multi-paradigm environment.
Abstract: There exist numerous techniques to define the abstract and the concrete syntax of metamodeled languages. However, only a few solutions are available to describe the dynamic behavior (animation) of visual languages. The aim of our research is to provide visual modeling techniques to define the dynamic behavior of the languages. Previously, we have created languages to describe animation. In this paper, we describe how these models can be processed by model transformation techniques. We elaborate the main steps of the transformation and show the details as well. We use graph rewriting-based model transformation, therefore we provide a highly generic solution which can be easily modified, and analyzed with the techniques borrowed from the field of graph rewriting. The termination analysis for the presented method is also provided.
Abstract: Model-driven Software Engineering is one of the most focused research fields. Model processors automatically generate the lower level artefacts. Graph transformation is a widely used technique for model transformations. Especially visual model transformations can be expressed by graph transformations. This paper presents a visual control flow support of the Visual Modelling and Transformation System and discusses the principles of the constraint-driven validated model transformation. The presented approach helps to validate, preserve or guarantee certain model properties not only for individual transformation rules but also for the whole transformation.
Abstract: In software engineering, reliability and development time are two of the most important aspects, therefore, modeling environments, which aide both, are widely used during software development. UML and OCL became industry standards, and are supported by many CASE tools. OCL code checking, which has to be performed by these tools, has a specialty, as not all of the information necessary for compilation is available from the code, the related model contains the types, navigations and attributes. The build time of OCL code fragments is increased if the development tool supports distributed modeling, because in this case, model element checking has to be performed in a model repository that cannot be held in memory. In this paper, we introduce a method that enables incremental OCL code building and therefore reduces the development time. Incremental builds require higher complexity than simple builds, thus balancing between the two methods is also considered.
Abstract: Reasoning about graph and model transformation systems is an important means to underpin model-driven software engineering, such as Model-Driven Architecture (MDA) and Model Integrated Computing (MIC). Termination criteria for graph and model transformation systems have become a focused area recently. This paper provides termination criteria for graph and model transformation systems with injective matches and finite input structure. It proposes a treatment for infinite sequences of rule applications, and takes attribute conditions, negative application conditions, and type constraints into account. The results are illustrated on case studies excerpted from real-world transformations, which show the termination properties of the frequently used ''transitive closure'' and ''leaf collector'' transformation idioms. An intuitive comparison with other approaches is also given.
Abstract: The most common consideration of web-based information
systems is performance. Performance metrics depend on many
factors. The first goal of our work is to analyse how some
of them affect the response time. Our results have shown that
the thread pool properties and the queue size limits are performance
factors. In addition, the distribution of the response time
has been determined. With the help of properly designed performance
models and evaluation algorithms, the performance
metrics of a system can be determined at the early stages of the
development process. The second goal of our work is to predict
the response time, the throughput, and the tier utilization of
ASP.NET web applications, based on queueing models handling
one and multiple session classes. In addition, web applications
have been tested with concurrent user sessions to validate the
models in different versions of the ASP.NET environment.
Abstract: The growing importance of modeling and model transformation has attracted attention to create precise models and transformations. Visual model definitions have a tendency to be incomplete, or imprecise, thus, the definitions are often extended by textual constraints attached to the model items. Textual constraints can eliminate the incompleteness stemming from the limitations of the visual definitions. Object Constraint Language (OCL) is one of the most popular constraint languages in the field of UML, Domain Specific Modeling Languages, and model transformations. Efficient constraint handling needs the optimization of the constraints. Our research focuses on creating optimization algorithms for OCL constraint handling. This paper presents three algorithms that can accelerate the validation process, and thus, make the modeling more efficient. Proofs are also provided to show that the optimized and the unoptimized code are functionally equivalent, and the paper contains a simple case study to show the practica l relevance of the algorithms.
Abstract: Efficient constraint handling is essential in UML, in metamodeling as well as in model transformation. OCL is a popular, textual formal language that is used in most of the modeling frameworks to express constraints. Our research focuses on the optimization of OCL handling. Previous work have presented algorithms that can accelerate the constraint validation by rewriting and decomposing the constraints and caching the model queries. Although these algorithms can be used in general, there are special cases, where additional restrictions apply. The aim of this paper is to present these refined restrictions and the extended optimization algorithms.
Abstract: Model-based development is an increasingly applied method in producing software artifacts that is driven by model transformation. For instance, OMG's Model-Driven Architecture as a model-based approach to software development facilitates the synthesis of application programs from models created using customized, domain-specific model processors. Meta Object Facility 2.0 Query/ Views/ Transformation (QVT) is the OMG's standard for specifying model queries, views, and transformations. Extensive research of graph transformation provides a strong formal background for model transformation. The main contribution of this paper is to show how high-level constraint constructs facilitate to realize transformations specified in QVT with metamodel-based model transformation. As a result we can reuse the graph transformation constructs, and its formal background, which facilitates to make QVT transformations validated.
Abstract: Graph rewriting-based visual model processing is a widely used technique for model transformation. Visual model transformations often need to follow an algorithm that requires a strict control over the execution sequence of the transformation steps. Therefore, in Visual Model Processors (VMPs) the execution order of the transformation steps is crucial. This paper presents the visual control flow support of Visual Modeling and Transformation System (VMTS), which facilitates composing complex model transformations of simple transformation steps and executing them. The VMTS Visual Control Flow Language (VCFL) uses stereotyped activity diagrams to specify control flow structures and OCL constraints to choose between different control flow branches. This paper introduces VCFL, discusses its termination properties and provides an algorithm to support the termination analysis of VCFL transformations.
Abstract: Model transformation has become one of the most focused research field, motivated by for instance the OMGâs Model-Driven Architecture (MDA). Metamodeling is a central technique in the design of visual languages, and it reuses existing domains by extending the metamodel level. Metamodel-based software development requires the transformation of the models between various stages. These transformation steps must be formally and precisely specified, which can be accomplished along with constraints enlisted in transformation steps. Our metamodel-based approach uses graph rewriting techniques for model transformation. This paper summarizes our results related to the metamodel-based constraint validation during the model transformation. This work presents the Rule Constraint Validator (RCV) algorithm, the Invariant Analysis (IA) algorithm, the Persistent Analysis (PA) algorithm and the combination of the RCV and PA algorithms which results the Optimized Rule Constraint Validator (ORCV) algorithm. An illustrative case study for constraint validation in rewriting rules is also provided.
Abstract: Model transformation means converting an input model available at the beginning of the transformation process to an output model. A widely used approach to model transformation uses graph rewriting as the underlying transformation technique. In case of diagrammatic languages, such as the Unified Modeling Language (UML), the exclusive topological matching is found to be not enough. To define precisely the transformation steps beyond the topology of the visual models, additional constraints must be specified which ensures the correctness of the attributes, or other properties to be enforced. Dealing with OCL constraints provides a solution for these unsolved issues, because topological and attribute transformation methods cannot perform and express the problems which can be addressed by constraint validation. The use of OCL as a constraint and query language in modeling is essential. We have shown that it can be applied to model transformations as well. Often, the same constraint is repetitiously applied in many different places in a transformation. It would be beneficial to describe a common constraint in a modular manner, and to designate the places where it is to be applied. This paper presents the problem of crosscutting constraints in transformation rules, and provides an aspect-oriented solution for it. Our approach makes it possible to define constraints separately from the transformation steps, and facilitates specifying their propagation assignment to graph transformation rules. To illustrate the conceptual results, a case study is also provided, which introduces (i) how our approach generates user interface handler source code for mobile platform from a resource model and a statechart diagram, and (ii) how it validates specific properties during the transformation steps using aspect-oriented constraints.
Abstract: Models and model-based software development is one of the most focused research fields. Flexible, highly customizable models are required. Metamodeling is a proven solution for this problem, but the information represented by metamodels has a tendency to be incomplete, informal, imprecise, and sometimes even inconsistent. Object Constraint Language (OCL) is a wide-spread formalism to express model constraints, and it is also useful in graph transformation-based model transformation. There exist several interpreters and compilers that handle OCL constraints in modeling, but these tools do not support constraint optimization, therefore, the model validation is not always efficient. This paper presents efficient algorithms to optimize OCL compilers with respect to the traversing steps of the generated code, and accelerate the validation process by normalizing the OCL constraints. Proofs are also provided to show that the optimized and the unoptimized code are functionally equivalent.
Abstract: Metamodeling techniques are popular in describing the rules of special domains, but these techniques do not support defining presentation for these domains , namely the concrete syntax. The aim of our research is to provide a method to create the concrete syntax for metamodeling systems in a flexible, efficient way. Several domain-specific languages have been created that support defining the concrete syntax, i.e. the visualization. The main concern of this paper is to present a model transformation method that processes our presentation definitions and transforms them automatically into source code. The source code implements a plug-in capable of editing the models. A termination analysis for the presented method is also provided.
Abstract: The vision of the OMG´s Model-Driven Architecture (MDA) has necessitated the extensive research of model compilers, which are able to process graph-based visual models specified mainly in the Unified Modeling Language (UML). A possible mechanism for the realization of MDA model compilers can be graph rewriting-based transformation approach. Previous work has introduced the tool Visual Modeling and Transformation System, which uses graph rewriting as transformation mechanism, but the pattern language of the rewriting rules consists of UML class diagram elements instead of object diagram level patterns. This paper provides the algorithmic background for the application of these rules specified by the class diagram elements. To achieve that, it examines the allowed instantiation configuration based on the UML standard, and supplies a constructive algorithm to compute the allowed number of the objects participating in a valid instantiation of a class model. Furthermore, starting from the VF2 algorithm, the pattern matching algorithm for the left hand side of the metamodel-based rewriting rule is provided via several optimization steps examined.
Abstract: Highly configurable metamodeling environments and graph transformation techniques have been applied successfully in software system modeling and other areas. In this paper a uniform treatment of these two methods is illustrated by a tool called Visual Modeling and Transformation System. The concepts of an n-layer metamodeling environment is outlined with the related topological and attribute issues. Built on metamodeling techniques two alternatives for model transformation are elaborated, namely, the traversal and the graph-rewriting approaches. In our implementation all of the aforementioned mechanisms use metamodel as a common formalism, which can be considered as a uniform basis for storing, creating and transforming visual languages. The feasibility of the approach is illustrated by a transformation which generates C/C++ code from UML statecharts.
Abstract: This paper presents the visual control flow support of
Visual Modeling and Transformation System (VMTS), which
facilitates composing complex model transformations out of simple
transformation steps and executing them. The VMTS Visual Control
Flow Language (VCFL) uses stereotyped activity diagrams to specify
control flow structures and OCL constraints to choose between
different control flow branches. This work discusses the termination
properties of VCFL and provides an algorithm to support the
termination analysis of VCFL transformations.
Abstract: Model-Driven Architecture (MDA) standardized by OMG facilitates to separate the platform independent part and the platform specific part of a system model. Due to this separation Platform-Independent Model (PIM) can be reused across several implementation platforms of the system. Platform-Specific Model (PSM) is ideally generated automatically from PIM via model transformation steps. Because of the appearance of high level languages, object-oriented technologies and CASE tools, metamodeling becomes more and more important. Metamodeling is one of the most central techniques both in design of visual languages, and reuse existing domains by extending the metamodel level. The creation of model compliers on a metamodeling basis is illustrated by a software package called Visual Modeling and Transformation System (VMTS), which is an n-layer multipurpose modeling and metamodel-based transformation system. VMTS is able to realize an MDA model compiler. This paper (i) addresses the relationship between the constraints enlisted in metamodel-based rewriting rules and the pre- and postconditions, (ii) it introduces the concepts of general validation, general preservation and general guarantee, which facilitate that if a transformation step is specified adequately with the help of constraints, and the step has been executed successfully for the input model, then the generated output model is in accordance with the expected result, which is described by the transformation step refined with the constraints. An illustrative case study based on constraint specification in rewriting rules is also provided.
Abstract: Model transformation systems are an important contribution to the field of automated software engineering. This paper summarizes the theoretical background implemented in Visual Modeling and Transformation System (VMTS) to validate the topology of the transformation steps. The mathematical formalism is based on the double pushout approach, which is extended to rewriting steps consisting of metamodel elements. Firstly the instantiation relationship is transformed to a homomorphic mapping, then the theorems from DPO approach is applied in conjunction with the validation-related propositions. The theoretical results are accompanied with practical considerations throughout the paper, and the propositions are turned into algorithms to facilitate their applications.
Abstract: Model transformation methods are vital in several applications such as OMGÃÂs Model-Driven Architecture and Visual Model Processors. This paper contributes a metamodel-based rewriting rule representation similar to the UML class diagram and the supporting algorithms to determine valid instances of the patterns. The proposed algorithms are illustrated by specific examples throughout the paper. The results turn out to be useful not only for UML class diagram-based rewriting rule formulation patterns, but it provides a method for checking valid instantiation of UML class diagrams in modeling environments.
Abstract: With the proliferation of the OMGâs Model-Driven Architecture metamodel- based storage systems and software model transformation has become a crucial issue considering novel technologies. This paper illustrates the techniques and consideration related to the implementation of the Visual Modeling and Transformation System focusing the implementation of the core functionality called AGSI. Graph rewriting and theoretical achievements are outlined, then architectural decisions, and detailed design trade-offs are presented. The algorithmic solutions have a special emphasis; the metamodel-related techniques are elaborated and illustrated with pseudo code.
Abstract: As complex software and systems development projects need models as an important planning, structuring and development technique, models now face issues resolved for software earlier: models need to be versioned, differences captured, syntactic and semantic correctness checked as early as possible, documented, presented in easily accessible forms, etc. Quality management needs to be established for models as well as their relationship to other models, to code and to requirement documents precisely clarified and tracked. Business and product requirements, product technologies as well as development tools evolve. This also means we need evolutionary technologies both for models within a language and if the language evolves also for an upgrade of the models.
This chapter discusses the state of the art in model management and evolution and sketches what is still necessary for models to become as usable and used as software.
Abstract: Model-Based Design of complex software systems is an activity that requires the use of different modeling formalisms, with different perspectives of the system, to cover all relevant aspects of the system, to avoid over-design, to employ manageable models and to support system integration The comprehensive use of models in design has created a set of challenges beyond those of supporting one isolated design task In particular, the need to combine, couple, and integrate models at different levels of abstraction and in different formalisms is posing a set of specific problems that must be tackled Multi-Paradigm Modeling is precisely the research field to focus on developing an appropriate set of concepts and tools to address the challenge of integrating models of different aspects of a software system specified using different formalisms and eventually at different levels of abstraction This paper summarizes the results of the 3rd Workshop on Multi-Paradigm Modeling: Concepts and Tools
Abstract: The comprehensive use of models in design has created a set of challenges beyond that of supporting one isolated design task. In particular, the need to combine, couple, and integrate models at different levels of abstraction and in different formalisms is posing a set of specific problems that the field of Computer Automated Multi-Paradigm Modeling (CAMPaM) is aiming to address. This paper summarizes the results of the 2nd Workshop on Multi-Paradigm Modeling: Concepts and Tools.
Abstract: This paper reports on the findings of the first Workshop on Multi-Paradigm Modeling: Concepts and Tools. It contains an overview of the presented papers and of the results of three working groups which addressed multiple views, abstraction, and evolution. Besides this, a definition of the problem space, the main concepts, and an appropriate terminology for multi-paradigm modeling as presented and discussed during the workshop are provided.
Abstract: Metamodeling is foundational to many modeling frameworks, and so it is important to formalize and reason about it. Ideally, correctness proofs and test-case generation on the metamodeling framework should be automatic. However, it has yet to be shown that extensive automated reasoning on metamodeling frameworks can be achieved. In this paper we present one approach to this problem: Metamodeling frameworks are speciï¬ed modularly using algebraic data types and constraint logic programming (CLP). Proofs and test-case generation are encoded as CLP satisï¬ability problems and automatically solved
Abstract: In the industrial applications of Model-Based Development, the evolution of modeling languages is an inevitable issue. The migration to the new language involves the reuse of the existing artifacts created for the original language, such as models and model transformations. This paper is devoted to an evolution method for model transformations as well as the related algorithms. The change description is assumed to be available in a modeling language specific to the evolution. Based on the change description, our method is able to automate certain parts of the evolution. When automation is not possible, our algorithms automatically alert the user about the missing semantic information, which can then be provided manually after the automatic part of the interpreter evolution. The algorithms have been implemented and tested in an industrial environment. The results indicate that the semi-automated evolution of model transformations decreases the time and effort required with a manual approach.
Abstract: Although traceability is often a suggested requirement for
general software development, there are areas such as airborne
systems, where traceability is a compulsory part of
the development process. This paper describes a tool chain
that is able to generate and to follow traceability links across
model-to-model and model-to-code transformations, and capable
of providing navigability support along these traceability
links. We elaborate on the conceptual design of our
tool chain and provide details on its realization in a DSML
environment underpinned by graph rewriting-based model
transformation.
Abstract: Verification of models and model processing programs are inevitable in real world model-based software development. Model transformation developers are often interested in offline verification methods, when only the definition of the model transformation and the specification of the source and target languages are used to analyze the properties and no concrete input models are taken into account. Therefore, the results of the analysis hold for each output model not just particular ones, and we have to perform the analysis only once. Most often, formal verification of model transformations is performed manually or the methods can be applied only for a certain transformation or for the analysis of only a certain property. Previous work has presented formal and algorithmic background for a possible verification framework. Based on this background, this paper introduces a realization of an automated verification framework for graph rewriting-based model transformations. We illustrate the operation of the framework and demonstrate its applicability on a case study. Our goal is to further improve our approach in order to be able to be applied in more complex industrial solutions as well.
Abstract: Verification of models and model processing programs are inevitable in real-world model-based software development. Model transformation developers are interested in offline verification methods, when only the definition of the model transformation and the metamodels of the source and target languages are used to analyze the properties and no concrete input models are taken into account. Therefore, the results of the analysis hold for each output model not just particular ones, and we have to perform the analysis only once. Most often, formal verification of model transformations is performed manually or the methods can be applied only for a certain transformation or for the analysis of only a certain property. Previous work has presented a formalism to describe the characteristics of model transformations in separate formal expressions called assertions. This description is based on the first-order logic, therefore, if deduction rules are provided, a reasoning system can use an assertion set to automatically derive additional assertions describing additional properties of model transformations. In this paper, we propose deduction rules and present the verification of a model transformation of processing business process models.
Abstract: This paper presents the design, architecture, and implementation experiences related to building a multipurpose modeling and model transformation frameworks. We examine the usual expectations related to model-driven development tools, then we present the architecture and design decisions of a new modeling framework capable of fulfilling all these expectations. The suggested architecture and the provided implementation offer an approach that (i) has an efficient data structure, (ii) can be easily customized and (iii) optimized for different purposes of modeling.
Abstract: Metamodel evolution is becoming an inevitable part of software
projects that use domain-speci c modeling. Domainspeci
c modeling languages (DSMLs) evolve more frequently
than traditional programming languages, resulting in a large
number of invalid instance models that are no longer compliant
with the metamodel. The key to addressing this problem
is to provide a solution that focuses on the speci cation
of typical metamodel changes and automatically deduces
the corresponding instance model migration. Additionally,
a solution must be usable by domain experts not familiar
with low level programming issues. This paper presents the
Model Change Language (MCL), a language and supporting
framework aimed at ful lling these requirements.
Abstract: Verification of models and model processing programs are fundamental issues
and are inevitable in model-based software development in order to apply them in realworld
solutions. Verification concerns the analysis of non-functional and functional
properties as well. Model transformation developers are interested in offline methods for
the verification process. Offline analysis means that only the definition of the model
transformation and the metmodels of the source and target languages are used to analyze
the properties and no concrete input models are taken into account. Therefore, the results
of the analysis hold for each output model not just particular ones, and we have to perform
the analysis only once. Most often, formal verification of model transformations is
performed manually, but automated or semi-automated approaches have gained focus
recently. We have previously presented a method to formally describe the main
characteristics of model transformations. Our concept consists of two steps: (i) The
automatic generation of a formal description from a concrete transformation, which is
manually extended by formal assertions by transformation experts. (ii) A reasoning system
is used to automatically derive the proof of certain properties from the previous formal
description. In this paper, we show how deduction rules of the reasoning system can be
defined.
Abstract: This Model-Driven Development (MDD) facilitates the synthesis of application programs from models created using customized, domain-specific model processors. Model compilers can be realized by graph rewriting-based model transformation. In Visual Modeling and Transformation System (VMTS), metamodel-based rewriting rules facilitate to assign OCL constraints to model transformation rules. This approach supports validated model transformation. Unfortunately, the validation introduces a new concern that often crosscuts the functional concern of the transformation rules. To separate these concerns, an aspect-oriented solution is applied for constraint management. This paper introduces the identification method of the crosscutting constraints in metamodel-based model transformation rules. The presented algorithms facilitate the better understanding of the transformation, their easier constraint-based configuration, and make both the constraints and the rewriting rules reusable.
Abstract: In the recent years, software modeling became an essential part of designing large software systems. However, efficient model processing techniques are required, unless we use models only for documentation purposes. One way to improve efficiency is to apply model transformations in parallel. This paper introduces a truly parallel model transformation framework focusing on a new pattern matching approach. By using this new approach, the framework is now scalable and much more efficient than any parallel model transformation approach before.
Abstract: Metamodel evolution is a significant problem in domain specific software development for several reasons. Domain-specific modeling languages (DSMLs) are likely to evolve much more frequently than programming languages and commonly used software formalisms, often resulting in a large number of valuable instance models that are no longer compliant with the metamodel. In this paper, we present the Model Change Language (MCL), aimed at satisfying these requirements.
Abstract: Web-based software systems access some resources while executing the requests of the clients, typically several requests arrive at the same time, thus, competitive situation is established for the resources. In case of modeling such situation queueing model-based approaches are widely recognized. In our work, novel models and algorithms have been proposed to model the queue limit performance factor. In addition, the computational time and complexity of the proposed algorithms have been provided. Moreover, it has been shown that the proposed models and algorithms can be applied to performance prediction of webbased software systems in ASP.NET environment. The goal of our work is to validate the proposed models and algorithms and to verify the correctness of performance prediction with performance measurements in ASP.NET environment. The results have shown that the proposed models and algorithms predict the performance metrics much more accurate than the original model and algorithm.
Abstract: The proliferation of Mobile P2P systems made a next generation mobile BitTorrent client an appropriate target to compare two different development approaches: the traditional manual coding and domain-specific modeling languages (DSMLs) accompanied by generators. We present two DSMLs for mobile communication modeling, and one for user interface development. We compare the approaches by development time and maintenance, using our modeling and transformation tool Visual Modeling and Transformation System (VMTS).
Abstract: The performance of information systems is an important consideration. With the help of proper performance models and evaluation algorithms, performance metrics can be predicted accurately. The goal of our work is to improve the Mean-Value Analysis (MVA) evaluation algorithm based on the investigation of thread pools. In our work, the performance metrics of multi-tier information systems are predicted with the help of a queueing model and the improved MVA. The proposed evaluation algorithm has been implemented, the inputs have been estimated based on one measurement, and the model has been evaluated to predict performance metrics. In addition, ASP.NET web applications have been tested with concurrent clients in order to validate the proposed algorithm in different versions of ASP.NET environments.
Abstract: Verification of models and model processing programs are inevitable in model-based software development in order to apply them in real-world solutions. Verification of properties of model transformations means to prove that the application of a model transformation generates the expected output models from the input models. Model transformation developers are interested in offline methods for the verification process. Offline analysis means that only the definition of the model transformation and the metmodels of the source and target languages are used to analyze the properties and no concrete input models are taken into account. Therefore, the results of the analysis hold for each output model not just particular ones, and we have to perform the analysis only once. Most often, formal verification of model transformations is performed manually or the methods can be applied only for a certain transformation or for the analysis of only a certain property. In this paper, we propose a formalization to describe model transformation. A formal description can be automatically generated, and can be extended by the experts. An automated reasoning system may prove some properties of model transformations by deriving new assertions from the original description.
Abstract: Model-based development methodologies are gaining ground as software applications are getting more and more complex while the pressure to decrease time-to-market continually increase. Domain-specific modeling tools that support system analysis, simulation, and automatic code generation can increase productivity. However, most domain-specific model translators are still manually written. This paper presents a technique that automatically generates a domain-specific application programming interface from the same metamodels that are used to define the domain-specific modeling language itself. This facilitates the creation of domain-specific model translators by providing a high-level abstraction hiding all the cumbersome modeling tool-specific implementation details from the developer. The approach is illustrated using the Generic Modeling Environment and the Microsoft .NET C# language.
Abstract: In software engineering, modeling tools have become widely accepted to increase application reliability and decrease development time. The UML and the OCL became industry standards and are supported by many Computer-Aided Software Engineering tools. The increasing number of modeled functionalities results in complex models that need more and more textual constraints to express the hidden restrictions applying to the systems. The usual scenario of model development is to create an initial model of the system, and then fine-tune it with simple modifications. During development, rebuilding all the constraints is unnecessary when only a few changes have been applied. In this paper, we present an algorithm that handles changes incrementally on expression level, thus required rebuilds are kept to a minimum. The background and implementation framework for the discussed compiler is the Visual Modeling and Transformation System, but the algorithm is general enough to support any tree-based compiler integrated into an IDE.
Abstract: Domain-specific modeling is a powerful technique to describe complex systems in a precise but still understandable way. Rapid creation of graphical Domain-Specific Languages (DSLs) has been focused for many years. Research efforts have proven that metamodeling is a promising way of defining the abstract syntax of the language. It is also clear that DSLs can be developed to describe the concrete syntax and the dynamic behavior. Previous research has contributed a set of graphical DSLs to model the behavior ("animation") of arbitrary graphical DSLs. This paper contributes practical techniques to simplify our message handling method, automate the integration process, and show where domain-specific model patterns can help to accelerate the simulation modeling process.
Abstract: Developing software for mobile devices requires special attention, and it is still a larger effort compared to the development for desktop computers and servers. With the introduction and the popularity of wireless devices, the diversity of the platforms has also been increased. There are different platforms and tools from different vendors such as Microsoft, Sun, Nokia, SonyEricsson and many more. Therefore, generative techniques underpinned by model-driven development can be applied extensively in this field. This paper introduces the Mobile Toolkit for the tool Visual Modeling and Transformation System (VMTS). This toolkit provides a bridge between the different mobile platforms with respect to the user interface and network communication development.
Abstract: The performance of information systems is a very important and complicated consideration. With the help of a proper performance model and evaluation algorithm, performance metrics can be predicted. The goal of our work is to improve the mean-value analysis evaluation algorithm based on the investigation of thread pools. With the help of a queueing model and the improved algorithm the performance metrics of multi-tier information systems can be predicted much more accurate. In our work, effect analysis of the improved algorithm is performed, as well.
Abstract: process graph-based visual models. If the execution of transformations
is not supported by the continuous presentation of the
modifications performed on the model, the traceability and the
debugging of transformations becomes difficult. Recent modeling
tools usually support the definition of rewriting rules based transformations
in a visual or textual way, and only a few of them support
visual debugging facilities. These debuggers are hand-coded
at a price of a huge amount of work. This paper presents a model
transformation debugger built on the top of the animation framework
and the transformation engine of the Visual Modeling and
Transformation System. The integration of the transformation
engine and the animation of the user interface are described with
visual modeling techniques.
Abstract: The performance of web-based software systems is one of the most important and complicated consideration. These systems access some resources while executing the requests of the clients, typically several requests arrive at the same time, thus, competitive situation is established for the resources. In case of modeling such situation queueing model-based approaches are widely recognized. The goal of our work is to model the queue limit performance factor. The proposed algorithms modeling the global and application queue limits can be applied to performance prediction. The response time and throughput performance metrics can be correctly predicted with the novel algorithms.
Abstract: Domain-Specific Modeling has gained increasing popularity in software modeling. Domain-Specific Modeling Languages can simplify the design and the implementation of systems in various domains. Consequent domain specific visualization helps to understand the models for domain specialists. However, the efficiency of domain-specific modeling is often determined by the limited capabilities -- i.e. the lack of interactive design elements, low customization facilities -- of the editor applications.
This paper introduces the Presentation Framework of Visual Modeling and Transformation System, the framework provides a flexible environment for model visualization and provides a declarative solution for appearance description as well.
Abstract: Web-based software systems access some resources while executing the requests of the clients, typically several requests arrive at the same time, thus, competitive situation is established for the resources. In case of modeling such situation queueing model-based approaches are widely recognized. In our work, novel models and algorithms have been proposed to model the queue limit performance factor. In addition, the computational complexity and the limit analysis of the proposed models and algorithms have been provided. Moreover, the practical application of the results has been shown.
Abstract: The performance of information systems is one of the most important and complicated consideration. Performance metrics can be predicted with the help of a proper performance model and an appropriate evaluation algorithm. In our work, the Mean-Value Analysis evaluation algorithm is enhanced based on the investigation of thread pools. With the enhanced performance evaluation algorithm the performance metrics of multi-tier information systems can be predicted much more accurate. In addition, the enhanced algorithm is experimentally validated. The goal of our work is the convergence and limit analysis of the original and the enhanced algorithms.
Abstract: Metamodeling is a popular method to apply software modeling. A metamodel acts as set of rule for its instantiation, the model. The instantiation mechanism, originally restricted to two-layers, is more and more often generalized to n-layer. One of the most important issue in supporting n-layer instantiation in metamodeling is to create and handle n-layer attributes. The paper presents the N-layer Attribute Algebra, the formal description of our n-layer attribute structure and the transformation used in instantiation.
Abstract: Model-Driven Architecture (MDA) is one of the most popular model-based approaches to facilitate the synthesis of application programs from domain specific models using model transformation. One of the most popular model transformation techniques is graph transformation based on graph rewriting. Graph transformations have a strong mathematical background, but it requires exponential time in the size of the host model and the rewriting pattern, which is not always acceptable. Our research focuses on creating a distributed graph transformation solution to accelerate the execution of these transformations. This paper presents the basic ideas of our approach including the introduction of the theoretical basis of the solution and an architectural overview of a concrete implementation.
Abstract: The performance of a web application is affected by several factors. In this paper, the effects of two configurable software settings of J2EE application servers are discussed: the maximum size of the thread pool and the maximum size of the connection queue. Previous work has shown that both tuning parameters have a considerable impact on the performance metrics, and both of them should be taken into account when constructing a performance model of a web application. This paper presents a queueing network-based performance model that is able to capture the effect of the connection queue limit. New performance measurements which can help improving this model are also presented.
Abstract: Web-based information systems play an important role in computer science. The most common consideration is performance. With the help of a proper performance model and evaluation algorithm, the performance metrics can be determined at the early stages of the development process. In our work, the response time and the throughput of multi-tier Web applications have been predicted based on a queueing model. The goal of our work is to extend the mean-value analysis (MVA) algorithm according to the investigation of the thread pool. The MVA and the proposed extended MVA evaluation algorithms have been implemented with the help of MATLAB. The input parameters have been estimated based on one measurement, and the model has been evaluated to predict performance metrics. Moreover, a Web application has been tested with concurrent user sessions in order to validate the proposed algorithm in ASP.NET environment.
Abstract: Domain-specific model processors facilitate the efficient synthesis
of application programs from software models. Often, model
compilers are realized by graph rewriting-based model transformation.
In Visual Modeling and Transformation System (VMTS),
metamodel-based rewriting rules facilitate to assign Object Constraint
Language (OCL) constraints to model transformation rules.
This approach supports validated model transformation. Unfortunately,
the validation introduces a new concern that often crosscuts
the functional concern of the transformation rules. To separate
these concerns, an aspect-oriented solution is applied for constraint
management. This paper introduces the identification method of
the crosscutting constraints in metamodel-based model transformation
rules. The presented algorithms make both the constraints and
the rewriting rules reusable, furthermore, supports the better understanding
of model transformations.
Abstract: With the help of a proper performance model and evaluation algorithm, the performance metrics of information systems can be determined at the early stages of the development process. In our work, the response time and the throughput performance metrics of multi-tier Web applications have been predicted based on a queueing model. The goal of our work is to extend the mean-value analysis (MVA) algorithm according to the investigation of the thread pool. Web applications have been tested with concurrent user sessions in order to validate the proposed algorithm in different versions of ASP.NET environment. Moreover, error analysis has been performed to demonstrate the accuracy of the proposed algorithm.
Abstract: way of increasing productivity in software engineering. Model-based development is driven by model transformations that attempt to bridge the large semantic gaps between high-level models and low-level languages. There is a demand for researching the ways in which model transformation can become more flexible, efficient, highly-configurable as well as validated. This paper addresses issues of visually defined metamodel-based model transformations that support validated model transformations. We introduce our model transformation framework, visual modeling and transformation system (VMTS), and a list of applications realized with VMTS on metamodel-based model transformation basis. Furthermore, a comprehensive comparison is given related to other model transformation approaches.
Abstract: The transformation from UML activity diagrams to CSP models is a helpful
model transformation, which can be used to analyze and verify some aspects of a UML
activity diagrams. A working solution has been developed with our tool, the Visual
Modeling and Transformation System, and in this work we formally prove that the
transformation terminates for every valid input activity diagram model, and therefore it can
be used in practice.
Abstract: Distributed systems and web applications play an important role in computer science nowadays. The most common consideration is performance, because these systems must provide cost-effective and high-availability services in the long term, thus they have to be scaled to meet the expected load. Performance measurements can be the base for performance modeling and prediction. With the help of performance models, the performance metrics (like response time, throughput and utilization) can be determined at the early stages of the development process. The goal of our work is to predict the response time, the throughput and the utilization of the tiers of ASP.NET web applications based on a queueing model with MVA evaluation algorithm. We estimated the model parameters (number of customers, number of tiers, user think time, visit numbers, and service times) based on a measurement. We implemented the evaluation algorithm with the help of MATLAB. We tested a web application with concurrent user sessions to validate the model in ASP.NET environment.
Abstract: Distributed systems and web applications play an important role in computer science nowadays. The most common consideration is performance, because these systems must provide services with low response time, high availability, and certain throughput level. With the help of performance models, the performance metrics can be determined at the early stages of the development process. The goal of our work is to predict the response time, the throughput and the tier utilization of web applications, based on queueing models handling one and multiple session classes, with MVA and approximate MVA (Mean-Value Analysis) evaluation algorithm, in addition to balanced job bounds calculation. We estimated the model parameters based on one measurement. We implemented the MVA and the approximate MVA evaluation algorithm for closed queueing networks along with the calculation of the balanced job bounds with the help of MATLAB. We have tested a web application with concurrent user sessions in order to validate the models in ASP.NET environment.
Abstract: Model-Driven Architecture (MDA) as a model-based approach to
software development facilitates the synthesis of application
programs from models created using customized, domain-specific
model processors. MDA model compilers can be realized by
graph rewriting-based model transformation. In Visual Modeling
and Transformation System (VMTS), metamodel-based rewriting
rules facilitate to assign OCL constraints to model transformation
steps. This approach supports validated model transformation.
The goal is to validate not only the individual transformation
steps, but the whole transformations as well. Unfortunately, the
validation introduces a new concern that often crosscuts the
functional concern of the transformation steps. To separate these
concerns and make them reusable, an aspect-oriented solution is
presented for constraint management. This paper introduces a new
type of aspect, the constraint aspect to separate the crosscutting
constraints from model transformation steps. Moreover,
algorithms are given to create and weave constraint aspects to
model transformation steps prior to the execution of the
transformation. The presented method results in a more efficient
and optimized weaving, furthermore, we can require that not only
a single transformation step, but a whole transformation validates,
preserves or guarantees certain properties about the output of the
transformation.
Abstract: Graph rewriting-based visual model processing is a widely used technique for model transformation. Visual model transformations often need to follow an algorithm that requires a strict control over the execution sequence of the transformation steps. Thus, in Visual Model Processors (VMPs) the execution order of the rewriting rules is crucial. This paper presents the visual control flow support of Visual Modeling and Transformation System (VMTS), which facilitates composing complex model transformations of simple transformation steps and executing them. The VMTS Visual Control Flow Language (VCFL) uses stereotyped activity diagrams to specify control flow structures and OCL constraints to choose between different control flow branches. This paper introduces VCFL, discusses its termination properties and provides an algorithm to support the termination analysis of VCFL transformations. Furthermore, an illustrative case study is also provided.
Abstract: Constraint specification and validation lie at the heart of modeling and model transformation. The Object Constraint Language (OCL) is a wide-spread formalism to express constraints in modeling environments. There are several interpreters and compilers that handle OCL constraints in modeling, but these tools do not support constraint optimization, therefore, the model validation can be slow. This paper presents algorithms to optimize OCL compilers to reduce the number of database queries during the validation process by eliminating the unnecessary traversing steps and caching the database queries. Proofs are also given to show that the optimized and the unoptimized code are functionally equivalent. The optimized compiler has been integrated into the Visual Modeling and Transformation System tool and applied to constraints appearing in both metamodels and graph rewriting-based model transformation rules.
Abstract: Model-Driven Architecture (MDA) as a model-based approach to
software development facilitates the synthesis of application
programs from models created using customized, domain-specific
model processors. MDA model compilers can be realized by graph
rewriting-based model transformation. In Visual Modeling and
Transformation System (VMTS), metamodel-based transformation steps
facilitate to assign OCL constraints to model transformation
steps. Based on this facility the paper proposes a novel validated
model transformation approach that can ensure to validate not only
the individual transformation steps, but the whole transformations
as well. The discussed approach provides a visual control flow
language to define transformations visually in a simple way that
results more efficient development process. The presented methods
are illustrated using a case study from the field of model-based
development.
Abstract: The Unified Modeling Language (UML) has become a standard in modeling, but it cannot express all the necessary modeling information between the model items. Object Constraint Language (OCL) is used to extend the capabilities of UML diagrams, and define constraints for the model items. The combination of UML and OCL can be used to realize vision of OMGâs Model Driven Architecture (MDA). OCL is based on, but not limited to UML modeling diagrams, therefore, it can be used also in generic metamodeling environments to validate the models. This paper presents the concepts of an OCL 2.0 compliant compiler for metamodeling environments. An illustrative case study is also provided.
Abstract: The growing complexity of the software systems made the model-based application development one of the most focused research fields. Generic modeling languages, like UML are not always flexible enough to express domain specific features. Domain Specific Modeling Languages (DSMLs) are defined to model the special features, and rules of these domains. One way to visualize DSMLS is metamodeling. Metamodeling techniques are capable of expressing the domain-specific constraints, but metamodels do not define the visualization of the elements. Editing frameworks are needed that support customization with minimal programming effort. The Visual Modeling and Transformation System (VMTS) is an n-layer metamodeling environment that offers graphical metamodel editing features using the VMTS Presentation Framework (VPF). The goal of this paper is to present the common visualization issues of the metamodeling environments and to compare the solutions given by the most popular frameworks and VPF. Besides the comparison, the paper also introduces the main features of VPF and gives a vision how the existing facilities can be improved.
Abstract: The subtree matching is the problem of finding all the matching occurrences of a pattern tree in a subject tree as a subtree. This paper introduces many problems that are related to subtree matching and provides a classification of them. The basic problem has got several variations depending on the type of trees and on what we call a match. Trees can be rooted or unrooted, ordered and unordered and labeled or unlabeled. A subtree matching may mean subtree isomorphism, subtree homeomorphism, subtree inclusion or pattern matching. This paper introduces the most important algorithms for these problems while paying special attention to their complexities
Abstract: With the introduction and popularity of wireless devices, the diversity of the platforms has also been increased. There are different platforms and tools from different vendors such as Microsoft, Sun, Nokia, SonyEricsson and many more. Because of the relatively low-level programming interface, software development for Symbian platform is a tiresome and error prone task, whereas .NET CF contains higher level structures. This paper introduces the problem of the software development for incompatible mobile platforms, moreover, it provides a model-driven architecture (MDA) and Domain Specific Modeling Language (DSML)-based solution. We also discuss the relevance of the model-based approach that facilitates a more efficient software development, because the reuse and the generative techniques are key characteristics of model-based computing. In the presented approach, the platform-independence lies in the graph rewriting-driven visual model transformation. This paper illustrates the creation of model compilers on a metamodeling basis by a software package called Visual Modeling and Transformation System (VMTS), which is an n-layer multipurpose modeling and metamodel-based transformation system. A case study is also presented how model compilers can be used to generate user interface handler code for different mobile platforms from the same platform-independent input models
Abstract: With the introduction and popularity of wireless
devices, the diversity of the platforms has also been
increased. There are different platforms and tools from
different vendors such as Microsoft, Sun, Nokia,
SonyEricsson and many more. This paper introduces the
problem of the software development for incompatible
mobile platforms, and provides a Model-Driven
Architecture (MDA)-based solution. In the presented
approach the platform-independence lies in the graph
rewriting-driven visual model transformation. This work
illustrates the creation of model compliers on a
metamodeling basis by a software package called Visual
Modeling and Transformation System (VMTS), which is
an n-layer multipurpose modeling and metamodel-based
transformation system. A case study is also presented how
model compilers can be used to generate user interface
handler code for different mobile platforms from the same
platform-independent input models.
Abstract: Model validation is one of the most focused research field in modeling. Besides the topological constraints, the textual Object Constraint Language (OCL) is a popular formalism to express model constraints. OCL is based on but not limited to UML models, it can be used also in generic metamodeling environments to validate the models. Several model validation solution exist based on OCL constraints, but these solutions do not support flexible, customizable error messages. This paper presents an OCL 2.0 compliant compiler for metamodeling environments. The compiler is extended by error-handling supporting mechanisms.
Abstract: Software development based on Domain-Specific Modeling Languages is one of the most focused research fields. Metamodeling techniques can describe the topological rules of the target domains and express the domain-specific constraints of visual languages, but the presentation still cannot follow this flexibility. The aim of our research was to create a flexible visualization method for metamodeling environments. The main concern of this paper is to present the concepts of a domain-specific modeling language for specifying the presentation of arbitrary DSLs and standard UML models. The introduced language can fully describe the visualization and behavior of the linked model. The concrete syntax definitions can be bound to the models of the target domain using model transformation.
Abstract: Distributed systems and Web applications play an important role in computer science nowadays. The most common consideration is performance, because these systems must provide services with low response time, high availability, and certain throughput level. The performance of a Web application is affected by several factors. The goal of our work is to analyze how some of them affect the response time. In this paper, the effects of two configurable settings of the ASP.NET application server are discussed: the limit of the global queue and the limit of the application queue. The response time of a test Web application are measured, while changing these settings. The results are analyzed in a qualitative manner which is followed by using statistical methods: independence tests to investigate which factors influence principally the performance. Our experiments have shown that the global queue limit and the application queue limit are performance factors. Finally, optimal settings according to the performance-related requirements are determined as a function of client workload and the settings of the thread pool attributes
Abstract: Constraint handling is one of the most focused research field in both model validation and model transformation. Constraints are often simple topological conditions such as multiplicity checks, but the main strength of the constraint validation lies in the textual constraints defined in high-level languages. Object Constraint Language (OCL) is a wide-spread formalism to express model constraints. We have found that OCL is also useful in graph transformation-based model transformation rules. There exist several interpreters and compilers that handle OCL constraints in modeling, but these tools do not support constraint optimization, therefore, the model validation is not always efficient. This paper presents algorithms to optimize OCL compilers, and accelerate the validation process. The presented algorithms were implemented in the OCL Compiler of Visual Modeling and Transformation System, and they were tested in both metamodels and transformation rules.
Abstract: Model-based approaches in software development are widely
recognized as a potential way of increasing productivity in
software engineering. Model-based development is driven by
model transformations. There is a demand for researching the
ways how model transformation can become more flexible,
efficient, and highly-configurable as well as validated. Extensive
research of graph transformation provides a strong formal
background for graph rewriting-based model transformation. In
the tool Visual Modeling and Transformation System (VMTS),
metamodel-based transformation rules enable assigning OCL
constraints to model transformation rules that facilitate constraintdriven
online validated model transformations. Using aspectoriented
methods, this paper introduces the separation of the
refining and validation constraints that crosscut the transformation
rules, and discusses the constraint realization possibilities with
negative and positive application conditions (NAC, PAC). As a
result of the constraint-driven validation, we can not only ensure
the validation of the whole transformation, but the transformation
becomes more modular and applicable in larger projects as well.
Abstract: Although metamodeling techniques are capable of expressing the domain-specific constraints of visual languages, namely, the abstract syntax, the concrete syntax definition (the presentation) cannot follow this flexibility. The main concern of this paper is to present an overview of a generic and flexible solution: We introduce a domain-specific language for specifying the presentation of arbitrary DSLs and the standard UML models. Graphical visualization and editing solutions are also presented. Finally, we discuss a method that can be used to transform concrete syntax definitions automatically into source code, using model transformation. The source code can be used to edit the models of the selected domain.
Abstract: Object Constraint Language (OCL) is used to extend the capabilities of Unified Modeling Language (UML) diagrams by defining constraints for the model items. Since OCL is based on, but not limited to UML diagrams, it can be used in generic metamodeling environments to validate the models as well. Also, OCL can be used in model transformation systems to specify additional constraints for the transformation steps. Supporting constraints in metamodeling and model transformation systems require the extension of the generic OCL compiler architecture. This paper discusses the most important solutions suitable for extending a generic OCL compiler to support both metamodeling and model transformation in an n-layer metamodeling system. Using the presented solutions the two field of interest can be handled uniformly.
Abstract: Model-Driven Architecture (MDA) is a widely known software design approach,
which is intended to support model-driven engineering of software systems with
specifications expressed as models. Using the MDA methodology, system functionality may
first be defined as a platform-independent model (PIM) through an appropriate modeling
language. Then the PIM may be translated into one or more platform-specific models
(PSMs) for the actual implementation. These translations between the PIM and PSMs are
normally performed using automated tools, such as model transformation systems, for
example, tools compliant to the new OMG standard, named QVT
(Queries/Views/Transformations). To facilitate flexible and powerful model
transformations, OMG has specified the Imperative OCL language in QVT; this language
allows using the most common programming constructs. This paper descibes the necessary
steps of developing a compiler from lexical analysis to code generation through syntactic
and semantic analysis. Our implementation of the Imperative OCL compiler is attached to
the Visual Modeling and Transformation System (VMTS), which is an n-layered modeling
environment.
Abstract: Software modeling means producing diagrams. A software diagram, such as a UML class diagram, in general, not refined enough to provide all the relevant aspects of a specification. We need a mechanism to describe additional constraints about the objects in the model. The Object Constraint Language (OCL) is a formal language, OCL expressions are unambiguous and make the model more precise and more detailed. The navigations contained by the constraints increase the complexity of the constraint evaluation. This paper introduces the concept of AND/OR Clauses and provides algorithms ÃÂ constraint relocation and constraint decomposition ÃÂ to eliminate navigation steps from the OCL constraints appearing in UML class diagram-based models.
Abstract: Distributed systems and web applications play an important role in computer science nowadays. The most common consideration is performance, because these systems have to provide cost-effective and high-availability services in the long term, thus, they have to be scaled to meet the expected load. Performance measurements can be the base for performance modeling and prediction. With the help of performance models, the performance metrics (like response time) can be determined at early stages of the development process. The paper presents the results of performance measurements of an ASP.NET web application. The goal of our work is to predict the response time of ASP.NET web applications based on a queueing model handling multiple session classes with MVA evaluation algorithm. We have tested a web application with concurrent user sessions to estimate the model parameters. We implemented the evaluation algorithm with the help of MATLAB. We demonstrated and validated the model in ASP.NET environment.
Abstract: Programming for the Symbian OS assumes that developers invest particular and uncommon work, therefore the development lifecycle is rather longer and the costs are usually higher than these of common C++ software development. Dealing with user interface, database or communication, programming is not so straightforward as expected. However, am appropriate developer tool can help the developers to be more efficient and solve the designing and programming difficulties. In this paper we will introduce a rapid application development tool set on the Symbian OS. We model the user interface and the statechart of the mobile applications with a novel tool (Visual Modeling and Transformation System). After this design phase, source code can be generated. We describe a class library that helps the programmers or code generators to produce Symbian source code that is easy to read and maintain.
Abstract: The growing complexity of the software systems made the model-based application development one of the most focused research fields. General purpose modeling languages, like UML are not always flexible enough to express domain specific features. Domain Specific Modeling Languages (DSMLs) are defined to model the special features, and the rules of these domains. One way to define DSMLS is metamodeling. Metamodeling techniques facilitate creating domain-specific modeling environment in an efficient and simple way. Although metamodeling techniques are capable of expressing the domain-specific constraint of visual languages, the presentation still cannot follow this flexibility. Editing frameworks are required that support customization with minimal programming effort. The Visual Modeling and Transformation System (VMTS) is a metamodeling environment that offers graphical metamodel editing features using the VMTS Presentation Framework (VPF). The goal of this paper is to present the metamodeling environment based on VPF with all of their metamodel specific features and compare the capabilities of VPF with other metamodeling environments.
Abstract: Graph transformation has been widely used for expressing model transformations. Especially transformations of visual models can be naturally formulated by graph transformations, since graphs are well suited to describe the underlying structures of models. Based on a common sample model transformation, four different model transformation approaches are presented which all perform graph transformations. At first, a basic solution is presented and crucial points of model transformations are indicated. Subsequent solutions focus mainly on the indicated problems. Finally, a first comparison of the chosen approaches to model transformation is presented where the main ingredients of each approach are summarized.
Abstract: Following the evolution of high-level languages the concept of modelling has become natural. There exists many cases (e.g. domain specific models), where the classic (e. g. UML based) modelling are not flexible enough. Metamodeling is the way to the more dynamic model definition and model handling. The metamodel based frameworks usually have a visual interface for editing the models. There exists some area of interest (e.g. the code generating), where the visual editor can not be used directly. Models and model elements should be able to be analyzed, and walked through using the properties and the connections of the model elements. The framework should offer a high-level user interface (or language) for the users, with full support to get or set the attributes, and the topological information described in the model. This paper introduces the fundamental steps for creating a traversing processor that succeeds these conditions.
Abstract: Although the flexibility provided by metamodeling systems is proven to be enough in practical applications, the presentation is not supported to the same extent. The goal of this paper is to present a presentation framework which exploits the advantages of the underlying metamodeling system and provides enough flexibility to present the concrete syntax of feature models, UML 2.0 diagrams, and resource diagram for mobile telephones. The static structure as well as the behavioral aspect are described to illustrate the solutions and the design decisions related to the framework.
Abstract: Following the evolution of high-level languages the concept of modeling has become very natural. There exist several modeling tools that give very different solutions to the flexibility or attribute modeling. The Visual Modeling and Transformation System (VMTS) unifies the metamodeling techniques used by the common modeling tools, and the model transformation used by graph rewriting [1]. Adaptive Modeler is the graphical environment part of VMTS used for displaying the models. This paper explains the basic structure of the Adaptive Modeler focusing on the common problems related to the design of graphical frameworks. The presented solutions can be used not only in modeling, but in design of any universal graphical framework.
Abstract: Following the evolution of the high-level languages the conception of metamodeling became natural. The metamodel defines the constraints for the model, it can be used as a rule for the model level objects, the attributes of the objects, and the connection between them. The metamodel contains every rule, that the modeling environment has to follow. We use metamodels as the model of the modeling tools. Our system, the Visual Modeling and Transformation System (VMTS) [1] unifies the metamodeling techniques used by the common modeling tools, and the model transformation used by graph rewriting. The fundamental underlying data structure is a mathematical object: a labeled directed graph. The modeling objects are modeled as nodes, and the connection between them are modeled as edges. This method makes possible to use the well-known and the new graph traversing and transforming algorithms. The other benefit of the VMTS is that it extends the metamodel-model concepts of MOF [2] to an n-layer model-hierarchy. This paper is made to introduce the steps of metamodeling using a case study. For the case study we have chosen the MetaClass Diagram - Class Diagram - Object diagram models of UML. The reason of this choice is the three layer depth of this model-row, so the n-layer capabilities can be illustrated as well.
Abstract: Model- Driven Architecture (MDA) standardized by OMG facilitates to separate the platform independent part and the platform specific part of a system model. Due to this separation PIM can be reused across several implementation platforms of the software. PSM is ideally generated automatically from PIM via model transformation steps performed by model compilers. Because of the appearance of high level languages object-oriented technologies and wide spreading of CASE tools. metamodeling has become more and more important. Metamodeling is one of the most central techniques in the design of visual languages, and it reuses existing domains by extending the metamodel level. In this paper the creation of model compliers on a metamodeling basis is illustrated by a software package called Visual Modeling and Transformation System (VMTS) [1] [2], which is an n-layer multipurpose modeling and metamodel-based transformation system. This paper has two main subjects: (i) checking constraints contained by metamodels during the metamodel instantiation, and (ii) checking rewriting rules containing constraints during the graph transformation process. Besides these the paper addresses the relation between constraints and pre- and postconditions. These constraints are specified on the meta-layer and impose restrictions on the models residing on the instance layer of the rules. An illustrative case study for constraint validation in rewriting rules is also provided.
Abstract: Model-Driven Architecture standardized by OMG facilitates separating the platform-independent part (PIM) and the platform-specific part (PSM) of a system model. The platform-independent artifacts are mainly UML models created with CASE tools. Due to this separation, PIM specified by the developers can be reused across several implementation platforms of the software. PSM is ideally generated automatically from PIM via model transformation steps performed by model compilers. Beyond the topology of the visual models additional constraints must be specified, which ensure the correctness of the attributes among others. Dealing with OCL constraints provides a solution for the unsolved issues, because topological and attribute transformation methods cannot perform and express the problems that can be addressed by constraint validation. This paper discusses the need for combining UML and OCL, it introduces the compilers in general, it shows the architecture of our OCL Compiler for .NET, and it presents the lexical and syntactic analysis as well as the semantic analysis and code generation techniques in detail. The OCL Compiler has been implemented as a module of our n-layer multipurpose modeling and metamodel-based transformation system called Visual Modeling and Transformation System (VMTS). The OCL Compiler module facilitates validating (i) constraints contained by the metamodels at the time of the model instantiation process, and (ii) constraints contained by the transformation steps during the metamodel-based graph transformation. An illustrative case study is also provided, which introduces how VMTS generates source code from a statechart diagram, and how it validates specific properties using the OCL Compiler.
Abstract: Supporting the vision of Model-Driven Architecture (MDA), model compilers are an important area of software engineering research. Model transformation systems built on graph rewriting transformation steps can be used as a natural approach to implement model compilers. The rewriting rules can be described in terms of the metamodel elements. Validating these metamodel-based rules is addressed in this paper. A metamodel-based rule can be validated against the metamodels. The uniqueness of the application of the transformation rule is guaranteed in case of well-defined conditions. Two conditions are given in the form of categorical equations for validation, derived from the double pushout approach. A brief introduction to the categorical graph rewriting is also provided.
Abstract: This paper presents the aspect-oriented constraint management of the Visual Control Flow Language (VCFL) applied in the Visual Modeling and Transformation System (VMTS). To define the transformation steps precisely, additional constraints must be specified beyond the structure of the visual models (such as UML models). Structural and attribute transformation methods cannot perform and express the issues, which can be addressed by constraint validation. The use of OCL as a constraint and query language in modeling is a suitable choice. In our experience, constraints are proven to be useful in model transformations as well: VCFL uses OCL constraints to define constraints on the nodes of the transformation steps and to choose between different control flow branches. Often, the same constraint is repetitiously applied in many different places in a transformation and crosscuts it. It would be beneficial to describe a common constraint in a modular manner and designate the places where it will be applied. Using an illustrative case study, this paper introduces the problem of crosscutting constraints in visual model transformation steps, and provides an aspect-oriented solution for it, applying aspect-oriented constraints and constraint weaving methods. Finally, the similarities between AOP and the AO constraint concepts are also discussed.
Abstract: Model transformation has become one of the most focused research field, motivated by for instance the OMGâs Model-Driven Architecture (MDA). Graph rewriting has a strong formal background and several results related to the parallel and sequential execution of the rules. This paper takes steps toward the connection of the two fields taking the Double Pushout (DPO) approach as the mathematical background, and the metamodel-based graph rewriting techniques as the underlying transformation mechanism. Since the DPO approach builds on graph homomorphisms, the instantiation relationship should be turned into a graph homomorphism. To achieve that, an algorithm and the related theoretical results are elaborated, and the complexity of the algorithm is provided as well.
Abstract: This paper presents the visual control flow support of Visual Modeling and Transformation System (VMTS), which facilitates composing complex model transformations out of simple transformation steps and executing them. The VMTS Control Flow Language (VCFL) uses stereotyped activity diagrams to specify control flow structures and OCL constraints to choose between different control flow branches. In general, a control structure language needs are the sequence, the conditional branch, hierarchism, parallel executions and the iteration. VCFL has all these control structures in a deterministic version.
Abstract: Visual Model Processors consume visual models with graph representation using graph transformation techniques as opposed to Traversing Model Processors which traverse the graph representation in order to produce the output. This paper addresses open issues related to the attribute transformations of metamodel-based model transformation systems which use graph rewriting as the underlying technique. Among others these transformations facilitate the efficient reuse of MDA PIM model artifacts across several platform specific implementations. To illustrate the achievements a case study is presented which has been built on easy-to- formalize labeled directed graph structures. The implementation concepts are also delineated using the Visual Modeling and Transformation System (VMTS) [1] software package.
Abstract: Distributed systems and network applications play an important role in computer science nowadays. The most common consideration is performance, because these systems have to provide cost-effective and high availability services in the long term, thus they have to be scaled to meet the expected load. The performance of a web application is affected by several factors. The goal of our work is to analyze how some of them affect the response time. The paper presents the result of performance measurements of an ASP.NET web application. We measured the average response time of a test web application while changing the parameters of the application server. The results are analyzed using statistical methods: (i) independence tests to investigate which factors influence principally the performance, (ii) in addition certain plots and hypothesis tests to determine the distribution of the response time.
Abstract: Graph rewriting is a widely used approach to model transformation. In general, graph rewriting rules parse graphs only by topological concerns, but they are not sophisticated enough to match a graph with a node which has a special property. In case of diagrammatic languages, such as the Unified Modeling Language (UML), the exclusive topological parsing is found to be not enough. To define the transformation steps in a more refined way additional constraints must be specified, which ensures the correctness of the attributes among others. Dealing with OCL constraints provides a solution for the unsolved issues. Often, the same constraint is repetitiously applied in many different places in a transformation. It would be beneficial to describe a common constraint in a modular manner, and to designate the places where it is to be applied. This paper presents the problem of the crosscutting constraints in graph transformation steps, provides an aspect-oriented solution for it, and introduces the weaving algorithms used to propagate aspect-oriented constraints to graph transformation steps.
Abstract: Metamodeling techniques facilitate the efficient reuse of the elements of design tools and environments. This paper provides a flexible approach to store and instantiate the attributes in multilayer metamodeling environments. An XML-based representation and the related algorithms are presented as a technique for maintaining the attribute relationships between the model and the metamodel levels. The commonly applied two-layer instantiation mechanisms are generalized to n-layer environments. Nowadays the significance of the Unified Modeling Language is unquestionable. UML is widely adopted both in software and hardware system design. The concepts of the attribute instantiation are illustrated by creating metamodels for UML diagrams. The background and the implementation framework for the discussed constructs are the Visual Modeling and Transformation System (VMTS).
Abstract: Aspect-Oriented Software Development (AOSD) is an emerging area with the goal of promoting advanced separation of concerns throughout the software development lifecycle. AOSD started on programming language level, but it must be applicable on a higher abstraction level as well. This paper provides an overview of aspect-oriented software development, discusses the key AOSD concepts, and presents the aspect-oriented programming and aspect-oriented modeling. Furthermore, introduces an aspect-oriented constraint management approach applied in a metamodel-based model transformation system.
Abstract: Following the evolution of the high-level languages the conception of metamodeling became natural. The metamodel defines the constraints for the model, it can be used as a rule for the model level objects, the attributes of the objects, and the connection between them. The metamodel contains every rule, that the modeling environment has to follow. We use metamodels as the model of the modeling tools. Our system, the Visual Modeling and Transformation System (VMTS) [1] unifies the metamodeling techniques used by the common modeling tools, and the model transformation used by graph rewriting. The fundamental underlying data structure is a mathematical object: a labeled directed graph. The modeling objects are modeled as nodes, and the connection between them are modeled as edges. This method makes possible to use the well-known and the new graph traversing and transforming algorithms. The other benefit of the VMTS is that it extends the metamodel-model concepts of MOF [2] to an n-layer model-hierarchy. This paper is made to introduce the steps of metamodeling using a case study. For the case study we have chosen the MetaClass Diagram - Class Diagram - Object diagram models of UML. The reason of this choice is the three layer depth of this model-row, so the n-layer capabilities can be illustrated as well.
Abstract: Generative Programming is a young paradigm merging domain engineering and object-oriented techniques. The goals of GP are increasing reusability and adaptability, improving control of complexity, managing a large number of variants and increasing efficiency. Generative techniques are rather widespread, in most simple cases they can be found as wizards e.g. MS Visual Studio Wizards that generates MFC classes. Generative techniques always use generators to create code that correspond to the specifications. Design patterns are a popular and successful means of implementing flexible and reusable software systems, but if we want to reuse all parts of a complex system, the elementary components on the top of the inheritance hierarchy will become too complex and even a little change in the code easily causes many errors in properly working code. To avoid this problem, we use generative techniques where a code segment occurs repetitively to reduce the complexity of the central code. In this paper we want to illustrate the trade-off between using desing patterns and generative techniques.
Abstract: Software model transformation systems motivated by OMGâs Model-Driven Architecture (MDA) standard is an extremely important area which has a huge impact on the modern software development including the current industrial tendencies as well. This paper addresses the instantiation issues of Unified Modeling Language (UML) class diagram-like metamodels with association multiplicity constraints containing unknown variables. After establishing a formal mathematical model for parametric multiplicities the conditions of instantiation is given. Furthermore the maximal instantiation is elaborated, which is a crucial issue in metamodel-based model transformation systems.
Abstract: Generative software composition is an extraordinary efficient ways to design software for reuse and also addresses the problem of tool-supported system integration. Domain modeling lies at the heart of the generative approach which directly underpins the opportunity of reuse. This paper describes a multipurpose modeling and transformation system which facilitates creating, storing feature models and other UML diagrams, including built-in transformation framework based on graph rewriting with tree-based notation. Relation to the OMG Meta-Object Facility and an illustrative case study is also provided.
Abstract: Examining round-trip engineering in the software engineering process, we can realize that they have common parts, which we have to do in all cycles, such as model-code and code-model conversions. This paper presents a method and related algorithms, which generate those parts of model-code relation that can be automated, and makes possible to concentrate solely on the semantic information during the implementation. The method contains an automatic schema generation, which makes possible for the method to be practically adaptable for any models. In the proposed way an Universal Representation is generated which facilitates the separation of the original representation and the transformation steps in an automated yet checked way. A case study based on a complete implementation is provided as well.
Abstract: The implementation of computer based systems (CBSs) is commonly guided by constraints imposed by the particular domain of the CBS. Domain-specific programming is a convenient way to provide a domain expert with a language that is customized to the particular constraints and assumptions of the domain.. The careful thought and design that precede the development of any domain-specific visual language restrict the programmer from illegal formalisms, and allow for the rapid determination of the validity of the "program". Usually, the domain-specific visual language is designed and produced using a metamodel of some sort. Occasionally, similar domains can benefit from models created according to the ontology of this original metamodel, but usually some amount of model-transformation is required to give validity of the transformed models. This paper presents a visual language for transforming domain-models that can express the mapping between the meta-models of the "input" (i.e. the "old" domain) and the "output" (i.e. the "new" domain), and uses graph-rewriting techniques to transform the "old" domain-models into the appropriate "new" form.
Abstract: Metamodel-based transformations permit descriptions of mappings between models created using different concepts from possibly overlapping domains. This paper describes the basic algorithms used in matching metamodel constructs, and how this match is to be applied. The transformation process facilitates the reuse of models specified in one domain-specific modeling language in another context: another domain-specific modeling language. UML class diagrams are used as the language of the metamodels. The focus of the paper is on the matching and firing of transformation rules, and on finding efficient and generic algorithms. An illustrative case study is provided.
