Transforming Requirements into MDA from User Stories to CIM

Transcription

1 , pp Transing Requirements into MDA from User Stories to CIM Meryem Elallaoui 1, Khalid Nafil 2 and Raja Touahni 1 1 Faculty of Sciences, Ibn Tofail University, Kenitra, Morocco 2 Software Project Management Research Team, ENSIAS, University Mohammed V, Rabat, Morocco elallaoui.meryem@univ-ibntofail.ac.ma, k.nafil@um5s.net.ma Abstract Over the last few years, Model Driven Architecture (MDA) has become a central goal in the research areas as well as agile methodology. On the other hand, in order to reduce ambiguity in requirements specifications, UML has become a main purpose. It represents the best modeling language for software systems. Several works have been carried out in order to trans either the natural language into UML models, or model (CIM) to model (PIM) transation. In previous work, we have implemented an algorithm that takes UML model (PIM) as input and generate another UML model (PIT) as output, in Scrum process. In this paper, we propose a method for the automatic transation of user stories into behavioral models (CIM), and the development of a new plugin that transs requirements into a behavioral model. Keywords: MDA, UML, User story, Scrum, TreeTagger 1. Introduction Nowadays several methods of transing either requirements or UML models (CIM) [1] into a system design model have been appeared in order to reduce the cost of software development. In Scrum agile methodology [2], the development process is structured through iterations. An iteration includes the design, development, testing and delivering a set of implemented user stories. Design is a crucial phase for any software project that consists to trans the requirements expressed in simple natural language sentences into a modeling language such as UML. In agility, the requirements are expressed by user stories and respects the following syntax As a <actor>, I want to < some goal > so that < some reason >, called user stories [3]. Their transation into UML models is a timeconsuming activity that, moreover, is manual in most cases, and that requires expertise and a lot of effort. As a result, changes in the design level increases and therefore the time and cost of development increases. However, such increasing in term of time and cost is not desirable. Therefore, to increase productivity, and to significantly reducing the time and user stories modeling effort we propose an automation process. Unified Modeling Language (UML) [4] is usually used to represent requirements in a better powerful and structured way. It is often the most used language for modeling all parts of the system [5]. Various techniques and tools have been suggested in order to reduce ambiguity between design and requirements analysis phase, by applying UML models such as use cases, sequence diagrams and class diagrams [6]. The main objective of this paper is to show how to extract use case diagrams (CIM) from natural language (user story) by implementing a plugin for the generation of these diagrams. This approach must take as an input, a set of user stories expressed in natural language, then pers the pretreatment by using TreeTagger [7] for annotating ISSN: IJSEIA Copyright c 2017 SERSC

2 sentences with part-of-speech and lemma ination. Next, the extraction of use case diagrams from sentences pretreated is carried out using plugin that we have implemented. This paper is organized as follows: after a short introduction, Section 2 summarizes brief literature review. In Section 3, we discuss in detail our proposed methodology and describe the experimental evaluation of the proposed approach. Discussion is given in Section 4. Section 5 draws some conclusion and presents future lines of work. 2. Background In recent years, a multiple approach for the transation of natural language requirements into UML diagrams has been extensively studied. However, there is no study for agile requirements as far as we know. Few researchers have specifically focused on use case and class diagrams extraction from natural language requirements. Deva Kumar [9, 8], proposes a semi-automatic technique for generating both static and dynamic UML models from natural language requirements (UMGAR). In their previous work, they proposed a tool (SUGAR) for the generation of use case and class diagrams from natural language requirements. SUGAR focus on generating only static UML models from requirements, following the Rational Unified Process (RUP) [10]. Priyanka [11] demonstrate how to generate UML diagrams from NL specifications, by using an algorithm and implementing a prototype tool called RAPID. Herchi [12] suggest an approach based on natural language processing (NLP) technique for extracting class diagrams from textual requirements. The input is represented by textual data and user requirements, then selected class names, their associations and attributes in structured XML file. Zhou [13] present an approach for generating class diagram automatically from NL requirement documents. The system uses NLP techniques to understand written requirements and applies domain ontology to enhance the perance of class identification. The extraction of candidate classes is pered by using a part of speech (POS) tagger, a link grammar parser, and the uses of domain ontology for refined the result. Mich L. [14] introduce tool named LOLITA (Large-scale Object-based Language Interactor, translator and Analyser) for NLP. The tool consists to pre-process the user requirements, and including all the tasks for NL analysis. The limitation of the study is that LOLITA cannot differentiate between classes, objects and attributes, but only extract objects from natural language. Vrushali et al., [15] proposes a technique to translate software requirements expressed in NL into class diagram. They have implemented a system called RACE Requirements Analysis and class diagram Extraction. The architecture of RACE is quite similar to RAPID. 3. Methodology The aim of our approach is to facilitate the work of developers and designers by generating automatically use cases diagrams from user stories. Figure 1 illustrates the architecture of our system Architecture of the Transation Process The architecture has the following main features: The tools takes a set of user stories as input and the algorithm filters the documents by removing unnecessary words 16 Copyright c 2017 SERSC

