Skip to main content
SpringerLink
Log in

Using model transformation to refactor use case models based on antipatterns

  • Published:
Information Systems Frontiers Aims and scope Submit manuscript

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.

This is a preview of subscription content, log in via an institution to check access.

Access this article

Log in via an institution

Price excludes VAT (USA)
Tax calculation will be finalised during checkout.

Instant access to the full article PDF.

Institutional subscriptions

Fig. 1
Fig. 2
Fig. 3
Listing 1
Fig. 4
Listing 2
Fig. 5
Listing 3
Fig. 6
Listing 4
Fig. 7
Listing 5
Fig. 8
Listing 6
Fig. 9
Listing 7
Fig. 10
Fig. 11
Listing 8
Fig. 12
Listing 9
Fig. 13
Listing 10
Fig. 14
Listing 11
Listing 12
Fig. 15
Listing 13
Fig. 16
Listing 14
Fig. 17
Listing 15
Fig. 18
Listing 16
Fig. 19
Listing 17
Fig. 20
Listing 18
Fig. 21
Listing 19
Fig. 22
Listing 20
Fig. 23
Fig. 24
Fig. 25
Fig. 26
Fig. 27
Fig. 28
Fig. 29
Fig. 30
Fig. 31
Fig. 32
Fig. 33
Fig. 34
Fig. 35
Fig. 36

Similar content being viewed by others

