Information Systems Frontiers

, Volume 18, Issue 1, pp 171–204 | Cite as

Using model transformation to refactor use case models based on antipatterns

Article
First Online:

Abstract

Use Case modeling is a popular technique for documenting functional requirements of software systems. Refactoring is the process of enhancing the structure of a software artifact without changing its intended behavior. Refactoring, which was first introduced for source code, has been extended for use case models. Antipatterns are low quality solutions to commonly occurring design problems. The presence of antipatterns in a use case model is likely to propagate defects to other software artifacts. Therefore, detection and refactoring of antipatterns in use case models is crucial for ensuring the overall quality of a software system. Model transformation can greatly ease several software development activities including model refactoring. In this paper, a model transformation approach is proposed for improving the quality of use case models. Model transformations which can detect antipattern instances in a given use case model, and refactor them appropriately are defined and implemented. The practicability of the approach is demonstrated by applying it on a case study that pertains to biodiversity database system. The results show that model transformations can efficiently improve quality of use case models by saving time and effort.

Keywords

Use cases Antipatterns Model transformation Refactoring UML Use case modeling quality attributes 
This is a preview of subscription content, log in to check access.

Notes

Acknowledgments

The author would like to acknowledge the support provided by the Deanship of Scientific Research (DSR) at King Fahd University of Petroleum and Minerals (KFUPM) for funding this work through project No. IN121015.