3 The resulting new document is parsed by using the TreeTagger which produce parse tree for each user stories, through which verb, noun, determiner and proper noun can be identified. The extraction of actors, use cases and their associations can easily be pered from the parsed tree. Use case diagram is built using the Java technology Figure 1. Architecture of the Transation Process 3.2. Plugin use Case and TreeTagger Processing This subsection explains about the process of generating use case diagrams from user stories using TreeTagger. For the development of our use case generation plugin, we have implemented 9 java classes. Class FileCreator, this class consists in generating physical output files. Class IdGenerator, which is responsible for the generation of IDs. For each element of the model, we insert a basic ID. Class ElementFactory, the objective of this class is the creation of elements of the use case diagram (Creation of actors, use cases and their associations). Associations are represented by ends (send, eend) to associate the actor with the use case ( send= start End and eend= Fin End ). Class ModelFactory allows the creation of a model (use case). Add an element that can be an actor, association or use case, and finally generate the model as an (.uml) file. Classes Actor, Association and use case represent models for actor, associations and use cases. Class Model which contains a collection of actors, associations and use cases. Class OwnedEnd, allows to specify an end for the actor or use case. Identifying the Actors Actor represents the role that a user can play within a system. Actors mainly are the first (Noun [ (NN) or plural (NNS)]) of each user story. Before creating an actor, we check whether actor already exists or not. Identifying the use Cases The identification of the use cases is generally linked to the actors. The use cases detected are predicates (Verbs [base (VV) or past participle (VVN) or participle (VVG) or past tense (VVD)] + Noun [ (NN) or plural (NNS)]) in each user story that are associated with an actor (NN). Copyright c 2017 SERSC 17

4 Identifying relationships between actors and use cases Associations are triggered between each actor and use case. We have pered a test, the use case diagram generated shows a total of 6 user stories. The generated use case model is visualized using the Visual Paradigm tool [16]. Results We have pered an example to test our system on a set of user stories that are stored in a text file. Figure 2 shows the input of our system. Figure 2. A Set of User Stories After filtering the text file and eliminating unnecessary terms, we get a new file that contains only the actors and uses cases. Figure 3. Filtering User Stories Therefore, the system takes as input the new file, and using the TreeTagger tool, which allows the annotation of the text with ination about the type of words (verb, name, etc.,) and the lemmatization of the text, we identify from each user story the necessary ination. Extraction of Grammatical Occurrences Applying POS tags, terms are categorized into proper noun, personal noun, noun ( or plural) or verbs, etc. Each term in the user story is classified into a single part of speech. Table 1. User Stories Processing using TreeTagger User stories Word POS Tag Description customer NN Noun, verify VV Verb, base 1- customer, verify my account withdraw money my PP$ Possessive pronoun account NN Noun, withdraw VV Verb, base 18 Copyright c 2017 SERSC

5 2- client, checked my list; adding tasks 3- customer, update my account; change password 4- administrator, verify my database inserted data 5- user, create a ; registered ination s money NN Noun, client NN Noun, checked VVN Verb, past participle my PP$ Possessive pronoun list NN Noun, adding VVG Verb, gerund/ participle tasks NNS Noun plural customer NN Noun, update NN Noun, my PP$ Possessive pronoun account NN Noun, change NN Noun, password NN Noun, administrator NN Noun, verify VV Verb, base my PP$ Possessive pronoun database NN Noun, inserted VVN Verb, past participle data NNS Noun plural user NN Noun, create VV Verb, base a DT Determiner NN Noun, registered VVN Verb, past participle ination s NNS Noun plural designer NN Noun, Copyright c 2017 SERSC 19

6 6- designer, draw diagrams; modeling the system draw VV Verb, base diagrams NNS Noun plural modeling NN Noun, the DT Determiner system NN Noun, The extracted elements are then used to further extract elements of a use case diagram using a plugin that we have implemented. Finally, we generate an.uml file that contains the use case diagram, which represents the behavioral model. Figure 4 illustrates the output of the generated.uml file 4. Discussion Figure 4. Use Case Diagram There are several approach for transing either NL requirements into UML models, or model (CIM) to model (PIM) transation, but the combination of NLP tools with agile requirements for generating UML models is few and far between. In this paper, we have described a technique for generating automatically use cases diagram (CIM) from a set of user stories. The use cases diagrams are useful because they represent the user needs and describes sequences of actions pered by the system. The benefit of this approach lies in its capability to support the effort of the Product Owner and the development team to reduce the misunderstanding in requirements specifications, and produce automatically design models. UML models facilitate the communication between the development team. Also, these automation technique will reduce the time of design phase. 20 Copyright c 2017 SERSC

