EVALUATING THE COMPLEXITY OF UML CLASS...
Transcript of EVALUATING THE COMPLEXITY OF UML CLASS...
i
EVALUATING THE COMPLEXITY OF UML CLASS DIAGRAMS
AIDA SHAFIABADY
A MASTER PROJECT SUBMITTED IN FULFILLMENT OF THE
REQUIREMENTS FOR THE AWARDS OF THE DEGREE OF
MASTER OF SOFTWARE ENGINEERING
Advanced Informatics School
Universiti Teknologi Malaysia
January 2013
iv
ACKNOWLEDGMENT
It has been impossible to write this Master thesis without the assistance and
support of people around me whom it is not possible to thank and mention all of them
here.
Above all, I want to thank my academic mentor Madam Haslina Sarkan and my
industrial mentor Dr. Mohd Naz’ri Mahrin for their good advice, help, support and
patience. I am deeply appreciative and working with them has been a real pleasure to me.
I also want to thank them for their knowledge and listening to my ideas and discuss with
me about them. I also want to thank them for being so caring and kind to me, you made
me feel like a friend and I am grateful for that from my heart.
I would like to appreciate academic and technological support of the Universiti
Teknologi Malaysia which provided me the library facilities and also gave me this
opportunity to continue my studying in higher level.
I also want to thank my fellow friends whom their encouragement throughout this
work is valuable. Last, but not means least, I want to thank my dear family for their
infinite support. Thank them all with all my heart.
v
ABSTRACT
One of the main purposes of software engineering is to improve the quality of
software products. As we all know if we want to have good and acceptable software in
quality criteria we must spot it from the early phases of the development life cycle. One
of the key artifacts in theoretical modeling phase is class diagrams in which their quality
has an important impact on the quality of our system. If they have low quality they will
lead to so many problems, for instance, the construction cost will be more than the
estimated one, so if we measure the quality of class diagrams we can find out if they have
low or high quality and then we try to eliminate the problem in those diagrams.
One of the ways for evaluating the quality of UML class diagrams is to measure
the complexity of those classes. In this thesis we tried to recommend and present a way
of measuring the complexity of class diagrams with respect to the complexity metrics
based on the relationship between classes. This method of measuring has many good
assets and can measure the complexity of each class diagram independently by using the
tool based on fuzzy logics.
vi
ABSTRAK
Salah satu tujuan utama kejuruteraan perisian adalah untuk meningkatkan kualiti
produk perisian. Seperti yang kita semua tahu jika kita ingin mempunyai perisian yang
baik dan boleh diterima dalam kriteria kualiti kita mesti melihat dari fasa awal kitaran
hayat pembangunan. Salah satu artifak penting dalam fasa pemodelan teori rajah kelas di
mana kualiti mereka mempunyai kesan penting terhadap kualiti sistem kami. Jika mereka
mempunyai kualiti yang rendah mereka akan membawa kepada banyak masalah,
misalnya, kos pembinaan akan menjadi lebih daripada satu anggaran, jadi jika kita
mengukur kualiti gambar rajah kelas kita boleh mengetahui jika mereka mempunyai
kualiti yang rendah atau tinggi dan kemudian kita cuba untuk menghapuskan masalah
dalam orang-orang rajah.
Salah satu cara untuk menilai kualiti gambar rajah UML kelas adalah untuk
mengukur kerumitan kelas-kelas. Dalam tesis ini, kami cuba untuk mencadangkan dan
membentangkan satu cara mengukur kerumitan rajah kelas berkenaan metrik kerumitan
berdasarkan hubungan antara kelas. Ini kaedah mengukur mempunyai banyak aset yang
baik dan boleh mengukur kerumitan setiap rajah kelas bebas dengan menggunakan alat
yang berdasarkan bukti kabur.
vii
TABLE OF CONTENTS
CHAPTER TITLE PAGE
DECLARATION ii
DEDICATION iii
ACKNOWLEDGMENT iv
ABSTRACT v
ABSTRAK vi
TABLE OF CONTENTS vii
LIST OF TABLES xi
LIST OF FIGURES xiii
LIST OF EQUATIONS xv
LIST OF APPENDICES xvi
LIST OF ABBREVATION xvii
1 PROJECT OVERVIEW 1
1.1 Introduction 1
1.2 Background of the Company 2
1.3 Background of the problem 4
1.4 Problem Statement 5
viii
1.5 Objectives of the study 6
1.6 Scope of the study 6
1.7 Project Deliverables 7
2 LITERATURE REVIEW 8
2.1 Introduction 8
2.2 Unified Modeling Language for Class Diagrams 13
2.3 Class Diagram Notations 14
2.3.1 Association 15
2.3.2 Aggregation 15
2.3.3 Composition 16
2.3.4 Generalization 17
2.3.5 Dependency 18
2.4 Extensibility Mechanisms 20
2.4.1 Stereotypes 20
2.4.2 Tagged Values 21
2.4.3 Constraints 22
2.5 Unified Modeling Language Complexity 23
3 RESEARCH METHODOLOGY 25
3.1 Introduction 25
3.2 Systematic Literature Review 25
3.3 The Software Quality Metrics Methodology and Qualitative Evaluation of
DESMET Methodology 27
4 SYSTEMATIC LITERATURE REVIEW OF COMPLEXITY
METRICS 30
4.1 Introduction 30
4.2 Background 31
ix
4.3 Research Questions 32
4.4 Search Strategy 32
4.4.1 Search Terms 32
4.4.2 Resources Searched 33
4.4.3 Inclusion and exclusion criteria 34
4.5 Search Results 34
4.6 Conducting the Review 36
4.7 Discussion of research questions 37
4.7.1 Research Question 1 37
4.7.1.1 Chidamber and Kemerer’s metrics 37
4.7.1.2 Marchesi’s metrics 39
4.7.1.3 Genero’s metrics 41
4.7.1.4 Comparisons of the Metrics 43
4.7.2 Research Question 2 45
4.8 Bibliography Management 50
4.9 Summary 50
5 APPLYING COMPLEXITY VALUES 52
5.1 Introduction 52
5.2 Process for applying metrics 53
5.2.1 Definition 61
5.2.2 Planning 61
5.2.2.1 Context selection 62
5.2.2.2 Layout of the work 62
5.2.2.3 Variables selection 62
5.2.2.4 Selection of subjects 63
5.2.3 Operation 63
5.2.3.1 Preparation 63
5.2.3.2 Execution and Data Validation 64
x
5.2.4 Analysis and Interpretation 64
5.3 Summary 69
6 ENHANCING THE EVALUATION OF THE UML
COMPLEXITY MEASURES 70
6.1 Introduction 70
6.2 Making Fuzzy Decisions 71
6.2.1 Decision Making Types 73
6.2.2 Fuzzy Decision Making Tool 74
6.3 Evaluation Process Using FDM Tool 74
6.4 Comparison Between Genero and FDM Results 81
6.5 Summary 82
7 CONCLUSION 84
7.1 Conclusion 84
7.2 Future Work 85
REFERENCES 86
APPENDICES A-E 89-101
xi
LIST OF TABLES
TABLE NO. TITLE PAGE
1.1 Program offered by utm ais 3
1.2 Project deliverables 7
2.1 Metrics for uml class diagram structural complexity 12
2.2 UML class diagram relationship types 19
3.1 Objectives and their methods 29
4.1 Number of studies found, candidate and selected 35
4.2 Marchesi’s metrics 39
4.3 Theoretical validation of genero's metrics 42
4.4 Variable selection for genero's experiment 49
4.5 Comparison between complexity metrics 51
5.1 Goal definition based on gqm template for our experiment 61
5.2 Example of characteristic labels 64
5.3 Median value of characteristics 65
5.4 Summarized of collected data 66
5.5 di and di2 values 67
5.6 Spearman's correlation 68
xii
6.1 Attributes weight 76
6.2 Computed values for complexity of uml case study class diagrams 80
6.3 Genero and FDM final results comparison 81
xiii
LIST OF FIGURES FIGURE NO. TITLE PAGE
1.1 Organizational chart 3
2.1 Unified modeling language (uml) diagrams 9
2.2 The relationship between external quality attributes, structural
property and complexity (manso et al., 2003) 11
2.3 Class association logical view 15
2.4 Class aggregation view 16
2.5 Class composition view 16
2.6 Class generalization 17
2.7 Class dependency 18
2.8 Three way of depicting uml stereotypes class 21
2.9 Tagged value 22
2.10 Constraints view 23
4.1 Relationship between structural properties and external quality
attributes based on briand (bagheri and gasevic, 2011) 46
5.1 BETA group class diagram 54
5.2 CRUISE group class diagram 55
5.3 GULF group class diagram 56
xiv
5.4 PRANA group class diagram 57
5.5 ELEGANT group class diagram 58
5.6 DELTA group class diagram 59
5.7 KASRA group class diagram 60
6.1 Decision making process 75
6.2 New project window scheme 77
6.3 Attribute properties 78
6.4 Add new alternative box 78
6.5 Enter data for each alternative with respect to each attribute 79
6.6 Running and processing data display 80
xv
LIST OF EQUATIONS EQUATION NO. TITLE PAGE
4.1 Weighted methods per class definition 38
4.2 Average weighted number of classes 40
4.3 Standard deviation of the weighted number of responsibilities of
classes 40
4.4 Average of the number of direct dependencies of classes 40
4.5 Standard deviation of the number of direct dependencies 41
4.6 Percentage of inherited responsibilities with respect to their total
number 41
5.1 Spearman correlation coefficient 67
6.1 The modus ponens sequent notation 72
xvi
LIST OFAPPENDICES
APPENDIX TITLE PAGE
A DESMET Nine Different Evaluation Methods 889
B Gantt Chart 90
C Metric Values Visualization 91
D Journals and Papers for Candidate Studies 94
E Materials Given to Each Subject 101
xvii
LIST OF ABBREVATION
FDM - Fuzzy Decision Making
GMP - Generalized Modus Ponens
OBA - On-Board Automobile
OCL - Object Constraint Language
OMG - Object Management Group
OMT - Object Modeling Technique
OO - Object Oriented
OOIS - Object Oriented Information System
OOSE - Object Oriented Software Engineering
RUP - Rational Unified Process
SDD - Software Design Document
SLR - Systematic Literature Review
UML - Unified Modeling Language
1
CHAPTER 1
1 PROJECT OVERVIEW
1.1 Introduction
In today’s competitive markets, delivering software which has high quality is not
a benefit but it is one of the essentials of being successful among the other companies.
For having high quality software system we have to make sure that it has been qualified
from the early phases of its development life cycle. If we apply quality assurance
methods at initial phases it will be more effective than applying them after the
implementation of the system.
One of the most significant dependence of the quality of object-oriented (OO)
software systems is the exactness of the requirements specification (Genero et al., 2000).
As a result we have to focus on making the models which created in the early steps of the
software development life cycle better. Class diagrams are one of the main objects in the
OO model and development; it also presents the basis of the design work and the
2
implementation process of the software. So, we can say that the quality of a system
performance has influenced by the quality of the class diagrams.
1.2 Background of the Company
Universiti Teknologi Malaysia (UTM) is the oldest educational institute in
Malaysia which is specializes in the field of technology and engineering. This university
starts working since 1904. It has two main campuses; one of them is in Skudai which is
the first university in Johor Bahru and it is the second largest public university in
Malaysia. The other campuse is located in Kuala Lampur and it has an area of almost
about 17 hectares and it has so many faculties and schools such as Advanced Informatics
School (AIS).
AIS previously known as Centre for Advanced Software Engineering (CASE)
which is established in 1996. In the year 2008, UTM became one of the best universities
in Malaysia. During the process of improvement CASE has been promoted to the school
with faculty authority and it was called Advanced Informatics School (AIS).
UTM AIS suggested both master and doctorate levels programs. We summarized
all the programs which offered by UTM AIS in table 1.1.
AIS is an international campus and consist of graduates from all over the world
such as Indonesia, Iran, Iraq, Libya, Sudan, Yemen, Zambia and other countries.
3
Table 1.1: Program offered by UTM AIS
Master Programs Doctorate Programs
Master of Software Engineering
Master of Science (Information
Assurance)
Master of Science (Computer
Systems Engineering)
Master of Philosophy
Doctor of Software Engineering
Doctor of Philosophy
The Dean of UTM AIS is Prof. Dr. Shamsul Sahibuddin and he has this position
since 20061. Figure 1.1 shows organizational chart of UTM AIS.
Figure 1.1: Organizational Chart
1 http://www.ais.utm.my/
Dean
Deputy Dean (Academic)
Head of Departement
(Software Engineering)
Head of Departement(Information
Security)
Deputy Dean (Developement &
Management Technology)
Head of Departement(Informatics)
4
1.3 Background of the problem
Unified Modeling Language (UML) is a all purpose standard modeling language
which has a background in the object-oriented software engineering. This standard was
developed by the Object Management Group (OMG), and was first appended to the list
of OMG accepted technologies in 1997 (Han et al., 2009), and from that time become the
industry standard for modeling software-intensive systems.
Among the 14 different types of diagrams used in UML, half of them employed to
display structural information, and the other half represents general type of behavior four
of which allocated to different aspects of interactions.2
UML not only has the capability to be exploited for forward engineering, but also
beneficial on reverse engineering. This ability comes from its graphical representation of
a software system (Ben-Abdallah et al., 2004). One of basic uses of UML class diagrams
is to illuminate the structure of a software system that mostly leads to an appropriate
understanding of it. UML class diagrams model the classes and their various
relationships, such as generalization (inheritance), association (aggregation and
composition), and other dependencies.
Quality in software products is characterized by the presence of different external
and internal attributes (Genero et al., 2004) which external quality attributes are those
attributes that can be measured with respect to how the product relates to its environment
such as functionality, reliability, usability but an internal quality attributes are those that
2 Structural diagrams are Package Diagram, Component Diagram, Object Diagram, Deployment Diagram, Class Diagram, Composite Structure Diagram, Profile Diagram. And behavioral diagrams are Use Case Diagram, State Machine Diagram, Activity Diagram, Interaction Overview Diagram, Communication Diagram, Sequence Diagram, Timing Diagram.
5
can be measured purely in terms of the product and can be measured by examining the
product on its own, separate from its behavior such as complexity.
For having a good software design, software must be planned from early stages.
For example, if a class diagram is not designed with sufficient accuracy, we could not
reach to the ultimate goal of the project, so quality checks can be done on these diagrams
to assess the upcoming properties of the object-oriented information systems, such as
business and other kinds of database applications, to be developed. The quality is usually
assessed during the early development phase like requirement specification and
conceptual modeling to avoid poor quality models that will result in inadequate
implementation problems.
1.4 Problem Statement
Building software models before implementing them has become widely accepted
in the software industry. Object models, graphically represented by class diagrams, and
their quality can have a significant impact on the quality of the software which is
implemented (Zhou and Xu, 2005). The problem here is sometimes the final software
construction cost is more than what we estimated and also it has a low quality and this
problem is originated from the design work, to avoid these matters we have to find early
indicators of quality based such as class diagrams, and here is the basis where evaluation
is necessary because it can allow us to investigate the complexity of such diagrams in
initial phases.
6
1.5 Objectives of the study
This Master report aims:
I. To investigate the current UML class diagram complexity measurement.
II. To apply and evaluate the effectiveness of current UML class diagrams
complexity.
III. To improve the complexity evaluation of the UML class diagram.
1.6 Scope of the study
This research is focused on evaluating the quality based on the complexity of the
UML class diagrams which describes the structure of a system by showing the system's
classes, their attributes, and the relationship among the classes. We focus our work on
UML class diagram complexity measurement.
In this research the first step consists of investigation, where we will try to find
out and clear about the methods that software engineers use for measuring the complexity
of class diagrams in UML. The next step is to apply and evaluate the effectiveness of
current UML class diagrams complexity, in this part we will see if the current methods
are meaningful and sufficient enough for evaluating the complexity of class diagrams.
And at the end we will go to analysis the result of evaluating the complexity on class
diagrams based on the On-Board Automobile (OBA) project so our case study in this
thesis is OBA’s class diagrams of seven groups.
7
1.7 Project Deliverables
Each of our objectives has their own result and deliverable that you can see them
all in table 1.2.
Table 1.2: Project Deliverables
NO. OBJECTIVE DELIVERABLE
1 To investigate the current UML class diagram
complexity measurement Report
2 To apply and evaluate the effectiveness of current UML
class diagrams complexity
Report of the
results
3 To improve the complexity evaluation of the UML class
diagram
An improved
method
86
REFERENCES
Ali, S., Briand, L. C., Hemmati, H., and Panesar-Walawege, R. K. (2010). A systematic
review of the application and empirical investigation of search-based test case generation. Software Engineering, IEEE Transactions on. 36(6), 742-762.
Bagheri, E., and Gasevic, D. (2011). Assessing the maintainability of software product line feature models using structural metrics. Software Quality Journal. 19(3), 579-612.
Bakht, A. J., Rad, M. F., and Akbari, F. (2010). Using Fuzzy Multiple Criteria Decision Making in Evaluation of Software Quality. Computational Intelligence and Software Engineering (CiSE), 2010 International Conference on. 1-7.
Basili, V. R., Briand, L. C., and Melo, W. L. (1996). A validation of object-oriented design metrics as quality indicators. Software Engineering, IEEE Transactions on. 22(10), 751-761.
Bellman, R. E., and Zadeh, L. A. (1970). Decision-making in a fuzzy environment. Management science. 17(4), B-141-B-164.
Ben-Abdallah, H., Bouassida, N., Gargouri, F., and Ben-Hamadou, A. (2004). A uml based framework design method. Journal of Object Technology. 3(8), 97-120.
Bolboaca, S. D., and Jantschi, L. (2006). Pearson versus Spearman, Kendall's tau correlation analysis on structure-activity relationships of biologic active compounds. Leonardo Journal of Sciences. 5(9), 179-200.
Booch, G., Maksimchuk, R., Engle, M., Young, B., Conallen, J., and Houston, K. (2007). Object-oriented analysis and design with applications. Addison-Wesley Professional.
Briand, L. C., Morasca, S., and Basili, V. R. (1996). Property-based software engineering measurement. Software Engineering, IEEE Transactions on. 22(1), 68-86.
Briand, L. C., Morasca, S., and Basili, V. R. (2002). An operational process for goal-driven definition of measures. Software Engineering, IEEE Transactions on. 28(12), 1106-1125.
Brito e Abreu, F., and Melo, W. (1996). Evaluating the impact of object-oriented design on software quality. Software Metrics Symposium, 1996., Proceedings of the 3rd International. 90-99.
Cabot, J., Clarisó, R., and Riera, D. (2008). Verification of UML/OCL class diagrams using constraint programming 73-80.
87
Chidamber, S. R., and Kemerer, C. F. (1994). A metrics suite for object oriented design. Software Engineering, IEEE Transactions on. 20(6), 476-493.
Dawson, C. W. (2000). The essence of Computing projects: a student's guide. Prentice Hall.
Eick, S. G. (1997). Information visualization. IEEE Computer Graphics and Applications. 272, 97.
Farhad, J. (2002). The UML Extension Mechanisms. Department of Computer Science, University College London.
Garcıa, Y. A. I. (2009). Complexity boundaries for full satisfiability. A A. 1, 1.
Genero, M., Fernandez, A. M., Nelson, H. J., Poels, G., and Piattini, M. (2009). A Systematic Literature Review on the Quality of UML Models. Working Papers of Faculty of Economics and Business Administration, Ghent University, Belgium.
Genero, M., Manso, E., Visaggio, A., Canfora, G., and Piattini, M. (2007). Building measure-based prediction models for UML class diagram maintainability. Empirical Software Engineering. 12(5), 517-549.
Genero, M., Piattini-Velthuis, M., Cruz-Lemus, J. A., and Reynoso, L. (2004). Metrics for UML models. UML and Model Engineering. 5(1), 43.12.
Genero, M., and Piattini, M. (2001). Empirical validation of measures for class diagram structural complexity through controlled experiments.
Genero, M., Piattini, M., and Calero, C. (2000). Early measures for UML class diagrams. L’Objet. 6(4), 489-505.
Genero, M., Piattini, M., and Calero, C. (2002). Empirical validation of class diagram metrics 195-203.
Genero, M., Piattini, M., and Calero, C. (2005). A survey of metrics for UML class diagrams. Journal of Object Technology. 4(9), 59-92.
Han, X., Shang, L., and Bo, W. (2009). A tool for the application of software metrics to UML class diagram 181-184.
Henderson-Sellers, B. (1995). Object-oriented metrics: measures of complexity.
Kaneiwa, K., and Satoh, K. (2010). On the complexities of consistency checking for restricted UML class diagrams. Theoretical Computer Science. 411(2), 301-323.
Kitchenham, B. (2004). Procedures for performing systematic reviews. Keele, UK, Keele University. 33, 2004.
88
Kitchenham, B., Linkman, S., and Law, D. (1997). DESMET: a methodology for evaluating software engineering methods and tools. Computing & Control Engineering Journal. 8(3), 120-126.
Kobryn, C. (1999). UML 2001: a standardization odyssey. Communications of the ACM. 42(10), 29-37.
Manso, M., Genero, M., and Piattini, M. (2003). No-redundant metrics for UML class diagram structural complexity 1029-1029.
Marchesi, M. (1998). OOA metrics for the Unified Modeling Language 67-73.
O’Hagan, M. (2000). A fuzzy decision maker. Proc. Fuzzy Logic ‘93 (Computer.
Ortega, M., Pérez, M., and Rojas, T. (2003). Construction of a systemic quality model for evaluating a software product. Software Quality Journal. 11(3), 219-242.
Pavlova, M. (2010). http://sourcemaking.com/.
Pilone, D., and Pitman, N. (2005). UML 2.0 in a Nutshell (In a Nutshell (O'Reilly)). O'Reilly Media, Inc.
Ribeiro, R. A. (1996). Fuzzy multiple attribute decision making: a review and new preference elicitation techniques. Fuzzy Sets and Systems. 78(2), 155-181.
Sheldon, F. T., and Chung, H. (2006). Measuring the complexity of class diagrams in reverse engineering. Journal of Software Maintenance and Evolution: Research and Practice. 18(5), 333-350.
Tang, M. H., Kao, M. H., and Chen, M. H. (1999). An empirical study on object-oriented metrics. Software Metrics Symposium, 1999. Proceedings. Sixth International. 242-249.
Weyuker, E. J. (1988). Evaluating software complexity measures. Software Engineering, IEEE Transactions on. 14(9), 1357-1365.
Yi, T. (2009). Measuring Complexity of Relationships among Classes 1-4.
Yi, T. (2010). Comparison research of two typical UML-class-diagram metrics: Experimental software engineering V12-86-V12-90.
Yi, T., Wu, F., and Gan, C. (2004). A comparison of metrics for UML class diagrams. ACM SIGSOFT Software Engineering Notes. 29(5), 1-6.
Zhou, Y., and Xu, B. (2005). Measuring structural complexity for class diagrams: an information theory approach 1679-1683.