Modelling is a fundamental activity in requirements engineering (RE), as it helps bridge the gap between the real world and the software. Through modelling, the re-quirements analyst creates an abstract description of the user rere-quirements on a system and conveys this description to the software developer. Such a description is called a
"model", which turns the user requirements into concepts and their inter-relationships.
There exist a variety of software tools for requirements modelling. These tools can be classified into three groups, namely: traditional tools, generic software diagram-ming tools and computer-aided software engineering (CASE) tools. Traditional tools are non-electronic tools that can be used for modelling requirements through hand-drawn diagrams only. They are the most dominant modelling tools used for exploring domain problems and hand drawing design solutions during the early stages of requirements elicitation [1], [2]. The reason for this is that they are flexible, easy to use and do not constrain the notations that can be used for modelling. However, there are disadvantages that prevent the traditional tools from being the perfect tool for requirements modelling.
The most important drawbacks of these tools are their inability to 1) persist hand-drawn diagrams, 2) support manipulation of drawn diagrams and 3) transform hand-drawn diagrams into initial software models. Consequently, users of these tools must manually re-model the hand-drawn diagrams from scratch using software modelling tools. This recreation process is tedious, time consuming and prone to errors. Examples of these tools include whiteboard, flipcharts, and paper and pencil.
Generic software diagramming tools are software tools that support creation of di-agrams to model requirements mainly using mouse and keyboard. Like the traditional tools, the generic diagramming tools also do not constrain the notation that can be used for modelling [3] in that, users can use the tools to draw any type of diagrams to express
requirements models. In contrast to the traditional tools, they provide facilities that can be used for modifying and storing created models for a later reuse. These facilities help to address some of the drawbacks of the traditional tools. However, the generic dia-gramming tools do not allow users to express requirements models using hand-drawn diagram. Consequently, users are constrained to learning how to create various types of diagrams using the facilities provided by the tools. Also, the diagrams created by the tools are not formalized content and hence cannot be transformed into initial software models without a manual re-creation process using CASE tools. Examples of the gener-ic software diagramming tools include LucidChart, Visio, and Draw IO etc.
CASE tools are software tools that support the use of one or more formalized pre-defined notations (e.g., UML Diagrams, i* Diagram etc.) to create diagrams for model-ling requirements. CASE tools provide facilities that facilitate generation of initial soft-ware model, code, and documentation. They also give users the flexibility to store, edit and change diagrams [4]. However, CASE tools with their requirement to use prede-fined notations, focus on correctness and completeness. Users cannot freely create dia-grams without being forced to use a specific notation or required to provide more detail than they would want [5]. Furthermore, users are constrained to learning specific model-ling languages with formal syntaxes to be able to use CASE tools effectively [6]. Ex-amples of CASE tools include UML CASE tools like Rationale Rose, Visual Paradigm, and Enterprise Architect etc.
The above description shows that there is a lack of support for less formal and us-er-friendly tools for end-users to hand-draw diagrams to convey their initial ideas of software requirements from the user perspective. Such tools are particularly valuable at the early stage of RE.
Researchers have recognized the need to overcome the challenge of providing a single requirement modelling tool that supports users during the early phase of require-ments elicitation and have started tackling it from two directions.
First, by implementing a generic front-end to allow users express requirements through hand drawing of arbitrary diagrams. This led to various prototype tools such as SILK [1], InkKit [4] , and Calico [7]. While these tools addressed the challenge of sup-porting user to flexibly hand draw diagrams and save them for a later re-use, they how-ever do not support formalization and transformation of the drawn diagrams into initial
software models. Hence, the users still must re-create initial software models manually using CASE tools.
Second, by integrating sketch recognition facilities to allow users express re-quirements using hand-drawn diagrams and then subsequently beautify the diagrams into computer drawn diagrams. This resulted in various prototype tools such as Tahuti [8], SUMLOW [9] and OctoUML-Lite [3], In addition to enabling beautification of hand drawn diagrams, one of the tools, FlexiSketch [10], supports users to semi-automatically generate a meta-model of their drawn diagrams. However, the shortcom-ings of these tools are twofold, 1) users are constrained to either using a single stroke or multiple strokes to hand-draw diagrams. Diagrams that do not adhere to the type of stroke expected by the tools cannot be interpreted by the sketch recognizer leading to errors during the beautification or transformation of the hand drawn diagrams. Hence, users are still limited in their expressiveness of requirements using hand-drawn dia-grams [6], [11]. 2) Users are constrained to annotating elements in their diadia-grams with mainly names and types. They are not able to provide the text functional requirements of the software system being modelled, which can be used for documentation and auto-matic extraction of elements during initial software model generation from the diagram.
Consequently, the users must manually re-create initial software models in CASE tools using their hand-drawn diagrams and the text functional requirements of the software system they modelled.
This research project is motivated to address the problem by developing a re-quirement modelling tool that: 1) does not restrict users to using a specific type of stroke (single or multiple strokes) for expressing requirements with hand drawing, and 2) enables users to automatically transform their drawings into initial software models.
These problems will be addressed by utilizing Deep Neural Networks (DNNs) and PLANT’s Agent-Oriented Models (AOMs)
DNNs, especially convolutional neural networks have significantly improved and are promising for sketch recognition [12] while AOMs are suitable for identifying agents and their interactions needed for generating target initial software models from user requirements [13].