To see the other types of publications on this topic, follow the link: MDD (Model-Driven Development).
Journal articles on the topic 'MDD (Model-Driven Development)'
Create a spot-on reference in APA, MLA, Chicago, Harvard, and other styles
Consult the top 50 journal articles for your research on the topic 'MDD (Model-Driven Development).'
Next to every source in the list of references, there is an 'Add to bibliography' button. Press on it, and we will generate automatically the bibliographic reference to the chosen work in the citation style you need: APA, MLA, Harvard, Chicago, Vancouver, etc.
You can also download the full text of the academic publication as pdf and read online its abstract whenever available in the metadata.
Browse journal articles on a wide variety of disciplines and organise your bibliography correctly.
1
Kardas, Geylani. "Model-driven development of multiagent systems: a survey and evaluation." Knowledge Engineering Review 28, no. 4 (April 19, 2013): 479–503. http://dx.doi.org/10.1017/s0269888913000088.
Full textAbstract:
AbstractTo work in a higher abstraction level is of critical importance for the development of multiagent systems (MAS) since it is almost impossible to observe code-level details of such systems due to their internal complexity, distributedness and openness. As one of the promising software development approaches, model-driven development (MDD) aims to change the focus of software development from code to models. This paradigm shift, introduced by the MDD, may also provide the desired abstraction level during the development of MASs. For this reason, MDD of autonomous agents and MASs has been recognized and become one of the research topics in agent-oriented software engineering (AOSE) area. Contributions are mainly based on the model-driven architecture (MDA), which is the most famous and in-use realization of MDD. Within this direction, AOSE researchers define MAS metamodels in various abstraction levels and apply model transformations between the instances of these metamodels in order to provide rapid and efficient implementation of the MASs in various platforms. Reorganization of the existing MAS development methodologies to support model-driven agent development is another emerging research track. In this paper, we give a state of the art survey on above mentioned model-driven MAS development research activities and evaluate the introduced approaches according to five quality criteria we define on model-driven MAS engineering: (1) definition of a platform independent MAS metamodel, (2) model-to-model transformability, (3) model-to-code transformability, (4) support for multiple MAS platforms and finally (5) tool support for software modeling and code generation. Our evaluation has shown that the researchers contributed to the area by providing MDD processes in which design of the MASs are realized at a very high abstraction level and the software for these MASs are developed as a result of the application of a series of model transformations. However, most of the approaches are incapable of supporting multiple MAS environments due to the restricted specifications of their metamodels and model transformations. Also efficiency and practicability of the proposed methodologies are under debate since the amount and quality of the executable MAS components, gained automatically, appear to be not sufficient.
2
Knodel, Jens, Michalis Anastasopolous, Thomas Forster, and Dirk Muthig. "An Efficient Migration to Model-driven Development (MDD)." Electronic Notes in Theoretical Computer Science 137, no. 3 (September 2005): 17–27. http://dx.doi.org/10.1016/j.entcs.2005.07.002.
Full text
3
Umran Alrubaee, Afrah, Deniz Cetinkaya, Gernot Liebchen, and Huseyin Dogan. "A Process Model for Component-Based Model-Driven Software Development." Information 11, no. 6 (June 5, 2020): 302. http://dx.doi.org/10.3390/info11060302.
Full textAbstract:
Developing high quality, reliable and on time software systems is challenging due to the increasing size and complexity of these systems. Traditional software development approaches are not suitable for dealing with such challenges, so several approaches have been introduced to increase the productivity and reusability during the software development process. Two of these approaches are Component-Based Software Engineering (CBSE) and Model-Driven Software Development (MDD) which focus on reusing pre-developed code and using models throughout the development process respectively. There are many research studies that show the benefits of using software components and model-driven approaches. However, in many cases the development process is either ad-hoc or not well-defined. This paper proposes a new software development process model that merges CBSE and MDD principles to facilitate software development. The model is successfully tested by applying it to the development of an e-learning system as an exemplar case study.
4
Vera, Pablo Martin. "Component Based Model Driven Development." International Journal of Information Technologies and Systems Approach 8, no. 2 (July 2015): 80–100. http://dx.doi.org/10.4018/ijitsa.2015070106.
Full textAbstract:
Current MDD methodologies are complex to use and require doing lots of models and configurations. Usually after all that effort only some part of the application source code can be automatically created. It would be desirable to have a more simple technique, but powerful enough for automatically creating a fully functional application. This works introduces a component based model driven development approach where a set of user interface components will be configured to define system behavior. Component configuration will be direct, simple and supported by a modeling tool which also includes automatic transformations for reducing the modeling task. The methodology requires the designer to build only two models: a class diagram, representing the data model of the application and a component diagram defining the user interface and the system navigation. Both components are based on UML extended with stereotypes and tagged values allowing configuring the system behavior.
5
Ormeño, Yeshica Isela, Jose Ignacio Panach, Nelly Condori-Fernández, and Óscar Pastor. "A Proposal to Elicit Usability Requirements within a Model-Driven Development Environment." International Journal of Information System Modeling and Design 5, no. 4 (October 2014): 1–21. http://dx.doi.org/10.4018/ijismd.2014100101.
Full textAbstract:
Nowadays there are sound Model-Driven Development (MDD) methods that deal with functional requirements, but in general, usability is not considered from the early stages of the development. Analysts that work with MDD implement usability features manually once the code has been generated. This manual implementation contradicts the MDD paradigm and it may involve much rework. This paper proposes a method to elicit usability requirements at early stages of the software development process such a way non-experts at usability can use it. The approach consists of organizing several interface design guidelines and usability guidelines in a tree structure. These guidelines are shown to the analyst through questions that she/he must ask to the end-user. Answers to these questions mark the path throughout the tree structure. At the end of the process, the paper gathers all the answers of the end-user to obtain the set of usability requirements. If it represents usability requirements according to the conceptual models that compose the framework of a MDD method, these requirements can be the input for next steps of the software development process. The approach is validated with a laboratory demonstration.
6
WEISE, THOMAS, MICHAEL ZAPF, MOHAMMAD ULLAH KHAN, and KURT GEIHS. "COMBINING GENETIC PROGRAMMING AND MODEL-DRIVEN DEVELOPMENT." International Journal of Computational Intelligence and Applications 08, no. 01 (March 2009): 37–52. http://dx.doi.org/10.1142/s1469026809002436.
Full textAbstract:
Genetic programming (GP) is known to provide good solutions for many problems like the evolution of network protocols and distributed algorithms. In most cases it is a hardwired module of a design framework assisting the engineer in optimizing specific aspects in system development. In this article, we show how the utility of GP can be increased remarkably by isolating it as a component and integrating it into the model-driven software development process. Our GP framework produces XMI-encoded UML models that can easily be loaded into widely available modeling tools, which in turn offer code generation as well as additional analysis and test capabilities. We use the evolution of a distributed election algorithm as an example to illustrate how GP can be combined with model-driven development (MDD).
7
Romano, Breno Lisi, and Adilson Marques da Cunha. "A Framework for Web Applications using an Agile and Collaborative Model Driven Development (AC-MDD)." Acta Scientiarum. Technology 41, no. 1 (May 29, 2019): 38349. http://dx.doi.org/10.4025/actascitechnol.v41i1.38349.
Full textAbstract:
This paper presents, as its main contribution, a Framework for Web Applications named Agile and Collaborative Model Driven Development (AC-MDD), seeking to reduce wastes on the modeling and documentation activities of web applications. The AC-MDD framework was elaborated based on related works that present Agile Model Driven Development processes (AMDD), but it deals with issues not yet considered by these researches. To adopt the AC-MDD framework, some visual elements from a novel Unified Modeling Language (UML) profile named Web-AML was designed, allowing to represent agile models of web applications. Besides that, in order to apply the proposed framework using these new models, a method was defined providing steps to transform agile models into web application source-codes. A case study was performed successfully in a real project that gives support to the population of a city located in the State of São Paulo (Brazil) to deal with the real flood problem they have been facing in recent years. This project was developed at the Federal Institute of Education, Science, and Technology of São Paulo to verify and validate the AC-MDD framework. Finally, a comparative analysis between the AC-MDD Framework and other AMDD processes was presented and highlighted the main aspects of the proposed framework.
8
Kos, Tomaž, Marjan Mernik, and Tomaž Kosar. "A Tool Support for Model-Driven Development: An Industrial Case Study from a Measurement Domain." Applied Sciences 9, no. 21 (October 26, 2019): 4553. http://dx.doi.org/10.3390/app9214553.
Full textAbstract:
End-user programming may utilize Domain-Specific Modeling Languages (DSMLs) to develop applications in the form of models, using only abstractions found in a specific problem domain. Indeed, the productivity benefits reported from Model-Driven Development (MDD) are hard to ignore, and a number of MDD solutions are flourishing. However, not all stories from industry on MDD are successful. End-users, without having software development skills, are more likely to introduce software errors than professional programmers. In this study, we propose and encourage other DSML developers to extend the development of DSML with tool support. We believe the programming tools (e.g., debugger, testing tool, refactoring tool) are also needed for end-users to ensure the proper functioning of the products they develop. It is imperative that domain experts are provided with tools that work on the abstraction level that is familiar to them. In this paper, an industrial experience is presented for building various tools for usage in MDD. Debugger, automated testing infrastructure, refactoring, and other tools were implemented for Sequencer, a DSML. Our experience with the implementation of tool support for MDD confirms that these tools are indispensable for end-user programming in practice, and that implementing those tools might not be as costly as expected.
9
KARDAS, GEYLANI, ARDA GOKNIL, OGUZ DIKENELLI, and N. YASEMIN TOPALOGLU. "MODEL DRIVEN DEVELOPMENT OF SEMANTIC WEB ENABLED MULTI-AGENT SYSTEMS." International Journal of Cooperative Information Systems 18, no. 02 (June 2009): 261–308. http://dx.doi.org/10.1142/s0218843009002014.
Full textAbstract:
Semantic Web evolution brought a new vision into agent research. The interpretation of this second generation web will be realized by autonomous computational entities, called agents, to handle the semantic content on behalf of their human users. Surely, Semantic Web environment has specific architectural entities and a different semantic which must be considered to model a Multi-agent System (MAS) within this environment. Hence, in this study, we introduce a MAS development process which supports the Semantic Web environment. Our approach is based on Model Driven Development (MDD) which aims to change the focus of software development from code to models. We first define an architecture for Semantic Web enabled MASs and then provide a MAS metamodel which consists of the first class meta-entities derived from this architecture. We also define a model transformation process for MDD of such MASs. We present a complete transformation process in which the source and the target metamodels, entity mappings between models and the implementation of the transformation for two different real MAS frameworks by using a well-known model transformation language are all included. In addition to the model-to-model transformation, the implementation of the model-to-code transformation is given as the last step of the system development process. The evaluation of the proposed development process by considering its use within the scope of a real commercial software project is also discussed.
10
SOLBERG, ARNOR, DEVON SIMMONDS, RAGHU REDDY, ROBERT FRANCE, SUDIPTO GHOSH, and JAN ØYVIND AAGEDAL. "DEVELOPING DISTRIBUTED SERVICES USING AN ASPECT ORIENTED MODEL DRIVEN FRAMEWORK." International Journal of Cooperative Information Systems 15, no. 04 (December 2006): 535–64. http://dx.doi.org/10.1142/s0218843006001487.
Full textAbstract:
To manage the development of cooperative information systems that support the dynamics and mobility of modern businesses, separation of concern mechanisms and abstractions are needed. Model driven development (MDD) approaches utilize abstraction and transformation to handle complexity. In MDD, specifying transformations between models at various levels of abstraction can be a complex task. Specifying transformations for pervasive system services that are tangled with other system services is particularly difficult because the elements to be transformed are distributed across a model. This paper presents an aspect oriented model driven framework (AOMDF) that facilitates separation of pervasive services and supports their transformation across different levels of abstraction. The framework facilitates composition of pervasive services with enterprise services at various levels of abstraction. The framework is illustrated using an example in which a platform independent model of a banking service is transformed to a platform specific model.
11
Jensen, Jostein, and Martin Gilje Jaatun. "Not Ready for Prime Time." International Journal of Secure Software Engineering 2, no. 4 (October 2011): 49–61. http://dx.doi.org/10.4018/jsse.2011100104.
Full textAbstract:
Model Driven Development (MDD) is by many considered a promising approach for software development. This article reports the results of a systematic survey to identify the state-of-the-art within the topic of security in model driven development, with a special focus on finding empirical studies. The authors provide an introduction to the major secure MDD initiatives, but the survey shows that there is a lack of empirical work on the topic. The authors conclude that better standardization initiatives and more empirical research in the field is necessary before it can be considered mature.
12
AGÜERO, JORGE, CARLOS CARRASCOSA, MIGUEL REBOLLO, and VICENTE JULIÁN. "TOWARDS THE DEVELOPMENT OF AGENT-BASED ORGANIZATIONS THROUGH MDD." International Journal on Artificial Intelligence Tools 22, no. 02 (April 2013): 1350002. http://dx.doi.org/10.1142/s0218213013500024.
Full textAbstract:
Virtual Organizations are a mechanism where agents can demonstrate their social skills since they can work in a cooperative and collaborative way. Nonetheless, the development of organizations using Multi-Agent Systems (MAS) requires extensive experience in different methodologies and platforms. Model-Driven Development (MDD) is a technique for generating application code that is developed from basic models and meta-models using a variety of automatic transformations. This paper presents an approach to develop and deploy organization-oriented Multi-Agent Systems using a model-driven approach. Based on this idea, we introduce a relatively generic agent-based meta-model for a Virtual Organization, which was created by a comprehensive analysis of the organization-oriented methodologies used in MAS. Following the MDD approach, the concepts and relationships obtained were mapped into two different platforms available for MAS development, allowing the validation of our proposal. In this way, the resultant approach can generate Virtual Organization deployments from unified meta-models, facilitating the development process of agent-based software from the user point of view.
13
BALASUBRAMANIAN, KRISHNAKUMAR, ANIRUDDHA GOKHALE, YUEHUA LIN, JING ZHANG, and JEFF GRAY. "WEAVING DEPLOYMENT ASPECTS INTO DOMAIN-SPECIFIC MODELS." International Journal of Software Engineering and Knowledge Engineering 16, no. 03 (June 2006): 403–24. http://dx.doi.org/10.1142/s021819400600280x.
Full textAbstract:
Domain-specific models increase the level of abstraction used to develop large-scale component-based systems. Model-driven development (MDD) approaches (e.g., Model-Integrated Computing and Model-Driven Architecture) emphasize the use of models at all stages of system development. Decomposing problems using MDD approaches may result in a separation of the artifacts in a way that impedes comprehension. For example, a single concern (such as deployment of a distributed system) may crosscut different orthogonal activities (such as component specification, interaction, packaging and planning). To keep track of all entities associated with a component, and to ensure that the constraints for the system as a whole are not violated, a purely model-driven approach imposes extra effort, thereby negating some of the benefits of MDD. This paper provides three contributions to the study of applying aspect-oriented techniques to address the crosscutting challenges of model-driven component-based distributed systems development. First, we identify the sources of crosscutting concerns that typically arise in model-driven development of component-based systems. Second, we describe how aspect-oriented model weaving helps modularize these crosscutting concerns using model transformations. Third, we describe how we have applied model weaving using a tool called the Constraint-Specification Aspect Weaver (C-SAW) in the context of the Platform-Independent Component Modeling Language (PICML), which is a domain-specific modeling language for developing component-based systems. A case study of a joint-emergency response system is presented to express the challenges in modeling a typical distributed system. Our experience shows that model weaving is an effective and scalable technique for dealing with crosscutting aspects of component-based systems development.
14
Monfort, Valérie, and Slimane Hammoudi. "When Parameterized Model Driven Development Supports Aspect Based SOA." International Journal of E-Business Research 7, no. 3 (July 2011): 44–62. http://dx.doi.org/10.4018/jebr.2011070103.
Full textAbstract:
Service-Oriented Architectures (SOA) are widely used by companies to gain flexibility. Web services are the fitted technical solution used to support SOA by providing interoperability and loose coupling. Basic Web services are being assembled to composite Web services in order to directly support business processes. However, there is much to be done to obtain a genuine flawless Web service, and current market implementations do not provide adaptable Web service behavior depending on the service contract. This paper proposes two different approaches to increase adaptability of Web services and SOA. The first approach is based on Aspect Oriented Programming (AOP) as a new design solution for Web services. The authors have implemented an infrastructure to enrich services with aspects and to dynamically reroute messages according to changes, without redeployment. The second approach combines Model Driven Development (MDD) and Context-Awareness to promote reuse and adaptability of Web services behavior depending on the service context. Parameterized transformation techniques are proposed to bind context with business logic implemented by a service. The aim is to merge the two approaches to abstract and reduce the technical complexity of aspect based service solution.
15
Vieira, Andreza, and Franklin Ramalho. "Towards Measuring the Change Impact in ATL Model Transformations." International Journal of Software Engineering and Knowledge Engineering 26, no. 02 (March 2016): 153–81. http://dx.doi.org/10.1142/s021819401650008x.
Full textAbstract:
The Model-Driven Development (MDD) approach shifts the focus on code to models in the software development process. In MDD, model transformations are elements that play an important role. MDD-based projects evolve along their lifecycle in a way that changes in their transformations are frequent. Before applying changes it is important to measure their impacts within the transformation. However, currently no technique helps practitioners in this direction. We propose an approach to measure the change impact in ATL model transformations. Based on static analysis, it detects the elements impacted by a change and calculates the change impact value through three metrics we defined. By using our approach, practitioners can (i) save effort and development time since the elements impacted with the change are automatically detected and (ii) better schedule and prioritize changes according to the impact value. To empirically evaluate our approach we conducted a case study.
16
Neves, Romulo De Almeida, and Willian Massami Watanabe. "Geração automática de testes em um processo de Model Driven Development: um exemplo de utilização da ferramenta Sikuli." Revista Brasileira de Computação Aplicada 9, no. 4 (December 13, 2017): 90. http://dx.doi.org/10.5335/rbca.v9i4.6735.
Full textAbstract:
Contexto: Model Driven Development (MDD) eleva a importância de modelos dentro do ciclo de vida do software, incorporando-os como parte integrante do produto final por meio de técnicas de modelagem e geração de código, com isso, parte da complexidade do software fica escondida dentro de geradores. Problema: Mesmo com a utilização do processo MDD, o custo associado à elaboração de casos de teste ainda é alto. Objetivo: Automatizar a geração de casos de teste incorporando o Model Driven Testing (MDT) em um processo MDD já existente a fim de gerar automaticamente casos de teste de aceitação para um sistema legado. Justificativa: Garantir a qualidade do software gerado através de um processo de geração de código e reduzir o tempo geral do ciclo de vida do software. Método: Foi realizado uma prova de conceito como forma de validar o objetivo deste trabalho e avaliar a efetividade da abordagem de teste utilizando a métrica de Code Coverage dos casos de testes gerados automaticamente. Resultados: Para este estudo foram selecionados cinco Graphical User Interface (GUIs), na qual a GUI Seguradoras obteve 98% de cobertura de código pelos casos de teste, Moeda obteve 94,39%, Fornecedor com 95,04%, Tipo do item com 95,95% e por fim a GUI Classificação Contábil obteve 95,91% de cobertura dos casos de teste.
17
Guo, Hong, Shang Gao, John Krogstie, Hallvard Trætteberg, and Alf Inge Wang. "An Evaluation of Ontology Based Domain Analysis for Model Driven Development." International Journal on Semantic Web and Information Systems 11, no. 4 (October 2015): 41–63. http://dx.doi.org/10.4018/ijswis.2015100102.
Full textAbstract:
Although Domain Analysis (DA) is important for Model Driven Development (MDD), traditional DA methods are demanding and not practical in many situations. When computer games are developed, game design (problem domain) is usually decided in a gradual way within iterations where software prototypes are constructed and playtest are performed. In such a case, it is not practical to fit a heavyweight DA in the highly iterative process. Researchers indicated that vocabularies were expected to automate game design. Such vocabularies can be reused in another form in DA tasks. In this research, the authors developed an ontology and a DA procedure based on it. To evaluate them, theoretical analysis, case studies, and a user acceptance survey were used. The results indicated that the ontology met the general requirement as a domain vocabulary, and it enhanced the DA process in an expected way. Most of external potential users (46 in total) considered the ontology useful and easy to use.
18
Marín, Beatriz, Giovanni Giachetti, Oscar Pastor, and Alain Abran. "A Quality Model for Conceptual Models of MDD Environments." Advances in Software Engineering 2010 (July 27, 2010): 1–17. http://dx.doi.org/10.1155/2010/307391.
Full textAbstract:
In Model-Driven Development (MDD) processes, models are key artifacts that are used as input for code generation. Therefore, it is very important to evaluate the quality of these input models in order to obtain high-quality software products. The detection of defects is a promising technique to evaluate software quality, which is emerging as a suitable alternative for MDD processes. The detection of defects in conceptual models is usually manually performed. However, since current MDD standards and technologies allow both the specification of metamodels to represent conceptual models and the implementation of model transformations to automate the generation of final software products, it is possible to automate defect detection from the defined conceptual models. This paper presents a quality model that not only encapsulates defect types that are related to conceptual models but also takes advantage of current standards in order to automate defect detection in MDD environments.
19
Cervera, Mario, Manoli Albert, Victoria Torres, and Vicente Pelechano. "A Model-Driven Approach for the Design and Implementation of Software Development Methods." International Journal of Information System Modeling and Design 3, no. 4 (October 2012): 86–103. http://dx.doi.org/10.4018/jismd.2012100105.
Full textAbstract:
The Situational Method Engineering (SME) discipline emerged two decades ago to address the challenge of the in-house definition of software development methods and the construction of the corresponding supporting tools. Unfortunately, current SME approaches still have limitations that are hindering their adoption by industry. One of these limitations is that most approaches do not properly encompass two phases of the SME lifecycle, which refer to the method design and the method implementation. To address this limitation, this paper demonstrates how Model-Driven Development (MDD) techniques can contribute to successfully cover both phases. The proposal is illustrated by a real case study that is currently being used at the Valencian Regional Ministry of Infrastructure, Territory and Environment.
20
Taryana, Acep, Bangun Wijayanto, Naoyasu Ubayashi, and Joko Setyono. "MODEL-DRIVEN DEVELOPMENT : FASE AWAL VERIFIKASI MODEL DESIGN REKAM MEDIS ELEKTRONIS MENGGUNAKAN PERUMUSAN GRAF LENGKAP." Jurnal Ilmiah Matematika dan Pendidikan Matematika 6, no. 2 (December 26, 2014): 53. http://dx.doi.org/10.20884/1.jmp.2014.6.2.2904.
Full textAbstract:
In this paper will be shown a graph formulation as a formal approaches in research Model-Driven Development (MDD) with a case study : the development of Electronic Medical Record (RME) on the scope of the public health center. The model was designed using UML notation and be selected a State Machine diagram that represents prerequisite user needs (requirements). Before the model is derived (driven) into the skeleton code, the accuracy of the state machine must be verified. In order for the State Machine can be verified by formal approach, the State Machine should be first transformed into a propositional formula using the complete graph approach, and partial models. The initial phase of verification will check the suitability of the model with the requirements in Propositional Normal Form (PNF) using SAT Solver, respectively as and . SAT solver will provide a design decision, whether a requirement represented in the model or not. If these requirements are not hold in the model, the requirement is not certainty (uncertain) and model must be redesigned.
21
Figueroa, Pablo A. "Visual Programming for Virtual Reality Applications Based on InTml." Journal on Interactive Systems 3, no. 1 (June 15, 2012): 1. http://dx.doi.org/10.5753/jis.2012.607.
Full textAbstract:
This paper presents our work on a visual programming environment (VPE) for portable, implementation-independent, virtual reality (VR) applications. Previously, we have defined InTml, the Interaction Techniques Markup Language , a domain specific language for VR applications, and some initial, command-line based development tools. By using the concept of Model Driven Development (MDD) and with the aid of tools from the Eclipse Graphical Modeling Project (GMF), we built an IDE for VR applications, that allows the visual description of components, application creation, and code generation to targeted runtime environments in C++, Java, and ActionScript. We report some advantages and shortcomings in this approach for tool development, some results from our preliminary user studies and lessons learned. In general, an MDD based approach to VPE is challenging both in terms of learning curve and usability of the final IDE.
22
Clemente, Pedro, and Adolfo Lozano-Tello. "Model Driven Development Applied to Complex Event Processing for Near Real-Time Open Data." Sensors 18, no. 12 (November 24, 2018): 4125. http://dx.doi.org/10.3390/s18124125.
Full textAbstract:
Nowadays, data are being produced like never before because the use of the Internet of Things, social networks, and communication in general are increasing exponentially. Many of these data, especially those from public administrations, are freely offered using the open data concept where data are published to improve their reutilisation and transparency. Initially, the data involved information that is not updated continuously such as budgets, tourist information, office information, pharmacy information, etc. This kind of information does not change during large periods of time, such as days, weeks or months. However, when open data are produced near to real-time such as air quality sensors or people counters, suitable methodologies and tools are lacking to identify, consume, and analyse them. This work presents a methodology to tackle the analysis of open data sources using Model-Driven Development (MDD) and Complex Event Processing (CEP), which help users to raise the abstraction level utilised to manage and analyse open data sources. That means that users can manage heterogeneous and complex technology by using domain concepts defined by a model that could be used to generate specific code. Thus, this methodology is supported by a domain-specific language (DSL) called OpenData2CEP, which includes a metamodel, a graphical concrete syntax, and a model-to-text transformation to specific platforms, such as complex event processing engines. Finally, the methodology and the DSL have been applied to two near real-time contexts: the analysis of air quality for citizens’ proposals and the analysis of earthquake data.
23
Agüero, Jorge, Miguel Rebollo, Carlos Carrascosa, and Vicente Julián. "MDD-Approach for developing Pervasive Systems based on Service-Oriented Multi-Agent Systems." ADCAIJ: Advances in Distributed Computing and Artificial Intelligence Journal 2, no. 3 (November 25, 2013): 55–64. http://dx.doi.org/10.14201/adcaij2014265564.
Full textAbstract:
The development of Ubiquitous or Pervasive Systems can be considered a complex task, with multiple actors, devices and different hardware environments; where it is difficult to find a compact view of all the components. This work proposes to use a MDD (Model-Driven Development) approach to facilitate the development process of Agent-Based Pervasive Systems, providing the user with a set of abstractions that ease the implementation of Pervasive Systems and the deployment of a platform for their execution. The proposal allows designing pervasive applications using high-level abstractions, avoiding the low-level implementation details and, after that, the Pervasive System deployment (with embedded agents and devices) is generated by using automatic transformations. In this way, a non-expert programmer will be able to develop Agent-Based Pervasive Systems, reducing the gap between the design and the implementation phases.
24
Rybola, Zdeněk, and Karel Richta. "Possible realizations of multiplicity constraints." Computer Science and Information Systems 10, no. 4 (2013): 1621–46. http://dx.doi.org/10.2298/csis121210067r.
Full textAbstract:
Model Driven Development (MDD) approach is often used to model application data and behavior by a Platform Independent Model (PIM) and to generate Platform Specific Models (PSMs) and even the source code by model transformations. However, these transformations usually omit constraints of the binary association multiplicities, especially the source class optionality constraint. This paper is an extended version of the paper ?Transformation of Special Multiplicity Constraints - Comparison of Possible Realizations? presented at MDASD workshop at the FedCSIS 2012 conference. In this paper, we summarize the process of the transformation of a binary association from a PIM into a PSM for relational databases. We suggest several possible realizations of the source class optionality constraint to encourage the automatically transformation and discuss their advantages and disadvantages.We also provide experimental comparison of our suggested realizations to the common realization where this constraint is omitted.
25
Fernandes, José Eduardo, Ricardo J. Machado, and João Á. Carvalho. "A Case Studies Approach to the Analysis of Profiling and Framing Structures for Pervasive Information Systems." International Journal of Web Portals 4, no. 2 (April 2012): 1–18. http://dx.doi.org/10.4018/jwp.2012040101.
Full textAbstract:
Model-Based/Driven Development (MDD) constitutes an approach to software design and development that potentially contributes to: concepts closer to domain and reduction of semantic gaps, automation and less sensitivity to technological changes, and the capture of expert knowledge and reuse. The widespread adoption of pervasive technologies as basis for new systems and applications lead to the need of effectively design pervasive information systems that properly fulfil the goals they were designed for. This paper presents a profiling and framing structure approach for the development of Pervasive Information Systems (PIS). This profiling and framing structure allows the organization of the functionality that can be assigned to computational devices in a system and of the corresponding development structures and models, being. The proposed approach enables a structural approach to PIS development. The paper also presents two case studies that allowed demonstrating the applicability of the approach.
26
Soltani, Mokhtar, and Sidi Mohamed Benslimane. "Ontology-based Multi-Objective Evolutionary Algorithm for Deriving Software Services from Business Process Model." International Journal of Information Systems in the Service Sector 5, no. 3 (July 2013): 35–53. http://dx.doi.org/10.4018/jisss.2013070103.
Full textAbstract:
Various approaches uses business process models as starting point to derive software services. The first and the important task for developing service-oriented models is service identification. However, the majority of existing methods for service identification are developed manually because, on the one hand, they are based on the competence of the developers and, on the other hand, the business process models do not comprise sufficient knowledge to identify services automatically. The integration of Business Process Modeling (BPM), Model-Driven Development (MDD), and Ontology-based Semantic Annotation (OSA) allows the automation of the SOA (Service-Oriented Architecture) services development. Three steps are used for developing an SOA solution: service identification, service specification and finally service realization. In this paper, the authors illustrate a method called MOOSI (Multi-Objective Optimization-based Service Identification) that automatically identifies the architecturally significant elements from an annotated business process model in order to specify service model artifacts. The main goal of this work is to support the automation of the development process of service-oriented enterprise information system. The implementation results of our proposed method are discussed. This result shows that MOOSI can achieve high performance in terms of execution time and important quality in terms of modularization quality of identified services compared with other solution.
27
Górski, Tomasz, and Grzegorz Ziemski. "UML activity diagram transformation into BPEL integration flow." Bulletin of the Military University of Technology 67, no. 3 (September 28, 2018): 15–45. http://dx.doi.org/10.5604/01.3001.0012.6587.
Full textAbstract:
The growing interest of companies in integration and interoperability between information systems has caused increase in significance of Service-Oriented Architecture which provides tools for Enterprise Application Integration. In that architecture, Enterprise Service Bus provides technical possibilities of communication between IT systems. A key element in the communication are integration flows. Objective: The aim of this article is to present a new transformation Integration2BPEL, which automates the development of executable integration flow expressed in the Web Services Business Process Execution Language (WS-BPEL) based on the model of the integration flow presented in the Unified Modelling Language (UML) activity diagram. Method: The author proposes a transformation of the type of model-to-code type which generates integration flow expressed in WS-BPEL, which can be executed in any BPEL-compliant process engine. The integration flow is modelled using UML activity diagram with stereotypes from ‘UML Profile for Integration Flows’ profile in an IBM Rational Software Architect (RSA). Using Integration2BPEL transformation a complete, executable integration flow is generated, which is composed of many mediation mechanisms. Generated integration flows have been executed on OpenESB. Results: The ability to generate a complete integration flow in BPEL, which without any additions can be run on enterprise service bus. Implementation phase of an integration flow construction was automated. Each of integration flows is implemented according to the same rules. In addition, it allows to avoid mistakes made by designers and programmers. Conclusions: Model-Driven Development is an approach that leads to the automation of the design and programming phases. Integration2BPEL transformation is a uniform mechanism to design integration flow. Potentially, it also allows to avoid implementation errors. Keywords: Web Services Business Process Execution Language (BPEL), Enterprise Service Bus (ESB), Unified Modelling Language (UML), UML activity diagram, Model-Driven Development (MDD), Transformation. null
28
Cortés, Humberto, and Antonio Navarro. "Enterprise WAE: A Lightweight UML Extension for the Characterization of the Presentation Tier of Enterprise Applications with MDD-Based Mockup Generation." International Journal of Software Engineering and Knowledge Engineering 27, no. 08 (October 2017): 1291–331. http://dx.doi.org/10.1142/s0218194017500486.
Full textAbstract:
Nowadays, the Unified Modeling Language (UML) is the most successful notation for the design of object-oriented applications. However, plain UML is not enough to characterize the web presentation tier of enterprise applications, including the navigational, structural and role-based access control (RBAC) features present in these applications. In this paper, we present Enterprise Web Application Extension (E-WAE), a lightweight UML extension for the modeling of these elements, which permits the inclusion of multitier, Service-Oriented Architecture (SOA) and security design-level patterns in the models. Our approach follows a Model-Driven Development (MDD) approach, which enables the automatic generation of intermediate platform-specific models and automatic code generation for JavaServer Faces (JSF) and Active Server Pages.NET Model-View-Controller (ASP.NET MVC) frameworks. In addition, this generated code can be used as a low-cost mockup for early client validation of the navigational, structural and RBAC features of enterprise applications. E-WAE has been used with different applications. In this paper, we refer to the checkout process in the Amazon website, the delete resources use case in OdAJ2EE, an educational application developed by us, and the US Library of Congress Online Catalog search facility as examples of its applicability.
29
Zhang, Yuan Yuan, Qin Gao, and Heng Liang Wu. "Research on Model Driven Architecture." Applied Mechanics and Materials 40-41 (November 2010): 1012–15. http://dx.doi.org/10.4028/www.scientific.net/amm.40-41.1012.
Full textAbstract:
Model driven architecture (MDA) is an architecture specification of software development proposed by OMG in July 2001. MDA holds that the best way of software development is to enhance the level of abstraction of the system, isolate the design and implementation of the system, and separate the business conduct, so as to overcome the difficulties caused by the complexity of software. This paper presents the basic concept and core technology, and gives the software development process based on MDA.
30
Šilingas, Darius. "MD3 – integruotas modeliavimu pagrįstas duomenų projektavimas objektinėms, XML ir sąryšinių duomenų bazių technologijoms." Informacijos mokslai 50 (January 1, 2009): 301–5. http://dx.doi.org/10.15388/im.2009.0.3222.
Full textAbstract:
Modeliais pagrįstos architektūros (MDA) paradigma siūlo didinti programinės įrangos kūrimo efektyvumą keliant abstrakcijos lygį. Tuo tikslu siūloma kaip pagrindinę programų konstravimo priemonę naudoti ne tekstines programavimo kalbas, o vizualiasmodeliavimo kalbas, tokias kaip UML. Šiame straipsnyje nagrinėjamas MDA taikymas duomenų struktūrų projektavimui. Pristatomas MD3 metodikos karkasas, kuris apibrėžia duomenų projektavimo principus, veiksmų seką, UML poaibį, skirtą duomenims modeliuoti, UML plėtinius XML schemoms ir DDL kodui reprezentuoti, transformacijas tarp skirtingų duomenų abstrakcijos lygių bei duomenų struktūrų projektavimui specializuotą modeliavimo aplinką. MD3 taikymas iliustruojamas nedideliais, bet reprezentatyviais pavyzdžiais iš bibliotekos dalykinės srities. Pristatomas MD3 metodikos karkasas suvokiamas kaip pradinis atspirties taškas labiau specializuotiems ar formalizuotiemsų duomenų projektavimo metodams ir įrankiams kurti.MD3 – Integrated Model-Driven Data Design for Objects, XML, and Relational Databases Darius Šilingas SummaryThe Model-Driven Architecture (MDA) paradigm promotes raising the level of abstraction and development effi ciency by leveraging visual modeling instead of textual programming as the main means for producing software artifacts. In this paper, we focus on applying the MDA approach to data design. We introduce an integrated model-driven data design (MD3) framework, which consists of the data design workfl ow defi nition, a small subset of UML for conceptual data modeling, UML profi les for representing XML and relational database schemas, verifi cation rules for checking model completeness and correctness, transformations between data design abstraction layers, and a customized integrated modeling environment. Application of the MD3 framework is illustrated by a small representative data design sample from the library domain. The MD3 framework is a conceptual starting point for developing more specialized and formalized data design methods and tools.
31
Mad, Hassan. "Islamic development model: A shift from growth-driven to prosperity-driven model." Journal of Emerging Economies and Islamic Research 5, no. 2 (May 31, 2017): 1. http://dx.doi.org/10.24191/jeeir.v6i2.8799.
Full textAbstract:
Hassan Mad serves as the Secretary General of the Malay Consultative Council (Majlis Perundangan Melayu) and Adjunct Professor of the Malay Institute of Thought and Leadership (Insitut Pemikiran & Kepimpunan Melayu), Universiti Teknologi MARA. He obtained his PhD (Pomology) from Wye College, University of London in 1983.
32
Magableh, Basel, and Stephen Barrett. "Productivity Evaluation of Self-Adaptive Software Model Driven Architecture." International Journal of Information Technology and Web Engineering 6, no. 4 (October 2011): 1–19. http://dx.doi.org/10.4018/jitwe.2011100101.
Full textAbstract:
Anticipating context changes using a model-based approach requires a formal procedure for analysing and modelling context-dependent functionality and stable description of the architecture which supports dynamic decision-making and architecture evolution. This article demonstrates the capabilities of the context-oriented component-based application-model-driven architecture (COCA-MDA) to support the development of self-adaptive applications; the authors describe a state-of-the-art case study and evaluate the development effort involved in adopting the COCA-MDA in constructing the application. An intensive analysis of the application requirements simplified the process of modelling the application’s behavioural model; therefore, instead of modelling several variation models, the developers modelled an extra-functionality model. COCA-MDA reduces the development effort because it maintains a clear separation of concerns and employs a decomposition mechanism to produce a context-oriented component model which decouples the applications’ core functionality from the context-dependent functionality. Estimating the MDA approach’s productivity can help the software developers select the best MDA-based methodology from the available solutions. Thus, counting the source line of code is not adequate for evaluating the development effort of the MDA-based methodology. Quantifying the maintenance adjustment factor of the new, adapted, and reused code is a better estimate of the development effort of the MDA approaches.
33
Chai, Yong Sheng, Quan Bin Wang, Yu Lan Zhou, and Bin Zhu. "Reconfigurable Manufacturing Execution Systems Based on Model-Driven Architecture." Materials Science Forum 532-533 (December 2006): 1072–75. http://dx.doi.org/10.4028/www.scientific.net/msf.532-533.1072.
Full textAbstract:
By analyzing the trend of MES (Manufacturing Execution Systems), the concept of RMES (Reconfigurable Manufacturing Execution Systems) is put forward, which takes information integration as groundwork, aims at optimization of production processes and supports organizations, resources and processes for flexible conFig.. MDA (Model-driven Architecture) is introduced to provide more flexible in the process of the development of RMES, which would adapt to different technology used by the bottom systems and provide a more effective method to build RMES. During the development of RMES, many models are created, such as the model of business analysis, the model of components and the model of deployment. An instance of the system of plan, part of RMES, is presented to show how MDA used in the process of the development of RMES. Later, an application is given to show that RMES based on MDA can decrease the costs of development and maintenance for fitting the evolution of the enterprise.
34
Shi, Hai Peng. "Web Application Development Based on MDA Project-Driven Mode." Advanced Materials Research 971-973 (June 2014): 1862–65. http://dx.doi.org/10.4028/www.scientific.net/amr.971-973.1862.
Full textAbstract:
In the paper, the MDA (Model Driven Architecture) are brought into J2EE web application development based on project-driven mode and the teaching plan is proposed. First the current project-driven teaching mode in our institute is presented and the idea behind the MDA is introduced briefly, and then some suggestions on the J2EE MDA project-driven are given. Practice shows that the teaching mode can not only improve the efficiency of development and the quality of system, but also bring students the sense of achievement, and arouse their enthusiasm and initiatives; thereby the quality of teaching is greatly improved.
35
Huang, Jin. "The Research of Model-Driven Architecture in the Embedded System." Applied Mechanics and Materials 624 (August 2014): 524–27. http://dx.doi.org/10.4028/www.scientific.net/amm.624.524.
Full textAbstract:
Model Driven Architecture (MDA) as a software independent of the specific platform and software suppliers architecture design and development methodology has been great concern. The system is expanding at the same time, in order to solve the high reliability of embedded software development code, real-time, and the resulting system efficiency of the implementation issues, the paper used in the field of embedded software development according to MDA, and achieved good results. And this research work is summarized and analyzed, pointing out the challenges facing the sector and future research work.
36
Huang, Yen-Chieh, and Chih-Ping Chu. "Developing Web Applications Based on Model Driven Architecture." International Journal of Software Engineering and Knowledge Engineering 24, no. 02 (March 2014): 163–82. http://dx.doi.org/10.1142/s0218194014500077.
Full textAbstract:
Model Driven Architecture (MDA) is a new software development framework. This paper presents a model-driven approach to the development of Web applications by combining Conallen's web applications design concept and Kleppe's MDA process. We use the UML extension mechanism, i.e. stereotypes, to define the various web elements, and use the Robustness diagram to represent MVC 2 structure for Web application. After required analysis, we start by using a use case diagram as CIM, and then transform CIM to PIM, and PIM to PSM. We propose mapping rules for model-to-model transformation. Finally, we develop a tool named WebPSM2Code, which can automatically transform PSM diagram to Web application code, such as Java, JSP, HTML, Servlet, Javascript, as well as deployment descriptor file. All the files can automatically address to the correct directory structure for JSP Web application, and the transformation rate is about 39% of the whole system. Using this methodology, systems can be analyzed, designed, and generated more easily and systematically. Thereby, the time that Web programmers spend on coding can be reduced.
37
Asnina, Erika. "Use of Business Models within Model Driven Architecture." Scientific Journal of Riga Technical University. Computer Sciences 38, no. 38 (January 1, 2009): 119–30. http://dx.doi.org/10.2478/v10143-009-0010-1.
Full textAbstract:
Use of Business Models within Model Driven Architecture Model Driven Architecture is a framework dedicated for development of large and complex computer systems. It states and implements the principle of architectural separation of concerns. This means that a system can be modeled from three different but related to each other viewpoints. The viewpoint discussed in this paper is a Computation Independent one. MDA specification states that a model that shows a system from this viewpoint is a business model. Taking into account transformations foreseen by MDA, it should be useful for automation of software development processes. This paper discusses an essence of the Computation Independent Model (CIM) and the place of business models in the computation independent modeling. This paper considers four types of business models, namely, SBVR, BPMN, use cases and Topological Functioning Model (TFM). Business persons use SBVR to define business vocabularies and business rules of the existing and planned domains, BPMN to define business processes of both existing and planned domains, and use cases to define business requirements to the planned domain. The TFM is used to define functionality of both existing and planned domains. This paper discusses their capabilities to be used as complete CIMs with formally defined conformity between planned and existing domains.
38
Franky, Maria Consuelo, Jaime A. Pavlich-Mariscal, Maria Catalina Acero, Angee Zambrano, John C. Olarte, Jorge Camargo, and Nicolás Pinzón. "ISML-MDE." International Journal of Web Information Systems 12, no. 4 (November 7, 2016): 533–56. http://dx.doi.org/10.1108/ijwis-04-2016-0025.
Full textAbstract:
Purpose This purpose of this paper is to present ISML-MDE, a model-driven environment that includes ISML, a platform-independent modeling language for enterprise applications; ISML-GEN, a code generation framework to automatically generate code from models; and LionWizard, a tool to automatically integrate different components into a unified codebase. Design/methodology/approach The development comprises five stages: standardizing architecture; refactoring and adapting existing components; automating their integration; developing a modeling language; and creating code generators. After development, model-to-code ratios in ISML-MDE are measured for different applications. Findings The average model-to-code ratio is approximately 1:4.6 when using the code generators from arbitrary models. If a model transformation is performed previously to the code generation, this ratio raises to 1:115. The current validation efforts show that ISML properly supports several DSL essential characteristics described by Kahraman and Bilgen (2015). Research limitations/implications ISML-MDE was tested on relatively small applications. Further validation of the approach requires measurement of development times and their comparison with previous similar projects, to determine the gains in productivity. Originality/value The value of ISML-MDE can be summarized as follows: ISML-MDE has the potential to significantly reduce development times, because of an adequate use of models and transformations. The design of ISML-MDE addresses real-world development requirements, obtained from a tight interaction between the researchers and the software development company. The underlying process has been thoroughly documented and it is believed it can be used as a reference for future developments of MDE tools under similar conditions.
39
Wall, Johan, Marco Bertoni, and Tobias Larsson. "The Model-Driven Decision Arena: Augmented Decision-Making for Product-Service Systems Design." Systems 8, no. 2 (June 18, 2020): 22. http://dx.doi.org/10.3390/systems8020022.
Full textAbstract:
The shift towards Product-Service Systems (PSS) stresses the need to embed new and unique capabilities in Decision Support Systems, with the aim of helping the engineering team in handling the pool of information and knowledge available during decision events. Emerging from a multiple case study in the Swedish manufacturing industry, this paper describes the development of the Model-Driven Decision Arena (MDDA), an environment for collaborative decision-making that focuses on the early design phases of PSS. Based on the findings from multiple case studies, this paper illustrates the main goals of the MDDA, detailing its main functions, its physical environment, and its software architecture and models. This paper demonstrates the use of the MDDA in a case study related to the development of an asphalt compactor, presenting and discussing the results of verification activities conducted with industrial practitioners on the current MDDA prototype.
40
Grave, Andrejs. "Testing and Traceability Aspects in the Context of the Model Driven Architecture (MDA)." Scientific Journal of Riga Technical University. Computer Sciences 41, no. 1 (January 1, 2010): 52–59. http://dx.doi.org/10.2478/v10143-010-0024-8.
Full textAbstract:
Testing and Traceability Aspects in the Context of the Model Driven Architecture (MDA) With the growth of complexity of the software systems it becomes more complicated to ensure and evaluate quality of the software being built. This paper discusses quality of the software in the context of the Model Driven Architecture. Paper analyses factors that affect quality of the software in the software development projects that are developed using MDA. As one of the important factor that affects quality of the software, is traceability. This paper provides description of the traceability property and importance of it within development of the software. Within context of this paper traceability is considered as a property of a system description technique that allows changes in one of the system descriptions to be traced to the corresponding portions of the other descriptions. This paper is focused on such aspects of the software development as testing and traceability in the context of MDA. Paper contains in review of traceability, MDA and traceability within MDA. Also paper contains description of the method for formal definition of the problem domain - called Topological functioning modeling for model driven architecture (TFMfMDA). This paper introduces method of the application of the TFM as the traceability tool. TFM as the traceability tool can be used to analyze impact of the changes and select most important tests.
41
Chernichkin, Anton, and Oksana Nikiforova. "An approach to classification of MDA tools." Scientific Journal of Riga Technical University. Computer Sciences 38, no. 38 (January 1, 2009): 72–83. http://dx.doi.org/10.2478/v10143-009-0006-x.
Full textAbstract:
An approach to classification of MDA tools Nowadays there is a wide variety of tools, supporting the idea of software development process to be enriched by the principles of modelling—the source code is being generated from the model. Many of these purporting to be "MDA complaint" as well. Model driven architecture offers an approach to software development process that provides a separation of concerns, keeping the appropriate level of abstraction on each stage of development. Furthermore, the source code can be generated in a formal way, requiring no interference from the developer. There are two types of software development tools: the former type represents the semiautomatic approach, where the software is supposed to be created using system's model and code transformations, also considering different types of routines, which are done manually, while the latter type is an automatic solution, where no manual steps or routines are required. The original article defines various perspectives on positioning of MDA tools among CASE tools for software development, as well as proposes a methodological approach on classification of MDA tools. One of the perspectives that can be used in the MDA tool classification approach corresponds with the Model Driven Development life cycle, while the other one defines the role of modelling and model application levels in a whole development process. In addition, various sets of features have been defined, in order to clarify the accordance level of these tools from the MDA perspective.
42
Favre, Liliana Maria. "Formal Metamodeling for Secure Model-Driven Engineering." International Journal of Systems and Software Security and Protection 12, no. 2 (July 2021): 46–67. http://dx.doi.org/10.4018/ijsssp.2021070104.
Full textAbstract:
Systems and applications aligned with new paradigms such as cloud computing and internet of the things are becoming more complex and interconnected, expanding the areas in which they are susceptible to attacks. Their security can be addressed by using model-driven engineering (MDE). In this context, specific IoT or cloud computing metamodels emerged to support the systematic development of software. In general, they are specified through semiformal metamodels in MOF style. This article shows the theoretical foundations of a method for automatically constructing secure metamodels in the context of realizations of MDE such as MDA. The formal metamodeling language Nereus and systems of transformation rules to bridge the gap between formal specifications and MOF are described. The main contribution of this article is the definition of a system of transformation rules called NEREUStoMOF for transforming automatically formal metamodeling specifications in Nereus to semiformal-MOF metamodels annotated in OCL.
43
Bendraou, Reda, Philippe Desfray, Marie-Pierre Gervais, and Alexis Muller. "MDA Tool Components: a proposal for packaging know-how in model driven development." Software & Systems Modeling 7, no. 3 (May 23, 2007): 329–43. http://dx.doi.org/10.1007/s10270-007-0058-8.
Full text
44
RAGHUPATHI, W., and A. UMAR. "Exploring a model-driven architecture (MDA) approach to health care information systems development." International Journal of Medical Informatics 77, no. 5 (May 2008): 305–14. http://dx.doi.org/10.1016/j.ijmedinf.2007.04.009.
Full text
45
Jácome-Guerrero, Santiago P., Elizabeth Salazar-Jácome, Wilson E. Sánchez-Ocaña, Rolando X. Salazar-Paredes, and Juan M. Ferreira. "Software development environments and tools in MDE." KnE Engineering 1, no. 2 (January 30, 2018): 1. http://dx.doi.org/10.18502/keg.v1i2.1483.
Full textAbstract:
Abstract. Model-Driven Engineering (MDE) is the notion that we can construct a model of a system that we can then transform into the real thing. The development of software in MDE using Domain-Specific Languages (DSLs) has two phases. First, the development of artifacts such as DSLs and transformation mechanisms by the modeling experts. Second, people non-technical experts (domain expert or end user) using the artifacts created develop applications simply because of the high level of abstraction allowed by technology. Several factors are considered to limit the use of MDE. One of them, is the lack of knowledge the tools and the development activities with MDE. To support the MDE initiative, the present work makes a description of the theoretical foundations of MDE, also describes the main activities to build several MDE artifacts with some of the tools most known in this technology.
46
Dehbi, Rachid, Mohamed Talea, and Abderrahim Tragha. "MDA-Based Transformation of LMS Business Components." International Journal of Enterprise Information Systems 9, no. 4 (October 2013): 63–84. http://dx.doi.org/10.4018/ijeis.2013100105.
Full textAbstract:
The model driven engineering and generative programming are revolutionizing software development just as automation and computerization revolutionized the manufacturing process. The key technologies of these approaches are the model transformations, and development in the XML technologies. In this paper the authors show the contribution of these two techniques in the implementation of LMSGENERATOR, a Multi-target Learning management system generator with a model-driven methodology based on MDA approach coupled with component approach. Based on generative programming, from user specifications (abstract models) and the desired technologies, software bricks will be generated and assembled to produce a complete solution adapted to the area and the users’ needs. This paper focuses on the transformation rules implemented in the LMSGENERATOR cores, in particular the transformation of a detailed UML class diagram, representing a business model, into the LMS Business component. Thus, the authors show the role of programming in model transformations through the use of API manipulating UML diagrams and XML files. Also this work presents a case study to illustrate this proposed plan.
47
He, Kemeng, Yushan Sun, Zhang Qin, Yuqiang Sun, and Yuwan Gu. "The Research of Trusted Attribute Based on Model-Driven of MDA." Open Electrical & Electronic Engineering Journal 8, no. 1 (December 31, 2014): 273–77. http://dx.doi.org/10.2174/1874129001408010273.
Full textAbstract:
The research methods of trusted attribute based on model-driven for credibility problems in the development process of model-driven software proposed in the paper. An overall analysis for software requirements is carried out, considering the business specification and the need to achieve the function, testing the Integrity and accuracy of model in the PIM phase. Then, is a need to achieve the necessary component services in the concrete platform for implementing the business logic of PIM, studying the symmetry and reliability of model in the PSM phase. Finally, the use of transformation method of element mark to achieve the conversion of platform model, testing the transfer ratio of model in the phase of PIM transformed to PSM. The research of trusted attribute based on model-driven of MDA has effectively improved reliability and developing efficiency of software.
48
Essebaa, Imane, Salima Chantit, and Mohammed Ramdani. "MoDAr-WA: Tool Support to Automate an MDA Approach for MVC Web Application." Computers 8, no. 4 (December 5, 2019): 89. http://dx.doi.org/10.3390/computers8040089.
Full textAbstract:
Model-driven engineering (MDE) uses models during the application development process. Thus, the MDE is particularly based on model-driven architecture (MDA), which is one of the important variants of the Object Management Group (OMG). MDA aims to generate source code from abstract models through several model transformations between, and inside the different MDA levels: computation independent model (CIM), platform independent model (PIM), and platform specific model (PSM) before code. In this context, several methods and tools were proposed in the literature and in the industry that aim to automatically generate the source code from the MDA levels. However, researchers still meet many constraints—model specifications, transformation automation, and level traceability. In this paper, we present a tool support, the model-driven architecture for web application (MoDAr-WA), that implements our proposed approach, aiming to automate transformations from the highest MDA level (CIM) to the lowest one (code) to ensure traceability. This paper is a continuity of our previous works, where we automate transformation from the CIM level to the PIM level. For this aim, we present a set of meta-models, QVT and Acceleo transformations, as well as the tools used to develop our Eclipse plug-in, MoDAr-WA. In particular, we used QVT rules for transformations between models and Acceleo for generating code from models. Finally, we use MoDAr-WA to apply the proposed approach to the MusicStore system case study and compare the generated code from CIM to the original application code.
49
Zhu, Xi Yong, Shan Shan Gu, and Shi Xiong Wang. "Software Reconfiguration Based on Service Model-Driven Architecture over Cloud Computing." Advanced Materials Research 204-210 (February 2011): 2144–49. http://dx.doi.org/10.4028/www.scientific.net/amr.204-210.2144.
Full textAbstract:
Cloud computing is changing the way enterprises develop and deploy information systems. With the rapid development and successful implementations of the model-driven architecure(MDA) and service-oriented architecture (SOA), clouding computing has become the focus of researches. This paper describes the design and implementation of a service template markup language (STML) and its integrated development tools, which provide a comprehensive solution to the reconfiguration of applications over cloud computing platforms. In the paper, we first analyze and point out the limitations of current software reconfiguration approaches, then propose a framework for a SMDA-based approach to software reconfiguration in a PaaS platform, next present a series of PaaS service models and an XML-based service template markup language, finally conclude by an example showing the practicability of the tools.
50
Deng, Ming, and Xiao Lan Xie. "Constructing a Web System Presentation Layer Framework Based on MDA." Applied Mechanics and Materials 701-702 (December 2014): 1067–70. http://dx.doi.org/10.4028/www.scientific.net/amm.701-702.1067.
Full textAbstract:
MDA(Model Driven Architecture)[1] is model-centric software development methodology. Comparing to traditional code-centric method, MDA is closer to real applications, and it owns a higher level of abstraction. It has become an effective way to produce large scale software in heterogeneous environment, and it is widely used to develop web-based complex information systems [2]. Our paper applies MDA approach to design web system representation layer framework with instances, and extend UML model by MOF(Meta-Object Facility). We’ve also defined transform rules and realized the conversion from UML model to Web model. Our framework helps minimize the application code, reduces the dependence of the Servlet API, provides extensible interface, thus improve the efficiency of system development and maintenance.