scholarly journals Software Architecture and Framework to Develop NFC-Based Applications

Sensors ◽  
2018 ◽  
Vol 18 (8) ◽  
pp. 2654 ◽  
Author(s):  
Ricardo Tesoriero ◽  
Jose Gallud
Keyword(s):  
Graphical Model ◽  
Near Field ◽  
Source Code ◽  
Transformation Process ◽  
Functional Requirements ◽  
Model Driven ◽  
Domain Specific ◽  
System Requirements ◽  
Physical Objects ◽  
Model Editor

Applications are employing Near Field Communication (NFC) technology to interact with physical objects by using NFC tags. The architecture to implement these kinds of applications varies according to non-functional requirements such as the physical environment where the application is running, the flexibility to adapt the information to be manipulated through physical objects, etc. To cope with these challenges, this paper proposes a Model-driven Architecture (MDA) where designers are able to model the configuration of the system according to NFC based system requirements. Through a model-to-text transformation process, the MDA also provides developers with templates of source code for the applications that support the system. The proposed MDA process defines a Platform Independent Model (PIM) which supports a Domain Specific Language (DSL) implemented as an Eclipse platform plugin that provides designers with a graphical model editor, and a model to text transformation, to generate the source code templates using the Acceleo transformation language. The paper also presents the Albacete Photo Gallery case of study to illustrate the modelling process. The main benefit of the proposal is that it allows developers to create mixed environments where the availability and flexibility of NFC based interaction systems can be easily configured, extended and maintained.

ANALISIS KEMAMPUAN WEBRATIO UNTUK PENGEMBANGAN APLIKASI WEB MENGGUNAKAN INTERACTION FLOW MODELING LANGUAGE (IFML)

2020 ◽  
Vol 3 (2) ◽  
Author(s):  
Joe Lian Min
Keyword(s):  
Web Applications ◽  
Transformation Process ◽  
Modeling Language ◽  
Modeling Languages ◽  
Functional Requirements ◽  
Application Development ◽  
Model Driven ◽  
Measurement Results ◽  
Mdd Method

The model-driven development (MDD) method is a method that can accelerate the application development process. With this method, the model can be immediately transformed into an executable application. Model-driven architecture is one kind of MDD approaches. MDA has a standard modeling language that is used to facilitate the transformation process. One of the modeling languages in MDA is Interaction Flow Management Language (IFML). IFML models an application based on the interaction flow and interface of the application. This paper explains the capabilities of WebRatio in developing Web applications and their effectiveness. The effectiveness is calculated from the effort required for the development. On the other side, the effort is calculated from the line of code (LOC) generated from the model. The experiment's case study is a  simple web-shop application, with some functional and non-functional requirements. The measurement results show that to develop a web-shop, the effort required is quite efficient, only 13% of the total application. However, another study still needs to be done because many variables affect the productivity of application development.

scholarly journals Transformation of UML class diagram to internal java domain-specific language

2012 ◽  
Vol 13 (1) ◽  
pp. 61-67 ◽  
Author(s):  
Dmitry Buzdin ◽  
Oksana Nikiforova
Keyword(s):  
Model Transformation ◽  
Research Work ◽  
Transformation Process ◽  
Domain Specific Language ◽  
Programming Technique ◽  
Model Driven ◽  
Existing Problems ◽  
Domain Specific ◽  
Uml Class Diagram ◽  
Stated Problem

Abstract - the article addresses the existing problems found in the area of Domain-Specific Languages (DSLs). Being a widely adopted programming technique, DSL grammar creation process still lacks desirable traceability and automation. The paper proposes a sequential model transformation process based on Model-Driven Architecture concepts as one of the potential solutions to stated problem. One of the main results of the research work is the implementation of prototype of the full-cycle model transformation chain starting from the UML domainmodel and ending with internal Java-based DSL grammar implementation.

scholarly journals A domain-specific language for defining static structure of database applications

2010 ◽  
Vol 7 (3) ◽  
pp. 409-440 ◽  
Author(s):  
Igor Dejanovic ◽  
Gordana Milosavljevic ◽  
Branko Perisic ◽  
Maja Tumbas
Keyword(s):  
Source Code ◽  
Domain Specific Language ◽  
Static Structure ◽  
Code Generator ◽  
Specific Language ◽  
Meta Model ◽  
Model Driven ◽  
Domain Specific ◽  
Definition Of ◽  
Execution Semantics

In this paper we present DOMMLite - an extensible domain specific language (DSL) for static structure definition of data base oriented applications. The model-driven engineering (MDE) approach, an emerging software development paradigm, has been used. The language structure is defined by the means of a meta model supplemented by validation rules based on Check language and extensions based on Extend language, which are parts of the openArchitectureWare framework [1]. The meta model has been defined along with the textual syntax, which enables creation, update and persistence of DOMMLite models using a common text editor. DSL execution semantics has been defined by the specification and implementation of the source code generator for a target platform with an already defined execution semantics. In order to enable model editing, a textual Eclipse editor has also been developed. DSL, defined in this way, has the capability of generating complete source code for GUI forms with CRUDS (Create-Read-Update-Delete-Search) and navigation operations [2,3,4,5].

scholarly journals Generation of Custom Textual Model Editors

