A method for obtaining formal software specifications from knowledge representation languages

Software analysts use knowledge representation languages for characterizing the knowledge from stakeholders in the requirements engineering phase. Such languages encompass software models based on the unified modeling language and structured methods, including entity-relationship diagrams, class dia...

Full description

Autores:
Manjarrés Betancur, Roberto Antonio
Tipo de recurso:
Doctoral thesis
Fecha de publicación:
2023
Institución:
Universidad Nacional de Colombia
Repositorio:
Universidad Nacional de Colombia
Idioma:
eng
OAI Identifier:
oai:repositorio.unal.edu.co:unal/86094
Acceso en línea:
https://repositorio.unal.edu.co/handle/unal/86094
https://repositorio.unal.edu.co/
Palabra clave:
000 - Ciencias de la computación, información y obras generales
000 - Ciencias de la computación, información y obras generales::005 - Programación, programas, datos de computación
Lenguajes de programación (Computadores electrónicos)
Representación del conocimiento
Programación (Computadores electrónicos)
Knowledge representation
Requirements Engineering
Software model
Formal specification
Representación del conocimiento
Ingeniería de requisitos
Modelo de software
Especificación formal
Rights
openAccess
License
Atribución-NoComercial-SinDerivadas 4.0 Internacional
id UNACIONAL2_542a2a9260d57ced0c422e86cf22d3d8
oai_identifier_str oai:repositorio.unal.edu.co:unal/86094
network_acronym_str UNACIONAL2
network_name_str Universidad Nacional de Colombia
repository_id_str
dc.title.eng.fl_str_mv A method for obtaining formal software specifications from knowledge representation languages
dc.title.translated.spa.fl_str_mv Un método para la obtención de especificaciones formales de software a partir de leguajes de representación del conocimiento
title A method for obtaining formal software specifications from knowledge representation languages
spellingShingle A method for obtaining formal software specifications from knowledge representation languages
000 - Ciencias de la computación, información y obras generales
000 - Ciencias de la computación, información y obras generales::005 - Programación, programas, datos de computación
Lenguajes de programación (Computadores electrónicos)
Representación del conocimiento
Programación (Computadores electrónicos)
Knowledge representation
Requirements Engineering
Software model
Formal specification
Representación del conocimiento
Ingeniería de requisitos
Modelo de software
Especificación formal
title_short A method for obtaining formal software specifications from knowledge representation languages
title_full A method for obtaining formal software specifications from knowledge representation languages
title_fullStr A method for obtaining formal software specifications from knowledge representation languages
title_full_unstemmed A method for obtaining formal software specifications from knowledge representation languages
title_sort A method for obtaining formal software specifications from knowledge representation languages
dc.creator.fl_str_mv Manjarrés Betancur, Roberto Antonio
dc.contributor.advisor.none.fl_str_mv Zapata Jaramillo, Carlos Mario
Manrique Losada, Bell
dc.contributor.author.none.fl_str_mv Manjarrés Betancur, Roberto Antonio
dc.contributor.researchgroup.spa.fl_str_mv Lenguajes Computacionales
dc.subject.ddc.spa.fl_str_mv 000 - Ciencias de la computación, información y obras generales
000 - Ciencias de la computación, información y obras generales::005 - Programación, programas, datos de computación
topic 000 - Ciencias de la computación, información y obras generales
000 - Ciencias de la computación, información y obras generales::005 - Programación, programas, datos de computación
Lenguajes de programación (Computadores electrónicos)
Representación del conocimiento
Programación (Computadores electrónicos)
Knowledge representation
Requirements Engineering
Software model
Formal specification
Representación del conocimiento
Ingeniería de requisitos
Modelo de software
Especificación formal
dc.subject.lemb.none.fl_str_mv Lenguajes de programación (Computadores electrónicos)
Representación del conocimiento
Programación (Computadores electrónicos)
dc.subject.proposal.eng.fl_str_mv Knowledge representation
Requirements Engineering
Software model
Formal specification
dc.subject.proposal.spa.fl_str_mv Representación del conocimiento
Ingeniería de requisitos
Modelo de software
Especificación formal
description Software analysts use knowledge representation languages for characterizing the knowledge from stakeholders in the requirements engineering phase. Such languages encompass software models based on the unified modeling language and structured methods, including entity-relationship diagrams, class diagrams, cause-and-effect diagrams, and conceptual graphs. While such models are used for effectively representing the basic features of a software system, they still fail on including the behavior and components coming from complex software systems. Formal specifications comprise texts, math, and logic-based notations for representing the knowledge of a given domain. Software analysts use formal specifications for mitigating the impact of the ambiguity coming from traditional knowledge representation languages, easing computational processes, inference, and unambiguous validation of knowledge. However, the generation and validation of formal specifications require expertise in mathematics and logic from both software analysts and stakeholders, thereby impeding effective communication and validation of the software domain. In this Ph.D. Thesis, we propose a novel approach for bridging the gap between formal languages and knowledge representation languages. Our approach contributes to the fields of knowledge representation and formal languages by allowing software analysts for generating precise and comprehensive formal specifications from any knowledge representation language, regardless of their mathematical and logical proficiency. This approach eases the validation of resulting specifications by stakeholders. The proposed method is validated by developing three case studies. Our approach is a new work product for unambiguous knowledge representation. Also, our method is designed for supporting the requirements engineering phase as a new tool for software analysts. (Tomado de la fuente)
publishDate 2023
dc.date.issued.none.fl_str_mv 2023
dc.date.accessioned.none.fl_str_mv 2024-05-16T14:25:26Z
dc.date.available.none.fl_str_mv 2024-05-16T14:25:26Z
dc.type.spa.fl_str_mv Trabajo de grado - Doctorado
dc.type.driver.spa.fl_str_mv info:eu-repo/semantics/doctoralThesis
dc.type.version.spa.fl_str_mv info:eu-repo/semantics/acceptedVersion
dc.type.coar.spa.fl_str_mv http://purl.org/coar/resource_type/c_db06
dc.type.content.spa.fl_str_mv Text
dc.type.redcol.spa.fl_str_mv http://purl.org/redcol/resource_type/TD
format http://purl.org/coar/resource_type/c_db06
status_str acceptedVersion
dc.identifier.uri.none.fl_str_mv https://repositorio.unal.edu.co/handle/unal/86094
dc.identifier.instname.spa.fl_str_mv Universidad Nacional de Colombia
dc.identifier.reponame.spa.fl_str_mv Repositorio Institucional Universidad Nacional de Colombia
dc.identifier.repourl.spa.fl_str_mv https://repositorio.unal.edu.co/
url https://repositorio.unal.edu.co/handle/unal/86094
https://repositorio.unal.edu.co/
identifier_str_mv Universidad Nacional de Colombia
Repositorio Institucional Universidad Nacional de Colombia
dc.language.iso.spa.fl_str_mv eng
language eng
dc.relation.indexed.spa.fl_str_mv LaReferencia
dc.relation.references.spa.fl_str_mv Abdelnabi, E. A., Maatuk, A. M., Abdelaziz, T. M., & Elakeili, S. M. (2020). Generating UML Class Diagram using NLP Techniques and Heuristic Rules. 2020 20th International Conference on Sciences and Techniques of Automatic Control and Computer Engineering (STA), 277–282. https://doi.org/10.1109/STA50679.2020.9329301
Abdelnabi, E., Maatuk, A., & Hagal, M. (2021). Generating UML Class Diagram from Natural Language Requirements: A Survey of Approaches and Techniques. 288–293. https://doi.org/10.1109/MI-STA52233.2021.9464433
Abrial, J.-R. (2010). Modeling in Event-B - System and Software Engineering. In Modeling in Event-B: System and Software Engineering. https://doi.org/10.1017/CBO9781139195881
Alkhammash, E. (2020). Formal modelling of OWL ontologies-based requirements for the development of safe and secure smart city systems. Soft Computing, 24. https://doi.org/10.1007/s00500-020-04688-z
Amjad, A., Azam, F., Anwar, M., Haider, W., Rashid, M., & Naeem, A. (2018). UMLPACE for Modeling and Verification of Complex Business Requirements in Event-driven Process Chain (EPC). IEEE Access, 6, 1. https://doi.org/10.1109/ACCESS.2018.2883610
Ang, A., & Hartley, M. (2007). Object oriented knowledge representation framework for requirements engineering. 477–482.
Awan, M. M., Butt, W. H., Anwar, M. W., & Azam, F. (2022). Seamless Runtime Transformations from Natural Language to Formal Methods – A usecase of Z-Notation. 2022 17th Annual System of Systems Engineering Conference (SOSE), 375–380. https://doi.org/10.1109/SOSE55472.2022.9812644
Ben Younes, A., Ben Daly Hlaoui, Y., Ben Ayed, L., & Bessifi, M. (2019). From BPMN2 to Event B: A Specification and Verification Approach of Workflow Applications. 2019 IEEE 43rd Annual Computer Software and Applications Conference (COMPSAC), 2, 561–566. https://doi.org/10.1109/COMPSAC.2019.10266
Bernardo, M., Ciancarini, P., & Donatiello, L. (2002). Architecting Families of Software Systems with Process Algebras. ACM Trans. Softw. Eng. Methodol., 11(4), 386–426. https://doi.org/10.1145/606612.606614
Borgida, A., Horkoff, J., & Mylopoulos, J. (2014). Applying knowledge representation and reasoning to (simple) goal models. 2014 IEEE 1st International Workshop on Artificial Intelligence for Requirements Engineering (AIRE), 53–59. https://doi.org/10.1109/AIRE.2014.6894857
Boussetoua, R., Bennoui, H., Chaoui, A., Khalfaoui, K., & Kerkouche, E. (2015). An automatic approach to transform BPMN models to Pi-Calculus. 2015 IEEE/ACS 12th International Conference of Computer Systems and Applications (AICCSA), 1–8. https://doi.org/10.1109/AICCSA.2015.7507176
Bruijn, J. (2007). Logics for the Semantic Web. Semantic Web Services: Theory, Tools and Applications, 24–43. https://doi.org/10.4018/978-1-59904-045-5.ch002
Bruneliere, H., Cabot, J., Dupé, G., & Madiot, F. (2014). MoDisco: a Model Driven Reverse Engineering Framework. Information and Software Technology, 56. https://doi.org/10.1016/j.infsof.2014.04.007
Caetano, A., Antunes, G., Pombinho, J., Bakhshandeh, M., Granjo, J., Borbinha, J., & da Silva, M. M. (2017). Representation and analysis of enterprise models with semantic techniques: an application to ArchiMate, e3value and business model canvas. Knowledge and Information Systems, 50(1), 315–346. https://doi.org/10.1007/s10115-016-0933-0
Chu, M.-H., & Dang, D.-H. (2020). Automatic Extraction of Analysis Class Diagrams from Use Cases. 2020 12th International Conference on Knowledge and Systems Engineering (KSE), 109–114. https://doi.org/10.1109/KSE50997.2020.9287702
Clavel, M., Durán, F., Eker, S., Lincoln, P., Martí-Oliet, N., Meseguer, J., & Quesada, J. (2002). Maude: specification and programming in rewriting logic. Theor. Comput. Sci., 285, 187–243.
Correia, A., & e Abreu, F. (2012). Adding Preciseness to BPMN Models. Procedia Technology, 5, 407–417. https://doi.org/10.1016/j.protcy.2012.09.045
Couto, R., Ribeiro, A., & Campos, J. (2014). Application of Ontologies in Identifying Requirements Patterns in Use Cases. Electronic Proceedings in Theoretical Computer Science, 147. https://doi.org/10.4204/EPTCS.147.5
Dick, J., Hull, E., & Jackson, K. (2017). Requirements Engineering (4th ed.). Springer, Chan.
Djaoui, C., Kerkouche, E., Chaoui, A., & Khalfaoui, K. (2018). A Graph Transformation Approach to Generate Analysable Maude Specifications from UML Interaction Overview Diagrams. 2018 IEEE International Conference on Information Reuse and Integration (IRI), 511–517. https://doi.org/10.1109/IRI.2018.00081
Dubois, E., Hagelstein, J., Lahou, E., Ponsaert, F., & André, R. (1986). A knowledge representation language for requirements engineering. Proceedings of the IEEE, 74, 1431–1444. https://doi.org/10.1109/PROC.1986.13644
Finne, A. (2011). Towards a quality meta-model for information systems. Software Quality Journal, 19(4), 663–688. https://doi.org/10.1007/s11219-011-9131-1
Gasevic, D., Djuric, D., & Devedzic, V. (2006). Model Driven Architecture and Ontology Development. In Model Driven Architecture and Ontology Development. https://doi.org/10.1007/3-540-32182-9
Giorgini, P., Mylopoulos, J., Nicchiarelli, E., & Sebastiani, R. (2002). Reasoning with Goal Models. LNCS, 2503, 167–181. https://doi.org/10.1007/3-540-45816-6_22
Gogolla, M., Hilken, F., & Doan, K.-H. (2017). Achieving Model Quality through Model Validation, Verification and Exploration. Computer Languages, Systems & Structures, 54. https://doi.org/10.1016/j.cl.2017.10.001
Hahn, C., Schmitt, F., Tillman, J., Metzger, N., Siber, J., & Finkbeiner, B. (2022). Formal Specifications from Natural Language. https://doi.org/10.48550/arXiv.2206.01962
Hlaoui, Y. B., Younes, A. Ben, Ben Ayed, L. J., & Fathalli, M. (2017). From Sequence Diagrams to Event B: A Specification and Verification Approach of Flexible Workflow Applications of Cloud Services Based on Meta-model Transformation. 2017 IEEE 41st Annual Computer Software and Applications Conference (COMPSAC), 2, 187–192. https://doi.org/10.1109/COMPSAC.2017.135
Jamal, M., & Zafar, N. A. (2016). Formalizing structural semantics of UML 2.5 activity diagram in Z Notation. 2016 International Conference on Open Source Systems & Technologies (ICOSST), 66–71. https://doi.org/10.1109/ICOSST.2016.7838579
Jena, A., Swain, S., & Mohapatra, D. (2015). Model Based Test Case Generation from UML Sequence and Interaction Overview Diagrams. Smart Innovation, Systems and Technologies, 32, 247–257. https://doi.org/10.1007/978-81-322-2208-8_23
Jiang, T., She, Y., & Wang, X. (2016). An Approach for Automatically Verifying Metamodels Consistency. International Journal of Simulation Systems, Science and Technology, 17, 20.1-20.7. https://doi.org/10.5013/IJSSST.a.17.27.20
Karolita, D., Kanij, T., Grundy, J., McIntosh, J., & Obie, H. (2023). Use of Personas in Requirements Engineering: A Systematic Literature Review.
Kleppe, A., & Warmer, J. (2000). Making UML activity diagrams object-oriented. Proceedings 33rd International Conference on Technology of Object-Oriented Languages and Systems TOOLS 33, 288–299. https://doi.org/10.1109/TOOLS.2000.848769
Lapouchnian, A. (2005). Goal-Oriented Requirements Engineering : An Overview of the Current Research. Requirements Engineering, 8(3), 32. https://doi.org/10.1007/s00766-003-0178-9
Maio, P. Di. (2021). System Level Knowledge Representation for Complexity. 2021 IEEE International Systems Conference (SysCon), 1–6. https://doi.org/10.1109/SysCon48628.2021.9447091
Meziani, L., Bouabana-Tebibel, T., & Bouzar-Benlabiod, L. (2018). From Petri Nets to UML Model: A New Transformation Approach. 2018 IEEE International Conference on Information Reuse and Integration (IRI), 503–510. https://doi.org/10.1109/IRI.2018.00080
OMG. (2011). OMG Unified Modeling Language (OMG UML), Superstructure, Version 2.4.1. http://www.omg.org/spec/UML/2.4.1
Pang, C., Pakonen, A., Buzhinsky, I., & Vyatkin, V. (2016, June). A Study on User-Friendly Formal Specification Languages for Requirements Formalization. https://doi.org/10.1109/INDIN.2016.7819246
Parkes, A. (2002). Introduction to Languages, Machines and Logic. https://doi.org/10.1007/978-1-4471-0143-7
Pérez, B., & Porres, I. (2019). Reasoning about UML/OCL class diagrams using constraint logic programming and formula. Inf. Syst., 81, 152–177. https://api.semanticscholar.org/CorpusID:69512866
Pérez-Castillo, R., Guzmán, I., & Piattini, M. (2011). Knowledge Discovery Metamodel-ISO/IEC 19506: A standard to modernize legacy systems. Computer Standards & Interfaces, 33, 519–532. https://doi.org/10.1016/j.csi.2011.02.007
Popescu, D., & Dumitrache, I. (2023). Knowledge representation and reasoning using interconnected uncertain rules for describing workflows in complex systems. Information Fusion, 93. https://doi.org/10.1016/j.inffus.2023.01.007
Rabinia, A., & Ghanavati, S. (2017). FOL-Based Approach for Improving Legal-GRL Modeling Framework: A Case for Requirements Engineering of Legal Regulations of Social Media. 213–218. https://doi.org/10.1109/REW.2017.78
Ramadan, Q., Strüber, D., Salnitri, M., Jürjens, J., Riediger, V., & Staab, S. (2020). A semi-automated BPMN-based framework for detecting conflicts between security, data-minimization, and fairness requirements. Software and Systems Modeling. https://doi.org/10.1007/s10270-020-00781-x
Ries, B., Guelfi, N., & Jahic, B. (2021). An MDE Method for Improving Deep Learning Dataset Requirements Engineering using Alloy and UML. 41–52. https://doi.org/10.5220/0010216600410052
Rodríguez-Gil, L., García-Zubia, J., Orduña, P., Villar-Martinez, A., & López-De-Ipiña, Di. (2019). New Approach for Conversational Agent Definition by Non-Programmers: A Visual Domain-Specific Language. IEEE Access, 7, 5262–5276. https://doi.org/10.1109/ACCESS.2018.2883500
Ross, D. T., & Schoman, K. E. (1977). Structured Analysis for Requirements Definition. IEEE Transactions on Software Engineering, SE-3(1), 6–15. https://doi.org/10.1109/TSE.1977.229899
Sabri, M. (2015). REQUIREMENTS ENGINEERING DOMAIN KNOWLEDGE IN INFORMATION TECHNOLOGY. SSRN Electronic Journal, 3, 55–62.
Sammi, R., Rubab, I., & Qureshi, M. A. (2010). Formal specification languages for real-time systems. 3, 1642–1647. https://doi.org/10.1109/ITSIM.2010.5561643
Sangiorgi, D., & Walker, D. (2001). PI-Calculus: A Theory of Mobile Processes. Cambridge University Press.
Saratha, P., Uma, G. V, & Santhosh, B. (2017). Formal Specification for Online Food Ordering System Using Z Language. 2017 Second International Conference on Recent Trends and Challenges in Computational Models (ICRTCCM), 343–348. https://doi.org/10.1109/ICRTCCM.2017.59
Sengupta, S., & Bhattacharya, S. (2006). Formalization of UML use case diagram-a Z notation based approach. 2006 International Conference on Computing & Informatics, 1–6. https://doi.org/10.1109/ICOCI.2006.5276507
Sharaff, A., & Rath, S. K. (2020). Formalization of UML Class Diagram Using Colored Petri Nets. 2020 First International Conference on Power, Control and Computing Technologies (ICPC2T), 311–315. https://doi.org/10.1109/ICPC2T48082.2020.9071490
Siddique, A. B., Qadri, S., Hussain, S., Ahmad, S., Maqbool, I., Karim, A., & Khan, A. K. (2014, June). INTEGRATION OF REQUIREMENT ENGINEERING WITH UML IN SOFTWARE ENGINEERING PRACTICES.
Son, H. S., & Kim, R. Y. C. (2017). XCodeParser based on Abstract Syntax Tree Metamodel (ASTM) for SW visualization. Information (Japan), 20, 963–968.
Sonbol, R., Rebdawi, G., & Ghneim, N. (2020, June). Towards a Semantic Representation for Functional Software Requirements. https://doi.org/10.1109/AIRE51212.2020.00007
Spivey, J. M. (1989). The Z Notation: A Reference Manual. Prentice-Hall, Inc.
Sun, W., Zhang, H., Feng, C., & Fu, Y. (2016). A Method Based on Meta-model for the Translation from UML into Event-B. 2016 IEEE International Conference on Software Quality, Reliability and Security Companion (QRS-C), 271–277. https://doi.org/10.1109/QRS-C.2016.41
Tariq, O., Sang, J., Gulzar, K., & Xiang, H. (2017). Automated analysis of UML activity diagram using CPNs. 2017 8th IEEE International Conference on Software Engineering and Service Science (ICSESS), 134–138. https://doi.org/10.1109/ICSESS.2017.8342881
Tichelaar, S., Ducasse, S., & Demeyer, S. (2000). FAMIX: Exchange Experiences with CDIF and XMI.
Torlak Emina and Jackson, D. (2007). Kodkod: A Relational Model Finder. In M. Grumberg Orna and Huth (Ed.), Tools and Algorithms for the Construction and Analysis of Systems (pp. 632–647). Springer Berlin Heidelberg.
Varzi, A. (2022). Complementary Logics for Classical Propositional Languages. Kriterion (Austria), 1. https://doi.org/10.1515/krt-1992-010406
Wang, M., & Zeng, Y. (2009). Asking the right questions to elicit product requirements. International Journal of Computer Integrated Manufacturing, 22(4), 283–298. https://doi.org/10.1080/09511920802232902
Wieringa, R. J., & Wieringa, R. J. (2014). Single-Case Mechanism Experiments. In Design Science Methodology for Information Systems and Software Engineering (pp. 247–267). Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-662-43839-8_18
Wohlin, C., Runeson, P., Höst, M., Ohlsson, M. C., Regnell, B., & Wesslén, A. (2012). Experimentation in software engineering. In Experimentation in Software Engineering (Vol. 9783642290). https://doi.org/10.1007/978-3-642-29044-2
Xu, Y. (2011). The formal semantics of UML activity diagram based on Process Algebra. 2011 International Conference on Computer Science and Service System (CSSS), 2729–2732. https://doi.org/10.1109/CSSS.2011.5974744
Zapata, C. M. (2012). The UNC-Method Revisited: Elements of the New Approach Eliciting Software Requirements in a Complete, Consistent, and Correct Way. LAP LAMBERT Academic Publishing GmbH & Co, 5, 2013. https://www.lap-publishing.com/catalog/details/store/de/book/978-3-8484-0759-0/the-unc-method-revisited:-elements-of-the-new-approach?search=organic products
Zapata, C. M., & Arango, F. (2009). The UNC-method : a problem-based software development method UNC-Method : un método de desarrollo de software basado en problemas. Revista Ingeniería e Investigación, 29(1), 69–75.
Zimmermann, A. (2008). Colored Petri Nets. https://doi.org/10.1007/978-3-540-74173-2_6
dc.rights.coar.fl_str_mv http://purl.org/coar/access_right/c_abf2
dc.rights.license.spa.fl_str_mv Atribución-NoComercial-SinDerivadas 4.0 Internacional
dc.rights.uri.spa.fl_str_mv http://creativecommons.org/licenses/by-nc-nd/4.0/
dc.rights.accessrights.spa.fl_str_mv info:eu-repo/semantics/openAccess
rights_invalid_str_mv Atribución-NoComercial-SinDerivadas 4.0 Internacional
http://creativecommons.org/licenses/by-nc-nd/4.0/
http://purl.org/coar/access_right/c_abf2
eu_rights_str_mv openAccess
dc.format.extent.spa.fl_str_mv 81 páginas
dc.format.mimetype.spa.fl_str_mv application/pdf
dc.publisher.spa.fl_str_mv Universidad Nacional de Colombia
dc.publisher.program.spa.fl_str_mv Medellín - Minas - Doctorado en Ingeniería - Sistemas
dc.publisher.faculty.spa.fl_str_mv Facultad de Minas
dc.publisher.place.spa.fl_str_mv Medellín, Colombia
dc.publisher.branch.spa.fl_str_mv Universidad Nacional de Colombia - Sede Medellín
institution Universidad Nacional de Colombia
bitstream.url.fl_str_mv https://repositorio.unal.edu.co/bitstream/unal/86094/1/license.txt
https://repositorio.unal.edu.co/bitstream/unal/86094/2/71262410.2023.pdf
https://repositorio.unal.edu.co/bitstream/unal/86094/3/71262410.2023.pdf.jpg
bitstream.checksum.fl_str_mv eb34b1cf90b7e1103fc9dfd26be24b4a
996a1c0e6065d5dedd0756f38476d40b
d1b25f86ba69717dbf913f074282d566
bitstream.checksumAlgorithm.fl_str_mv MD5
MD5
MD5
repository.name.fl_str_mv Repositorio Institucional Universidad Nacional de Colombia
repository.mail.fl_str_mv repositorio_nal@unal.edu.co
_version_ 1814089561980010496
spelling Atribución-NoComercial-SinDerivadas 4.0 Internacionalhttp://creativecommons.org/licenses/by-nc-nd/4.0/info:eu-repo/semantics/openAccesshttp://purl.org/coar/access_right/c_abf2Zapata Jaramillo, Carlos Mario1f6ccc2b9bc8fd5381ffd55aef7e7d86Manrique Losada, Bellc32a18ec83001490b2397eaac2368436Manjarrés Betancur, Roberto Antonio5ffd25d70a69138288f42baacb44f559Lenguajes Computacionales2024-05-16T14:25:26Z2024-05-16T14:25:26Z2023https://repositorio.unal.edu.co/handle/unal/86094Universidad Nacional de ColombiaRepositorio Institucional Universidad Nacional de Colombiahttps://repositorio.unal.edu.co/Software analysts use knowledge representation languages for characterizing the knowledge from stakeholders in the requirements engineering phase. Such languages encompass software models based on the unified modeling language and structured methods, including entity-relationship diagrams, class diagrams, cause-and-effect diagrams, and conceptual graphs. While such models are used for effectively representing the basic features of a software system, they still fail on including the behavior and components coming from complex software systems. Formal specifications comprise texts, math, and logic-based notations for representing the knowledge of a given domain. Software analysts use formal specifications for mitigating the impact of the ambiguity coming from traditional knowledge representation languages, easing computational processes, inference, and unambiguous validation of knowledge. However, the generation and validation of formal specifications require expertise in mathematics and logic from both software analysts and stakeholders, thereby impeding effective communication and validation of the software domain. In this Ph.D. Thesis, we propose a novel approach for bridging the gap between formal languages and knowledge representation languages. Our approach contributes to the fields of knowledge representation and formal languages by allowing software analysts for generating precise and comprehensive formal specifications from any knowledge representation language, regardless of their mathematical and logical proficiency. This approach eases the validation of resulting specifications by stakeholders. The proposed method is validated by developing three case studies. Our approach is a new work product for unambiguous knowledge representation. Also, our method is designed for supporting the requirements engineering phase as a new tool for software analysts. (Tomado de la fuente)Los analistas de software usan lenguajes de representación del conocimiento para caracterizar el conocimiento proveniente de los interesados en la fase de ingeniería de requisitos. Estos lenguajes comprenden modelos de software basados en el lenguaje unificado de modelado y métodos estructurados, incluyendo diagramas entidad-relación, diagrama de clases, diagramas causa-efecto y grafos conceptuales. Si bien estos modelos se usan para representar características básicas de un sistema de software de manera efectiva, estos modelos todavía tienen limitaciones al representar el comportamiento y componentes de sistemas de software complejos. Las especificaciones formales incluyen textos, matemáticas y notaciones basadas en lógica para representar el conocimiento relacionado a un dominio específico. Los analistas de software usan especificaciones formales para mitigar el impacto de la ambigüedad inherente en los lenguajes de representación del conocimiento tradicionales, facilitando procesos computacionales, inferencia y la validación no ambigua de conocimiento. Sin embargo, la generación y validación de especificaciones formales requiere experiencia en matemáticas y lógica por parte de los analistas de software e interesados, impidiendo una comunicación y validación efectiva del dominio de software. En esta Tesis de Doctorado, proponemos un novedoso enfoque para cerrar la brecha entre los lenguajes formales y los lenguajes de representación de conocimiento. Este enfoque contribuye a los campos de representación del conocimiento y lenguajes formales, permitiéndole a los analistas de software generar especificaciones formales precisas y completas desde cualquier lenguaje de representación del conocimiento sin importar su experiencia en matemáticas y lógica. Este enfoque facilita la validación de especificaciones a los interesados. El método propuesto es validado desarrollando tres casos de estudio. Este enfoque es un nuevo producto de trabajo para la representación de conocimiento no ambigua. Además, este método está diseñado para apoyar la fase de ingeniería de requisitos como una nueva herramienta para el analista de software.DoctoradoDoctor en IngenieríaIngeniería de SoftwareIngeniería De Sistemas E Informática.Sede Medellín81 páginasapplication/pdfengUniversidad Nacional de ColombiaMedellín - Minas - Doctorado en Ingeniería - SistemasFacultad de MinasMedellín, ColombiaUniversidad Nacional de Colombia - Sede Medellín000 - Ciencias de la computación, información y obras generales000 - Ciencias de la computación, información y obras generales::005 - Programación, programas, datos de computaciónLenguajes de programación (Computadores electrónicos)Representación del conocimientoProgramación (Computadores electrónicos)Knowledge representationRequirements EngineeringSoftware modelFormal specificationRepresentación del conocimientoIngeniería de requisitosModelo de softwareEspecificación formalA method for obtaining formal software specifications from knowledge representation languagesUn método para la obtención de especificaciones formales de software a partir de leguajes de representación del conocimientoTrabajo de grado - Doctoradoinfo:eu-repo/semantics/doctoralThesisinfo:eu-repo/semantics/acceptedVersionhttp://purl.org/coar/resource_type/c_db06Texthttp://purl.org/redcol/resource_type/TDLaReferenciaAbdelnabi, E. A., Maatuk, A. M., Abdelaziz, T. M., & Elakeili, S. M. (2020). Generating UML Class Diagram using NLP Techniques and Heuristic Rules. 2020 20th International Conference on Sciences and Techniques of Automatic Control and Computer Engineering (STA), 277–282. https://doi.org/10.1109/STA50679.2020.9329301Abdelnabi, E., Maatuk, A., & Hagal, M. (2021). Generating UML Class Diagram from Natural Language Requirements: A Survey of Approaches and Techniques. 288–293. https://doi.org/10.1109/MI-STA52233.2021.9464433Abrial, J.-R. (2010). Modeling in Event-B - System and Software Engineering. In Modeling in Event-B: System and Software Engineering. https://doi.org/10.1017/CBO9781139195881Alkhammash, E. (2020). Formal modelling of OWL ontologies-based requirements for the development of safe and secure smart city systems. Soft Computing, 24. https://doi.org/10.1007/s00500-020-04688-zAmjad, A., Azam, F., Anwar, M., Haider, W., Rashid, M., & Naeem, A. (2018). UMLPACE for Modeling and Verification of Complex Business Requirements in Event-driven Process Chain (EPC). IEEE Access, 6, 1. https://doi.org/10.1109/ACCESS.2018.2883610Ang, A., & Hartley, M. (2007). Object oriented knowledge representation framework for requirements engineering. 477–482.Awan, M. M., Butt, W. H., Anwar, M. W., & Azam, F. (2022). Seamless Runtime Transformations from Natural Language to Formal Methods – A usecase of Z-Notation. 2022 17th Annual System of Systems Engineering Conference (SOSE), 375–380. https://doi.org/10.1109/SOSE55472.2022.9812644Ben Younes, A., Ben Daly Hlaoui, Y., Ben Ayed, L., & Bessifi, M. (2019). From BPMN2 to Event B: A Specification and Verification Approach of Workflow Applications. 2019 IEEE 43rd Annual Computer Software and Applications Conference (COMPSAC), 2, 561–566. https://doi.org/10.1109/COMPSAC.2019.10266Bernardo, M., Ciancarini, P., & Donatiello, L. (2002). Architecting Families of Software Systems with Process Algebras. ACM Trans. Softw. Eng. Methodol., 11(4), 386–426. https://doi.org/10.1145/606612.606614Borgida, A., Horkoff, J., & Mylopoulos, J. (2014). Applying knowledge representation and reasoning to (simple) goal models. 2014 IEEE 1st International Workshop on Artificial Intelligence for Requirements Engineering (AIRE), 53–59. https://doi.org/10.1109/AIRE.2014.6894857Boussetoua, R., Bennoui, H., Chaoui, A., Khalfaoui, K., & Kerkouche, E. (2015). An automatic approach to transform BPMN models to Pi-Calculus. 2015 IEEE/ACS 12th International Conference of Computer Systems and Applications (AICCSA), 1–8. https://doi.org/10.1109/AICCSA.2015.7507176Bruijn, J. (2007). Logics for the Semantic Web. Semantic Web Services: Theory, Tools and Applications, 24–43. https://doi.org/10.4018/978-1-59904-045-5.ch002Bruneliere, H., Cabot, J., Dupé, G., & Madiot, F. (2014). MoDisco: a Model Driven Reverse Engineering Framework. Information and Software Technology, 56. https://doi.org/10.1016/j.infsof.2014.04.007Caetano, A., Antunes, G., Pombinho, J., Bakhshandeh, M., Granjo, J., Borbinha, J., & da Silva, M. M. (2017). Representation and analysis of enterprise models with semantic techniques: an application to ArchiMate, e3value and business model canvas. Knowledge and Information Systems, 50(1), 315–346. https://doi.org/10.1007/s10115-016-0933-0Chu, M.-H., & Dang, D.-H. (2020). Automatic Extraction of Analysis Class Diagrams from Use Cases. 2020 12th International Conference on Knowledge and Systems Engineering (KSE), 109–114. https://doi.org/10.1109/KSE50997.2020.9287702Clavel, M., Durán, F., Eker, S., Lincoln, P., Martí-Oliet, N., Meseguer, J., & Quesada, J. (2002). Maude: specification and programming in rewriting logic. Theor. Comput. Sci., 285, 187–243.Correia, A., & e Abreu, F. (2012). Adding Preciseness to BPMN Models. Procedia Technology, 5, 407–417. https://doi.org/10.1016/j.protcy.2012.09.045Couto, R., Ribeiro, A., & Campos, J. (2014). Application of Ontologies in Identifying Requirements Patterns in Use Cases. Electronic Proceedings in Theoretical Computer Science, 147. https://doi.org/10.4204/EPTCS.147.5Dick, J., Hull, E., & Jackson, K. (2017). Requirements Engineering (4th ed.). Springer, Chan.Djaoui, C., Kerkouche, E., Chaoui, A., & Khalfaoui, K. (2018). A Graph Transformation Approach to Generate Analysable Maude Specifications from UML Interaction Overview Diagrams. 2018 IEEE International Conference on Information Reuse and Integration (IRI), 511–517. https://doi.org/10.1109/IRI.2018.00081Dubois, E., Hagelstein, J., Lahou, E., Ponsaert, F., & André, R. (1986). A knowledge representation language for requirements engineering. Proceedings of the IEEE, 74, 1431–1444. https://doi.org/10.1109/PROC.1986.13644Finne, A. (2011). Towards a quality meta-model for information systems. Software Quality Journal, 19(4), 663–688. https://doi.org/10.1007/s11219-011-9131-1Gasevic, D., Djuric, D., & Devedzic, V. (2006). Model Driven Architecture and Ontology Development. In Model Driven Architecture and Ontology Development. https://doi.org/10.1007/3-540-32182-9Giorgini, P., Mylopoulos, J., Nicchiarelli, E., & Sebastiani, R. (2002). Reasoning with Goal Models. LNCS, 2503, 167–181. https://doi.org/10.1007/3-540-45816-6_22Gogolla, M., Hilken, F., & Doan, K.-H. (2017). Achieving Model Quality through Model Validation, Verification and Exploration. Computer Languages, Systems & Structures, 54. https://doi.org/10.1016/j.cl.2017.10.001Hahn, C., Schmitt, F., Tillman, J., Metzger, N., Siber, J., & Finkbeiner, B. (2022). Formal Specifications from Natural Language. https://doi.org/10.48550/arXiv.2206.01962Hlaoui, Y. B., Younes, A. Ben, Ben Ayed, L. J., & Fathalli, M. (2017). From Sequence Diagrams to Event B: A Specification and Verification Approach of Flexible Workflow Applications of Cloud Services Based on Meta-model Transformation. 2017 IEEE 41st Annual Computer Software and Applications Conference (COMPSAC), 2, 187–192. https://doi.org/10.1109/COMPSAC.2017.135Jamal, M., & Zafar, N. A. (2016). Formalizing structural semantics of UML 2.5 activity diagram in Z Notation. 2016 International Conference on Open Source Systems & Technologies (ICOSST), 66–71. https://doi.org/10.1109/ICOSST.2016.7838579Jena, A., Swain, S., & Mohapatra, D. (2015). Model Based Test Case Generation from UML Sequence and Interaction Overview Diagrams. Smart Innovation, Systems and Technologies, 32, 247–257. https://doi.org/10.1007/978-81-322-2208-8_23Jiang, T., She, Y., & Wang, X. (2016). An Approach for Automatically Verifying Metamodels Consistency. International Journal of Simulation Systems, Science and Technology, 17, 20.1-20.7. https://doi.org/10.5013/IJSSST.a.17.27.20Karolita, D., Kanij, T., Grundy, J., McIntosh, J., & Obie, H. (2023). Use of Personas in Requirements Engineering: A Systematic Literature Review.Kleppe, A., & Warmer, J. (2000). Making UML activity diagrams object-oriented. Proceedings 33rd International Conference on Technology of Object-Oriented Languages and Systems TOOLS 33, 288–299. https://doi.org/10.1109/TOOLS.2000.848769Lapouchnian, A. (2005). Goal-Oriented Requirements Engineering : An Overview of the Current Research. Requirements Engineering, 8(3), 32. https://doi.org/10.1007/s00766-003-0178-9Maio, P. Di. (2021). System Level Knowledge Representation for Complexity. 2021 IEEE International Systems Conference (SysCon), 1–6. https://doi.org/10.1109/SysCon48628.2021.9447091Meziani, L., Bouabana-Tebibel, T., & Bouzar-Benlabiod, L. (2018). From Petri Nets to UML Model: A New Transformation Approach. 2018 IEEE International Conference on Information Reuse and Integration (IRI), 503–510. https://doi.org/10.1109/IRI.2018.00080OMG. (2011). OMG Unified Modeling Language (OMG UML), Superstructure, Version 2.4.1. http://www.omg.org/spec/UML/2.4.1Pang, C., Pakonen, A., Buzhinsky, I., & Vyatkin, V. (2016, June). A Study on User-Friendly Formal Specification Languages for Requirements Formalization. https://doi.org/10.1109/INDIN.2016.7819246Parkes, A. (2002). Introduction to Languages, Machines and Logic. https://doi.org/10.1007/978-1-4471-0143-7Pérez, B., & Porres, I. (2019). Reasoning about UML/OCL class diagrams using constraint logic programming and formula. Inf. Syst., 81, 152–177. https://api.semanticscholar.org/CorpusID:69512866Pérez-Castillo, R., Guzmán, I., & Piattini, M. (2011). Knowledge Discovery Metamodel-ISO/IEC 19506: A standard to modernize legacy systems. Computer Standards & Interfaces, 33, 519–532. https://doi.org/10.1016/j.csi.2011.02.007Popescu, D., & Dumitrache, I. (2023). Knowledge representation and reasoning using interconnected uncertain rules for describing workflows in complex systems. Information Fusion, 93. https://doi.org/10.1016/j.inffus.2023.01.007Rabinia, A., & Ghanavati, S. (2017). FOL-Based Approach for Improving Legal-GRL Modeling Framework: A Case for Requirements Engineering of Legal Regulations of Social Media. 213–218. https://doi.org/10.1109/REW.2017.78Ramadan, Q., Strüber, D., Salnitri, M., Jürjens, J., Riediger, V., & Staab, S. (2020). A semi-automated BPMN-based framework for detecting conflicts between security, data-minimization, and fairness requirements. Software and Systems Modeling. https://doi.org/10.1007/s10270-020-00781-xRies, B., Guelfi, N., & Jahic, B. (2021). An MDE Method for Improving Deep Learning Dataset Requirements Engineering using Alloy and UML. 41–52. https://doi.org/10.5220/0010216600410052Rodríguez-Gil, L., García-Zubia, J., Orduña, P., Villar-Martinez, A., & López-De-Ipiña, Di. (2019). New Approach for Conversational Agent Definition by Non-Programmers: A Visual Domain-Specific Language. IEEE Access, 7, 5262–5276. https://doi.org/10.1109/ACCESS.2018.2883500Ross, D. T., & Schoman, K. E. (1977). Structured Analysis for Requirements Definition. IEEE Transactions on Software Engineering, SE-3(1), 6–15. https://doi.org/10.1109/TSE.1977.229899Sabri, M. (2015). REQUIREMENTS ENGINEERING DOMAIN KNOWLEDGE IN INFORMATION TECHNOLOGY. SSRN Electronic Journal, 3, 55–62.Sammi, R., Rubab, I., & Qureshi, M. A. (2010). Formal specification languages for real-time systems. 3, 1642–1647. https://doi.org/10.1109/ITSIM.2010.5561643Sangiorgi, D., & Walker, D. (2001). PI-Calculus: A Theory of Mobile Processes. Cambridge University Press.Saratha, P., Uma, G. V, & Santhosh, B. (2017). Formal Specification for Online Food Ordering System Using Z Language. 2017 Second International Conference on Recent Trends and Challenges in Computational Models (ICRTCCM), 343–348. https://doi.org/10.1109/ICRTCCM.2017.59Sengupta, S., & Bhattacharya, S. (2006). Formalization of UML use case diagram-a Z notation based approach. 2006 International Conference on Computing & Informatics, 1–6. https://doi.org/10.1109/ICOCI.2006.5276507Sharaff, A., & Rath, S. K. (2020). Formalization of UML Class Diagram Using Colored Petri Nets. 2020 First International Conference on Power, Control and Computing Technologies (ICPC2T), 311–315. https://doi.org/10.1109/ICPC2T48082.2020.9071490Siddique, A. B., Qadri, S., Hussain, S., Ahmad, S., Maqbool, I., Karim, A., & Khan, A. K. (2014, June). INTEGRATION OF REQUIREMENT ENGINEERING WITH UML IN SOFTWARE ENGINEERING PRACTICES.Son, H. S., & Kim, R. Y. C. (2017). XCodeParser based on Abstract Syntax Tree Metamodel (ASTM) for SW visualization. Information (Japan), 20, 963–968.Sonbol, R., Rebdawi, G., & Ghneim, N. (2020, June). Towards a Semantic Representation for Functional Software Requirements. https://doi.org/10.1109/AIRE51212.2020.00007Spivey, J. M. (1989). The Z Notation: A Reference Manual. Prentice-Hall, Inc.Sun, W., Zhang, H., Feng, C., & Fu, Y. (2016). A Method Based on Meta-model for the Translation from UML into Event-B. 2016 IEEE International Conference on Software Quality, Reliability and Security Companion (QRS-C), 271–277. https://doi.org/10.1109/QRS-C.2016.41Tariq, O., Sang, J., Gulzar, K., & Xiang, H. (2017). Automated analysis of UML activity diagram using CPNs. 2017 8th IEEE International Conference on Software Engineering and Service Science (ICSESS), 134–138. https://doi.org/10.1109/ICSESS.2017.8342881Tichelaar, S., Ducasse, S., & Demeyer, S. (2000). FAMIX: Exchange Experiences with CDIF and XMI.Torlak Emina and Jackson, D. (2007). Kodkod: A Relational Model Finder. In M. Grumberg Orna and Huth (Ed.), Tools and Algorithms for the Construction and Analysis of Systems (pp. 632–647). Springer Berlin Heidelberg.Varzi, A. (2022). Complementary Logics for Classical Propositional Languages. Kriterion (Austria), 1. https://doi.org/10.1515/krt-1992-010406Wang, M., & Zeng, Y. (2009). Asking the right questions to elicit product requirements. International Journal of Computer Integrated Manufacturing, 22(4), 283–298. https://doi.org/10.1080/09511920802232902Wieringa, R. J., & Wieringa, R. J. (2014). Single-Case Mechanism Experiments. In Design Science Methodology for Information Systems and Software Engineering (pp. 247–267). Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-662-43839-8_18Wohlin, C., Runeson, P., Höst, M., Ohlsson, M. C., Regnell, B., & Wesslén, A. (2012). Experimentation in software engineering. In Experimentation in Software Engineering (Vol. 9783642290). https://doi.org/10.1007/978-3-642-29044-2Xu, Y. (2011). The formal semantics of UML activity diagram based on Process Algebra. 2011 International Conference on Computer Science and Service System (CSSS), 2729–2732. https://doi.org/10.1109/CSSS.2011.5974744Zapata, C. M. (2012). The UNC-Method Revisited: Elements of the New Approach Eliciting Software Requirements in a Complete, Consistent, and Correct Way. LAP LAMBERT Academic Publishing GmbH & Co, 5, 2013. https://www.lap-publishing.com/catalog/details/store/de/book/978-3-8484-0759-0/the-unc-method-revisited:-elements-of-the-new-approach?search=organic productsZapata, C. M., & Arango, F. (2009). The UNC-method : a problem-based software development method UNC-Method : un método de desarrollo de software basado en problemas. Revista Ingeniería e Investigación, 29(1), 69–75.Zimmermann, A. (2008). Colored Petri Nets. https://doi.org/10.1007/978-3-540-74173-2_6EstudiantesInvestigadoresMaestrosLICENSElicense.txtlicense.txttext/plain; charset=utf-85879https://repositorio.unal.edu.co/bitstream/unal/86094/1/license.txteb34b1cf90b7e1103fc9dfd26be24b4aMD51ORIGINAL71262410.2023.pdf71262410.2023.pdfTesis de Doctorado en Ingeniería - Sistemasapplication/pdf1854995https://repositorio.unal.edu.co/bitstream/unal/86094/2/71262410.2023.pdf996a1c0e6065d5dedd0756f38476d40bMD52THUMBNAIL71262410.2023.pdf.jpg71262410.2023.pdf.jpgGenerated Thumbnailimage/jpeg5397https://repositorio.unal.edu.co/bitstream/unal/86094/3/71262410.2023.pdf.jpgd1b25f86ba69717dbf913f074282d566MD53unal/86094oai:repositorio.unal.edu.co:unal/860942024-05-16 23:04:54.462Repositorio Institucional Universidad Nacional de Colombiarepositorio_nal@unal.edu.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

Publicaciones similares