Abstract
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.
Similar content being viewed by others
Notes
In our model, expressions in Manchester Syntax can be translated into description logics automatically and vice versa.
In description logics, roles represent binary relationships between classes.
References
Anton, A. (1996). Goal-based requirements analysis. In Proceedings of the second international conference on requirements engineering, pp. 136–144. IEEE.
Baader, F., Horrocks, I., & Sattler, U. (2007). Description logics. In van Harmelen, F., Lifschitz, V., Porter, B., editors, Handbook of knowledge representation. Amsterdam: Elsevier.
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.
Boehm, B. & In, H. (1999). Conflict analysis and negotiation aids for cost-quality requirements. Software Quality Professional, 1(2), 38–50.
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.
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.
Chung, K. (1993). Representing and using non-functional requirements: A process-oriented approach. IEEE Transactions on Software Engineering, 18(6), 483–497.
Clark & Parsia, LCC. (2012). Pellet—OWL 2 reasoner.
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.
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.
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.
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.
Dardenne, A., Van Lamsweerde, A., & Fickas, S. (1993). Goal-directed requirements acquisition. Science of Computer Programming, 20(1–2), 3–50.
DeMarco, T. (1979). Structured analysis and system specification. Upper Saddle River, NJ: Yourdon Press.
Doe, R. (2009). The standish group chaos report.
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.
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.
Egyed, A., & Grunbacher, P. (2004). Identifying requirements conflicts and cooperation: How quality attributes and automated traceability can help. IEEE Software, 21(6), 50–58.
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.
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.
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.
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.
Grundy, J., Hosking, J., & Mugridge, W. (1998). Inconsistency management for multiple-view software development environments. IEEE Transactions on Software Engineering, 24(11), 960–981.
Guarino, N., Oberle, D., & Staab, S. (2009). What is an ontology? Handbook on ontologies, pp. 1–17.
Henderson, P. (2006). Why large IT projects fail. ACM Transactions on Programming Languages and Systems, 15(5), 795–825.
Horridge, M., Drummond, N., Goodwin, J., Rector, A., Stevens, R., & Wang, H. (2006). The Manchester OWL Syntax. OWL: Experiences and directions, pp. 10–11.
Horridge, M., & Patel-Schneider, P. F. (2009). OWL 2 web ontology language manchester Syntax. W3C Working Group Note, W3C.
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.
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.
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.
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.
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.
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.
Kazakov, Y. (2008). Riq and sroiq shoiq.
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.
Krötzsch, M., Rudolph, S., & Hitzler, P. (2012). Complexities of horn description logics. ACM Transacton on Computer Logics To Appear.
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.
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.
Maedche, A., & Staab, S. (2001). Ontology learning for the semantic web. Intelligent systems. IEEE, 16(2), 72–79.
Mostow, J. (1985). Toward better models of the design process. AI Magazine, 6(1), 44.
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.
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.
Noy, N., & McGuinness, D., et al. (2001). Ontology development 101: A guide to creating your first ontology.
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.
Pratt-Hartmann, I. (2003). A two-variable fragment of English. Journal of Logic, Language and Information, 12(1), 13–45.
Pressman, R. S. (2005). Software engineering: A practitioner’s approach, 6th edn. Maidenherd: McGraw Hill.
Robinson, W., & Pawlowski, S. (1999). Managing requirements inconsistency with development goal monitors. IEEE Transactions on Software Engineering, 25(6), 816–835.
Ross, D. (1977). Structured Analysis (SA): A language for communicating ideas. IEEE Transactions on Software Engineering.
Rumbaugh, J., Blaha, M., Premerlani, W., Eddy, F., & Lorensen, W. (1991). Object-oriented modeling and design, Vol. 38. Upper Saddle River: Prentice Hall.
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.
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.
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.
Sistla, A. P., & Clarke, E. M. (1985). The complexity of propositional linear temporal logics. Journal of the ACM (JACM), 32(3), 733–749.
Sommerville, I. (2011). Software Engineering, 9th edition. Saddle River, NJ: Pearson Education Inc..
Sommerville, I., & Sawyer, P. (1997). Requirements engineering: A good practice guide. Bristol: Wiley.
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.
TONES. (2008). Tones ontology repository.
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.
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.
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.
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.
Van Lamsweerde, A., Darimont, R., & Letier, E. (1998). Managing conflicts in goal-driven requirements engineering. IEEE Transactions on Software Engineering, 24(11), 908–926.
Weston, N., Chitchyan, R., & Rashid, A. (2009). Formal semantic conflict detection in aspect-oriented requirements. Requirements Engineering, 14(4), 247–268.
Wiki, P. (2007).
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.
Zave, P., & Jackson, M. (1997). Four dark corners of requirements engineering. ACM Transactions on Software Engineering and Methodology (TOSEM), 6(1), 1–30.
Acknowledgements
We thank the anonymous reviewers for the helpful discussions and comments. This work is supported by the ARC Grant DP0987380.
Author information
Authors and Affiliations
Corresponding author
Appendix
Appendix
1.1 ReInDetector description
In this section, we present a scenario to demonstrate the functionality of REInDetector. The scenario in this demonstration is part of the traveler social networking use case which was taken in the evaluation section. The steps through this demonstration are described as followed.
-
1.
In the first step, the requirement F24_IfGrpCommNoForum is added (assume that it has not been added) (cf. Fig. 10).
-
2.
In this step, we show the value of domain knowledge and semantics and how they can help in detecting requirements inconsistencies. We use
-
F22_SupForum : System needs to provide a forum for discussions ( System SubClassOf supportFeature SOME Forum ).
-
F26_SupUserGroup : System supports the creation of user groups to facilitate the connection ( System SubClassOf supportFeature SOME UserGroup ).
-
F24_IfGrpCommNoForum : If the system supports any type of group communication, then no forum is needed ( supportFeature SOME GroupCommunication NOT (SubClassOf supportFeature SOME Forum) ).
But without a proper characterization of the associated relationship between the capture concepts, no problems can manifest (cf. Fig. 11). We wish to emphasize this point here, in particular, to motivate the need for proper knowledge representation in RE.
-
-
3.
Next, we demonstrate how the ontology editor can be used to define concepts, roles, instances, domain knowledge, rules, and constraints (cf. Fig. 12) In particular, we show how “UserGroup” can be defined as a sub-concept of “GroupCommunication”.
-
4.
Next, we show how to use the reasoner in analyzing requirements to identify inconsistencies and how the provided explanations may help requirements engineers get more insights into the problem (cf. Fig. 13).
-
5.
In the next step, we present the requirement query support provided by REInDetector. We particularly make a query to analyze a partial set of requirements which does not contains all requirements involved in the inconsistency. The results from the reasoner indicates that there is no inconsistency in this set of requirements (cf. Figure 14).
-
6.
In the final step of the demonstration, we show how the identified inconsistency can be resolved. In this case, that is done by removing one of the inconsistent requirements ( F24_IfGrpCommNoForum ) (cf. Fig. 15)
1.2 Availability
REInDetector, accompanied with a demo scenario and user quick-start guide are available for download at: http://www.ict.swin.edu.au/personal/huannguyen/REInDetector.html
Rights and permissions
About this article
Cite this article
Nguyen, T.H., Vo, B.Q., Lumpe, M. et al. KBRE: a framework for knowledge-based requirements engineering. Software Qual J 22, 87–119 (2014). https://doi.org/10.1007/s11219-013-9202-6
Published:
Issue Date:
DOI: https://doi.org/10.1007/s11219-013-9202-6