Software Quality Journal

, Volume 22, Issue 1, pp 87–119 | Cite as

KBRE: a framework for knowledge-based requirements engineering

  • Tuong Huan NguyenEmail author
  • Bao Quoc Vo
  • Markus Lumpe
  • John Grundy


Detecting inconsistencies is a critical part of requirements engineering (RE) and has been a topic of interest for several decades. Domain knowledge and semantics of requirements not only play important roles in elaborating requirements but are also a crucial way to detect conflicts among them. In this paper, we present a novel knowledge-based RE framework (KBRE) in which domain knowledge and semantics of requirements are central to elaboration, structuring, and management of captured requirements. Moreover, we also show how they facilitate the identification of requirements inconsistencies and other-related problems. In our KBRE model, description logic (DL) is used as the fundamental logical system for requirements analysis and reasoning. In addition, the application of DL in the form of Manchester OWL Syntax brings simplicity to the formalization of requirements while preserving sufficient expressive power. A tool has been developed and applied to an industrial use case to validate our approach.


Requirements engineering Inconsistencies Identification Description logics Manchester OWL Syntax Ontology 



We thank the anonymous reviewers for the helpful discussions and comments. This work is supported by the ARC Grant DP0987380.


  1. Anton, A. (1996). Goal-based requirements analysis. In Proceedings of the second international conference on requirements engineering, pp. 136–144. IEEE.Google Scholar
  2. Baader, F., Horrocks, I., & Sattler, U. (2007). Description logics. In van Harmelen, F., Lifschitz, V., Porter, B., editors, Handbook of knowledge representation. Amsterdam: Elsevier.Google Scholar
  3. Boehm, B., Bose, P., Horowitz, E., & Lee, M. (1995). Software requirements negotiation and renegotiation aids: A theory-W based spiral approach. In Proceeding of the 17th international conference on software engineering, on IEEE, pp. 243–243.Google Scholar
  4. Boehm, B. & In, H. (1999). Conflict analysis and negotiation aids for cost-quality requirements. Software Quality Professional, 1(2), 38–50.Google Scholar
  5. Breaux, T., Antón, A., & Doyle, J. (2008). Semantic parameterization: A process for modeling domain descriptions. ACM Transactions on Software Engineering and Methodology (TOSEM), 18(2), 5.Google Scholar
  6. Brockmans, S., Volz, R., Eberhart, A., & Löffler, P. (2004). Visual modeling of owl dl ontologies using uml. The semantic web–ISWC 2004, pp. 198–213.Google Scholar
  7. Chung, K. (1993). Representing and using non-functional requirements: A process-oriented approach. IEEE Transactions on Software Engineering, 18(6), 483–497.Google Scholar
  8. Clark & Parsia, LCC. (2012). Pellet—OWL 2 reasoner.Google Scholar
  9. Corcho, O., & Gómez-Pérez, A. (2000). A roadmap to ontology specification languages. In Proceedings of the 12th European workshop on knowledge acquisition, modeling and management, EKAW ’00, London: Springer, pp. 80–96.Google Scholar
  10. Cregan, A., Schwitter, R., & Meyer, T. (2007). Sydney OWL Syntax—towards a controlled natural language syntax for OWL 1.1. In Proceedings of the OWLED 2007 workshop on OWL: Experiences and directions. OWLED.Google Scholar
  11. D’Aquin, M., & Noy, N. (2011). Where to publish and find ontologies? A survey of ontology libraries. Web Semantics: Science, Services and Agents on the World Wide Web.Google Scholar
  12. Dardenne, A., Fickas, S., & van Lamsweerde, A. (1991). Goal-directed concept acquisition in requirements elicitation. In Proceedings of the 6th international workshop on software specification and design, IEEE Computer Society Press, pp. 14–21.Google Scholar
  13. Dardenne, A., Van Lamsweerde, A., & Fickas, S. (1993). Goal-directed requirements acquisition. Science of Computer Programming, 20(1–2), 3–50.CrossRefzbMATHGoogle Scholar
  14. DeMarco, T. (1979). Structured analysis and system specification. Upper Saddle River, NJ: Yourdon Press.Google Scholar
  15. Doe, R. (2009). The standish group chaos report.Google Scholar
  16. Dwyer, M., Avrunin, G., & Corbett, J. (1999). Patterns in property specifications for finite-state verification. In Software engineering, 1999. proceedings of the 1999 international conference on IEEE, pp. 411–420.Google Scholar
  17. Dwyer, M. B., Avrunin, G. S., & Corbett, J. C. (1998). Property specification patterns for finite-state verification. In Proceedings of the second workshop on formal methods in software practice, pp. 7–15.Google Scholar
  18. Egyed, A., & Grunbacher, P. (2004). Identifying requirements conflicts and cooperation: How quality attributes and automated traceability can help. IEEE Software, 21(6), 50–58.CrossRefGoogle Scholar
  19. Fuchs, N., Höfler, S., Kaljurand, K., Rinaldi, F., & Schneider, G. (2005). Attempto controlled English: A knowledge representation language readable by humans and machines. Reasoning Web, pp. 95–95.Google Scholar
  20. Fuxman, A., Liu, L., Mylopoulos, J., Pistore, M., Roveri, M., & Traverso, P. (2004). Specifying and analyzing early requirements in tropos. Requirements Engineering, 9(2), 132–150.CrossRefGoogle Scholar
  21. Goldin, L., & Berry, D. (1997). Abstfinder, a prototype natural language text abstraction finder for use in requirements elicitation. Automated Software Engineering, 4(4), 375–412.CrossRefGoogle Scholar
  22. Greenspan, S., Mylopoulos, J., & Borgida, A. (1994). On formal requirements modeling languages: Rml revisited. In Proceedings of the 16th international conference on software engineering on IEEE Computer Society Press, pp. 135–147.Google Scholar
  23. Grundy, J., Hosking, J., & Mugridge, W. (1998). Inconsistency management for multiple-view software development environments. IEEE Transactions on Software Engineering, 24(11), 960–981.CrossRefGoogle Scholar
  24. Guarino, N., Oberle, D., & Staab, S. (2009). What is an ontology? Handbook on ontologies, pp. 1–17.Google Scholar
  25. Henderson, P. (2006). Why large IT projects fail. ACM Transactions on Programming Languages and Systems, 15(5), 795–825.Google Scholar
  26. Horridge, M., Drummond, N., Goodwin, J., Rector, A., Stevens, R., & Wang, H. (2006). The Manchester OWL Syntax. OWL: Experiences and directions, pp. 10–11.Google Scholar
  27. Horridge, M., & Patel-Schneider, P. F. (2009). OWL 2 web ontology language manchester Syntax. W3C Working Group Note, W3C.Google Scholar
  28. Horrocks, I., Kutz, O., & Sattler, U. (2006). The even more irresistible SROIQ. In Proceedings of the 10th international conference on principles of knowledge representation and reasoning, pp. 57–67.Google Scholar
  29. Jaramillo, C., Gelbukh, A., & Isaza, F. (2006). Pre-conceptual schema: A conceptual-graph-like knowledge representation for requirements elicitation. MICAI 2006: Advances in Artificial Intelligence, pp. 27–37.Google Scholar
  30. Kaiya, H., & Saeki, M. (2005). Ontology based requirements analysis: Lightweight semantic processing approach. In Proceedings of the fifth international conference on quality software on IEEE, pp. 223–230.Google Scholar
  31. Kaiya, H., Shimizu, Y., Yasui, H., Kaijiri, K., & Saeki, M. (2010). Enhancing domain knowledge for requirements elicitation with web mining. In Proceedings of the 17th Asia Pacific software engineering conference on IEEE, pp. 3–12.Google Scholar
  32. Kalyanpur, A., Parsia, B., Sirin, E., Grau, B., & Hendler, J. (2006). Swoop: A ’Web’ Ontology Editing browser. Web Semantics: Science, Services and Agents on the World Wide Web, 4(2), 144–153.CrossRefGoogle Scholar
  33. Kamalrudin, M., Grundy, J., & Hosking, J. (2010). Managing consistency between textual requirements, abstract interactions and essential use cases. In Proceedings of the 34th annual IEEE computer software and applications conference on IEEE, pp. 327–336.Google Scholar
  34. Kazakov, Y. (2008). Riq and sroiq shoiq.Google Scholar
  35. Kenzi, K., Soffer, P., & Hadar, I. (2010). The role of domain knowledge in requirements elicitation: An exploratory study. In Proceedings of the 5th mediterranean conference on information systems. paper 48.Google Scholar
  36. Krötzsch, M., Rudolph, S., & Hitzler, P. (2012). Complexities of horn description logics. ACM Transacton on Computer Logics To Appear.Google Scholar
  37. Lauenroth, K., & Pohl, K. (2008). Dynamic consistency checking of domain requirements in product line engineering. In Proceedings of the 16th IEEE international conference on requirements engineering on IEEE, pp. 193–202.Google Scholar
  38. Lee, J. (1991). Extending the potts and bruns model for recording design rationale. In Proceedings of the 13th international conference on software engineering on IEEE, pp. 114–125.Google Scholar
  39. Maedche, A., & Staab, S. (2001). Ontology learning for the semantic web. Intelligent systems. IEEE, 16(2), 72–79.Google Scholar
  40. Mostow, J. (1985). Toward better models of the design process. AI Magazine, 6(1), 44.Google Scholar
  41. Mylopoulos, J., Borgida, A., Jarke, M., & Koubarakis, M. (1990). Telos: Representing knowledge about information systems. ACM Transactions on Information Systems (TOIS), 8(4), 325–362.CrossRefGoogle Scholar
  42. Noy, N., Crubézy, M., Fergerson, R., Knublauch, H., Tu, S., Vendetti, J., & Musen, M., et al. (2003). Protégé-2000: An open-source ontology-Development and Knowledge-Acquisition Environment. In Proceedings of the AMIA annual symposium, p. 953.Google Scholar
  43. Noy, N., & McGuinness, D., et al. (2001). Ontology development 101: A guide to creating your first ontology.Google Scholar
  44. O’Madadhain, J., Fisher, D., Smyth, P., White, S., & Boey, Y. (2005). Analysis and visualization of network data using JUNG. Journal of Statistical Software, 10(2), 1–25.Google Scholar
  45. Pratt-Hartmann, I. (2003). A two-variable fragment of English. Journal of Logic, Language and Information, 12(1), 13–45.CrossRefzbMATHMathSciNetGoogle Scholar
  46. Pressman, R. S. (2005). Software engineering: A practitioner’s approach, 6th edn. Maidenherd: McGraw Hill.Google Scholar
  47. Robinson, W., & Pawlowski, S. (1999). Managing requirements inconsistency with development goal monitors. IEEE Transactions on Software Engineering, 25(6), 816–835.CrossRefGoogle Scholar
  48. Ross, D. (1977). Structured Analysis (SA): A language for communicating ideas. IEEE Transactions on Software Engineering.Google Scholar
  49. Rumbaugh, J., Blaha, M., Premerlani, W., Eddy, F., & Lorensen, W. (1991). Object-oriented modeling and design, Vol. 38. Upper Saddle River: Prentice Hall.Google Scholar
  50. Schwitter, R. (2002). English as a formal specification language. In Database and expert systems applications. Proceedings of the 13th international workshop on IEEE, pp. 228–232.Google Scholar
  51. Schwitter, R., Kaljurand, K., Cregan, A., Dolbear, C., & Hart, G. (2008). A comparison of three controlled natural languages for owl 1.1. In 4th OWL experiences and directions workshop (OWLED 2008 DC), Washington, pp. 1–2.Google Scholar
  52. Siegemund, K., Thomas, E., Zhao, Y., Pan, J., & Assmann, U. (2011). Towards Ontology-driven Requirements Engineering. In Proceedings of the 7th international workshop on semantic web enabled software engineering on SWESE.Google Scholar
  53. Sistla, A. P., & Clarke, E. M. (1985). The complexity of propositional linear temporal logics. Journal of the ACM (JACM), 32(3), 733–749.CrossRefzbMATHMathSciNetGoogle Scholar
  54. Sommerville, I. (2011). Software Engineering, 9th edition. Saddle River, NJ: Pearson Education Inc..Google Scholar
  55. Sommerville, I., & Sawyer, P. (1997). Requirements engineering: A good practice guide. Bristol: Wiley.zbMATHGoogle Scholar
  56. Spanoudakis, G., & Zisman, A. (2001). Inconsistency management in software engineering: Survey and open research issues. Handbook of software engineering and knowledge engineering, 1, pp. 329–380.CrossRefGoogle Scholar
  57. TONES. (2008). Tones ontology repository.Google Scholar
  58. Tsai, J., Weigert, T., & Jang, H. (1992). A hybrid knowledge representation as a basis of requirement specification and specification analysis. Software Engineering, IEEE Transactions on, 18(12), 1076–1100.CrossRefGoogle Scholar
  59. Van Lamsweerde, A. (2000). Requirements engineering in the year 00: A research perspective. In Proceedings of the 22nd international conference on software engineering on ACM, pp. 5–19.Google Scholar
  60. Van Lamsweerde, A. (2001). Goal-oriented requirements engineering: A guided tour. In Proceedings of the fifth IEEE international symposium on requirements engineering on IEEE, pp. 249–262.Google Scholar
  61. van Lamsweerde, A. (2003). Goal-oriented requirements engineering: From system objectives to uml models to precise software specifications. In Proceedings of the 25th international conference on software engineering on IEEE computer society, pp. 744–745.Google Scholar
  62. Van Lamsweerde, A., Darimont, R., & Letier, E. (1998). Managing conflicts in goal-driven requirements engineering. IEEE Transactions on Software Engineering, 24(11), 908–926.CrossRefGoogle Scholar
  63. Weston, N., Chitchyan, R., & Rashid, A. (2009). Formal semantic conflict detection in aspect-oriented requirements. Requirements Engineering, 14(4), 247–268.CrossRefGoogle Scholar
  64. Wiki, P. (2007).Google Scholar
  65. Yu, E. (1993). Modeling organizations for information systems requirements engineering. In Proceedings of the IEEE international symposium on requirements engineering on IEEE, pp. 34–41.Google Scholar
  66. Zave, P., & Jackson, M. (1997). Four dark corners of requirements engineering. ACM Transactions on Software Engineering and Methodology (TOSEM), 6(1), 1–30.CrossRefGoogle Scholar

Copyright information

© Springer Science+Business Media New York 2013

Authors and Affiliations

  • Tuong Huan Nguyen
    • 1
    Email author
  • Bao Quoc Vo
    • 1
  • Markus Lumpe
    • 1
  • John Grundy
    • 1
  1. 1.Faculty of Information and Communication TechnologySwinburne University of TechnologyMelbourneAustralia

Personalised recommendations