Master Data Management requires creation of Central repository, applying constraints on Repository and designing processes to manage data. Designing of Repository, constraints on repository and business processes is very tedious and time consuming task for large Enterprise. Hence Visual Repository, constraints and Process (Workflow) modeling is the most critical step in Master Data Management. In this paper, we realize a Visual Modeling tool for implementing Repositories, Constraints and Processes based on Eclipse Plugin using GMF/EMF which follows principles of Model Driven Engineering (MDE).

Complex systems are hard to define. Nevertheless they are more and more frequently encountered. Examples include a worldwide airline traffic management system, a global telecommunication or energy infrastructure or even the whole legacy portfolio accumulated for more than thirty years in a large insurance company. There are currently few engineering methods and tools to deal with them in practice. The purpose of this Dagstuhl Perspectives Workshop on Model Engineering for Complex Systems was to study the applicability of Model Driven Engineering (MDE) to the development and management of complex systems. MDE is a software engineering field based on few simple and sound principles. Its power stems from the assumption of considering everything - engineering artefacts, manipulations of artefacts, etc - as a model. Our intuition was that MDE may provide the right level of abstraction to move the study of complex systems from an informal goal to more concrete grounds. In order to provide first evidence in support of this intuition, the workshop studied different visions and different approaches to the development and management of different kinds of complex systems. This note presents the summary of the discussions.

Lengyel introduced a sequence of numbers Zn, defined combinatorially, that satisfy a recurrence where the coefficients are Stirling numbers of the second kind. He proved some 2-adic properties of these numbers. In this paper, we give another recurrence for the sequence Zn, where the coefficients are Stirling numbers of the first kind. Using this formula, we give another proof of Lengyel’s lower bound on the 2-adic valuation of the Zn. We also resolve some conjectures of Lengyel about the sequence Zn. We also define (a) A new sequence Yn analogous to Zn, exchanging the role of Stirling numbers of the first and second kind. We study its 2-adic properties. (b) Another sequence similar to Lengyel’s sequence, and we study its p-adic properties for p ≥ 3.

Let q∈ℤ such that |q|≥2. In this note, we show that if f is an entire function such that f(q n +iq m )∈ℤ[i] for n,m∈ℕ, and if f is of sufficiently slow growth, then f is a polynomial.

This paper provides a summary of the First International Workshop on Model Driven Interoperability (MDI 2010), held on October 5, 2010, in conjunction with the MODELS 2010 conference in Oslo, Norway.

Roles for composite objects in object-oriented analysis and design. mu(A* plug): slot(plug) {} // new methods rely on inline // message forwarding mu_1 template <class Type> class Mu: public Type, public mu { public: Mu(Type& prototype) : Type(prototype), mu(this) {} }; In contrast to the approach relying solely on parameterized classes, instantiation of the template Mu is possible only with subclasses of A. This restriction is a consequence of the use of conngurability in the class mu, which has a slot of type A. 5 Conclusions We have presented a new object-oriented programming and design technique called conngurable objects that allows the dynamic construction of composite objects. The technique is based on the usage of the composition mechanism combined with the employment of polymorphism as a tool for arranging data. The characteristics of conngurable objects make them similar to software boards, and as such they ooer to their clients new levels of exibility and extensibility. Conngurability allows also a diierent kind of reuse, that can not be achieved through inheritance nor composition. Conng-urable objects capture a relationship among classes and represent it in a form which can be reused when the related classes are improved. While the traditional techniques emphasize the development of components that may be useful in the future, conngurability encourages the reuse of improved components which may be developed in the future. Some consequences and potentials of the new technique were discussed through the exposition of several related concepts, such as compatibility and conngurability. Examples were presented to illustrate some possible applications of con-gurable objects, where traditional techniques are clearly unsatisfactory. These examples expose some of the merits and weaknesses of con-gurability. Finally, implementations strategies in C++ were presented and their applicability to these examples was demonstrated. We observe that C++, as well as many other major OOP languages, leaves something to be desired in terms of support of conngurable objects. We had to combine several features of C++ as a substitute of a single lingual construct for the deenition of slots and their operations. Moreover, while implementing conng-urable objects, we encountered several methods whose only action is resending a message to a component. This explicit forwarding could be avoided if the programming language had a facility for a conngurable to selectively export part of the interface of its components. Ideally, such a facility should also allow renaming of exported methods. The advantages of conngurable objects when …

Software tools and corresponding knowledge tend to be collected and packaged into platforms like Eclipse, MathLab or KDE. Their success and usefulness combined with their growing size and complexity rise issues about management of dependencies between their components and between the platform and other applications which rely on its plug-in system and/or provided functionalities. Such problems imply need for dependencies management tools in which visualization is a core feature. As dependencies are also a concern in domains like Object-Oriented Programming or Operating System packaging, we may expect to reuse corresponding works in visualization. But each domain and its related dependencies problem have induced their own hard coded viewing and browsing tools. In this article we present how we have reuse existing visualization tools for our platform cartography together with our own displays using a Model-Driven Interoperability approach to easily realize bindings between visualization tools.

