Conference PaperPDF Available

Applying Model Driven Engineering to Develop a Bee Information System

Abstract and Figures

WebBee is an information system that organizes knowledge and facilitates sharing of information about bees. It was written in PHP language. Model Driven Engineering (MDE) is a software development approach in which concrete artifacts such as source code and database creation scripts are automatically generated from high level models according to mapping functions. MDE is expected to increase software development productivity and it offers the possibility to generate specific implementations of the same system in different platforms. Our objective is to rewrite parts of WebBee as high level software models and apply MDE transformations to generate source code. Since WebBee presents characteristics of business applications, a domain specific modeling language specialized in this kind of software was used. Although some parts of the implementation could not be automatically generated, requiring direct coding, several parts of it were obtained by MDE transformations, saving efforts in coding and in testing. Future maintenances in the system can be obtained by changes in models and automatic regeneration of source code, and the system can be ported to new platforms more easily.
Content may be subject to copyright.
EFITA/WCCA/CIGR 2015 Poznan, Poland 29.06 - 02.07.2015
103
European Federation for Information Technology in
Agriculture, Food and the Environment
EFITA/WCCA/CIGR 2015
Sustainable Agriculture through ICT Innovation
Conference Proceedings
Applying Model Driven Engineering to Develop a Bee Information System
Sergio R. M. Canovas
1
, Carlos E. Cugnasca
2
I N F O
Received
Accepted
Available on-line
Responsible Editor:
Keywords:
WebBee, Bee, Information
System, Model Driven
Engineering, Domain Specific
Language
A B S T R A C T
WebBee is an information system that organizes knowledge and facilitates sharing of
information about bees. It was written in PHP language. Model Driven Engineering
(MDE) is a software development approach in which concrete artifacts such as source
code and database creation scripts are automatically generated from high level models
according to mapping functions. MDE is expected to increase software development
productivity and it offers the possibility to generate specific implementations of the same
system in different platforms. Our objective is to rewrite parts of WebBee as high level
software models and apply MDE transformations to generate source code. Since WebBee
presents characteristics of business applications, a domain specific modeling language
specialized in this kind of software was used. Although some parts of the implementation
could not be automatically generated, requiring direct coding, several parts of it were
obtained by MDE transformations, saving efforts in coding and in testing. Future
maintenances in the system can be obtained by changes in models and automatic
regeneration of source code, and the system can be ported to new platforms more easily.
1. Introduction
WebBee is a web-based information system developed to organize knowledge and to facilitate
sharing information on bees (Cunha et al. 2002). Bees are among threatened species and their decline
is especially dangerous because these pollinators are crucial for maintaining global biodiversity and
for crop production. This information system is aimed at different audiences, from researchers to
students, from policy makers to beekeepers. A database is a central part of the system, storing data
from different investigations conducted by a network of research groups. It includes data from bee
species, plant species visited by the bees and others. This system was implemented in PHP language
with a MySQL database server, and it can be accessed on the Internet by a web browser.
Model-Driven Engineering (MDE) is a software development approach based on the use of models
as essential artifacts. In essence, systems are created by transforming high-level abstraction models
into more concrete models, both in terms of subject matter and language. In the ideal scenario, source
code is generated from models by a compilation step as machine code is generated from source code
(Yang, Liu & Wang 2012). In contrast to traditional software development methodologies in which
models are mainly used for communication and documentation purposes, in MDE they are the main
living and evolving artifacts from which concrete software development artifacts can be produced
automatically (Kolovos et al. 2013). To apply MDE in practice, it is necessary to create software
models in languages that can be read and processed by computer programs. Therefore, the use of
natural language is not adequate for this goal when used to describe or to provide details about
software models. Models are then combined and transformed into source code in a target language
according to mapping functions. Eventually, intermediate models are generated in this process before
the final source code.
MDE can increase software development productivity by a factor of as much as 10 (Papotti et al.
2013). Another advantage is the possibility of generating the same software system for different
1
Sergio Roberto de Mello Canovas
University of São Paulo, Brazil
sergio.canovas@usp.br
2
Carlos Eduardo Cugnasca
University of São Paulo, Brazil
carlos.cugnasca@poli.usp.br
EFITA/WCCA/CIGR 2015 Poznan, Poland 29.06 - 02.07.2015
104
platforms, since the same models can be applied as input to different mapping functions, each one
generating code for a specific platform in a specific target language. This advantage is especially
important nowadays because of the current variety of mobile and desktop platforms and devices
available in the market (Reed 2013). When a new platform or operating system becomes available, if
new mapping functions are developed, existing software models can generate new concrete
implementations for this platform, and the original investment is preserved.
The objective of this work is to rewrite two modules of the WebBee information system (Service
and Maintenance modules) as high-level software models. UML class diagrams and a specific domain
specific language (DSL) for business applications were used. This DSL includes capabilities to
describe models for object editors and navigation user interfaces, client applications and user
permission control. Therefore, advantages of the MDE approach, such as automatically creating client
applications for new platforms and making software maintenances easier, can be obtained for
WebBee.
Section 2 provides a WebBee overview, including its system architecture and the Entity-
Relationship (ER) diagram, which describes how data is organized. Section 3 introduces DSLs and
how metamodels are used to describe them. Since WebBee is classified as a business application, a
DSL intended to model this kind of system is also presented, while section 4 presents models of
WebBee used for automatic code generation. Section 5 shows the results and section 6 concludes the
paper.
2. WebBee Information System
WebBee is a web-based information system intended to organize knowledge and to facilitate
sharing information on bees. The system can be accessed on the Internet with a simple web browser
and was implemented in PHP, using MySQL as the relational database server. Besides including data
from bee species and plant species visited by bees, it also includes data automatically collected by data
loggers and weather stations in several experiments regarding thermoregulation and flight activity of
the colonies (Saraiva et al. 2003). Data are stored in different formats such as texts, photos and videos.
Figure 1 shows the system architecture. A data acquisition system collects data from sensors
installed inside the colonies, currently located at the Bee Laboratory of the Biosciences Institute,
University of São Paulo. Some variables collected at each colony are: air temperature, humidity inside
the hive and bee flux at the hive entrance. Together with weather data, the effect of abiotic conditions
on the bees flight activity and on the temperature regulation inside the colonies can be studied. Data
from the acquisition system and from the weather station is sent via Internet to a central MySQL
database server at the Agricultural Automation Laboratory, School of Engineering, University of São
Paulo. An Apache web server running the web-based system, written in PHP, offers web access to
researchers and to the general public (Cunha et al. 2002).
WebBee is composed of three modules: Service Module, Maintenance Module and Web Module.
The Service Module is the core of the system and contains the database. The Maintenance Module is
used by system administrators for data input and the Web Module provides functionalities for the
general users on the Internet. Figure 2 shows an ER diagram presenting an overview of the database
structure. The modelling was based on the needs expressed by the experts in the application domain. It
considers data obtained from different sources in different formats. Information related to species
taxonomy, for example, may include texts and images, while behavioural information may also require
video format (Saraiva et al. 2002).
The main functions of the Maintenance Module, besides providing user authentication to allow
only administrators to access the system, is to provide query mechanisms and
Create/Retrieve/Update/Delete (CRUD) interfaces for system maintenance. CRUD interfaces are
common requirements of business applications, whose requirements are discussed in section 3.1.
EFITA/WCCA/CIGR 2015 Poznan, Poland 29.06 - 02.07.2015
105
Figure 1. WebBee system architecture (Saraiva et al. 2002)
Figure 2. Entity-Relationship diagram of WebBee (Saraiva et al. 2002)
The Web Module provides access to general users, with special emphasis on accessing information
related to bee species and data automatically acquired by the acquisition board and the weather station.
Bee species information is presented in record cards containing images and texts related to each
species. Images cover, for example, different aspects of the body of the queen, of the worker and of
the male. Since the number of bees is very large, information is presented in several pages
dynamically built by PHP scripts. The user can sort the list by popular or scientific name. After
accessing a specific record card, the user can browse several images. Presenting numerical data
acquired from instrumentation is another part of WebBee. The following variables can be selected and
EFITA/WCCA/CIGR 2015 Poznan, Poland 29.06 - 02.07.2015
106
presented as a graph for a period of time, or can be exported to a spreadsheet file: air temperature, air
relative humidity, air pressure, wind speed, rain, solar radiation and ultra-violet radiation.
Due to the importance of WebBee to many research groups, productivity gains in the software
development effort of future maintenances are welcome. The application of MDE approach as a
software engineering strategy is intended to provide the gains mentioned in section 1. However,
adequate models, mapping functions and tools are necessary.
3. Domain Specific Languages and Metamodels
One possible approach to apply MDE is adopting a general-purpose modeling language (GPL),
such as UML, to create models of the intended software system. Standardized mapping functions can
be used to automatically generate source code according to the modeling language semantics. Many
works in the literature provide specific solutions for certain UML diagrams or parts of them.
Gessenharter & Rauscher (2011), for example, presents a way to generate Java code from UML
activity diagrams.
However, although UML is the de facto standard for software modeling, it still depends on natural
language to describe certain models (Marchetti 2012), it presents ambiguities and a large number of
concepts in its diagrams (Pastor & Molina 2010), and it is not complete (Ambler 2004). Research
(Kolovos et al. 2013) indicates that domain specific modeling languages (DSLs), in combination with
GPLs, are better solutions to avoid the pitfalls of one-size-fits-all CASE tools.
Modeling languages are specified by metamodels. In other words, a metamodel is a specific kind of
model intended to describe a modeling language. The basic building blocks of a metamodel are:
metaclasses, properties (Alanen & Porres 2008), enumerations and constraints (Canovas & Cugnasca
2015).
A metaclass represents an abstraction of a modeling concept, in the same way as the classes of an
object-oriented system model represent abstractions of real world or problem domain concepts. In a
UML use case diagram, for example, the concepts of use cases and actors are metaclasses. Metaclasses
have properties such as use case name, use case description, etc. Specific use cases and actors in a
given UML diagram are instances of these metaclasses. Instances of metaclasses are elements of
models (not metamodels), and they carry values for properties. Inheritances are allowed. A metaclass
may have a parent metaclass, and the first one is said to be sub-metaclass of the second one.
Enumerations correspond to the primitive data types of traditional programming languages, such as
string, integer, Boolean, etc.
Every metaclass property is associated to a type, which determines which values instances are
allowed to carry for the property. A type can be a metaclass or an enumeration. The use case name, for
example, is a property whose type is string. Every property has a multiplicity, which specifies how
many values an instance can carry for it. Multiplicity ‘0..*’, for example, denotes that any arbitrary
number of values are accepted (from zero to infinity).
All models conforming to a metamodel must satisfy its constraints. In a UML class diagram, for
example, there cannot be an association disconnected from classes, and this condition is established by
a constraint. Good metamodels are supposed to adequately capture modeling needs, and hence they
must contain metaclasses, properties, enumerations and constraints that allow the modeler user to
precisely represent his/her models of interest. The less ambiguous and the clearer the semantics of
each metaclass, the more precisely the represented concept can be automatically transformed into
source code by model-to-code mapping functions.
As an example, the upper layer of Figure 3 presents a metamodel that describes the abstract syntax
of a modeling language for state machines. It is represented in Meta Object Facility (MOF) notation
(OMG 2014), which is the standard language to represent metamodels defined by the Object
Management Group (OMG). The lower layer is an example of a model conforming to this metamodel.
States S1 and S2 are instances of metaclass State, while transition T1 is an instance of Transition. The
graphic notation in which this state machine is represented corresponds to the concrete syntax
associated to the language, although it is not specified by its metamodel.
EFITA/WCCA/CIGR 2015 Poznan, Poland 29.06 - 02.07.2015
107
This metamodel contains an enumeration called String. It represents the usual string data type, and
is used as the type of properties Name in both metaclasses. S1 carries the content “S1” for this
property, while S2 carries “S2” and T1 carries “T1”. Source and Destination are also properties of
Transition. Since their type is a metaclass, they are represented by arrows pointing to the
corresponding type. Multiplicities 1 indicate that each instance of Transition must have exactly one
source and one destination.
Figure 3. Example of a metamodel for state machines and a specific state machine model
3.1. Common Characteristics and Requirements of Business Applications
DSLs are supposed to address specific modeling domains. WebBee can be classified into a
category of systems called business applications. This kind of application presents the following
common characteristics and requirements:
Persistent Objects. A business object is an instance of a class that models a concept of the
domain. A persistent object is an object (e.g. a customer object) that is saved to permanent storage
(usually a relational database) for later retrieval. Persistent objects are of extreme importance for
business applications, otherwise the application should run forever to avoid losing user data stored in
the memory. Persistent classes are the types of persistent objects. Although object persistence is an
important requirement, current object-oriented programming languages (e.g. Java, C#) do not have
native mechanisms to persist objects. A persistence layer can be included in the application. This layer
is responsible for transparently storing, retrieving and deleting objects in a persistence mechanism,
usually a relational database (Ambler 2005).
Object Navigation User Interfaces. This kind of user interface allows the user to somehow
navigate through persistent objects (e.g. in lists showing the main attributes divided by pages) and
execute operations on them. There are five basic operations that can be performed on persistent objects
regarding their classes: create, retrieve, update, delete and query. They correspond to the CRUD
interfaces mentioned in Section 2.
Data Input User Interfaces. Persistent objects carry data according to the attributes defined
at their persistent classes. In many cases the business application user must be able to edit values of
attributes in existing or just created persistent objects (e.g. edit the street address of a customer object).
This kind of user interface addresses this requirement.
Data Export and Import. Business applications are hardly never alone in the context of
organizations. They must somehow interact with other applications, internal or external to the
organization. File-based data export and import (e.g. Excel files, XML, etc.) is a simple and effective
way to allow a certain level of integration.
Reports. Reports aggregate existing data (carried by persistent objects) and can include
calculated information (e.g. sums, averages, max, min, etc.). They also may include graphs or images,
not only text.
Client Applications. Considering the variety of the existing computing platforms, a business
application should to provide more than one kind of access. An important architecture in the business
applications world is the three-tier architecture. The application is divided into three layers:
presentation, business and data storage. The presentation layer is responsible for providing user
interfaces and, therefore, interaction with the user. A mobile application providing access to WebBee
data on the server, for example, is a client application.
EFITA/WCCA/CIGR 2015 Poznan, Poland 29.06 - 02.07.2015
108
Business Processes. A business process is a collection of related and structured activities in a
business context. The order in which things are done and the conditions under which they are done are
fundamental parts of any business process (Grahan 2006). An example is the business process of
making a sale. A prescribed order for the activities that make up a sale is needed (e.g. invoice, pay and
deliver). Parallelism is also allowed for the activities that make up the business process. Business
applications use business objects and business rules to run business processes.
3.2. A DSL for Business Applications
At this point, the reasons for choosing a DSL and not pure UML should be clear. Besides DSLs
provide abstractions closer to the modelling needs, UML code generators are usually able to generate
code for class diagrams or state chart diagrams, yet discarding any information provided by use case
diagrams or timing diagrams. It does not necessarily mean that such tools should be blamed for not
covering all aspects of UML. Discarded information is just useless within the perspective of the intent
of the tools (Fondement et al. 2013).
Some DSLs for business applications such as ActionGUI (ActionGui 2015) and WebML (WebML
2015) are available. They embbed concepts of UML, which is a GPL, to provide more specific
elements for creating business applications using the MDE approach. This section presents a simple
DSL for business applications defined by the merging of five metamodels. It also embedds concepts of
UML class diagrams, using benefits of this well established GPL.
Class Metamodel. The first metamodel is basically the class diagram of UML. It was created
to express abstractions of real world objects (concrete or abstract) and it is the main base of object-
oriented technology. It describes the static structure of the application and has advanced tool support.
The predominant elements of structural models are classes and relationships between classes, most
often generalizations and associations (Gessenharter & Rauscher 2011). Classes have properties and
operations. In this metamodel, just a subset of the core elements of UML 2 class diagram was taken.
Some modifications were made to apply more constraints aiming at automatically generating source
code. This strategy is not new in MDE approach. Some initiatives for executable UML such as xUML
and fUML (OMG 2012) are trying to simplify the number of concepts found in UML metamodels and
remove semantic ambiguities. The MOF-based class metamodel can be seen in Figure 4.
Data Form Metamodel. This metamodel provides elements to model data input user
interfaces, as described in section 3.1. A data form is defined as a user interface, independently of any
concrete implementation, which provides means to edit an object properties. Metaclass DataForm
models the concept of a data form, and this metamodel is presented in Figure 5. A data form has
widgets. Widgets are graphic components such as edit boxes and check boxes that work as editors of
property values.
Object Navigation Form Metamodel. This metamodel provides elements to model object
navigation user interfaces, as described in section 3.1 and shown in Figure 6. An object navigation
form is assumed to show persistent objects in a list or a grid. Each navigation form is associated to a
class, and that determines which persistent objects must be shown. Objects of subclasses can also be
displayed if the property ShowInstancesOfSubClasses is True. Columns of this grid contain the values
of the persistent objects properties, and they are represented by instances of concrete sub-metaclasses
of NavigationFormColumn. Each column is associated to a property and specifies a presentation label
to be mapped to the title of the column in a corresponding generated user interface.
Client Application Metamodel. This metamodel is presented in Figure 7 and provides
elements to model client applications, which are, for the purposes of this work, basically composed of
a two-level hierarchy of menus. Each menu item is associated to one navigation form. This form is
displayed when the user accesses the corresponding menu, and then he/she can navigate through
persistent objects and create, delete or update them.
Permission Metamodel. This metamodel includes capabilities to model user permission
access for previous interfaces. It is composed of only one metaclass, according to Figure 8. Each
instance of it in the system model represents a permission to be configured for each user, and it is
used for code generation of the Maintenance Module.
EFITA/WCCA/CIGR 2015 Poznan, Poland 29.06 - 02.07.2015
109
Figure 4. Class metamodel for the business application DSL
Figure 5. Data Form metamodel for the business application DSL
Figure 6. Object navigation metamodel for the business application DSL
EFITA/WCCA/CIGR 2015 Poznan, Poland 29.06 - 02.07.2015
110
Figure 7. Client application metamodel for the business application DSL
Figure 8. Permission metamodel for the business application DSL
If mapping functions for many platforms are available, such as desktop operating systems, mobile
devices and web, then many versions of the same application can be generated from the same models,
and this is the core concept of the MDE approach. The closer the metamodels are to the modeling
needs, the more complete mapping functions can potentially be, avoiding several manual interventions
in the source code by the programmer.
4. Applying MDE
After presenting metamodels for a business application DSL, this section presents models of
WebBee conforming to them. Then, transformations are applied to generate the intended application.
4.1. WebBee Models
The first model is a class diagram conforming to the metamodel from Figure 4. It is shown in
Figure 9 using the usual notation of the UML class diagram. Only class names are displayed to save
space and to focus on how information is structured. All classes are persistent, which means that they
carry the value True for the Persistent property. This model reflects the original ER diagram from
Figure 2 with some adaptations. Since the metamodel does not allow many-to-many associations,
intermediate association classes such as BeePlant and ProjectResearcher were created to implement
them.
A model describing data forms is also part of the set of WebBee models. Figure 10 shows part of
this model, using object notation, describing a data form with widgets used to edit project instances.
This model includes specialized widgets for editing the name of the project, its description, start date
and end date. It also includes detail grids for researchers, equipment, colonies and bee species related
to the project. Each grid has one column.
Part of the navigation form model corresponding to the Project class is presented in Figure 11.
Navigation form NavFormProject has three exhibition columns: NFProject_Name,
NFProject_StartDate (which is the default column to order by) and NFProject_EndDate. It is
associated to NavFormProject_Permission, instance of metaclass Permission from the permission
metamodel. It represents the fact that the user administrator must be able to configure five permissions
for this navigation form: view, list (generate report), insert, edit and delete. Other data forms and
navigation forms are not shown herein due to lack of space, but they are analogous to the ones
presented.
WebBee Maintenance Module can be viewed as a client application that provides CRUD
functionalities for the persistent classes of Figure 9. Its model, conforming to the metamodel presented
EFITA/WCCA/CIGR 2015 Poznan, Poland 29.06 - 02.07.2015
111
in Figure 7, describes menus and references navigation forms. The simplified diagram, showing only
the project navigation form and its respective menu item, is presented in Figure 12.
Figure 9. WebBee class model
Figure 10. WebBee data form model for Project class
Figure 11. WebBee navigation form model for Project class
EFITA/WCCA/CIGR 2015 Poznan, Poland 29.06 - 02.07.2015
112
Figure 12. WebBee client application form model for Maintenance Module
4.2. The Generated Application
Model-to-code transformations are responsible for generating source code from models. They are
described by model-to-code mapping functions. MOFM2T (OMG 2008) is the language standard
language from OMG to define this kind of function. SBMMTool (Canovas & Cugnasca 2015) is a
meta-CASE tool. This kind of software is capable of generating or behaving as a customized CASE
tool by providing metamodels to them. By inserting the metamodels described in section 3.2, we were
able to use the SBMMTool to create the software models presented in section 4.1. Moreover, this tool
provides an embedded and simplified MOFM2T interpreter. With the existing model-to-code mapping
functions, it was possible to generate a client application for WebBee Maintenance Module in Free
Pascal language, which can be compiled for Windows and Mac desktop environments using Lazarus
IDE.
The first part of the generated code is a script file with data definition instructions such as CREATE
TABLE to create the relational database that serves as the persistence mechanism of the application. It
represents the Service Module described in section 2. Ambler (2005) provides more details about
mapping class diagrams to relational databases.
Then, the code to implement a main form for Maintenance Module client application is generated
with its respective menus and links to navigation forms. Navigation forms call their respective data
forms to provide inserting and editing functionality, while visualization and deletion are implemented
by themselves. A permission editor is automatically generated inside the module based on the
instances of Permission metaclass.
Figure 13. Screen shots of the generated client application
Figure 13 shows two screenshots. The first one is the client application with NavFormProject
loaded after the user has clicked on the CAMaintenance_NFProjectMenuItem menu, whose
EFITA/WCCA/CIGR 2015 Poznan, Poland 29.06 - 02.07.2015
113
presentation label is “Studies/Projects” in the form. The mapping functions generate a toolbar for each
navigation form, also providing functionalities to print a report and to export contents to Excel besides
CRUD. It addresses more usual requirements of business applications without the need to manually
write any source code. The second one is the rendered data form NavFormProject, showing fields
according to the model of Figure 10. It is shown when the user double-clicks on a project or inserts a
new one.
5. Results and Discussion
The WebBee Service Module and the Maintenance Module were recreated using the MDE
approach. It required the construction of models to apply them to a transformation that automatically
generates source code. Research (Kolovos et al. 2013) indicates that MDE goals can be better
achieved by the use of combinations of GPLs and DSLs according to the type of the application to be
generated. Adequate DSLs allow the modeller to describe the concepts of interest in an adequate level
of abstraction, and also allow the creation of mapping functions that capture their intended semantics.
Since the WebBee Maintenance Module is predominantly composed of CRUD interfaces and the
DSL used captures this concept very well, then most of the application could be automatically
generated. However, concepts not captured by this DSL such as graphic widgets and video widgets for
inserting and displaying videos on a data form (which is a requirement for this application) could not
be generated. The MDE approach also allows manual code insertion in the generated source code files.
MOFM2T allows defining protected areas in the generated code. After the first code generation, i.e.,
after the first execution of the transformation, code manually inserted by the programmer in these
sections is preserved.
With MDE, many future maintenances of the system can be conducted by changes in models and
automatic regeneration of the source code, providing the effort reduction gain proposed by this
approach. The reduction in testing effort is also another gain. If the mapping functions used are
supposed to be correct, then all the source code generated by transformations, in principle, does not
need to be tested. Other tests, such as performance tests, could be necessary in specific cases.
The relational database automatically generated from the class diagram does not match the
structure of the original one. Differences in rules to define table and field names and field types are the
causes. Hence, the application automatically generated is not directly compatible with the original one.
Data migration must be performed before updating the production environment.
Model notation is also another important topic to be discussed. The class model presented in Figure
9 uses the usual UML class diagram notation. However, a metamodel only defines an abstract syntax
for a DSL. Concrete syntaxes are externally defined. We used the UML object diagram notation for
the other models, considering that the objects in this case are actually instances of metaclasses and not
instances of classes in runtime. It addresses our purposes, but specific concrete syntaxes are usually
more convenient. The state machine of Figure 3, for example, is presented using a concrete syntax for
this kind of model, and not using object diagrams.
6. Conclusion
MDE is considered to be the latest paradigm shift in software engineering (Kolovos et al. 2013).
Although the benefits proposed by this approach are significant, they can be achieved only by
adequate DSLs and specific mapping functions in many cases. If they are not available, creating or
extending a DSL and writing mapping functions may be more complex than directly writing the
application. However, if the application to be developed must evolve constantly or many applications
of the same type must be constructed, then this option should be considered. Moreover, existing
models can be applied as inputs to future mapping functions to generate the same application for new
platforms, preserving the investment of the original software development artifacts.
As future work, we are creating mapping functions to generate Java source code for Android and
the Maintenance Module will then be able to be ported to this mobile platform too, using the same
original models as development artifacts.
EFITA/WCCA/CIGR 2015 Poznan, Poland 29.06 - 02.07.2015
114
Acknowledgements
The authors would like to thank Etienne Cartolano, Tereza Cristina Giannini and Professor Antônio
Mauro Saraiva, all of them from University of São Paulo, Brazil, for providing help and information
about the current implementation of the WebBee Information System.
References
1. Yang, D, Liu, M & Wang, S 2012, ‘Object-Oriented Methodology Meets MDA Software
Paradigm’, in IEEE 3rd International Conference on Software Engineering and Service Science
(ICSESS), IEEE, pp. 208-211.
2. Kolovos, DS, Rose, LM, Matgragkas, N, Paige, R, Guerra, E, Cuadrado, JS, de Lara, J, Varró, D,
Tisi, M & Cabot, J 2013, ‘A Research Roadmap Towards Achieving Scalability in Model Driven
Engineering’, in Proceedings of the Workshop on Scalability in Model Driven Engineering, pp. 2.
3. Marchetti, GA 2012, Um método de transformação de modelos UML para a inclusão de
componentes de frameworks com o uso de planejador lógico, University of São Paulo.
4. Pastor, O & Molina, JC 2010, Model-driven architecture in practice: a software production
environment based on conceptual modeling, Springer-Verlag, New York.
5. Ambler, S 2004, The Object Primer: Agile Modeling-Driven Development with UML 2.0,
Cambridge University Press, New York.
6. Reed, B 2013, It’s not Windows’ world anymore. 18 July 2013. Brad Reed: Blog. Available from:
<http://bgr.com/2013/07/18/windows-computing-platform-market-share-analysis>. [6 May 2015].
7. Cunha, RS, Saraiva, AM, Cugnasca, CE, Hirakawa, AR & Hilário, SD 2002, ‘WebBee a web-
based information system for research on stingless bees.’, in Proceedings of the World Conference
of Computers In Agriculture and Natural Resources, ASAE / SBIAgro, pp. 676-678.
8. Canovas, SRM & Cugnasca, CE 2015, ‘Em Direção ao Desenvolvimento de Programas
Adaptativos Utilizando MDE’, in Memórias do Novo Workshop de Tecnologias Adaptativas, pp.
29-39, University of São Paulo, Brazil.
9. Alanen, M & Porres, I 2008, ‘A metamodeling language supporting subset and union properties’,
in Software & Systems Modeling, Vol. 7, No. 1, pp. 103-124.
10. Papotti, P, Prado, AF, Souza, WL, Cirilo, CE, Pires, LF 2013, ‘A Quantitative Analysis of Model-
Driven Code Generation through Software Experimentation’, in Advanced Information Systems
Engineering, Springer, pp. 321-327.
11. Gessenharter, D, Rauscher, M 2011, ‘Code Generation for UML 2 Activity Diagrams’, in
Proceedings of the European Conference of Modeling Foundations and Applications, Springer,
pp. 205-220.
12. Ambler, S 2005, The Design of a Robust Persistence Layer for Relational Databases. Available
from: < http://www.ambysoft.com/downloads/persistenceLayer.pdf>. [24 May 2015].
13. Grahan, I 2006, Business Rules Management and Service Oriented Architecture, Wiley,
Chichester.
14. ActionGui 2015, ActionGUI: Secure Business Application Development. Available from:
<http://www.actiongui.org>. [24 May 2015].
15. WebML 2015, WebML: The Web Modeling Language. Available from: <http://www.webml.org>.
[24 May 2015].
16. Saraiva, AM, Imperatriz-Fonseca, VL, Cunha, RS & Cartolano-Júnior, EA 2003, ‘WebBee a
Web-based Information Network on Bees’, Revista de Engenharia de Computação e Sistemas
Digitais, vol. 1., no. 1, pp. 77-86.
17. OMG 2014, Meta Object Facility (MOF) Core Specification, formal/2014-04-03. Available from:
Object Management Group. [3 April 2014].
18. Fondement, F, Muller, PA, Thiry, L, Wittmann, B, Forestier, G 2013, ‘Big metamodels are evil’,
in Model-Driven Engineering Languages and Systems, pp. 138-153.
19. OMG 2012, Semantics of a Foundational Subset for Executable UML Models (fUML) v1.0,
ptc/2012-10-08. Available from: Object Management Group [8 October 2012].
20. OMG 2008, MOF Model to Text Transformation Language v1.0, formal/2008-01-16. Available
from: Object Management Group. [16 January 2008].
... Existem, por exemplo, metamodelos que especificam a UML. Eles determinam as abstrações e conceitos que podem ser instanciados em seus modelos, bem como as restrições aplicáveis [11]. Em um diagrama de classes UML, como exemplo de restrição, não pode haver uma associação desconectada de classes. ...
... Não consideramos essa classificação muito precisa para determinar modelos executáveis. Observemos um exemplo de modelo que descreve uma interface de usuário do tipo Create/Retrieve/Update/Delete (CRUD) para objetos persistentes em aplicativos de negócio [11]. O metamodelo correspondente define uma DSML que prevê apenas elementos estruturais da interface de usuário, podendo seus modelos serem classificados como modelos de produto. ...
Conference Paper
Full-text available
Model Driven Engineering (MDE) é uma abordagem para desenvolvimento de software em que modelos são artefatos fundamentais a serem construídos e manipulados, podendo gerar código-fonte automaticamente. Uma das possibilidades é a execução direta de modelos, e para isso caracterizam-se linguagens de modelagem interpretáveis. Recentemente, surgiu o conceito de modelos adaptativos, que são modelos executáveis com capacidade de passar por alterações estruturais durante sua execução através de autorresposta a estímulos externos. Este trabalho apresenta um mapeamento de tais modelos para uma formulação geral de dispositivos adaptativos guiados por regras encontrada na literatura. Como estratégia, um padrão de projeto de linguagens de modelagem executáveis é utilizado e estendido para incluir conceitos de adaptatividade. Algumas outras restrições são adicionadas aos modelos para que se possa identificar de forma geral todos os elementos necessários para mapeá-los. Com isso, modelos adaptativos são colocados no contexo geral da área de adaptatividade, aproveitando-se as teorias subjacentes já existentes.
Conference Paper
Full-text available
While reuse is typically considered a good practice, it may also lead to keeping irrelevant concerns in derived elements. For instance, new metamodels are usually built upon existing metamodels using additive techniques such as profiling and package merge. With such additive techniques, new metamodels tend to become bigger and bigger, which leads to harmful overheads of complexity for both tool builders and users. In this paper, we introduce ≪ package unmerge≫ - a proposal for a subtractive relation between packages - which complements existing metamodel-extension techniques.
Conference Paper
Full-text available
Model Driven Engineering (MDE) é uma abordagem para desenvolvimento de software baseada na transformação de modelos de alto nível, tais como diagramas UML, até a geração automática do código-fonte em uma linguagem alvo. Set Based Meta Modeling (SBMM) é um formalismo que permite descrever metamodelos, os quais consistem em um tipo específico de modelos para descrever linguagens de modelagem de software tais como a UML. Este trabalho apresenta um metamodelo para programas adaptativos, definido em SBMM, que estende um metamodelo anterior encontrado na literatura pela adição de restrições. Esta especificação formal de metamodelo é introduzida no software SBMMTool juntamente com uma função de mapeamento para geração de código, que passa então a funcionar como uma ferramenta CASE para edição de modelos de programas adaptativos e abre caminho em direção à aplicação da MDE nesta área.
Article
Full-text available
There is a growing awareness on the importance of the world's biodiversity and on its fast decline due to many factors, including human activities. Among the huge number of animal and plant species on Earth, it is estimated that only 10% are known and this is one of the main obstacles for developing conservation programs. In order to increase the knowledge and understanding of that diversity, there is a worldwide effort for digitizing and integrating the information already available but geographically disperse, which will eventually result in an electronic Catalogue of Life, accessible on the Internet. Many pollinators, including bees, are among those threatened species and their decline is especially dangerous as they are crucial for maintaining global biodiversity and for crop production. This paper presents a Web-based information system that was developed to organize knowledge and facilitate sharing of information on bees. It is aimed at different audiences, from researchers to basic level students, from policy-makers to beekeepers, who need high quality information on bees. A database is a central part of the system, storing data from different investigations conducted by a network of researchers and research groups. That includes data from bee species, plant species visited by the bees, and a great deal of other information on their behavior and characteristics. It also includes data collected automatically by data loggers and by a weather station in several experiments on thermoregulation and flight activity of the colonies. Data is stored in different formats such as texts, photos and videos. The system can be accessed on the Internet with a simple Web browser and was implemented with a MySQL DBMS, Apache Web server and PHP scripts. Developed initially to hold the information from one research group, it was afterwards proposed as a platform for the integration of the information of different groups, forming an information network. Currently groups from other countries are willing to use it as their platform, configuring it as an international portal on bees.
Conference Paper
As software are becoming more and more complex and platforms are increasing of diversity, software industry has faced some unprecedented challenges, such as interoperability. It is difficult to use objected-oriented methodology and traditional software paradigms to meet the challenges. Model Driven Architecture (MDA) has been proposed to solve the problems. In this paper, the principles, the advantages, the disadvantages, key techniques and some important issues of objected-oriented methodology and MDA are highlighted; the mechanism of combining objected-oriented methodology and MDA software paradigm is studied, especially the corresponding relations among models, domains, stages and languages are explored, and a modeling process for MDA is proposed. The research is helpful to apply MDA.
Conference Paper
As Model-Driven Engineering (MDE) is increasingly applied to larger and more complex systems, the current generation of modelling and model management technologies are being pushed to their limits in terms of capacity and efficiency. Additional research and development is imperative in order to enable MDE to remain relevant with industrial practice and to continue delivering its widely recognised productivity, quality, and maintainability benefits. Achieving scalability in modelling and MDE involves being able to construct large models and domain-specific languages in a systematic manner, enabling teams of modellers to construct and refine large models in a collaborative manner, advancing the state of the art in model querying and transformations tools so that they can cope with large models (of the scale of millions of model elements), and providing an infrastructure for efficient storage, indexing and retrieval of large models. This paper attempts to provide a research roadmap for these aspects of scalability in MDE and outline directions for work in this emerging research area.
Conference Paper
Recent research results have shown that Model-Driven Development (MDD) is a beneficial approach to develop software systems. The reduction of development time enabled by code generation mechanisms is often acknowledged as an important benefit to be further explored. This paper reports on an experiment in which an MDD-based approach using code generation from models is compared with manual coding based on the classic life-cycle. In this experiment, groups of senior students from Computer Science and Computer Engineering undergraduate academic programs implemented a web application using both approaches, and we evaluated in quantitative terms the performance of the groups. The results showed that the development time when code generation was applied was consistently shorter than otherwise. The participants also indicated that they found less difficulties when applying code generation.
Conference Paper
Modeling static structure and modeling behavior are often regarded as two distinct topics, however, in UML they are not. They are even tightly coupled as can be seen e.g. by looking at attributes: That an attribute holds values at runtime is defined within the Classes language unit whereas the act of setting or getting a concrete value of an attribute is defined in the Actions language unit. Tool support for modeling static structure is far more advanced than for modeling behavior. In particular, further model processing for activities like transformations or code generation is in a rudimentary stage. In this paper, we present an approach for code generation for activities preceded by model transformations. Besides advancing model-driven development to properly include behavior, our contribution also enhances structural modeling by providing generation of code for accessing structural features based on the UML semantics of Actions.