A method for obtaining formal software specifications from knowledge representation languages

Vista sencilla de ítem
dc.contributor.advisorZapata Jaramillo, Carlos Mario
dc.contributor.advisorManrique Losada, Bell
dc.contributor.authorManjarrés Betancur, Roberto Antonio
dc.contributor.researchgroupLenguajes Computacionalesspa
dc.date.accessioned2024-05-16T14:25:26Z
dc.date.available2024-05-16T14:25:26Z
dc.date.issued2023
dc.description.abstractSoftware 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)eng
dc.description.abstractLos 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.spa
dc.description.curricularareaIngeniería De Sistemas E Informática.Sede Medellínspa
dc.description.degreelevelDoctoradospa
dc.description.degreenameDoctor en Ingenieríaspa
dc.description.researchareaIngeniería de Softwarespa
dc.format.extent81 páginasspa
dc.format.mimetypeapplication/pdfspa
dc.identifier.instnameUniversidad Nacional de Colombiaspa
dc.identifier.reponameRepositorio Institucional Universidad Nacional de Colombiaspa
dc.identifier.repourlhttps://repositorio.unal.edu.co/spa
dc.identifier.urihttps://repositorio.unal.edu.co/handle/unal/86094
dc.language.isoengspa
dc.publisherUniversidad Nacional de Colombiaspa
dc.publisher.branchUniversidad Nacional de Colombia - Sede Medellínspa
dc.publisher.facultyFacultad de Minasspa
dc.publisher.placeMedellín, Colombiaspa
dc.publisher.programMedellín - Minas - Doctorado en Ingeniería - Sistemasspa
dc.relation.indexedLaReferenciaspa
dc.relation.referencesAbdelnabi, 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.9329301spa
dc.relation.referencesAbdelnabi, 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.9464433spa
dc.relation.referencesAbrial, 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/CBO9781139195881spa
dc.relation.referencesAlkhammash, 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-zspa
dc.relation.referencesAmjad, 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.2883610spa
dc.relation.referencesAng, A., & Hartley, M. (2007). Object oriented knowledge representation framework for requirements engineering. 477–482.spa
dc.relation.referencesAwan, 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.9812644spa
dc.relation.referencesBen 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.10266spa
dc.relation.referencesBernardo, 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.606614spa
dc.relation.referencesBorgida, 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.6894857spa
dc.relation.referencesBoussetoua, 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.7507176spa
dc.relation.referencesBruijn, 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.ch002spa
dc.relation.referencesBruneliere, 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.007spa
dc.relation.referencesCaetano, 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-0spa
dc.relation.referencesChu, 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.9287702spa
dc.relation.referencesClavel, 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.spa
dc.relation.referencesCorreia, A., & e Abreu, F. (2012). Adding Preciseness to BPMN Models. Procedia Technology, 5, 407–417. https://doi.org/10.1016/j.protcy.2012.09.045spa
dc.relation.referencesCouto, 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.5spa
dc.relation.referencesDick, J., Hull, E., & Jackson, K. (2017). Requirements Engineering (4th ed.). Springer, Chan.spa
dc.relation.referencesDjaoui, 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.00081spa
dc.relation.referencesDubois, 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.13644spa
dc.relation.referencesFinne, 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-1spa
dc.relation.referencesGasevic, 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-9spa
dc.relation.referencesGiorgini, 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_22spa
dc.relation.referencesGogolla, 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.001spa
dc.relation.referencesHahn, C., Schmitt, F., Tillman, J., Metzger, N., Siber, J., & Finkbeiner, B. (2022). Formal Specifications from Natural Language. https://doi.org/10.48550/arXiv.2206.01962spa
dc.relation.referencesHlaoui, 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.135spa
dc.relation.referencesJamal, 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.7838579spa
dc.relation.referencesJena, 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_23spa
dc.relation.referencesJiang, 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.20spa
dc.relation.referencesKarolita, D., Kanij, T., Grundy, J., McIntosh, J., & Obie, H. (2023). Use of Personas in Requirements Engineering: A Systematic Literature Review.spa
dc.relation.referencesKleppe, 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.848769spa
dc.relation.referencesLapouchnian, 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-9spa
dc.relation.referencesMaio, P. Di. (2021). System Level Knowledge Representation for Complexity. 2021 IEEE International Systems Conference (SysCon), 1–6. https://doi.org/10.1109/SysCon48628.2021.9447091spa
dc.relation.referencesMeziani, 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.00080spa
dc.relation.referencesOMG. (2011). OMG Unified Modeling Language (OMG UML), Superstructure, Version 2.4.1. http://www.omg.org/spec/UML/2.4.1spa
dc.relation.referencesPang, 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.7819246spa
dc.relation.referencesParkes, A. (2002). Introduction to Languages, Machines and Logic. https://doi.org/10.1007/978-1-4471-0143-7spa
dc.relation.referencesPé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:69512866spa
dc.relation.referencesPé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.007spa
dc.relation.referencesPopescu, 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.007spa
dc.relation.referencesRabinia, 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.78spa
dc.relation.referencesRamadan, 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-xspa
dc.relation.referencesRies, 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/0010216600410052spa
dc.relation.referencesRodrí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.2883500spa
dc.relation.referencesRoss, 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.229899spa
dc.relation.referencesSabri, M. (2015). REQUIREMENTS ENGINEERING DOMAIN KNOWLEDGE IN INFORMATION TECHNOLOGY. SSRN Electronic Journal, 3, 55–62.spa
dc.relation.referencesSammi, R., Rubab, I., & Qureshi, M. A. (2010). Formal specification languages for real-time systems. 3, 1642–1647. https://doi.org/10.1109/ITSIM.2010.5561643spa
dc.relation.referencesSangiorgi, D., & Walker, D. (2001). PI-Calculus: A Theory of Mobile Processes. Cambridge University Press.spa
dc.relation.referencesSaratha, 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.59spa
dc.relation.referencesSengupta, 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.5276507spa
dc.relation.referencesSharaff, 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.9071490spa
dc.relation.referencesSiddique, 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.spa
dc.relation.referencesSon, H. S., & Kim, R. Y. C. (2017). XCodeParser based on Abstract Syntax Tree Metamodel (ASTM) for SW visualization. Information (Japan), 20, 963–968.spa
dc.relation.referencesSonbol, R., Rebdawi, G., & Ghneim, N. (2020, June). Towards a Semantic Representation for Functional Software Requirements. https://doi.org/10.1109/AIRE51212.2020.00007spa
dc.relation.referencesSpivey, J. M. (1989). The Z Notation: A Reference Manual. Prentice-Hall, Inc.spa
dc.relation.referencesSun, 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.41spa
dc.relation.referencesTariq, 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.8342881spa
dc.relation.referencesTichelaar, S., Ducasse, S., & Demeyer, S. (2000). FAMIX: Exchange Experiences with CDIF and XMI.spa
dc.relation.referencesTorlak 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.spa
dc.relation.referencesVarzi, A. (2022). Complementary Logics for Classical Propositional Languages. Kriterion (Austria), 1. https://doi.org/10.1515/krt-1992-010406spa
dc.relation.referencesWang, 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/09511920802232902spa
dc.relation.referencesWieringa, 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_18spa
dc.relation.referencesWohlin, 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-2spa
dc.relation.referencesXu, 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.5974744spa
dc.relation.referencesZapata, 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 productsspa
dc.relation.referencesZapata, 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.spa
dc.relation.referencesZimmermann, A. (2008). Colored Petri Nets. https://doi.org/10.1007/978-3-540-74173-2_6spa
dc.rights.accessrightsinfo:eu-repo/semantics/openAccessspa
dc.rights.licenseAtribución-NoComercial-SinDerivadas 4.0 Internacionalspa
dc.rights.urihttp://creativecommons.org/licenses/by-nc-nd/4.0/spa
dc.subject.ddc000 - Ciencias de la computación, información y obras generalesspa
dc.subject.ddc000 - Ciencias de la computación, información y obras generales::005 - Programación, programas, datos de computaciónspa
dc.subject.lembLenguajes de programación (Computadores electrónicos)
dc.subject.lembRepresentación del conocimiento
dc.subject.lembProgramación (Computadores electrónicos)
dc.subject.proposalKnowledge representationeng
dc.subject.proposalRequirements Engineeringeng
dc.subject.proposalSoftware modeleng
dc.subject.proposalFormal specificationeng
dc.subject.proposalRepresentación del conocimientospa
dc.subject.proposalIngeniería de requisitosspa
dc.subject.proposalModelo de softwarespa
dc.subject.proposalEspecificación formalspa
dc.titleA method for obtaining formal software specifications from knowledge representation languageseng
dc.title.translatedUn método para la obtención de especificaciones formales de software a partir de leguajes de representación del conocimientospa
dc.typeTrabajo de grado - Doctoradospa
dc.type.coarhttp://purl.org/coar/resource_type/c_db06spa
dc.type.coarversionhttp://purl.org/coar/version/c_ab4af688f83e57aaspa
dc.type.contentTextspa
dc.type.driverinfo:eu-repo/semantics/doctoralThesisspa
dc.type.redcolhttp://purl.org/redcol/resource_type/TDspa
dc.type.versioninfo:eu-repo/semantics/acceptedVersionspa
dcterms.audience.professionaldevelopmentEstudiantesspa
dcterms.audience.professionaldevelopmentInvestigadoresspa
dcterms.audience.professionaldevelopmentMaestrosspa
oaire.accessrightshttp://purl.org/coar/access_right/c_abf2spa

Archivos

Bloque original

Mostrando 1 - 1 de 1
Miniatura
Nombre:
71262410.2023.pdf
Tamaño:
1.77 MB
Formato:
Adobe Portable Document Format
Descripción:
Tesis de Doctorado en Ingeniería - Sistemas
Descargar

Bloque de licencias

Mostrando 1 - 1 de 1
Miniatura
Nombre:
license.txt
Tamaño:
5.74 KB
Formato:
Item-specific license agreed upon to submission
Descripción:
Descargar

Colecciones

Doctorado en Ingeniería - Sistemas