Modelling ◽  
2021 ◽  
Vol 2 (4) ◽  
pp. 609-625
Author(s):  
Eugene Syrian ◽  
Daniel Riegelhaupt ◽  
Bruno Barroca ◽  
Istvan David
Keyword(s):  
Source Code ◽  
Model Driven Engineering ◽  
Model Driven ◽  
Domain Specific ◽  
Domain Specific Modeling ◽  
Architecture Modeling ◽  
Basic Features ◽  
And Behavior ◽  
New Generation ◽  
Specific Modeling

Textual editors are omnipresent in all software tools. Editors provide basic features, such as copy-pasting and searching, or more advanced features, such as error checking and text completion. Current technologies in model-driven engineering can automatically generate textual editors to manipulate domain-specific languages (DSLs). However, the customization and addition of new features to these editors is often limited to changing the internal structure and behavior. In this paper, we explore a new generation of self-descriptive textual editors for DSLs, allowing full configuration of their structure and behavior in a convenient formalism, rather than in source code. We demonstrate the feasibility of the approach by providing a prototype implementation and applying it in two domain-specific modeling scenarios, including one in architecture modeling.

scholarly journals Model-Driven Engineering for End-Users in the Loop in Smart Ambient Systems

2021 ◽  
Vol 27 (7) ◽  
pp. 755-773
Author(s):  
Sylvie Trouilhet ◽  
Jean-Paul Arcangeli ◽  
Jean-Michel Bruel ◽  
Maroun Koussaifi
Keyword(s):  
End Users ◽  
Transformation Process ◽  
User Feedback ◽  
Model Driven Engineering ◽  
Software Environment ◽  
Modeling Framework ◽  
Model Driven ◽  
Domain Specific ◽  
Develop Software ◽  
Ambient Systems

At the heart of cyber-physical and ambient systems, the user should permanently benefit from applications adapted to the situation and her/his needs. To do this, she/he must be able to configure her/his software environment and be supported as much as possible in that task. To this end, an intelligent “engine” assembles software components that are present in the ambient environment at the time and makes unanticipated applications emerge. The problem is to put the user “in the loop”, i.e., provide adapted and intelligible descriptions of the emerging applications, and present them so that the user can accept, modify or reject them. Besides, user feedback must be collected to feed the engine’s learning process. Our approach relies on Model-Driven Engineering (MDE). However, differently from the regular use of MDE tools and techniques by engineers to develop software and generate code, our focus is on end-users. Models of component assemblies are represented and made editable for them. Based on a metamodel that supports modeling and de- scription of component-based applications, a user interface provides multi-faceted representations of the emerging applications and captures user feedback. Our solution relies on several domain- specific languages and a transformation process, based on the established MDE tools (Gemoc studio, Eclipse Modeling Framework, EcoreTools, Sirius, Acceleo). It works in conjunction with the intelligent engine that builds the emerging applications and to which it provides learning data.

scholarly journals Polyhedral+Dataflow Graphs

2020 ◽  
Author(s):  
Eddie C. Davis
Keyword(s):  
Differential Equation ◽  
Sparse Matrix ◽  
Source Code ◽  
Tensor Decomposition ◽  
Domain Specific Language ◽  
Intermediate Representation ◽  
Specific Language ◽  
Domain Specific ◽  
Temporary Storage ◽  
Matrix Operations

This research presents an intermediate compiler representation that is designed for optimization, and emphasizes the temporary storage requirements and execution schedule of a given computation to guide optimization decisions. The representation is expressed as a dataflow graph that describes computational statements and data mappings within the polyhedral compilation model. The targeted applications include both the regular and irregular scientific domains. The intermediate representation can be integrated into existing compiler infrastructures. A specification language implemented as a domain specific language in C++ describes the graph components and the transformations that can be applied. The visual representation allows users to reason about optimizations. Graph variants can be translated into source code or other representation. The language, intermediate representation, and associated transformations have been applied to improve the performance of differential equation solvers, or sparse matrix operations, tensor decomposition, and structured multigrid methods.

scholarly journals Comparison Between Internal and External DSLs via RubyTL and Gra2MoL

2012 ◽  
pp. 109-131 ◽  
Author(s):  
Jesús Sánchez Cuadrado ◽  
Javier Luis Cánovas Izquierdo ◽  
Jesús García Molina
Keyword(s):  
Empirical Studies ◽  
Lessons Learned ◽  
The Other ◽  
Model Transformations ◽  
Domain Specific Languages ◽  
Model Driven ◽  
Domain Specific ◽  
Advantages And Disadvantages

Domain Specific Languages (DSL) are becoming increasingly more important with the emergence of Model-Driven paradigms. Most literature on DSLs is focused on describing particular languages, and there is still a lack of works that compare different approaches or carry out empirical studies regarding the construction or usage of DSLs. Several design choices must be made when building a DSL, but one important question is whether the DSL will be external or internal, since this affects the other aspects of the language. This chapter aims to provide developers confronting the internal-external dichotomy with guidance, through a comparison of the RubyTL and Gra2MoL model transformations languages, which have been built as an internal DSL and an external DSL, respectively. Both languages will first be introduced, and certain implementation issues will be discussed. The two languages will then be compared, and the advantages and disadvantages of each approach will be shown. Finally, some of the lessons learned will be presented.

Sign in / Sign up

Export Citation Format

Share Document