Available online at www.sciencedirect.

com
Available online at www.sciencedirect.com
ScienceDirect
ScienceDirect
Procedia online
Available Computer
at Science 00 (2021) 000–000
www.sciencedirect.com
Procedia Computer Science 00 (2021) 000–000 www.elsevier.com/locate/procedia
www.elsevier.com/locate/procedia
ScienceDirect
Procedia Computer Science 184 (2021) 797–802

The 2nd International Workshop on the Advancements Model Driven Engineering (AMDE)
The 2nd International Workshop
Marchon the Advancements
23-26, 2021, Warsaw,Model
PolandDriven Engineering (AMDE)
March 23-26, 2021, Warsaw, Poland
Towards an automatic model-based Scrum Methodology
Towards an automatic model-based Scrum Methodology
Salima CHANTITa,a,*, Imane ESSEBAAaa
Salima CHANTIT *, Imane ESSEBAA
a
Computer Science Laboratory of Mohammedia, Hassan II University of Casablanca, Morocco
a
Computer Science Laboratory of Mohammedia, Hassan II University of Casablanca, Morocco

Abstract
Abstract
Software systems evolve continuously and must be developed quickly to fit user requirements and new advances in technology.
Software
This has ledsystems evolve engineering
the software continuouslytoand must several
propose be developed
methods quickly to fit user requirements
and approaches to overcome theanddevelopment
new advancesandinmaintenance
technology.
This has software
of these led the software
systems.engineering to propose
In this regard, several methods
Agile Methodologies and
and approaches toEngineering
Model-Driven overcome the development
(MDE) and maintenance
are two main approaches
of
thatthese
havesoftware
emergedsystems.
in recentInyears
this and
regard, Agile
suggest Methodologies
a solution to someand Model-Driven
of the Engineering
issues associated (MDE) systems
with Software are two developments.
main approaches
that
MDEhave emerged
focuses in recentreuse
on software years through
and suggest a solution
models and ontogenerative
some of the issues associated
approaches based on with Softwareofsystems
separation developments.
concerns whereas Agile
MDE
Methods focuses on software
promote the use ofreuse through
simpler models
models and practices
and best on generative approaches based
for programming on separation
to achieve of concerns
quick feedback whereas
from clients Agilea
within
Methods
development promote the use
process. of simpler
However, thesemodels and best practices
two approaches for programming
have evolved to achieve
separately and quick
there are onlyfeedback from clients
a few works related within
to theira
development
combination. process. However, these two approaches have evolved separately and there are only a few works related to their
combination.
This paper presents a customized V development life cycle based on models which combines the two MDE variants: The MDA
This paperinpresents
approach the V lefta customized
branch with V development life cycle
the MBT approach to based on models
generate tests of which
the V combines the two
right branch. MDE variants:
In addition, The MDA
we integrate this
approach
customizedinVthe lifeVcycle
left branch withScrum
in the agile the MBT approachtotofacilitate
methodology generatethetests of the V right
management branch.
of each ScrumInsprint.
addition, we integrate this
customized V life cycle in the agile Scrum methodology to facilitate the management of each Scrum sprint.
© 2021 The Authors. Published by Elsevier B.V.
© 2021
© 2021 TheThe Authors.
Authors. Published
Published byby Elsevier
Elsevier B.V.
B.V.
This is an open access article under the CC BY-NC-ND license (http://creativecommons.org/licenses/by-nc-nd/4.0/)
This is an open access article under the CC BY-NC-ND license (http://creativecommons.org/licenses/by-nc-nd/4.0/)
This is an open
Peer-review underaccess article under
responsibility theConference
ofthe
the CC BY-NC-ND license
Program (http://creativecommons.org/licenses/by-nc-nd/4.0/)
Chairs.
Peer-review under responsibility of Conference Program Chairs.
Peer-review under responsibility of the Conference Program Chairs.
Keywords: Model Driven Engineering; Model Driven Architecture; Model-Based Testing; Agile Methodologies; Scrum; V development Life
Keywords: Model Driven Engineering; Model Driven Architecture; Model-Based Testing; Agile Methodologies; Scrum; V development Life
Cycle.
Cycle.

1. Introduction
1. Introduction
Software development evolves rapidly and becomes more and more important in different application areas,
Software
which development
requires evolves
the acceleration rapidly
of the and becomes
development cycle,more andas more
as well important ofinall
the integration different application
stakeholders in this areas,
cycle
which requires the acceleration of the development cycle, as well as the integration of all stakeholders in this cycle

* Corresponding author.
* E-mail
Corresponding salima.chantit@fstm.ac.ma
address:author.
E-mail address: salima.chantit@fstm.ac.ma
1877-0509 © 2021 The Authors. Published by Elsevier B.V.
1877-0509 © 2021
This is an open Thearticle
access Authors. Published
under by Elsevier B.V.
the CC BY-NC-ND license (http://creativecommons.org/licenses/by-nc-nd/4.0/)
Peer-review
This under
is an open responsibility
access of the Conference
article under CC BY-NC-NDProgram Chairs.
license (http://creativecommons.org/licenses/by-nc-nd/4.0/)
Peer-review under responsibility of the Conference Program Chairs.

1877-0509 © 2021 The Authors. Published by Elsevier B.V.

This is an open access article under the CC BY-NC-ND license (http://creativecommons.org/licenses/by-nc-nd/4.0/)
Peer-review under responsibility of the Conference Program Chairs.
10.1016/j.procs.2021.03.099
798 Salima Chantit et al. / Procedia Computer Science 184 (2021) 797–802
2 Author name/ Procedia Computer Science 00 (2018) 000–000

for an agile management of the developed system needs. The treatment and resolution of this issue is considered an
important research question, for which two main paradigms have been proposed: Agile Methodologies and Model
Driven Engineering.
Agile Methodologies focus on best programming practices and their integration into the development process.
They are approaches that define the disciplined management of software development: agility recommends the use
of an iterative and incremental method to develop software systems that truly meet customer needs.
In addition, the second paradigm that aims to address this research question is MDE (Model Driven Engineering).
MDE is defined as a paradigm based on the use of models throughout the development lifecycle of an application,
from the analysis and design of the system to be developed, to code and testing. To do this, the MDE is based on all
of its variants for which models are the heart of these approaches, namely the MDA where models describe the
system in three different levels of abstraction before the generation of source code and the MBT (Model-Based
Testing) which objective is to automatically generate test cases from these models.
Existing research shows that both paradigms, Agile Methods and Model Driven Engineering, aim to manage
more easily the evolution and frequent changes of requirements. Indeed, Agile Methods focus on the methodological
aspect that defines the system development and testing process, while MDE is more focused on the architectural
aspect and aims at automating model transformations in order to ensure traceability and completeness between the
different levels of system design.
A variety of works has been carried out in these two areas, allowing their improvements, but separately. Indeed,
little research has focused on how to combine MDE and agility.
It is in this context that our approach, which aims to improve software development processes, is included. This
approach focuses on combining the two main variants of Model Driven Engineering (MDA and MBT) in a V
development life cycle to perform the sprints of the agile Scrum methodology.
This paper is organized as follows; the second section summarizes the concepts elaborated in this paper. In the
third section, some previous works made in this context were presented and discussed. The following section
(Section 4) overviews our proposed approach. Finally, the paper is finished by a conclusion and some of our future
works.

2. Backgrounds concepts

2.1. Model Driven Engineering

2.1.1. Model Driven Architecture

The MDA (Model Driven Architecture) is an initiative of the OMG (Object Management Group) released in 2000
[1] . The basic idea of the MDA approach is the separation of the functional system specifications and its
implementation on a particular platform. This approach lies in the context of Model Driven Engineering which
involves the use of models and meta-models in the different phases of lifecycle development. MDA defines three
viewpoints: CIM (Computation Independent Model), PIM (Platform Independent Model) and PSM (Platform
Specific Model). The transition from one level to another is realized by applying transformations to source elements,
to generate target elements. There are two types of model transformations that are used in this context: Model to
Model transformation (M2M) are used to move from CIM to PIM, and from PIM to PSM and the second type is
Model to Text (M2T) which is used for the generation of source code from PSM (PSM to Code).

2.1.2. Model-Based Testing

Testing a system is an activity performed to identify software problems and failures in order to improve the
quality of a program. The Model-Based Testing (MBT) is a variant of test techniques that are based on explicit
behavior models, describing the expected behaviors of the System Under Test (SUT), or the behavior of its
environment that are built from functional requirements. The MBT is an evolutionary approach that aims to generate
automatically from models, test cases to apply on the SUT [2] .
 Salima Chantit et al. / Procedia Computer Science 184 (2021) 797–802 799
Author name / Procedia Computer Science 00 (2018) 000–000 3

2.2. Agile Methodologies

The "Agile Manifesto" published in February 2001 [3] based on analysis of previous experiences that allow to
propose good practices to developers. The agile principle introduced by the agile manifesto is related to time
invested in analysis and design [4] .
Agility, a paradigm for a new vision of an organization, asserts itself as an alignment and coherence tool between
internal forces and external challenges that give dynamism to an enterprise [5] .
Agile methodology is a loom to project management, classically used in software development. It helps teams
respond to the changeability of building software through incremental, iterative work cadences, known as sprints.
Agile methods are methodologies essentially dedicated to the management of IT projects. They are based on
adaptive and iterative development cycles depending on the evolving needs of the client. There are several agile
methods for the management of the IT project in its various phases of development. In this work, the researchers
focus on Scrum methodology.

3. Related works
Being aware of the importance of Model Driven Engineering with its both variant MDA and MBT, agile
methodologies and development lifecycles, many works were made on these domains in order to improve
development process taking into account managing system changes. However, it is noted that these domains evolve
separately and their combination was discussed in few works that are presented in the following of this section.
V.Kulkarni and al. discuss and argue in their paper [6] why agile methodology can't be used with Model Driven
Engineering, then they propose a modification to make on agile methodologies in order to combine them with MDE.
Indeed, this paper describes a new Software Development process that combines Scrum and MDE. In this approach
authors proposed the use of Meta Sprints that run in parallel to Sprints in order to validate models, they suggest two
to three months as timescales for meta sprints where clients must provide feedback on models and prototyping,
which is opposite to agility principles. As a matter of fact, that agility recommends that the feedback of clients must
be in period less than what was proposed in this approach.
H.Alfraihi in his paper [7] analyses the challenge of combining Agility and Model Driven Development. The
paper describes an approach that aims to increase the adaptability of these domains by proposing a framework that
facilitates Agility and MDD. This approach proposes recommendations, guidelines, and procedure in order to use
Agile MDD in practice. However, even if this approach proposes some practices to implement the Agile MDD but it
does not take account of the architecture of the MDD, Model Driven Architecture, and how to benefit from the
different abstraction levels to produce sustainable software systems.
In their paper [8] , V.Mahé and al. present their first reflections about the fusion of the MDA and Agility in order
to have a combination with improved properties than the additions of the two approaches, they propose a canvas
based on processes and agile practices in both modelling and meta-modelling level.

4. Proposed Approach
The definition of our approach is divided into three main parts: The first one is to automate the transformations
between all levels of abstraction of the MDA approach; from CIM to PIM, then from PIM to PSM up to code
generation. This step is implemented in our approach and plugin entitled MoDAr-WA, that we previously presented
in our paper [9] .
The second part consists in combining the two variants MDA and MBT in a V cycle to generate the different
types of test cases (UT: Unit Test, IT: Integration Test and VT: Validation Test) according to the levels of
abstraction of the MDA, and to manage the changes and make the necessary corrections at the corresponding level.
The approach of generating different test cases from models is presented and detailed through several case studies
in our previous papers [10] [11] .
The third and last step consists in integrating this new version of the V cycle into the Scrum methodology sprints,
and managing the automatic transition from one sprint to another while taking into account the evolution of the
system's needs.
800 Salima Chantit et al. / Procedia Computer Science 184 (2021) 797–802
4 Author name/ Procedia Computer Science 00 (2018) 000–000

In this section we focus on presenting the new version of the V development life cycle and its integration in each
sprint of Scrum agile methodology.
4.1. Customized model-based V development life cycle
In order to take into consideration all of the key steps in the creation of the system to be developed (from analysis
to development and testing), we aim in the second stage of our approach to combine the two model-based
approaches, source code generation and testing, in a V cycle.
This step consists mainly in covering the left branch of the V cycle with the MDA approach we have proposed for
source code generation and the right branch with the proposed MBT test generation approach.

Fig. 1: Combination of the MDA and MBT paradigms in the V-cycle

As shown in Fig 1, there are several steps of this customized V cycle that are as follows:
 (1) The specification of the functional requirements: The functional requirements expressed using the
SBVR at the CIM level cover the functional requirements specification step of cycle V. From this CIM
level, two different transformations allow to:
o (1.1) Generate the PIM level using Model-to-Model transformations;
o (1.2) Generate the Validation Tests to validate the functional needs expressed at the CIM level;
 (2) High-level design: This step is covered by the PIM level, generated from the CIM of step (1). From the
models of the obtained CIM, two distinct transformations will allow to:
o (2.1) Generate the PSM level in conformity with the proposed MoDAr-WA approach;
o (2.2) Generate the Integration Tests;
 (3) Low-level design: The SHP generated from the MIP of the previous step covers the low-level design
step and from this SHP we will apply a set of transformations for:
o (3.1) Generate the system source code;
o (3.2) Generate the Unit Tests;
 (4) Generating the source code from the PSM.
 (5) Execution of the Unit Tests and analysis of the results of these tests:
o (5.1) In the event of errors, the return will be made to the PSM level to make the necessary
corrections. Step "3.1" as well as the following steps will then be re-executed;
o (5.2) If there are no errors, we will then move on to the next step which consists of the
implementation of the Integration Tests;
 (6) The execution of the Integration Tests and the analysis of the results of these tests:
o (6.1) In case of errors, the return will be made to the PIM level to make the necessary corrections
and step "2.1" and the following steps will be re-run;
o (6.2) If there are no errors, the transition to the Validation Tests phase is made;
 (7) The execution of the Validation Tests and the analysis of the results:
o (7.1) If there are errors, the return to the CIM level will be made to make the necessary
corrections, then step "1.1" and all subsequent steps will be re-executed.
 Salima Chantit et al. / Procedia Computer Science 184 (2021) 797–802 801
Author name / Procedia Computer Science 00 (2018) 000–000 5

4.2. Integration of the model-based development cycle into the Scrum methodology
In the previous section, we presented the combination of the MDA paradigm with MBT in a V development
cycle. In this section, we present our solution steps for efficiently integrating the new version of the V cycle in the
Scrum methodology sprints. This solution is described by the following set of process steps:
 Step 1: Definition of the system requirements in the Backlog Product;
 Step 2: RoadMap planning and distribution of features;
 Step 3: Definition of the sprint backlog;
Implementation of the sprint:
 Step 4: Application of the new version of the V-cycle, which combines MoDAr-WA and MBT;
 Step 5: Validation of the generated code and Automatic Backup with GIT (AB);
o If the current sprint is the first one, then go to step 6;
o Otherwise, comparison with the previous backup (AB-1):
 If the new generation influences the saved system version, give the user the hand to
merge the two versions (add/modify or delete a code fragment that exists only in one of
the two versions);
 Step 6: Manually add missing code parts;
 Step 7: Define tests for the manually added part;
 Step 8: Validation and Automatic Backup (GIT);
 Step 9: Review with the client;
End of the sprint
 Back to step 1 to update the Backlog Product and plan the next sprint.
NB: It is important to note that the approach keeps all versions saved to allow the user to return to an
intermediate step.
The figure 2 below, illustrates the flowchart of our process of combining the MoDAr-WA and MBT approach for
the implementation of the Scrum methodology sprints.

Fig 2. Combination Approach Flowchart

802 Salima Chantit et al. / Procedia Computer Science 184 (2021) 797–802
6 Author name/ Procedia Computer Science 00 (2018) 000–000

As our combination approach is based on models that cover all MDA levels (CIM, PIM, PSM), it allows us to
ensure automatic documentation of the system to develop. Moreover, thanks to the transformation rules between
these different levels, our approach ensures traceability throughout the development and testing process. In addition,
the automation of these transformation rules guarantees the speed of development, and the making of changes.
However, at this level, test automation is partially covered by our approach as it is not yet integrated in the plugin.
Concerning the standard agile development processes, it allows to ensure an easy development and modification
of systems, however, the development, tests and system documentation are carried out manually by different actors,
which influences the traceability between the different stages of the system development.
In fine, it is possible to conclude that the combination of MDE approaches with an agile methodology improves
the quality and speed of development while respecting the values of agility.
5. Conclusion and future work
In this paper, we have presented a new approach that aims to improve software development processes by
combining the main variants of Model Driven Engineering (MDA and MBT) with the agile Scrum methodology. In
particular, we provide a new customized V development life cycle based on MDA and MBT to cover the different
steps of a system development (specification, coding and testing) in each iteration of Scrum method.
The left branch of the V life cycle is defined using our MDA approach (MoDAr-WA [8]) that is fully tool-
supported. The right V cycle branch is generated using the MBT approach that generates the different types of test
cases (UT: Unit Test, IT: Integration Test and TV: Validation Test) according to MDA abstraction levels. This new
version of the V cycle is integrated into the Scrum methodology sprints. In addition, we provide full process steps to
deal with managing the automatic switch from one sprint to another while taking into account the evolution of the
system's needs.
At this stage of our research project, the test generation part of this approach has been developed and tested
manually.
In perspective, we aim to integrate the different transformation rules defined to generate the different types of test
cases in an Eclipse plugin, as we did for the MoDAr-WA approach. The resulting tool will be used either with scrum
methodology or separately. The use of this tool in other agile methodologies can also be explored in a future work in
order to benefit from combining MDE and Agile methodologies.
References
[1] Soley, Richard (2000). Model driven architecture (mda). In: http://www.omg.org/cgibin/doc?omg/00-11-05.
[2] Utting, Mark, Legeard, Bruno, (2007). Practical Model-Based Testing: A Tools Approach. Morgan Kaufmann Publishers Inc., San Francisco,
CA, USA.
[3] Beck, Kent and al., (2001-2015). Agile manifesto.
[4] Tore Dybå and Torgeir Dingsøyr (2009). What do we know about agile software development? Vol. 46. Software, IEEE.
[5] Vickoff, Jean. Pierre., (2001). Agile why not? In: www.entreprise-agile.com.
[6] Kulkarni, V., Barat, S., Ramteerthkar, U., 2011. Early experience with agile methodology in a model driven approach. In: Model Driven
Engineering Languages and Systems, 14th International Conference, MODELS 2011, Wellington, New Zealand, October 16-21, 2011.
Proceedings. pp. 578590.
[7] Alfraihi, H., 2016. Towards improving agility in model-driven development. In: Joint Proceedings of the Doctoral Symposium and Projects
Showcase Held as Part of STAF 2016 co-located with Software Technologies: Applications and Foundations (STAF 2016), Vienna, Austria,
July 4-7, 2016. pp. 2_10.
[8] Mahe, V., Combemale, B., Cadavid, J., 2010. Crossing model driven engineering and agility - preliminary thoughts on benefits and
challenges.
[9] Essebaa, Imane; Chantit, Salima and Ramdani, Mohammed (2019). MoDAr-WA: Tool Support to Automate an MDA Approach for MVC
Web Application. MDPI Computers Journal.
[10] Essebaa, Imane and Chantit, Salima. (2018). A Combination of V Development Life Cycle and Model-based Testing to Deal with
Software System Evolution Issues. In Proceedings of the 6th International Conference on Model-Driven Engineering and Software
Development - Volume 1: MODELSWARD, ISBN 978-989-758-283-7, ISSN 2184-4348, pages 528-535.
[11] Essebaa, Imane; Chantit, Salima and Ramdani, Mohammed (2020). Model-Based Testing from Model Driven Architecture: A Novel
Approach for Automatic Test Cases Generation. In: Advances in Smart Technologies Applications and Case Studies.