This paper reports on a panel discussion held during the Educators' Symposium at MODELS'2009. It shortly explains the context provided for the discussion and outlines the statements made by the panelists. The panelists were asked to make their statements along a number of topics relevant to teaching modeling like: Notation, Semantics, Programming, Tooling, Suitability, Metamodeling.

Successful application of model-driven engineering approaches requires interchanging a lot of relevant data among the tool ecosystem employed by an engineering team (e.g., requirements elicitation tools, several kinds of modeling tools, reverse engineering tools, development platforms and so on). Unfortunately, this is not a trivial task. Poor tool interoperability makes data interchange a challenge even among tools with a similar scope. This paper presents a model-based solution to overcome such interoperability issues. With our approach, the internal schema/s (i.e., metamodel/s) of each tool are explicited and used as basis for solving syntactic and semantic differences between the tools. Once the corresponding metamodels are aligned, model-to-model transformations are (semi)automatically derived and executed to perform the actual data interchange. We illustrate our approach by bridging the Eclipse and Microsoft (DSL Tools and SQL Server Modeling) modeling tools.

Research groups develop plenty of tools aimed at solving real industrial problems. Unfortunately, most of these tools remain as simple proof-of-concept tools that companies consider too risky to use due to their lack of proper user interface, documentation, completeness, support, etc that companies expect from commercial-quality level tools. Based on our tool development experience in the AtlanMod research team, specially regarding the evolution of our ATL model transformation tool, we argue in this paper that the best solution for research teams aiming to create high-quality and widely-used tools is to industrialize their research prototypes through a partnership with a technology provider.

For nearly ten years, modern forms of software modeling have been used in various contexts, with good apparent success. This is a convenient time to reflect on what has been achieved, where we stand now, and where we are leading to with Model-Driven Engineering (MDE). If there is apparently some consensual agreement on the core mechanisms, it is much more difficult to delimitate the scope and applicability of MDE. The three main questions we have to answer in sequence are: 1. What is a model? 2. Where are models coming from? 3. What may models be useful for? There is now some consensus in the community about the answer to the first question. A (terminal) model is a graph conforming to another graph usually called its metamodel, and this terminal model represents a system. Terminal models and their metamodels are similarly organized and may be unified as abstract models, yielding a regular organization. In such an organization, some of the models (e.g., a transformation) may be executable. The relation of conformance between a terminal model and its metamodel provides most of the information on the first question.

Model Driven Engineering (MDE) advocates the use of models, metamodels and model transformations to revisit some of the classical operations in software engineering. MDE has been mostly used with success in forward and reverse engineering (for software development and better maintenance, respectively). Supporting system interoperability is a third important area of applicability for MDE. The particular case of tool interoperability is currently receiving a lot of interest. In this paper, we describe some experiments in this area that have been performed in the context of open source modeling efforts. Taking stock of these achievements, we propose a general framework where various tools are associated to implicit or explicit metamodels. One of the interesting properties of such an organization is that it allows designers starting some software engineering activity with an informal light-weight tool and carrying it out later on in a more complete or formal context. We analyze such situations and discuss the advantages of using MDE to build a general tool interoperability framework.

Model-Driven Engineering (MDE) advocates the use of models at every step of the software development process. Within this context, a team of engineers collectively and collaboratively contribute to a large set of interrelated models. Even if the main focus can be on a single model (e.g. a class diagram model), related elements in other models (e.g. a requirement model) often have to be considered and/or accessed. Moreover, all the involved models do not necessarily conform to the same metamodel and thus may have been built using different independent Domain-Specific Languages (DSLs). Such a situation has already been frequently observed in many large-scale industrial deployments of MDE. Manually coordinating all the involved models, i.e. being able to both manage and use the links existing between them, can become a cumbersome and difficult task. As a proposal to solve this inter-DSL coordination issue, we introduce in this paper a generic and extensible inter-model traceability and navigation environment based on the complementary use of megamodeling and model weaving. We illustrate our solution with a concrete working example.

Complex software systems are often constructed by assembling bundles from repositories. Eclipse is one of these systems; build on top of a platform accepting different sets of bundles according to the user needs. This adaptability is one of the main benefits of this kind of systems but implies also several configuration problems. The consistency of Eclipse plug‐in's bundles is one of them. This problem involves a need for the configuration validation. To adress this problem, this paper proposes an approach using model driven engineering. The presented solution combines different MDE techniques such as global model management and model transformations to check the coherency of Eclipse plug‐in's bundles.

Technological and business changes influence the evolution of software systems. When this happens, the software artifacts may need to be adapted to the changes. This need is rapidly increasing in systems built using the Model-Driven Engineering (MDE) paradigm. An MDE system basically consists of metamodels, terminal models, and transformations. The evolution of a metamodel may render its related terminal models and transformations invalid. This paper proposes a three-step solution that automatically adapts terminal models to their evolving metamodels. The first step computes the equivalences and (simple and complex) changes between a given metamodel, and a former version of the same metamodel. The second step translates the equivalences and differences into an adaptation transformation. This transformation can then be executed in a third step to adapt to the new version any terminal model conforming to the former version. We validate our ideas by implementing a prototype based on the AtlanMod Model Management Architecture (AMMA) platform. We present the accuracy and performance that the prototype delivers on two concrete examples: a Petri Net metamodel from the research literature, and the Netbeans Java metamodel.