Professional Documents
Culture Documents
discussions, stats, and author profiles for this publication at: http://www.researchgate.net/publication/202193810
CITATIONS
READS
16
76
3 AUTHORS:
Imran Sarwar Bajwa
Behzad Bordbar
University of Birmingham
SEE PROFILE
SEE PROFILE
Mark G. Lee
University of Birmingham
78 PUBLICATIONS 366 CITATIONS
SEE PROFILE
I.
INTRODUCTION
II.
PRELIMINARIES
204
cName: String
cAge: Integer
cDOB: Date
has an account in
customer
Bank
1
bankAccount
accNo: String
accType: String
withDraw(): Integer
isAdult(cDOB): Bool
context
inv :
customer
self.cAge >= 18
context customer
inv: self.cAge >= 18
205
C. Model Transformation
Model Driven Architecture (MDA) [1] is a flavor of
model-driven development (MDD) [20] proposed by the
OMG . Central to the MDD and MDA is the process of
model transformation, i.e. automated creation of new
models, which is depicted in Figure 4 and can be described
briefly as follows. Model Transformations rely on the
instanceof relationship between models and metamodels
to convert models. Model Transformations define the
mappings rules between two modelling languages
metamodels. Rules typically define the conversion of
element(s) of the source metamodel to equivalent element(s)
of the destination metamodel. The Model Transformation
frameworks
execute
the
Model
Transformation
implementations on models. Upon execution with a given
model, the necessary rules are applied by the transformation
framework, applying rules to generate an equivalent model
in the destination modelling language.
206
III.
A. NL to SBVR Transformation
The transformation of natural language specification to
SBVR rules is performed by performing following four
steps:
1) Parsing NL Specification
2) Extracting Fact Types
3) Verifying with the UML Model
4) Apply Semantic Formulation
A breif description of all these steps is provided in the
following section.
1) Parsing NL Specification: The NL represeantaiton is
semanically analyzed using LESSA [14] (Language
Engineering System for Semantic Analysis) approach.
Parsing information of a SBVR rules A customer should be
18 years old is following:
TABLE I.
Syntactic
Elements
S
NP
VP
VB
P
HV
NL to
SBVR Transformation
Meanings
Action Verb
Determiner
Adjective
Noun
Number
Preposition Phrase
NP
VP
DT
VB
customer
HV
should be
NP
NP
NR
18
AJ
old
years
NL User
Interface
Syntactic
Elements
English Sentence V
Noun Phrase
DT
Verb Phrase
AJ
Verb
N
Pronoun
NR
Helping verb
PP
Meanings
SBVR
Rules
OCL
Constraints
SBVR to
OCL Transformation
207
years old.
At least-n
Noun
Fact
At least-n
Noun
Quantification Concept Type Quantification Concept
208
then Expression
else Expression
endif |
Method
Parameters
Literal
CollectionName
InfixOper
PrefixOper
context
customer
inv: Constraint-Body
TABLE III.
Logical Formulation
Structure SBVR rule
Behavioral SBVR rule
method a of class b
TABLE IV.
OCL
a.b
ab
a::b
a:b
a():b
OCL
Logical Formulation
b1 is added with b2
b1 is subtracted from
b1<=b2
b2
b1>b2
b1 is multiplied with b2
OCL
b1+b2
b1-b2
b1*b2
b1>=b2
b1 is divided by b2
b1/b2
b1=b2
b1 is not equal to b2
b1<>b2
OCL
Logical Formulation
OCL
a AND b
a implies b
Not a
a is T or b is T: any one
a is T or b is T: not both
a or b
a xor b
Constraint
ContextName
Identifier
Class
ConstraintBody
Expression
Context |
Context : Method-Name (Parameters): Literal
Identifier :: Identifier | Collection-Name (Class)
a is context
Constraint/Invariant
If TRUE then a else b
TABLE VI.
OCL
b1<b2
TABLE V.
Logical
Formulation
a is T and b is T
b is T then T
a is F
Logical Formulation
b is data type of a
b is return type of a
comments
Logical Formulation
b1 is less than b2
b1 is less than OR
equals to b2
b1 is greater than b2
b1 is greater than OR
equal to b2
b1 is equal to b2
customer or self
Syntax Rule
TABLE II.
Expression (. | ) Method |
Expression InfixOper Expression |
PrefixOper Expression | Literal
forAll | exists | select | allInstances |
include | iterate |
Parameter-Name : Literal
Integer | Real | String | Boolean | Collection
If Expression
209
OCL
Context a
Inv
If T then
a else b
Package
Pre
Logical Formulation
OCL
init
Derive
Define
Let
Define private variable
operation post-condition Post
TABLE VII.
OCL COLLECTIONS
Logical Formulation
More than One Elements
Unique AND Unordered list of elements
Unique AND Ordered list of elements
Non-Unique (Repeating) AND Unordered list of
elements
Non-Unique (Repeating) AND Ordered list of
elements
OCL
Collection(T)
Set(T)
OrderedSet(T)
Sequence(T)
Bag(T)
self.cAge
Rule 1
T[context-inv(actor)] = context-name
context
customer
inv: self.cAge >= 18
V.
Rule 2
T[context-cond(actor, action)] = context-name :: operationname
A SKETCH OF IMPLEMENTATION
To generate the body of an invariant and pre/postconditions a complete set of rules were defined. Due to
shortage of space we present few of them. Here the rules 3
transforms SBVR information to the OCL invariant, while
rule 4 and 5 are used to transform SBVR rules to OCL
preconditions and post conditions.
Rule 3
T[invariant( context-inv, inv-body )]
= context context-inv\
inv: inv-body
Rule 4
T[pre-cond ( context-cond, pre-cond-body )]
= context context-cond
pre: pre-cond-body
Rule 5
T[post-cond ( context-cond, post-cond-body )]
= context context-cond
post: post-cond-body
These are some of the rules that were used for SBVR to
OCL transformation. Our approach only addresses the
invariants and pre/post conditions. We have not addressed
yet the OCL queries.
210
VI.
But these tools are limited to verify the syntax and type
checking of the already written OCL code. Currently, no
suitable tool is available that is capable of automatic
generation of OCL code from natural languages. This is the
major reason that after more than ten years of introduction
of OCL, OCL is yet no fully adapted in software developer
communities as other language of UML. The related work is
briefly expressed in reaming part of the section.
In last decade, many automated solutions for
transformation of natural language software requirement
specification (SRS) to UML based formal presentation have
been presented [36], [37], [38], [39], [40]. Introduction of
frameworks and tools for automated transformation NL to
UML model have made things very easy and time saving for
the software designers.
J. Cabot also presented some transformation techniques to
get semantically alike representations of an OCL constraint
[7]. The proposed technique assists in simplifying the
modeling phase of software development by increasing the
understanding level of the designer by providing him more
than one alternate OCL representations. The presented work
can also help out in future for PIM-to-PIM, PIM-to-PSM
and PIM-to-code transformations. In the same direction of
research, Bryant presented a system that used natural
language processing for developing a business domain
model from system requirements given in natural languages
[41]. First of all simple pre-processing actions were
performed on the input text i.e. spelling and grammar
checking, use of consistent vocabulary and appropriate
sentence usage. Afterwards this pre-processed text was
translated into XML representation with the help of domain
specific knowledge. Bryant has also proposed that business
domain model created by his work can be further
transformed into UML representation.
The transformation of formal specifications (e.g. OCL) to
information specifications (e.g. NL) is another recent trend
of research regarding OCL. Transformation of OCL into NL
has been addressed by Kristofer J. where he presented a rule
system. The rule system annotates an OCL syntax tree with
OCL semantic annotation on it and also performs
disambiguation of syntax trees [21]. This work is part of the
project for translating OCL code into a natural language
representation e.g. English or German. The major
limitations of this work are that it supports OCL 1.5. J.
Linehan presented his work for the translating Structured
English representation to predicate logic [25] and then
finally this mathematical representation is transformed into
equivalent OCL structures. In the context of our proposed
research, his work is not helpful because, writing SBVR
rules in Structured English representation is itself an
overhead.
On the other hand, some work has been done to transform
OCL and UML to SBVR by Cabot [8]. He proposed
automatic transformation of UML and OCL schema to
SBVR specification. This work is basically reverse
engineering of software modeling and better for generating
TOOL SUPPORT
211
[4]
[5]
[6]
[7]
[8]
[9]
[10]
[11]
[12]
[13]
[14]
[15]
[16]
[17]
[18]
[19]
[20]
[21]
[22]
REFERENCES
[1]
[2]
[3]
[23]
[24]
[25]
[26]
212
[35] Emine G. A., Richard F. P., Jim W.: Evaluation of OCL for LargeScale Modelling: A Different View of the Mondex Purse. Springer
LNCS Vol. 5002, pp. 194-205 (2008)
[36] Ilieva M., Olga O.: Automatic Transition of Natural Language
Software requirements Specification into Formal Presentation.
Springer LNCS Vol. 3513, pp.392--397 (2005)
[37] Whittle J., Jayaraman P., et al.: MATA: A Unified Approach for
Composing UML Aspect Models on Graph Transformation: Springer
LNCS Vol. 5560, p. 191--237 (2009)
[38] Oliveira A., Seco N., Gomes P.: A CBR Approach to Text to Class
Diagram Translation, In TCBR Workshop at the 8th European
Conference on Case-Based Reasoning. (2004).
[39] Bajwa I., Samad A., Mumtaz S.: Object Oriented Software modeling
Using NLP based Knowledge Extraction, European Journal of
Scientific Research, 35(01), p.22--33 (2009)
[40] Kovacs L., Kovasznai G., Kusper G.: Metamodels in Generation of
UML Using NLI-Based Dialogue. In 5th International Symposium on
ACII, pp. 29--33 (2009)
[41] Bryant B., et al.: From Natural Language Requirements to Executable
Models of Software Components. In Workshop on S. E. for
Embedded Systems pp.51-58 (2008)
213