0000000000073863
AUTHOR
Audris Kalnins
How to Comprehend Large and Complicated Systems
The basic problem at early analysis stage of the development life cycle is how to quickly comprehend a large and complicated system. One of the ways to comprehend such a system is to build an object model, as it was suggested by the pioneers of object modelling approach such as J.Rumbaugh1 and J.Martin2. In up-to-date terminology it means building a UML class diagram. The authors have got convinced in their everyday practice on extreme efficiency of this type of modelling, though at the same time a significant experience for this job is also required. To make this job easier, a modelling methodology must be developed. The goal of this paper is, on the one hand, to give some methodological r…
Metamodel specialization based DSL for DL lifecycle data management
A new Domain Specific Language (DSL) based approach to Deep Learning (DL) lifecycle data management (LDM) is presented: a very simple but universal DL LDM tool, still usable in practice (called Core tool); and an advanced extension mechanism, that converts the Core tool into a DSL tool building framework for DL LDM tasks. The method used is based on the metamodel specialisation approach for DSL modeling tools introduced by authors.
Graphical Template Language for Transformation Synthesis
Higher-Order Transformations (HOT) have become an important support for the development of model transformations in various transformation languages. Most frequently HOTs are used to synthesize transformations from different kinds of models, for example, mapping models. This means that model driven development (MDD) is being successfully applied to transformations themselves too. The standard HOT solution is to create the transformation as a model using the abstract syntax. However, for graphical transformation languages a significantly more efficient solution would be to create the transformation using its graphical (concrete) syntax. An analogy could be the textual template languages such…
Automatic construction of test sets: Practical approach
The problem of symbolic execution and test generation is considered both for sequential and concurrent programs. Practical methods for test construction for the given program path are presented.
Domain-Driven Reuse of Software Design Models
This chapter presents an approach to software development where model driven development and software reuse facilities are combined in a natural way. The basis for all of this is a semiformal requirements language RSL. The requirements in RSL consist of use cases refined by scenarios in a simple controlled natural language and the domain vocabulary containing the domain concepts. The chapter shows how model transformations building a platform independent model (PIM) can be applied directly to the requirements specified in RSL by domain experts. Further development of the software case (PSM, code) is also supported by transformations, which in addition ensure a rich traceability within the s…
Saying Hello World with MOLA - A Solution to the TTC 2011 Instructive Case
This paper describes the solution of Hello World transformations in MOLA transformation language. Transformations implementing the task are relatively straightforward and easily inferable from the task specification. The required additional steps related to model import and export are also described.
Model transformation language MOLA
The paper describes a new graphical model transformation language MOLA. The basic idea of MOLA is to merge traditional structured programming as a control structure with pattern-based transformation rules. The key language element is a graphical loop concept. The main goal of MOLA is to describe model transformations in a natural and easy readable way.
Semantics of UML 2.0 Activity Diagram for Business Modeling by Means of Virtual Machine
The paper proposes a more formalized definition of UML 2.0 Activity Diagram semantics. A subset of activity diagram constructs relevant for business process modeling is considered. The semantics definition is based on the original token flow methodology, but a more constructive approach is used. The Activity Diagram Virtual machine is defined by means of a metamodel, with operations defined by a mix of pseudocode and OCL pre- and postconditions. A formal procedure is described which builds the virtual machine for any activity diagram. The relatively complicated original token movement rules in control nodes and edges are combined into paths from an action to action. A new approach is the us…
Modeling Business
Business concepts are studied using a metamodel-based approach, using UML 2.0. The Notation Independent Business concepts metamodel is introduced. The approach offers a mapping between different business modeling notations which could be used for bridging BM tools and boosting the MDA approach.
Business Modelling. Languages and Tools
The paper provides an overview of business modelling techniques — both at language and tool level. The basic elements of some most popular business modelling languages are briefly outlined, including the GRAPES-BM language developed by IMCS, University of Latvia. The paper presents also the basic principles, how metamodel based generic modelling techniques can be used for supporting several modelling notations simultaneously.
Towards Integrated Computer Aided Systems and Software Engineering Tool for Information Systems Design
The paper starts with a brief overview of the current situation in the world of CASE tools for information systems. Then there follows the outline of the basic ideas and principles of integrated CASE tool GRADE. The most outstanding characteristics of GRADE are that the tool is based on a unified specification language GRAPES and that it supports all information system development phases including analysis, requirements specification, design and implementation.
Metamodel specialization for graphical modeling language support
Most of current modeling languages are based on graphical diagrams. The concrete graphical syntax of these languages typically is defined informally -- by text and diagram examples. Only recently, starting from UML 2.5, a formalism is offered for defining the graphical syntax of UML. This formalism is based on Diagram Definition standard by OMG, where the main emphasis is on enabling diagram interchange between different tools implementing the given language. While this is crucial for standardized languages such as UML, this aspect is not so important for domain specific languages. In this paper an approach is offered for simple direct definition of concrete graphical syntax by means of met…
Editor Definition Language and Its Implementation
Universal graphical editor definition language based on logical metamodel extended by presentation classes is proposed. Implementation principles of this language, based on Graphical Diagramming Engine are described.
Behaviour modelling notation for information system design
Problems related to behaviour modelling within the platform independent model (PIM) during the model driven design are discussed in the paper. The emphasis is on design problems for information systems, especially on building a behaviour draft. At first issues in the traditional approach using sequence diagrams are discussed. Then a new approach based on activity diagrams is proposed. An extension of activity diagram notation specifically oriented towards comprehensive and readable behaviour design description is presented.
Towards DSL for DL Lifecycle Data Management
A new method based on Domain Specific Language (DSL) approach to Deep Learning (DL) lifecycle data management tool support is presented: a very simple DL lifecycle data management tool, which however is usable in practice (it will be called Core tool) and a very advanced extension mechanism which in fact converts the Core tool into domain specific tool (DSL tool) building framework for DL lifecycle data management tasks. The extension mechanism will be based on the metamodel specialization approach to DSL modeling tools introduced by authors. The main idea of metamodel specialization is that we, at first, define the Universal Metamodel (UMM) for a domain and then for each use case define a …
Metamodel Specialization for DSL Tool Building
Most of domain-specific tool building and especially diagram editor building nowadays involves some usage of metamodels. However normally the metamodel alone is not sufficient to define an editor. Frequently the metamodel just defines the abstract syntax of the domain, mappings or transformations are required to define the editor. Another approach [8] is based on a fixed type metamodel, there an editor definition consists of an instance of this metamodel to be executed by an engine. However there typically a number of functionality extensions in a transformation language is required. The paper offers a new approach based on metamodel specialization. First the metamodel specialization based …
DSL Based Platform for Business Process Management
Currently nearly all commercial and open source BPMS are based on BPMN as a process notation. In contrast, the paper proposes to build a BPMS based on a domain specific language (DSL) as a process notation – DSBPMS. In such a DSBPMS a specific business process support could be created by business analysts. A platform for creating such DSBPMS with feasible efforts is described. This platform contains a Configurator for easy creation of graphical editors for the chosen DSL and a simple mapping language for transforming processes in this DSL to a language directly executable by the execution engine of this platform. The engine includes also all typical execution support functions so no other t…
Developing Software with Domain-Driven Model Reuse
This chapter presents an approach to software development where model-driven development and software reuse facilities are combined in a natural way. It shows how model transformations building a Platform Independent Model (PIM) can be applied directly to the requirements specified in RSL by domain experts. Further development of the software case (PSM, code) is also supported by transformations, which in addition ensure a rich traceability within the software case. Alternatively, the PSM model and code can also be generated directly from requirements in RSL, thus providing fast development of the final code of at least a system prototype in many situations. The reuse support relies on a si…
Comprehensive System for Systematic Case-Driven Software Reuse
Reuse of software artifacts (blueprints and code) is normally associated with organising a systematic reuse framework most often constructed for a specific problem domain. In this paper we present a system (language, tool, reuse process) where software reuse is based on building and retrieving of so-called software cases (large compound artifacts) that can be reused between domains. The system is opportunistic in that software cases result from usual (non-reuse oriented) activities where also semantic information is added. This information is used to support regular development but may serve later to retrieve software cases. Having this common semantic basis, we can organise a systematic cr…
Use of UML and Model Transformations for Workflow Process Definitions
Currently many different modeling languages are used for workflow definitions in BPM systems. Authors of this paper analyze the two most popular graphical languages, with highest possibility of wide practical usage - UML Activity diagrams (AD) and Business Process Modeling Notation (BPMN). The necessary in practice workflow aspects are briefly discussed, and on this basis a natural AD profile is proposed, which covers all of them. A functionally equivalent BPMN subset is also selected. The semantics of both languages in the context of process execution (namely, mapping to BPEL) is also analyzed in the paper. By analyzing AD and BPMN metamodels, authors conclude that an exact transformation …
Model Transformation Languages and Their Implementation by Bootstrapping Method
In this paper a sequence of model transformation languages L0, L1, L2 is defined. The first language L0 is very simple, and for this language it is easy to build an efficient compiler to C++. The next language L1 is an extension of L0, and it contains powerful pattern definition facilities. The last language L2 is of sufficiently high level and can be used for implementation of traditional pattern-based high level model transformation languages, as well as for the development of model transformations directly. For languages L1 and L2 efficient compilers have been built using the bootstrapping method: L1 to L0 in L0, and L2 to L1 in L1. The results confirm the efficiency of model transformat…
DSL Tool Development with Transformations and Static Mappings
A tool development framework for domain-specific languages combining mapping and transformation based approaches is proposed in this research project. The combination of both approaches permits to use advantages and eliminate disadvantages as far as possible. First results are described including draft architecture for the framework implementing proposed ideas. A sketch of mapping definition facilities is presented. Initial implementation proposals are described as well. A template based graphical generation language Template MOLA for implementation algorithm description is introduced.
Automatic construction of test sets: Theoretical approach
We consider the problem of automatic construction of complete test set (CTS) from program text. The completeness criterion adopted is C1, i.e., it is necessary to execute all feasible branches of program at least once on the tests of CTS. A simple programming language is introduced with the property that the values used in conditional statements are not arithmetically deformed. For this language the CTS problem is proved to be algorithmically solvable and CTS construction algorithm is obtained. Some generalizations of this language containing counters, stacks or arrays are considered where the CTS problem remains solvable. In conclusion the applications of the obtained results to CTS constr…
Tree Based Domain-Specific Mapping Languages
Model transformation languages have been mainly used by researchers --- the software engineering industry has not yet widely accepted the model driven software development (MDSD). One of the main reasons is the complexity of metamodelling principles the developers are required to know to actually use model transformations in the way the OMG has stated. We offer the basic principles how to create domain-specific model transformation languages which can be used by developers relying only on familiar modelling concepts. We propose to use simple graphical mappings to specify the correspondence between source and target models which are represented using trees based on the concrete syntax of und…
From Requirements to Code in a Model Driven Way
Though there is a lot of support for model driven development the support for complete model driven path from requirements to code is limited. The approach proposed in this paper offers such a path which is fully supported by model transformations. The starting point is semiformal requirements containing behaviour description in a controlled natural language. A chain of models is proposed including analysis, platform independent and platform specific models. A particular architecture style is chosen by means of selecting a set of appropriate design patterns for these models. It is shown how to define informally and then implement in model transformation language MOLA the required transforma…
Tool support for MOLA
AbstractThe paper describes the MOLA Tool, which supports the model transformation language MOLA. MOLA Tool consists of two parts: MOLA definition environment and MOLA execution environment. MOLA definition environment is based on the GMF (Generic Modeling Framework) and contains graphical editors for metamodels and MOLA diagrams, as well as the MOLA compiler. The main component of MOLA execution environment is a MOLA virtual machine, which performs model transformations, using an SQL database as a repository. The execution environment may be used as a plug-in for Eclipse based modeling tools (e.g., IBM Rational RSA). The current status of the tool is truly academic.