References

  • 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).

  • 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).

  • Adolph, S., et al. (2002). Patterns for effective use cases. Reading: Addison-Wesley Professional.

    Google Scholar 

  • Akiyama, M., et al. (2011). “Supporting design model refactoring for improving class responsibility assignment.” Model Driven Engineering Languages and Systems (pp. 455–469).

  • 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).

  • Anda, B., et al. (2001). “Quality and understandability of use case models,” ECOOP 2001—Object-Oriented Programming (pp. 402–428).

  • 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).

  • 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).

  • Armour, F., & Miller, G. (2000). Advanced use case modeling: Software systems. Reading: Addison-Wesley Professional.

    Google Scholar 

  • 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.

    Article  Google Scholar 

  • 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).

  • 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).

  • Biddle, R., et al. (2002). Essential use cases and responsibility in object-oriented development. Australian Computer Science Communications, 24, 7–16.

    Google Scholar 

  • Bittner, K., & Spence, I. (2003). Use case modeling. Reading: Addison-Wesley Professional.

    Google Scholar 

  • Bois, B. D., et al. (2006). “Does god class decomposition affect comprehensibility?.” In IASTED International Conference on Software Engineering.

  • Brown, W. J. (1998). AntiPatterns: Refactoring software, architectures, and projects in crisis. New York: Wiley.

    Google Scholar 

  • Budinsky, F. (2004). Eclipse modeling framework: A developer’s guide. Addison-Wesley Professional.

  • Butler, G., & Xu, L. (2001). Cascaded refactoring for framework. ACM SIGSOFT Software Engineering Notes, 26, 51–57.

    Article  Google Scholar 

  • Cailliau, A. (2010). “Automating model transformation and refactoring for goal-oriented models”, M.Sc. Thesis, Department of Computer Engineering, Catholic University of Louvain.

  • 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).

  • Cockburn, A. (2001). Writing effective use cases. Addison-Wesley.

  • Constantine, L. L. (1995). Essential modeling: use cases for user interfaces. Interactions, 2, 34–46.

    Article  Google Scholar 

  • 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.

  • 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).

  • Cox, K., & Phalp, K. (2000). Replicating the CREWS use case authoring guidelines experiment. Empirical Software Engineering, 5, 245–267.

    Article  Google Scholar 

  • 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).

  • Deligiannis, I., et al. (2003). An empirical investigation of an object-oriented design heuristic for maintainability. Journal of Systems and Software, 65, 127–139.

    Article  Google Scholar 

  • 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.

    Article  Google Scholar 

  • Demuth, B., et al. (2001). “Experiments with XMI based transformations of software models.” In Workshop on Transformations in UML.

  • 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).

  • 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).

  • 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.

  • 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).

  • 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.

  • 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).

  • 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.

    Article  Google Scholar 

  • El-Attar, M., & Miller, J. (2010). Improving the quality of use case models using antipatterns. Software and Systems Modeling, 9, 141–160.

    Article  Google Scholar 

  • El-Attar, M., & Miller, J. (2012). Constructing high quality use case models: a systematic review of current practices. Requirements Engineering, 17, 187–201.

    Article  Google Scholar 

  • 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).

  • 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).

  • Favre, J.-M. (2004). “Towards a basic theory to model model driven engineering.” In 3rd Workshop in Software Model Engineering, WiSME.

  • Firesmith, D. G. (1999) “Use case modeling guidelines.” In Technology of Object-Oriented Languages and Systems, 1999. TOOLS 30. Proceedings (pp. 184–193).

  • Folli, A., & Mens, T. (2008). “Refactoring of UML models using AGG.” Electronic Communications of the EASST, vol. 8.

  • 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.

  • Fowler, M., et al. (2012). Refactoring: Improving the design of existing code. Pearson Education.

  • 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).

  • 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).

  • Harwood, R. J. (1997). Use case formats: requirements, analysis, and design. Journal of Object Oriented Programming, 9, 54–57.

    Google Scholar 

  • Issa, A. (2007). “Utilising refactoring to restructure use-case models.” In Proc. of the World Congress on Engineering (pp. 523–527).

  • 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).

  • Jaaksi, A. (1998). Our cases with use cases. Journal of Object Oriented Programming, 10, 58–65.

    Google Scholar 

  • Kalnins, A., et al. (2004). “Model transformation language MOLA” In MDAFA (Model-Driven Architecture: Foundations and Applications) (pp. 14–28).

  • 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).

  • Khan, Y. A. (2012). “Antipattern based use case refactoring” [online] Available: https://sourceforge.net/projects/apucrefactoring [Feb. 8, 2013].

  • 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).

  • Khomh, F., et al. (2011). BDTEX: a GQM-based Bayesian approach for the detection of antipatterns. Journal of Systems and Software, 84, 559–572.

    Article  Google Scholar 

  • 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.

    Article  Google Scholar 

  • Kim, Y., & Doh, K.-G. (2007). “The service modeling process based on use case refactoring.” In Business information systems (pp. 108–120).

  • Kleppe, A. G., Warmer, J., Bast, W. (2003). MDA explained: The model driven architecture. Upper Saddle River: Prentice Hall.

  • Kolovos, D. S., et al. (2003). “Update transformations in the small with the epsilon wizard language.” Journal of Object Technology (JOT) 6(9).

  • 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).

  • Kroll, P., & Kruchten, P. (2003). The rational unified process made easy: A practitioner’s guide to the RUP. Addison-Wesley.

  • Kruchten, P. (1998). “Modeling component systems with the unified modeling language.” In International Workshop on Component-Based Software Engineering.

  • Kulak, D., & Guiney, E. (2004). Use cases: Requirements in context. Addison-Wesley Professional.

  • 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).

  • 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.

    Article  Google Scholar 

  • Li, K., et al. (2011). “A generic technique for domain-specific visual language model refactoring to patterns.” Electronic Communications of the EASST, vol. 31.

  • 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).

  • Liu, H., et al. (2007). Detecting overlapping use cases. Software IET, 1, 29–36.

    Article  Google Scholar 

  • 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).

  • MAPSTEDI [online] Available: http://mapstedi.sourceforge.net/ [Feb. 8, 2013].

  • 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).

  • Markovic, S. (2008). “Model refactoring using transformations”, Ph.D. dissertation, Institute of Computing and Multimedia, Federal Polytechnic School of Lausanne, Switzerland.

  • Markovic, S., & Baar, T. (2005). “Refactoring OCL annotated UML class diagrams,” Model Driven Engineering Languages and Systems (pp. 280–294).

  • Massoni, T., et al. (2008). “Formal model-driven program refactoring,” Fundamental Approaches to Software Engineering (pp. 362–376).

  • Mattingly, L., & Rao, H. (1998). Writing effective use cases and introducing collaboration cases. Journal of Object Oriented Programming, 11, 77–84.

    Google Scholar 

  • 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).

  • Medvidovic, N., et al. (2002). Modeling software architectures in the Unified Modeling Language. ACM Transactions on Software Engineering and Methodology, 11, 2–57.

    Article  Google Scholar 

  • Mens, T., et al. (2006). Applying a model transformation taxonomy to graph transformation technology. Electronic Notes in Theoretical Computer Science, 152, 143–159.

    Article  Google Scholar 

  • Mens, T., et al. (2007). “Challenges in model refactoring.” In Proc. 1st Workshop on Refactoring Tools, University of Berlin.

  • Metz, P., O’Brien, J., & Weber, W. (2001). Against use case interleaving. Lecture Notes in Computer Science, 2185, 472–486.

    Article  Google Scholar 

  • 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.

    Article  Google Scholar 

  • 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).

  • Muliawan, O., & Janssens, D. (2010). “Model refactoring using MoTMoT.” International Journal on Software Tools for Technology Transfer (STTT), vol. 12 (pp. 201–209).

  • 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).

  • O’Brien, J., & Weber, W. (2004). Specifying use case interaction: clarifying extension points and rejoin points. Journal of Object Technology, 3, 87–102.

    Article  Google Scholar 

  • 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].

  • 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).

  • Object Management Group, “MOF/XMI Specification” Aug 2011, www.omg.org/spec/XMI. (Last accessed December 2013).

  • 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).

  • 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).

  • Opdyke, W. F. (1992). “Refactoring object-oriented frameworks.” University of Illinois at Urbana-Champaign.

  • Overgraad, G., & Palmkvist, K. (2005) Use cases patterns and blueprints. Addison-Wesley.

  • Pettersson, F., et al. (2005). Automotive use case standard for embedded systems. ACM SIGSOFT Software Engineering Notes, 30, 1–6.

    Google Scholar 

  • Porres, I. (2005). Rule-based update transformations and their application to model refactorings. Software and Systems Modeling, 4, 368–385.

    Article  Google Scholar 

  • 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).

  • 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.

  • 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).

  • Rosenberg, D., & Scott, K. (1999). Use case driven object modeling with UML: A practical approach. Reading: Addison-Wesley.

    Google Scholar 

  • 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).

  • Rumbaugh, J., et al. (2005). The unified modeling language reference manual. Addison-Wesley.

  • 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.

  • Schneider, G., & Winters, J. P. (2001). Applying use cases: A practical guide. Que Publishing.

  • Segura, S., et al. (2008). “Automated merging of feature models using graph transformations.” Generative and Transformational Techniques in Software Engineering II (pp. 489–505).

  • Sendall, S., & Kozaczynski, W. (2003). “Model transformation: The heart and soul of model-driven software development,” IEEE Softw., vol. 20 (pp. 42–45).

  • Settas, D., et al. (2012). Enhancing ontology-based antipattern detection using Bayesian networks. Expert Systems with Applications: An International Journal, 39(10), 9041.

    Article  Google Scholar 

  • Simon, F., et al. (2001). “Metrics based refactoring.” In Software Maintenance and Reengineering, 2001. Fifth European Conference on (pp. 30–38).

  • 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.

  • 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.

  • 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.

  • Smialek, M., Jarzebowski, N., & Nowakowski, W. (2012b). Translation of use case scenarios to Java Code. Computer Science, 13, 35–52.

    Google Scholar 

  • 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).

  • The Eclipse Modeling Framework (2013). “ATL—a model transformation technology” [online] Available: http://www.eclipse.org/atl/ [Feb. 8, 2013].

  • Travassos, G., et al. (1999). Detecting defects in object-oriented designs: using reading techniques to increase software quality. ACM SIGPLAN Notices, 34, 47–56.

    Article  Google Scholar 

  • 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).

  • 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.

    Article  Google Scholar 

  • 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).

  • Wagelaar, D., et al. (2010). Module superimposition: a composition technique for rule-based model transformation languages. Software and Systems Modeling, 9, 285–309.

    Article  Google Scholar 

  • Wieman, R. (2011). Anti-pattern scanner: An approach to detect anti-patterns and design violations. LAP Lambert Academic Publishing.

  • Wirfs-Brock, R. (1993). Designing scenarios: Making the case for a use case framework. The Smalltalk Report, 3, 7.

    Google Scholar 

  • Xu, L., & Butler, G. (2006). “Cascaded refactoring for framework development and evolution.” In Software Engineering Conference, 2006. Australian (pp. 319–330).

  • 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).

  • 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).

  • Yu, W., et al. (2004). “Refactoring use case models on episodes.” In Automated Software Engineering, 2004. Proceedings. 19th International Conference on (pp. 328–335).

  • Zhang, J., et al. (2005). “Generic and domain-specific model refactoring using a model transformation engine,” Model-driven Software Development (pp. 199–218).

Download references

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.

Author information

Authors and Affiliations

  1. Department of Information & Computer Science, King Fahd University of Petroleum & Minerals, Dhahran, Saudi Arabia

    Yasser A. Khan & Mohamed El-Attar

Authors
  1. Yasser A. Khan
    View author publications

    You can also search for this author in PubMed Google Scholar

  2. Mohamed El-Attar
    View author publications

    You can also search for this author in PubMed Google Scholar

Corresponding author

Correspondence to Mohamed El-Attar.

Rights and permissions

Reprints and permissions

About this article

Check for updates. Verify currency and authenticity via CrossMark

Cite this article

Khan, Y.A., El-Attar, M. Using model transformation to refactor use case models based on antipatterns. Inf Syst Front 18, 171–204 (2016). https://doi.org/10.1007/s10796-014-9528-z

Download citation

  • Published:

  • Issue Date:

  • DOI: https://doi.org/10.1007/s10796-014-9528-z

Keywords

Search

Navigation