References

  1. Abbes, M., et al. (2011). “An empirical study of the impact of two antipatterns, blob and spaghetti code, on program comprehension.” In Software Maintenance and Reengineering (CSMR), 2011 15th European Conference on (pp. 181–190).Google Scholar
  2. Achour, C. B., Rolland, C., Souveyet, C., Maiden, N. (1999). “Guiding use case authoring: Results of an empirical study.” In Requirements Engineering, 1999. Proceedings. IEEE International Symposium on (pp. 36–43).Google Scholar
  3. Adolph, S., et al. (2002). Patterns for effective use cases. Reading: Addison-Wesley Professional.Google Scholar
  4. Akiyama, M., et al. (2011). “Supporting design model refactoring for improving class responsibility assignment.” Model Driven Engineering Languages and Systems (pp. 455–469).Google Scholar
  5. Anda, B., & Sjøberg, D. I. K. (2002). “Towards an inspection technique for use case models.” In Proceedings of the 14th international conference on Software engineering and knowledge engineering (pp. 127–134).Google Scholar
  6. Anda, B., et al. (2001). “Quality and understandability of use case models,” ECOOP 2001—Object-Oriented Programming (pp. 402–428).Google Scholar
  7. Anderson, E., et al. (1997). “Use case and business rules: Styles of documenting business rules in use cases.” In Conference on Object Oriented Programming Systems Languages and Applications: Addendum to the 1997 ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications (Addendum) (pp. 85–87).Google Scholar
  8. Arcelli, D., et al. (2012). “Antipattern-based model refactoring for software performance improvement.” In Proceedings of the 8th international ACM SIGSOFT conference on Quality of Software Architectures (pp. 33–42).Google Scholar
  9. Armour, F., & Miller, G. (2000). Advanced use case modeling: Software systems. Reading: Addison-Wesley Professional.Google Scholar
  10. Ballis, D., et al. (2008a). A rule-based method to match software patterns against UML models. Electronic Notes in Theoretical Computer Science, 219, 51–66.CrossRefGoogle Scholar
  11. Ballis, D., et al. (2008). “A minimalist visual notation for design patterns and antipatterns.” In Information Technology: New Generations, 2008. ITNG 2008. Fifth International Conference on (pp. 51–56).Google Scholar
  12. Berenbach, B. (2004). “The evaluation of large, complex UML analysis and design models.” In Software Engineering, 2004. ICSE 2004. Proceedings. 26th International Conference on (pp. 232–241).Google Scholar
  13. Biddle, R., et al. (2002). Essential use cases and responsibility in object-oriented development. Australian Computer Science Communications, 24, 7–16.Google Scholar
  14. Bittner, K., & Spence, I. (2003). Use case modeling. Reading: Addison-Wesley Professional.Google Scholar
  15. Bois, B. D., et al. (2006). “Does god class decomposition affect comprehensibility?.” In IASTED International Conference on Software Engineering.Google Scholar
  16. Brown, W. J. (1998). AntiPatterns: Refactoring software, architectures, and projects in crisis. New York: Wiley.Google Scholar
  17. Budinsky, F. (2004). Eclipse modeling framework: A developer’s guide. Addison-Wesley Professional.Google Scholar
  18. Butler, G., & Xu, L. (2001). Cascaded refactoring for framework. ACM SIGSOFT Software Engineering Notes, 26, 51–57.CrossRefGoogle Scholar
  19. Cailliau, A. (2010). “Automating model transformation and refactoring for goal-oriented models”, M.Sc. Thesis, Department of Computer Engineering, Catholic University of Louvain.Google Scholar
  20. Chandrasekaran, P. (1997). “How use case modeling policies have affected the success of various projects (or how to improve use case modeling).” In Addendum to the 1997 ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications (Addendum) (pp. 6–9).Google Scholar
  21. Cockburn, A. (2001). Writing effective use cases. Addison-Wesley.Google Scholar
  22. Constantine, L. L. (1995). Essential modeling: use cases for user interfaces. Interactions, 2, 34–46.CrossRefGoogle Scholar
  23. Cortellessa, V., et al. (2010). “Digging into UML models to remove performance antipatterns.” In Proc. of the 2010 ICSE Workshop on Quantitative Stochastic Models in the Verification and Design of Software Systems (Quovadis’ 10), Cape Town, South Africa.Google Scholar
  24. Cortellessa, V., et al. (2010). “Performance antipatterns as logical predicates.” In Proc. Of the 15th IEEE International Conference on Engineering of Complex Computer Systems (ICECCS) (pp. 146–156).Google Scholar
  25. Cox, K., & Phalp, K. (2000). Replicating the CREWS use case authoring guidelines experiment. Empirical Software Engineering, 5, 245–267.CrossRefGoogle Scholar
  26. Czarnecki, K., & Helsen, S. (2003). “Classification of model transformation approaches.” In Proceedings of the 2nd OOPSLA Workshop on Generative Techniques in the Context of the Model Driven Architecture (pp. 1–17).Google Scholar
  27. Deligiannis, I., et al. (2003). An empirical investigation of an object-oriented design heuristic for maintainability. Journal of Systems and Software, 65, 127–139.CrossRefGoogle Scholar
  28. Deligiannis, I., et al. (2004). A controlled experiment investigation of an object-oriented design heuristic for maintainability. Journal of Systems and Software, 72, 129–143.CrossRefGoogle Scholar
  29. Demuth, B., et al. (2001). “Experiments with XMI based transformations of software models.” In Workshop on Transformations in UML.Google Scholar
  30. Dhambri, K., et al. (2008). “Visual detection of design anomalies.” In Software Maintenance and Reengineering, 2008. CSMR 2008. 12th European Conference on (pp. 279–283).Google Scholar
  31. Dobrzański, Ł., & Kuźniarz, L. (2006). “An approach to refactoring of executable UML models.” In Proceedings of the 2006 ACM symposium on Applied computing (pp. 1273–1279).Google Scholar
  32. Einarsson, H. (2011). “Refactoring UML diagrams and models with model-to-model transformations,” M.S. thesis, Faculty of Industrial Engineering, Mechanical Engineering and Computer Science, University of Iceland, Reykjavík, Iceland.Google Scholar
  33. Einarsson, H., & Neukirchen, H. (2012). “An approach and tool for synchronous refactoring of UML diagrams and models using model-to-model transformations.” In Proceedings of the Fifth Workshop on Refactoring Tools (pp. 16–23).Google Scholar
  34. El-Attar, M. (2009). “Improving the quality of use case models and their utilization in software development”, Ph.D. Dissertation, Department of Electrical and Computer Engineering, University of Alberta.Google Scholar
  35. El-Attar, M., & Miller, J. (2006). “Matching antipatterns to improve the quality of use case models.” In Requirements Engineering, 14th IEEE International Conference (pp. 99–108).Google Scholar
  36. El-Attar, M., & Miller, J. (2008). Producing robust use case diagrams via reverse engineering of use case descriptions. Software and Systems Modeling, 7, 67–83.CrossRefGoogle Scholar
  37. El-Attar, M., & Miller, J. (2010). Improving the quality of use case models using antipatterns. Software and Systems Modeling, 9, 141–160.CrossRefGoogle Scholar
  38. El-Attar, M., & Miller, J. (2012). Constructing high quality use case models: a systematic review of current practices. Requirements Engineering, 17, 187–201.CrossRefGoogle Scholar
  39. Enckevort, T. V. (2009). “Refactoring UML models: Using openarchitectureware to measure UML model quality and perform pattern matching on UML models with OCL queries.” In Proceedings of the 24th ACM SIGPLAN conference companion on Object oriented programming systems languages and applications (pp. 635–646).Google Scholar
  40. Fantechi, A., et al. (2002). “Application of linguistic techniques for use case analysis.” In Proc. of the IEEE Joint International Conference on Requirements Engineering (pp. 157–164).Google Scholar
  41. Favre, J.-M. (2004). “Towards a basic theory to model model driven engineering.” In 3rd Workshop in Software Model Engineering, WiSME.Google Scholar
  42. Firesmith, D. G. (1999) “Use case modeling guidelines.” In Technology of Object-Oriented Languages and Systems, 1999. TOOLS 30. Proceedings (pp. 184–193).Google Scholar
  43. Folli, A., & Mens, T. (2008). “Refactoring of UML models using AGG.” Electronic Communications of the EASST, vol. 8.Google Scholar
  44. Fourati, R., Bouassida, N., Abdallah, H. B. (2011). A metric-based approach for anti-pattern detection in UML designs. In R. Lee (Ed.), Computer and information science 2011. vol. 364 (pp. 17–33). Heidelberg: Springer Berlin.Google Scholar
  45. Fowler, M., et al. (2012). Refactoring: Improving the design of existing code. Pearson Education.Google Scholar
  46. France, R., & Bieman, J. M. (2001). “Multi-view software evolution: A UML-based framework for evolving object-oriented software.” In Proc. of the IEEE International Conference on Software Maintenance (pp. 386–395).Google Scholar
  47. Gomaa, H. (1997). “Use cases for distributed real-time software architectures.” In Proc. of the Joint Workshop on, Parallel and Distributed Real-Time Systems (pp. 34–42).Google Scholar
  48. Harwood, R. J. (1997). Use case formats: requirements, analysis, and design. Journal of Object Oriented Programming, 9, 54–57.Google Scholar
  49. Issa, A. (2007). “Utilising refactoring to restructure use-case models.” In Proc. of the World Congress on Engineering (pp. 523–527).Google Scholar
  50. Ivkovic, I., & Kontogiannis, K. (2006). “A framework for software architecture refactoring using model transformations and semantic annotations.” In Proc. of the 10th European Conference on Software Maintenance and Reengineering (CSMR) (pp. 10–144).Google Scholar
  51. Jaaksi, A. (1998). Our cases with use cases. Journal of Object Oriented Programming, 10, 58–65.Google Scholar
  52. Kalnins, A., et al. (2004). “Model transformation language MOLA” In MDAFA (Model-Driven Architecture: Foundations and Applications) (pp. 14–28).Google Scholar
  53. Kessentini, M., et al. (2010) “Deviance from perfection is a better criterion than closeness to evil when identifying risky code.” In Proceedings of the IEEE/ACM international conference on Automated software engineering (pp. 113–122).Google Scholar
  54. Khan, Y. A. (2012). “Antipattern based use case refactoring” [online] Available: https://sourceforge.net/projects/apucrefactoring [Feb. 8, 2013].
  55. Khan, Y. A., & El-Attar, M. (2012). “A model transformation approach towards refactoring use case models based on antipatterns”, 21st International Conference on Software Engineering and Data Engineering (SEDE’12), Los Angeles, California, USA (pp. 49–54).Google Scholar
  56. Khomh, F., et al. (2011). BDTEX: a GQM-based Bayesian approach for the detection of antipatterns. Journal of Systems and Software, 84, 559–572.CrossRefGoogle Scholar
  57. Khomh, F., et al. (2012). An exploratory study of the impact of antipatterns on class change-and fault-proneness. Empirical Software Engineering, 17, 243–275.CrossRefGoogle Scholar
  58. Kim, Y., & Doh, K.-G. (2007). “The service modeling process based on use case refactoring.” In Business information systems (pp. 108–120).Google Scholar
  59. Kleppe, A. G., Warmer, J., Bast, W. (2003). MDA explained: The model driven architecture. Upper Saddle River: Prentice Hall.Google Scholar
  60. Kolovos, D. S., et al. (2003). “Update transformations in the small with the epsilon wizard language.” Journal of Object Technology (JOT) 6(9).Google Scholar
  61. Kovse, J., & Härder, T. (2002). “Generic XMI-based UML model transformations.” In Proc. of the 8th International Conference on Object-Oriented Information Systems (pp. 183–190).Google Scholar
  62. Kroll, P., & Kruchten, P. (2003). The rational unified process made easy: A practitioner’s guide to the RUP. Addison-Wesley.Google Scholar
  63. Kruchten, P. (1998). “Modeling component systems with the unified modeling language.” In International Workshop on Component-Based Software Engineering.Google Scholar
  64. Kulak, D., & Guiney, E. (2004). Use cases: Requirements in context. Addison-Wesley Professional.Google Scholar
  65. Langelier, G., et al. (2005). “Visualization-based analysis of quality for large-scale software systems.” In Proceedings of the 20th IEEE/ACM international Conference on Automated software engineering (pp. 214–223).Google Scholar
  66. Li, W., & Shatnawi, R. (2007). An empirical study of the bad smells and class error probability in the post-release object-oriented system evolution. Journal of Systems and Software, 80, 1120–1128.CrossRefGoogle Scholar
  67. Li, K., et al. (2011). “A generic technique for domain-specific visual language model refactoring to patterns.” Electronic Communications of the EASST, vol. 31.Google Scholar
  68. Lilly, S. (1999). “Use case pitfalls: Top 10 problems from real projects using use cases.” In Technology of Object-Oriented Languages and Systems, 1999. TOOLS 30. Proceedings (pp. 174–183).Google Scholar
  69. Liu, H., et al. (2007). Detecting overlapping use cases. Software IET, 1, 29–36.CrossRefGoogle Scholar
  70. Maiga, A., et al. (2012). “SMURF: A SVM-based incremental anti-pattern detection approach.” In Reverse Engineering (WCRE), 2012 19th Working Conference on (pp. 466–475).Google Scholar
  71. MAPSTEDI [online] Available: http://mapstedi.sourceforge.net/ [Feb. 8, 2013].
  72. Marinescu, R. (2004). “Detection strategies: Metrics-based rules for detecting design flaws.” In Software Maintenance, 2004. Proceedings. 20th IEEE International Conference on (pp. 350–359).Google Scholar
  73. Markovic, S. (2008). “Model refactoring using transformations”, Ph.D. dissertation, Institute of Computing and Multimedia, Federal Polytechnic School of Lausanne, Switzerland.Google Scholar
  74. Markovic, S., & Baar, T. (2005). “Refactoring OCL annotated UML class diagrams,” Model Driven Engineering Languages and Systems (pp. 280–294).Google Scholar
  75. Massoni, T., et al. (2008). “Formal model-driven program refactoring,” Fundamental Approaches to Software Engineering (pp. 362–376).Google Scholar
  76. Mattingly, L., & Rao, H. (1998). Writing effective use cases and introducing collaboration cases. Journal of Object Oriented Programming, 11, 77–84.Google Scholar
  77. McCoy, J. R. (2003). “Requirements use case tool (RUT).” In Companion of the 18th annual ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications (pp. 104–105).Google Scholar
  78. Medvidovic, N., et al. (2002). Modeling software architectures in the Unified Modeling Language. ACM Transactions on Software Engineering and Methodology, 11, 2–57.CrossRefGoogle Scholar
  79. Mens, T., et al. (2006). Applying a model transformation taxonomy to graph transformation technology. Electronic Notes in Theoretical Computer Science, 152, 143–159.CrossRefGoogle Scholar
  80. Mens, T., et al. (2007). “Challenges in model refactoring.” In Proc. 1st Workshop on Refactoring Tools, University of Berlin.Google Scholar
  81. Metz, P., O’Brien, J., & Weber, W. (2001). Against use case interleaving. Lecture Notes in Computer Science, 2185, 472–486.CrossRefGoogle Scholar
  82. Moha, N., et al. (2010a). DECOR: a method for the specification and detection of code and design smells. IEEE Transactions on Software Engineering, 36, 20–36.CrossRefGoogle Scholar
  83. Moha, N., et al. (2010). “Evaluation of Kermeta for solving graph-based problems,” International Journal on Software Tools for Technology Transfer (STTT), vol. 12 (pp. 273–285).Google Scholar
  84. Muliawan, O., & Janssens, D. (2010). “Model refactoring using MoTMoT.” International Journal on Software Tools for Technology Transfer (STTT), vol. 12 (pp. 201–209).Google Scholar
  85. Munro, M. J. (2005). “Product metrics for automatic identification of “Bad Smell” design problems in Java Source-Code.” In Proc. of the 11th IEEE International Software Metrics Symposium (p. 15).Google Scholar
  86. O’Brien, J., & Weber, W. (2004). Specifying use case interaction: clarifying extension points and rejoin points. Journal of Object Technology, 3, 87–102.CrossRefGoogle Scholar
  87. Object Management Group (2009). “OMG Unified Modeling Language Superstructure Specification,” [online] Available: http://www.omg.org/spec/UML/2.2/Superstructure/PDF/ [Feb. 8, 2013].
  88. Object Management Group, “MOF 2.0 Query/Views/Transformations RFP,” Jan. 2011, http://www.omg.org/spec/QVT/1.1/PDF/. (last accessed December 2013).
  89. Object Management Group, “MOF/XMI Specification” Aug 2011, www.omg.org/spec/XMI. (Last accessed December 2013).
  90. Olbrich, S., et al. (2009). “The evolution and impact of code smells: A case study of two open source systems.” In Proceedings of the 2009 3rd International Symposium on Empirical Software Engineering and Measurement (pp. 390–400).Google Scholar
  91. Oliveto, R., et al. (2010). “Numerical signatures of antipatterns: An approach based on B-Splines.” In Software maintenance and reengineering (CSMR), 2010 14th European Conference on (pp. 248–251).Google Scholar
  92. Opdyke, W. F. (1992). “Refactoring object-oriented frameworks.” University of Illinois at Urbana-Champaign.Google Scholar
  93. Overgraad, G., & Palmkvist, K. (2005) Use cases patterns and blueprints. Addison-Wesley.Google Scholar
  94. Pettersson, F., et al. (2005). Automotive use case standard for embedded systems. ACM SIGSOFT Software Engineering Notes, 30, 1–6.Google Scholar
  95. Porres, I. (2005). Rule-based update transformations and their application to model refactorings. Software and Systems Modeling, 4, 368–385.CrossRefGoogle Scholar
  96. Porres, I., et al. (2003). “Model refactorings as rule-based update transformations.” In In Proceedings of UML 2003 Conference, Springer-Verlag LNCS 2863, ed: Springer (pp. 159–174).Google Scholar
  97. Ramos, R., et al. (2007). “Improving the quality of requirements with refactoring,” VI Simpósio Brasileiro de Qualidade de Software–SBQS2007, Porto de Galinhas, Recife, Pernambuco, Brasil.Google Scholar
  98. Romano, D., et al. (2012). “Analyzing the impact of antipatterns on change-proneness using fine-grained source code changes.” In Reverse Engineering (WCRE), 2012 19th Working Conference on (pp. 437–446).Google Scholar
  99. Rosenberg, D., & Scott, K. (1999). Use case driven object modeling with UML: A practical approach. Reading: Addison-Wesley.Google Scholar
  100. Rui, K., & Butler, G. (2003). “Refactoring use case models: The metamodel.” In Proceedings of the 26th Australasian computer science conference-Volume 16 (pp. 301–308).Google Scholar
  101. Rumbaugh, J., et al. (2005). The unified modeling language reference manual. Addison-Wesley.Google Scholar
  102. Ryndia, O., & Kritzinger, P. (2004). “Improving requirements specification verification of use case models with Susan,” Technical Report CS04-06-00, Department of Computer Science, University of Cape Town.Google Scholar
  103. Schneider, G., & Winters, J. P. (2001). Applying use cases: A practical guide. Que Publishing.Google Scholar
  104. Segura, S., et al. (2008). “Automated merging of feature models using graph transformations.” Generative and Transformational Techniques in Software Engineering II (pp. 489–505).Google Scholar
  105. Sendall, S., & Kozaczynski, W. (2003). “Model transformation: The heart and soul of model-driven software development,” IEEE Softw., vol. 20 (pp. 42–45).Google Scholar
  106. Settas, D., et al. (2012). Enhancing ontology-based antipattern detection using Bayesian networks. Expert Systems with Applications: An International Journal, 39(10), 9041.CrossRefGoogle Scholar
  107. Simon, F., et al. (2001). “Metrics based refactoring.” In Software Maintenance and Reengineering, 2001. Fifth European Conference on (pp. 30–38).Google Scholar
  108. Simons, A. J. H. (1999). Use cases considered harmful, Proceedings of the 29th Conference on Technology of Object-Oriented Languages and Systems-TOOLS Europe’99, 194–203.Google Scholar
  109. Sinnig, D., Chalin, P., Khendek, F. (2009). LTS semantics for use case models, Proceedings of the 2009 ACM symposium on Applied Computing, ACM, 365–370.Google Scholar
  110. Smialek, M., Jarzebowski, N., Nowakowski, W. (2012). Runtime semantics of use case stories, Visual Languages and Human-Centric Computing (VL/HCC), 2012 I.E. Symposium on, 159–162.Google Scholar
  111. Smialek, M., Jarzebowski, N., & Nowakowski, W. (2012b). Translation of use case scenarios to Java Code. Computer Science, 13, 35–52.Google Scholar
  112. Stoianov, A., & Sora, I. (2010). “Detecting patterns and antipatterns in software using Prolog rules.” In Computational Cybernetics and Technical Informatics (ICCC-CONTI), 2010 International Joint Conference on (pp. 253–258).Google Scholar
  113. The Eclipse Modeling Framework (2013). “ATL—a model transformation technology” [online] Available: http://www.eclipse.org/atl/ [Feb. 8, 2013].
  114. Travassos, G., et al. (1999). Detecting defects in object-oriented designs: using reading techniques to increase software quality. ACM SIGPLAN Notices, 34, 47–56.CrossRefGoogle Scholar
  115. Trubiani, C., & Koziolek, A. (2011). “Detection and solution of software performance antipatterns in palladio architectural models.” In ACM SIGSOFT Software Engineering Notes (pp. 19–30).Google Scholar
  116. van den Berg, K. G., & Simons, A. J. H. (1999). Control flow semantics of use cases in UML. Information and Software Technology, 41, 651–659.CrossRefGoogle Scholar
  117. Van Emden, E., & Moonen, L. (2002). “Java quality assurance by detecting code smells.” In Reverse Engineering, 2002. Proceedings. Ninth Working Conference on (pp. 97–106).Google Scholar
  118. Wagelaar, D., et al. (2010). Module superimposition: a composition technique for rule-based model transformation languages. Software and Systems Modeling, 9, 285–309.CrossRefGoogle Scholar
  119. Wieman, R. (2011). Anti-pattern scanner: An approach to detect anti-patterns and design violations. LAP Lambert Academic Publishing.Google Scholar
  120. Wirfs-Brock, R. (1993). Designing scenarios: Making the case for a use case framework. The Smalltalk Report, 3, 7.Google Scholar
  121. Xu, L., & Butler, G. (2006). “Cascaded refactoring for framework development and evolution.” In Software Engineering Conference, 2006. Australian (pp. 319–330).Google Scholar
  122. Xu, J., et al. (2004). “Use case refactoring: a tool and a case study.” In Software Engineering Conference, 2004. 11th Asia-Pacific (pp. 484–491).Google Scholar
  123. Xue-Bin, W., et al. (2007). “Research and implementation of design pattern-oriented model transformation.” In Proc. of the International Multi-Conference on Computing in the Global Information Technology (ICCGI) (pp. 24–24).Google Scholar
  124. Yu, W., et al. (2004). “Refactoring use case models on episodes.” In Automated Software Engineering, 2004. Proceedings. 19th International Conference on (pp. 328–335).Google Scholar
  125. Zhang, J., et al. (2005). “Generic and domain-specific model refactoring using a model transformation engine,” Model-driven Software Development (pp. 199–218).Google Scholar

Copyright information

© Springer Science+Business Media New York 2014

Authors and Affiliations

  1. 1.Department of Information & Computer ScienceKing Fahd University of Petroleum & MineralsDhahranSaudi Arabia

Personalised recommendations