Software Quality Journal

, Volume 22, Issue 1, pp 121–149

From requirements to UML models and back: how automatic processing of text can support requirements engineering

  • Mathias Landhäußer
  • Sven J. Körner
  • Walter F. Tichy


Software engineering is supposed to be a structured process, but manual tasks leave much leeway. Ideally, these tasks lie in the hands of skilled analysts and software engineers. This includes creating the textual specification of the envisioned system as well as creating models for the software engineers. Usually, there is quite a bit of erosion during the process due to requirement changes, implementation decisions, etc. To deliver the software as specified, textual requirements, models, and the actual software need to be synchronized. However, in practice, the cost of manually maintaining consistency is too high. Our requirements engineering feedback system automates the process of keeping textual specification and models consistent when the models change. To improve overall processing of natural language specifications, our approach finds flaws in natural language specifications. In addition to the already published workshop paper, we show how well our tools support even non-software-engineers in improving texts. The case studies show that we can speed up the process of creation texts with fewer flaws significantly.


Natural language specification Ontology Modeling UML 


  1. Abrial, J.-R., Börger, E., & Langmaack, H. (1996). The steam boiler case study: Competition of formal program specification and development methods. In Formal methods for industrial applications. Specifying and programming the steam-boiler control (pp. 1–12). Berlin: Springer. URL:
  2. Ackerman, A. F., Buchwald, L. S., & Lewski, F. H. (1989). Software inspections: An effective verification process. Software, IEEE, 6(3), 31–36, ISSN 0740-7459. doi:10.1109/52.28121.
  3. Ambriola, V., & Gervasi, V. (2006). On the systematic analysis of natural language requirements with circe. Automated Software Engginiering, 13, 107–167, ISSN 0928-8910. doi:10.1007/s10515-006-5468-2. URL:
  4. Arkley, P., & Riddle, S. (2005). Overcoming the traceability benefit problem. In Proceedings of 13th IEEE International Requirements Engineering Conference (RE) (pp. 385–389). doi:10.1109/RE.2005.49.
  5. Bajwa, I. S., & Choudhary, M. A. (2006). Natural language processing based automated system for UML diagrams generation. In The 18th Saudi National Computer Conference on computer science (NCC18). Riyadh: The Saudi Computer Society (SCS).Google Scholar
  6. Berry, D. M. (2004). The inevitable pain of software development: Why there is no silver bullet. In M. Wirsing, A. Knapp, & S. Balsamo (Eds.), Proceedings of Monterey Workshop 2002: Radical Innovations of Software and Systems Engineering in the Future, LNCS 2941. Berlin: Springer.Google Scholar
  7. Berry, D. M. (2008). In A. Bucchiarone, S. Gnesi, & G. Trentanni (Eds.), A new quality model for natural language requirements specifications. URL:
  8. Berry, D. M., Kamsties, E., & Krieger, M. M. (2003). From contract drafting to software specification: Linguistic sources of ambiguity—a handbook. URL: Scholar
  9. Bohner, S. A., & Arnold, R. S. (Eds.). (1996). An introduction to software change impact analysis. In Software change impact analysis (pp. 1–26). Los Alamitos: IEEE Computer Society Press.Google Scholar
  10. Briand, L. C., Labiche, Y., & O’Sullivan, L. (2003). Impact analysis and change management of uml models. Technical Report SCE-03-01, Carleton University.Google Scholar
  11. Chantree, F., Nuseibeh, B., de Roeck, A., & Willis, A. (2006). Identifying nocuous ambiguities in natural language requirements. In RE ’06: Proceedings of the 14th IEEE International Requirements Engineering Conference (RE’06) (pp. 56–65). Washington, DC: IEEE Computer Society, ISBN 0-7695-2555-5. doi:10.1109/RE.2006.31.
  12. Chaumun, M. A., Kabaili, H., Keller, R. K., & Lustman, F. (2002). A change impact model for changeability assessment in object-oriented software systems. Science of Computer Programming, 45(2–3), 155–174, ISSN 0167-6423. doi:10.1016/S0167-6423(02)00058-8
  13. Chen, R. (2011). The old new thing. MSDN blogs. URL:
  14. Cheng, B. H. C., & Atlee, J. M. (2007). Research directions in requirements engineering. In Proceedingfs of Future of Software Engineering FOSE ’07. doi:10.1109/FOSE.2007.17, pp. 285–303.
  15. Courtois, P.-J., & Parnas, D. L. (1993). Documentation for safety critical software. In ICSE ’93: Proceedings of the 15th international conference on Software Engineering (pp. 315–323). Los Alamitos, CA: IEEE Computer Society Press. ISBN 0-89791-588-7.Google Scholar
  16. Daigle, L. (2004). WHOIS protocol specification. Internet. URL: The Internet Engineering Task Force (IETF).
  17. Davis, A., Overmyer, S., Jordan, K., Caruso, J., Dandashi, F., Dinh, A., Kincaid, G., Ledeboer, G., Reynolds, P., Sitaram, P., Ta, A., & Theofanos, M. (1993). Identifying and measuring quality in a software requirements specification. In Proceedings of the First International Software Metrics Symposium (pp. 141–152). ISBN 0-8186-3740-4. doi:10.1109/METRIC.1993.263792.
  18. Dawson, L., & Swatman, P. A. (1999). The use of object-oriented models in requirements engineering: A field study. In ICIS (pp. 260–273). doi:10.1145/352925.352949.
  19. Denger, C., Berry, D. M., & Kamsties, E. (2003). Higher quality requirements specifications through natural language patterns. In Proceedings of the IEEE International Conference on Software-Science, Technology & Engineering (SWSTE ’03) (p. 80). Washington, DC: IEEE Computer Society. ISBN 0-7695-2047-2. doi:10.1109/SWSTE.2003.1245428.
  20. Derre, B. (2010). Rückkopplung von Softwaremodelländerungen in textuelle Spezifikationen. Master’s thesis. Karlsruhe: Karlsruhe Institute of Technology.Google Scholar
  21. Deva Kumar, D., & Sanyal, R. (2008). Static UML model generator from analysis of requirements (SUGAR). In Advanced software engineering and its applications, 2008 (ASEA 2008) (pp. 77–84). doi:10.1109/ASEA.2008.25.
  22. Deva Kumar, D., & Sanyal, R. (2009). An innovative approach for generating static UML models from natural language requirements. In Advances in Software Engineering, vol. 30 of Communications in Computer and Information Science, pp. 147–163. Berlin: Springer. ISBN 978-3-642-10241-7 (Print) 978-3-642-10242-4 (Online). doi:10.1007/978-3-642-10242-4_13.
  23. Eclipse Modeling Framework Project. (2010). Eclipse modeling framework compare. URL: Last visited: 05/07/2012.
  24. Fabbrini, F., Fusani, M., Gnesi, S., & Lami, G. (2001). The linguistic approach to the natural language requirements quality: Benefit of the use of an automatic tool. In SEW ’01: Proceedings of the 26th Annual NASA Goddard Software Engineering Workshop (p. 97). Washington, DC: IEEE Computer Society. ISBN 0-7695-1456-1.Google Scholar
  25. Fagan, M. E. (1976). Design and code inspections to reduce errors in program development. IBM Systems Journal, 15(3), 182–211. doi:10.1109/ASEA.2008.25 CrossRefGoogle Scholar
  26. Fantechi, A., Gnesi, S., Lami, G., & Maccari, A. (2002). Application of linguistic techniques for use case analysis. In Proceedings of the IEEE International Conference on Requirements Engineering, 2002 (pp. 157–164). ISSN 1090-705X. doi:10.1109/ICRE.2002.1048518.
  27. Fillmore, C. J. (1969). Toward a modern theory of case. In D. A. Reibel, & S. A. Schane (Eds.), Modern studies in English (pp. 361–375). Englewood Cliffs: Prentice Hall.Google Scholar
  28. Fliedl, G., Kop, C., & Mayr, H. C. (2004). Recent results of the NLRE (natural language based requirements engineering) project. EMISA Forum, 24(1), 24–25.Google Scholar
  29. Fuchs, N. E., Schwertel, U., & Schwitter, R. (1999). Attempto controlled English—not just another logic specification language. Lecture Notes in Computer Science, 1559, 1–20, ISSN 0302-9743. doi:10.1007/3-540-48958-4_1.
  30. Gelhausen, T. (2010). Modellextraktion aus natürlichen Sprachen: Eine Methode zur systematischen Erstellung von Domänenmodellen. Ph.D. thesis. Karlsruhe: Karlsruhe Institute of Technology.Google Scholar
  31. Gelhausen, T., Derre, B., & Gei,  R. (2008). Customizing for model transformation. In Proceedings of GRaMoT ’08 (pp. 17–24). ACM. ISBN 978-1-60558-033-3. doi:10.1145/1402947.1402951.
  32. Gelhausen, T., & Tichy, W. F. (2007). Thematic role based generation of UML models from real world requirements. In Proceedings of the ICSC 2007, (pp. 282–289). doi:10.1109/ICOSC.2007.4338360.
  33. Glinz, M., Heymans, P., Persson, A., Sindre, G., Aurum, A., Madhavji, N. H., Paech, B., Regev, G., & Wieringa, R. (2009). Report on the working conference on requirements engineering: Foundation for software quality (REFSQ’09). ACM SIGSOFT Software Engineering Notes, 34(5), 40–45.CrossRefGoogle Scholar
  34. Han, J. (1997). Supporting impact analysis and change propagation in software engineering environments. In Proceedings of the 8th IEEE International Workshop on Software Technology and Engineering Practice (pp. 172–182). doi:10.1109/STEP.1997.615479.
  35. Harmain, H. M., & Gaizauskas, R. J. (2000). CM-Builder: An automated NL-based CASE tool. In ASE (pp. 45–54). doi:10.1109/ASE.2000.873649.
  36. Hasegawa, R., Kitamura, M., Kaiya, H., & Saeki, M. (2009). Extracting conceptual graphs from Japanese documents for software requirements modeling. In M. Kirchberg, & S. Link (Eds.), APCCM, vol. 96 of CRPIT (pp. 87–96). Australian Computer Society. ISBN 978-1-920682-77-4.Google Scholar
  37. Havasi, C., Speer, R., & Alonso, J. B. (2007). ConceptNet 3: A flexible, multilingual semantic network for common sense knowledge. In Recent advances in natural language processing. Borovets, Bulgaria. URL: Scholar
  38. Heitmeyer, C. L., Jeffords, R. D., & Labaw, B. G. (1996). Automated consistency checking of requirements specifications. ACM Transactions on Software Engineering Methodology, 5(3), 231–261, ISSN 1049-331X. doi:10.1145/234426.234431.Google Scholar
  39. IEEE Computer Society. (1998). IEEE recommended practice for software requirements specifications. IEEE Standard 830-1998, pp. 1–40. doi:10.1109/IEEESTD.1998.88286.
  40. Juristo, N., Moreno, A. M., & López, M. (2000). How to use linguistic instruments for object-oriented analysis. IEEE Software, 17(3), 80–89. doi:10.1109/52.896254.CrossRefGoogle Scholar
  41. Kaiya, H., & Saeki, M. (2005). Ontology based requirements analysis: Lightweight semantic processing approach. In Proceedings of Fifth International Conference on Quality Software (QSIC 2005) (pp. 223–230, 19–20). doi:10.1109/QSIC.2005.46.
  42. Kaiya, H., & Saeki, M. (2006). Using domain ontology as domain knowledge for requirements elicitation. In Proceedings of the IEEE International Conference Requirements Engineering (pp. 189–198, 11–15). doi:10.1109/RE.2006.72.
  43. Kamsties, E., Knethen, A. V., Philipps, J., & Schätz, B. (2001). An empirical investigation of the defect detection capabilities of requirements specification languages. In EMMSAD’01: Proceedings of the Sixth CAiSE/IFIP8.1 International Workshop on Evaluation of Modelling Methods in Systems Analysis and Design.Google Scholar
  44. Kiyavitskaya, N., Zeni, N., Mich, L., & Berry, D. M. (2008). Requirements for tools for ambiguity identification and measurement in natural language requirements specifications. Requirements Engineering, 13(3), 207–239, ISSN 0947-3602. doi:10.1007/s00766-008-0063-7.
  45. Konrad, S., & Cheng, B. H. C. (2005). Facilitating the construction of specification pattern-based properties. Requirements Engineering, IEEE International Conference on (pp. 329–338). doi:10.1109/RE.2005.29.
  46. Körner, S. J., & Brumm, T. (2010). Natural language specification improvement with ontologies. International Journal of Semantic Computing (IJSC), 03, 445–470.CrossRefGoogle Scholar
  47. Körner, S. J., & Landhäußer, M. (2010). Semantic enriching of natural language texts with automatic thematic role annotation. In Proceedings of the Natural language processing and information systems, and 15th international conference on Applications of natural language to information systems, NLDB’10 (pp. 92–99). Berlin: Springer. ISBN 3-642-13880-2, 978-3-642-13880-5.
  48. Körner, S. J., Landhäußer, M., Gelhausen, T., & Derre, B. (2012). RECAA – the requirements engineering complete automation approach. URL:
  49. Kroha, P. (2000). Preprocessing of requirements specification. In M. T. Ibrahim, J. Küng, & N. Revell (Eds), Database and expert systems applications, vol. 1873 of Lecture Notes in Computer Science (pp. 675–684). Berlin: Springer. ISBN, 978-3-540-67978-3. doi:10.1007/3-540-44469-6_63.
  50. Kroha, P., Gerber, P., & Rosenhainer, L. (2006). Towards generation of textual requirements descriptions from UML models. In Proceedings of the 9th International Conference Information Systems Implementation and Modelling ISIM2006 (pp. 31 – 38). ISIM.Google Scholar
  51. Kung, D. C., Gao, J., Hsia, P., Wen, F., Toyoshima, Y., & Chen, C. (1994). Change impact identification in object oriented software maintenance. In Proceedings of the International Conference on Software Maintenance (pp. 202–211). doi:10.1109/ICSM.1994.336774.
  52. Landhäußer, M., Körner, S. J., & Tichy, W. F. (2012). Synchronizing domain models with natural language specifications. In Proceedings of the Workshop on Realizing Artificial Intelligence Synergies in Software Engineering (RAISE’2012). doi:10.1109/RAISE.2012.6227965.
  53. Li, K., Dewar, R. G., & Pooley, R. J. (2005). Towards semi-automation in requirements elicitation: Mapping natural language and object-oriented concepts. In RE05 (pp. 5–7).Google Scholar
  54. Liaskos, S., Lapouchnian, A., Yu, Y., Yu, E., & Mylopoulos, J. (2006). On goal-based variability acquisition and analysis. In Proceedings of the 14th IEEE International Requirements Engineering Conference, RE ’06 (pp. 76–85). Washington, DC: IEEE Computer Society. ISBN 0-7695-2555-5. doi:10.1109/RE.2006.45.
  55. Liu, H., & Singh, P. (2004). ConceptNet—a practical commonsense reasoning tool-kit. BT Technology Journal, 22. URL:
  56. Mala, G. S. A., & Uma, G. V. (2006). Automatic construction of object oriented design models [UML diagrams] from natural language requirements specification. In PRICAI(pp. 1155–1159). Guilin, China. doi:10.1007/11801603_152.
  57. Meng, W. J., Rilling, J., Zhang, Y., Witte, R., & Charland, P. (2006). An ontological software comprehension process model. 3rd International Workshop on Metamodels, Schemas, Grammars, and Ontologies for Reverse Engineering (ATEM 2006). October 1st, Genoa, Italy.Google Scholar
  58. Meziane, F., Athanasakis, N., & Ananiadou, S. (2008). Generating natural language specifications from UML class diagrams. Requirements Engineering, 13(1), 1–18. doi:10.1007/s00766-007-0054-0.CrossRefGoogle Scholar
  59. Mich, L., Franch, M., & Inverardi, P. (2004). Market research for requirements analysis using linguistic tools. Requirements Engineering, 9, 40–56, ISSN 0947-3602. doi:10.1007/s00766-003-0179-8.
  60. Montes, A., Pacheco, H., Estrada, H., & Pastor, O. (2008). Conceptual model generation from requirements model: A natural language processing approach. In E. Kapetanios, V. Sugumaran, & M. Spiliopoulou (Eds.), NLDB, vol. 5039 of Lecture Notes in Computer Science (pp. 325–326). Berlin: Springer. ISBN 978-3-540-69857-9.Google Scholar
  61. Moreno, A. M., & van de Riet, R. P. (1997). Justification of the equivalence between linguistic and conceptual patterns for the object model.Google Scholar
  62. Natt och Dag, J., Gervasi, V., Brinkkemper, S., & Regnell, B. (2004). Speeding up requirements management in a product software company: Linking customer wishes to product requirements through linguistic engineering. In Proceedings of the Requirements Engineering Conference, 12th IEEE International, RE ’04 (pp. 283–294). Washington, DC: IEEE Computer Society. ISBN 0-7695-2174-6. doi:10.1109/RE.2004.47.
  63. Natt och Dag, J., Regnell, B., Gervasi, V., & Brinkkemper, S. (2005). A linguistic-engineering approach to large-scale requirements management. Software, IEEE, 22(1), 32–39. doi:10.1109/MS.2005.1.CrossRefGoogle Scholar
  64. Niu, N., & Easterbrook, S. (2008). Extracting and modeling product line functional requirements. In Proceedings of the 2008 16th IEEE International Requirements Engineering Conference, RE ’08 (pp. 155–164). Washington, DC: IEEE Computer Society. ISBN 978-0-7695-3309-4. doi:10.1109/RE.2008.49.
  65. Nuseibeh, B., & Easterbrook, S. (2000). Requirements engineering: A roadmap. In ICSE ’00: Proceedings of the Conference on The Future of Software Engineering (pp. 35–46). New York, NY: ACM Press. ISBN 1-58113-253-0. doi:10.1145/336512.336523.
  66. Overmyer, S. P., Lavoie, B., & Rambow, O. (2001). Conceptual modeling through linguistic analysis using LIDA. In Proceedings of the ICSE ’01 (pp. 401–410). Washington, DC: IEEE Computer Society. ISBN 0-7695-1050-7.Google Scholar
  67. Parnas, D. L. (1985). Software aspects of strategic defense systems. Communications of the ACM, 28(12), 1326–1335, ISSN 0001-0782. doi:10.1145/214956.214961.
  68. Pease, A., & Murray, W. (2003). An english to logic translator for ontology-based knowledge representation languages. In Natural Language Processing and Knowledge Engineering. Proceedings of the 2003 International Conference on (pp. 777–783). doi:10.1109/NLPKE.2003.1276010.
  69. Pisan, Y. (2000). Extending requirement specifications using analogy. In ICSE ’00: Proceedings of the 22nd international conference on Software engineering (pp. 70–76). New York, NY: ACM. ISBN 1-58113-206-9. doi:
  70. Reiter, E., & Dale, R. (2000). Building natural language generation systems. Natural language processing. Cambridge: Cambridge University Press. doi:10.2277/052102451X.
  71. Rumbaugh, J., Blaha, M., Premerlani, W., Eddy, F., & Lorensen, W. (1991). Object-oriented modeling and design. Upper Saddle River, NJ: Prentice-Hall, Inc. ISBN 0-13-629841-9.Google Scholar
  72. Rupp, C., & die SOPHISTen (2006). Requirements-Engineering und Management (4th ed.). Munich: Carl Hanser Verlag. ISBN 3-446-40509-7.Google Scholar
  73. Saeki, M. (2004). Ontology-based software development techniques. ERCIM News, 58, 14–15. URL:
  74. Smith, R. L., Avrunin, G. S., Clarke, L. A., & Osterweil, L. J. (2002). Propel: An approach supporting property elucidation. In ICSE 2002: Proceedings of the 24rd International Conference on Software Engineering (pp. 11–21). ISBN 1-58113-472-X.Google Scholar
  75. Volere. (2009). List of requirement engineering tools. URL:
  76. Wiegers, K. E. (2003). Software requirements : Practical techniques for gathering and managing requirements throughout the product development cycle (2nd. ed.). Redmond, WA: Microsoft Press. ISBN 0-7356-1879-8; 978-0-7356-1879-4.Google Scholar
  77. Wilson, W. M., Rosenberg, L. H., & Hyatt, L. E. (1997). Automated analysis of requirement specifications. In ICSE ’97: Proceedings of the 19th International Conference on Software Engineering (pp. 161–171). ISBN 0-89791-914-9.Google Scholar
  78. Xing, Z., & Stroulia, E. (2005). Umldiff: An algorithm for object-oriented design differencing. In Proceedings of the 20th IEEE/ACM international Conference on Automated software engineering, ASE ’05 (pp. 54–65). New York, NY: ACM. ISBN 1-58113-993-4. doi:10.1145/1101908.1101919.
  79. Yang, H., de Roeck, A., Gervasi, V., Willis, A., & Nuseibeh, B. (2010). Extending nocuous ambiguity analysis for anaphora in natural language requirements. In Proceedings of the 2010 18th IEEE International Requirements Engineering Conference, RE ’10 (pp. 25–34). Washington, DC: IEEE Computer Society. ISBN 978-0-7695-4162-4. doi:10.1109/RE.2010.14.
  80. Zhang, Y., Witte, R., Rilling, J., & Haarslev, V. (2006). An ontology-based approach for traceability recovery. In 3rd International Workshop on Metamodels, Schemas, Grammars, and Ontologies for Reverse Engineering (ATEM 2006). Jean-Marie Favre Dragan Gasevic Ralf Lämmel Andreas Winter.Google Scholar

Copyright information

© Springer Science+Business Media New York 2013

Authors and Affiliations

  • Mathias Landhäußer
    • 1
  • Sven J. Körner
    • 1
  • Walter F. Tichy
    • 1
  1. 1.Karlsruhe Institute of Technology (KIT)KarlsruheGermany

Personalised recommendations