7 In reality, the combination of agile methodology and Model Driven Architecture is an impressive viewpoint for the software engineering [17]. Because it's a crucial task for team development to decide which technology and plat are the best. The proposed technique is pered in two steps, which has its own advantages of quick design, removing ambiguity in sentences and facilitating task automation. The first is to extracting grammatical occurrences from a set of user stories using TreeTagger tool, and the second is to generate automatically use case diagrams using plugin that we have implemented. We used Visual Paradigm to visualizing the use case diagram generated, which describes our behavioral model. The benefit of integrating the TreeTagger tool lies in its ability to classify each term of user story into a single part of speech, which facilitate the connection of requirements to design and the generation of the results in a common language such as UML. This allows clear interpretation of user stories, improving workflow and gain time. 5. Conclusion In this paper, we have presented an approach to automate the generation of behavioral model (CIM) from a set of user stories using efficient NLP tool like TreeTagger. The transation process has been made in various steps. First, we per the pretreatment by removing unnecessary terms from each user stories. The second step focuses on annotating each sentence with ination about type of words and lemmatizing the text. Finally, the selected words are used to extracting elements of a use case diagram using a plugin that we have implemented. We believe that this technique can facilitate the work of designers, this method can help software analyst to reducing time of drawing use cases diagrams. We wrote this paper to show the first results, in the next step we will concentrate to determining other types of associations (Generalization and specialization) between actors and use cases, extends and includes between use cases. References [1] J. Miller and J. Mukerji, Model Driven architecture (MDA), OMG Document available at: on ( ). [2] K. Schwaber, Scrum Development Process, in OOPSLA Business Object Design and Implementation Workshop, Eds. London: Springer, (1997), pp [3] M. Cohn, User Stories Applied: For Agile Software Development, Addison-Wesley, (2004). [4] Object Management Group, The Unified Modeling Language, OMG Document available at: on (06/08/2011). [5] N. J. Kamarudin, N. F. M. Sani and R. Atan, Automated transation approach from user requirement to behavior design, Journal of Theoretical and Applied Ination Technology, vol. 81, no. 1, (2015), pp [6] D. Bell, UML basics: An introduction to the unified modeling language, IBM Developer Works, available at: ( ). [7] G. Schmid, TreeTagger A language-independent part-of-speech tagger, Available at (1994). [8] D. D. Kumar and R. Sanyal, Static UML Model Generator from Analysis of Requirements (SUGAR), In Advanced software engineering and its applications, (ASEA 2008), pp [9] D. D. Kumar and M. A. Babar, An Automated Tool for Generating UML Models from Natural Language Requirements, Automated Software Engineering, (2009), pp [10] P. Kruchten, The Rational Unified Process An Introduction, Second Edition, Addison Wesley, Second Edition, USA, (2000). [11] P. More and R. Phalnikar, Generating UML Diagrams from Natural Language Specifications, International Journal of Applied Ination Systems, Foundation of Computer Science, vol. 1, no. 8, (2012), pp [12] H. Herchi and W. B. Abdessalem, From user requirements to uml class diagram, CoRR, abs/ , (2012). [13] N. Zhou and X. Zhou, Automatic Acquisition of Linguistic Patterns for Conceptual Modeling, INFO629: Concepts in Artificial Intelligence, (2004). Copyright c 2017 SERSC 21

8 [14] L. Mich, NL-OOPS: From Natural Language to Object Oriented Requirements Using the Natural Language Processing System LOLITA, Natural Language Engineering, vol. 2, no. 2, (1996), pp [15] A. Vrushali, A. Darshana, J. Aarti and L. Dipali, Class Diagram Extraction from Textual Requirements Using NLP Techniques, IOSR Journal of Computer Engineering (IOSR-JCE), vol. 17, no. 2, Ver. III, (2015), pp [16] Visual Paradigm, available at: [17] C. Paloma, D. Francisco and M. Esperanza, Integrating an Agile Process in a Model Driven Architecture, (2012), pp Authors Meryem ELallaoui is currently a phd student at Systems of Telecommunication and Engineering Decision Laboratory (LSTED) at Ibn Tofail University, Kenitra-Morocco. Her main research fields are model-based testing and model driven engineering in the domain of agile software development. She has Master s degree in Computer Science - Software Quality at Ibn Tofail University, Kenitra-Morocco. Khalid Nafil is a professor in the National Higher School of IT (ENSIAS). He has received his ph.d in Computer Science from Mohammed V University, Rabat-Morocco. Dr. Nafil's research focus is software engineering. He has investigated issues in software design, web engineering, cost estimation, serious games and software testing. Raja Touahni is a professor in faculty of sciences at Ibn Tofail University, Kenitra-Morocco. Dr. Touahni's research focus is Data processing. She has investigated issues in image data analysis, classification, data mining and segmentation 22 Copyright c 2017 SERSC