@inproceedings{krasniqi_capturing_2023,
	address = {Bogotá, Colombia},
	title = {Capturing {Contextual} {Relationships} of {Buggy} {Classes} for {Detecting} {Quality}-{Related} {Bugs}},
	isbn = {9798350327830},
	url = {https://ieeexplore.ieee.org/document/10336297/},
	doi = {10.1109/ICSME58846.2023.00048},
	abstract = {Quality concerns are critical for addressing system-wide issues related to reliability, security, and performance, among others. However, these concerns often become scattered across the codebase, making it challenging for software developers to effectively address quality bugs. In this paper, we propose a holistic approach to detecting and clustering quality-related content hidden within the codebase. By leveraging the Hierarchical Dirichlet Process (HDP) and complementary techniques such as information retrieval and machine learning, including structural and textual analysis, we create a meaningful hierarchy that detects classes containing relevant information for addressing quality bugs. This approach allows us to uncover rich synergies between complex structured artifacts and infer bug-fixing classes for repairing quality bugs. The reported results show that our approach improves over the state-of-the-art achieving a high precision of 83\%, recall of 82\%, and F1 score of 83\%.},
	urldate = {2023-12-16},
	booktitle = {2023 {IEEE} {International} {Conference} on {Software} {Maintenance} and {Evolution} ({ICSME})},
	publisher = {IEEE},
	author = {Krasniqi, Rrezarta and Do, Hyunsook},
	year = {2023},
	keywords = {Conference Short Papers},
	pages = {375--379},
}

Quality concerns are critical for addressing system-wide issues related to reliability, security, and performance, among others. However, these concerns often become scattered across the codebase, making it challenging for software developers to effectively address quality bugs. In this paper, we propose a holistic approach to detecting and clustering quality-related content hidden within the codebase. By leveraging the Hierarchical Dirichlet Process (HDP) and complementary techniques such as information retrieval and machine learning, including structural and textual analysis, we create a meaningful hierarchy that detects classes containing relevant information for addressing quality bugs. This approach allows us to uncover rich synergies between complex structured artifacts and infer bug-fixing classes for repairing quality bugs. The reported results show that our approach improves over the state-of-the-art achieving a high precision of 83%, recall of 82%, and F1 score of 83%.

@article{krasniqi_multi-model_2023,
	title = {A {Multi}-{Model} {Framework} for {Semantically} {Enhancing} {Detection} of {Quality}-{Related} {Bug} {Report} {Descriptions}},
	volume = {28},
	issn = {1382-3256, 1573-7616},
	url = {https://link.springer.com/article/10.1007/s10664-022-10280-w},
	doi = {10.1007/s10664-022-10280-w},
	abstract = {Maintaining and delivering a high-quality software system is a delicate process. One way to ensure that a software system achieves the desired quality is to systematically monitor and timely address quality-related concerns. Quality concerns, such as reliability, usability, performance, and maintainability, among others, can have a broad impact in ensuring that a system remains consistently reliant and available at all times. In contrast, when such concerns are overlooked, become difficult to navigate, or maintain, system-wide failures could emerge. Typically, these failures can chiefly hinder the core functionality of the system and produce a large amount of quality bug reports. For the developers, manually examining these high-impacted quality-related bug reports in open-source issue tracking systems can become a prohibitively expensive and impractical task to deliver. Partly, because such bugs often require expert knowledge to address them. The more perplexing concern is the fact that these bugs are deemed difficult to detect due to their intertwined relationship with functional bugs. Even worse, there are instances when several types of quality concerns are intertwined among each other. Seemingly, these scenarios make quality concerns non-discernible. To ease this problem, we built a multi-model framework (BugReportSoftQualDetector) to automatically detect quality-related content in bug report descriptions. Specifically, we leveraged a weighted combination of semantics, lexical, and shallow features in conjunction with the Random Forest model to detect six most emerging quality concerns present in bug report descriptions. Our results indicate that our approach outperformed both state-of-the-art approaches, one that leveraged lexical features and the other that leveraged shallow features. To assess our approach, we examined six diverse open-source domains hosted from two issue-tracking systems such as Jira and Bugzilla. Through a grounded theory approach, we created a catalog of rules and employed ISO 25010 taxonomy and the FURPS taxonomy to categorize bug reports into six quality types of: performance, maintainability, reliability, portability, usability, and security. We then employed content analysis to manually label 5,400 bug reports. Finally, we included a case study for tracing and visually mapping quality concerns into the codebase.},
	language = {en},
	number = {2},
	journal = {Empirical Software Engineering (EMSE) [Invitation for a Special Issue for Top Best Papers of SANER 2021]},
	author = {Krasniqi, Rrezarta and Do, Hyunsook},
	year = {2023},
	keywords = {Journal Articles},
	pages = {62},
}

Maintaining and delivering a high-quality software system is a delicate process. One way to ensure that a software system achieves the desired quality is to systematically monitor and timely address quality-related concerns. Quality concerns, such as reliability, usability, performance, and maintainability, among others, can have a broad impact in ensuring that a system remains consistently reliant and available at all times. In contrast, when such concerns are overlooked, become difficult to navigate, or maintain, system-wide failures could emerge. Typically, these failures can chiefly hinder the core functionality of the system and produce a large amount of quality bug reports. For the developers, manually examining these high-impacted quality-related bug reports in open-source issue tracking systems can become a prohibitively expensive and impractical task to deliver. Partly, because such bugs often require expert knowledge to address them. The more perplexing concern is the fact that these bugs are deemed difficult to detect due to their intertwined relationship with functional bugs. Even worse, there are instances when several types of quality concerns are intertwined among each other. Seemingly, these scenarios make quality concerns non-discernible. To ease this problem, we built a multi-model framework (BugReportSoftQualDetector) to automatically detect quality-related content in bug report descriptions. Specifically, we leveraged a weighted combination of semantics, lexical, and shallow features in conjunction with the Random Forest model to detect six most emerging quality concerns present in bug report descriptions. Our results indicate that our approach outperformed both state-of-the-art approaches, one that leveraged lexical features and the other that leveraged shallow features. To assess our approach, we examined six diverse open-source domains hosted from two issue-tracking systems such as Jira and Bugzilla. Through a grounded theory approach, we created a catalog of rules and employed ISO 25010 taxonomy and the FURPS taxonomy to categorize bug reports into six quality types of: performance, maintainability, reliability, portability, usability, and security. We then employed content analysis to manually label 5,400 bug reports. Finally, we included a case study for tracing and visually mapping quality concerns into the codebase.

@article{krasniqi_towards_2023,
	title = {Towards {Semantically} {Enhanced} {Detection} of {Emerging} {Quality}-{Related} {Concerns} in {Source} {Code}},
	issn = {0963-9314, 1573-1367},
	url = {http://link.springer.com/article/10.1007/s11219-023-09614-8},
	doi = {10.1007/s11219-023-09614-8},
	abstract = {Quality concerns defined by ISO/IEC 9126 that focus on the quality aspect of the product, such as efficiency, usability, and security, among other, tend to be neglected until they are retrofitted later at the implementation level. This retrofitted strategy poses a major challenge and hinders developers from efficiently detecting and understanding quality concerns because they are frequently implemented with no particular structure and are bound to low cohesion (qualities scattered across the codebase). To address these problems, we propose an alternative approach for detecting scattered quality-related content in the codebase. We introduce SoftQualDetector, a lightweight framework that combines three unsupervised techniques for extracting a rich set of logical text units from the code from the context of semantics, importance, and textual features to detect quality-related classes and generate short keyword summaries pertaining to quality-related classes. SoftQualDetector also provides a 3D visualization for monitoring automated detected quality-related concerns across the codebase so that developers can easily locate the emerging quality concerns and the associated classes. Our evaluation of 1,248 annotated Java classes shows that SoftQualDetector outperforms several state-of-the-art methods.},
	language = {en},
	urldate = {2023-07-20},
	journal = {Software Quality Journal (SQJ)},
	author = {Krasniqi, Rrezarta and Do, Hyunsook},
	year = {2023},
	keywords = {Journal Articles},
	pages = {51},
}

Quality concerns defined by ISO/IEC 9126 that focus on the quality aspect of the product, such as efficiency, usability, and security, among other, tend to be neglected until they are retrofitted later at the implementation level. This retrofitted strategy poses a major challenge and hinders developers from efficiently detecting and understanding quality concerns because they are frequently implemented with no particular structure and are bound to low cohesion (qualities scattered across the codebase). To address these problems, we propose an alternative approach for detecting scattered quality-related content in the codebase. We introduce SoftQualDetector, a lightweight framework that combines three unsupervised techniques for extracting a rich set of logical text units from the code from the context of semantics, importance, and textual features to detect quality-related classes and generate short keyword summaries pertaining to quality-related classes. SoftQualDetector also provides a 3D visualization for monitoring automated detected quality-related concerns across the codebase so that developers can easily locate the emerging quality concerns and the associated classes. Our evaluation of 1,248 annotated Java classes shows that SoftQualDetector outperforms several state-of-the-art methods.

@inproceedings{krasniqi_hierarchical_2023,
	address = {Taipa, Macao},
	title = {A {Hierarchical} {Topical} {Modeling} {Approach} for {Recommending} {Repair} of {Quality} {Bugs}},
	isbn = {9781665452786},
	url = {https://ieeexplore.ieee.org/document/10123610/},
	doi = {10.1109/SANER56733.2023.00014},
	abstract = {Quality bugs are difficult to detect because the implemented quality-related features are commonly scattered across the codebase. Unfortunately, this scattered information prevents software developers from holistically understanding the root cause of quality bugs. The traditional view of a system does not support a hierarchical code view for monitoring and tracing how quality features are topically related and how they interact with each other. In this paper, we show how these limitations can be overcome by leveraging a Hierarchical Dirichlet Process (HDP) topic modeling technique along with other supporting intermediary techniques such as structural and textual analyses to capture hierarchical topical relationships among quality features across the codebase that yield to detection of quality bugs. We present SoftQualTopicDetector, that is capable of clustering scattered quality concerns into a meaningful hierarchy to infer a set of candidate classes relevant for recommending repair of quality bugs. The higher the ranking of classes into a hierarchy the more relevant they are regarded to contain information about the bug under investigation. Additionally, SoftQualTopicDetector incorporates three rich visualization features for monitoring, prioritizing, and 3-D tracing of suspicious classes to enhance aspects of maintainability, functional suitability, and traceability. We conduct an empirical evaluation of SoftQualTopicDetector that shows an improvement over the baseline and the state-of-the-art by terms ≈17\% and in of average precision and ≈21\% recall respectively.},
	language = {en},
	urldate = {2023-07-20},
	booktitle = {2023 {IEEE} {International} {Conference} on {Software} {Analysis}, {Evolution} and {Reengineering} ({SANER})},
	publisher = {IEEE},
	author = {Krasniqi, Rrezarta and Do, Hyunsook},
	month = mar,
	year = {2023},
	keywords = {Conference Full Papers},
	pages = {37--48},
}

Quality bugs are difficult to detect because the implemented quality-related features are commonly scattered across the codebase. Unfortunately, this scattered information prevents software developers from holistically understanding the root cause of quality bugs. The traditional view of a system does not support a hierarchical code view for monitoring and tracing how quality features are topically related and how they interact with each other. In this paper, we show how these limitations can be overcome by leveraging a Hierarchical Dirichlet Process (HDP) topic modeling technique along with other supporting intermediary techniques such as structural and textual analyses to capture hierarchical topical relationships among quality features across the codebase that yield to detection of quality bugs. We present SoftQualTopicDetector, that is capable of clustering scattered quality concerns into a meaningful hierarchy to infer a set of candidate classes relevant for recommending repair of quality bugs. The higher the ranking of classes into a hierarchy the more relevant they are regarded to contain information about the bug under investigation. Additionally, SoftQualTopicDetector incorporates three rich visualization features for monitoring, prioritizing, and 3-D tracing of suspicious classes to enhance aspects of maintainability, functional suitability, and traceability. We conduct an empirical evaluation of SoftQualTopicDetector that shows an improvement over the baseline and the state-of-the-art by terms ≈17% and in of average precision and ≈21% recall respectively.

@inproceedings{krasniqi_detecting_2023,
	address = {Melbourne, Australia},
	title = {Detecting {Scattered} and {Tangled} {Quality} {Concerns} in {Source} {Code} to {Aid} {Maintenance} and {Evolution} {Tasks}},
	isbn = {9798350322637},
	url = {https://ieeexplore.ieee.org/document/10172720/},
	doi = {10.1109/ICSE-Companion58688.2023.00051},
	abstract = {Quality concerns, such as reliability, security, usability concerns, among others, are typically well-defined and prioritized at the requirement level with the set goal of achieving high quality, robust, user-friendly, and trustworthy systems. However, quality concerns are challenging to address at the implementation level. Often they are scattered across multiple modules in the codebase. In other instances, they are tangled with functional ones within a single module. Reasoning about quality concerns and their interactions with functional ones while being hindered by the effects of scattered and tangled code can only yield to more unseen problems. For example, developers can inadvertently retrofit new bugs or wrongly implement new features that deviate from original system requirement specifications. The goal of this thesis is twofold. First, we aim to detect quality concerns implemented at code level to differentiate them from functional ones when they are scattered across the codebase. Second, we aim to untangle quality concerns from unrelated changes to gain a detailed knowledge about the history of specific quality changes. This knowledge is crucial to support consistency between the requirements-and-design and to verify architecture conformance. From the practical stance, developers could gain a breadth of understanding about quality concerns and their relations with other artifacts. Thus, with more confidence, they could perform code modifications, improve module traceability, and provide a better holistic assessment of change impact analysis.},
	language = {en},
	urldate = {2023-07-20},
	booktitle = {2023 {IEEE}/{ACM} 45th {International} {Conference} on {Software} {Engineering}: {Companion} {Proceedings} ({ICSE}-{Companion})},
	publisher = {IEEE},
	author = {Krasniqi, Rrezarta},
	month = may,
	year = {2023},
	keywords = {Conference Short Papers},
	pages = {184--188},
}

Quality concerns, such as reliability, security, usability concerns, among others, are typically well-defined and prioritized at the requirement level with the set goal of achieving high quality, robust, user-friendly, and trustworthy systems. However, quality concerns are challenging to address at the implementation level. Often they are scattered across multiple modules in the codebase. In other instances, they are tangled with functional ones within a single module. Reasoning about quality concerns and their interactions with functional ones while being hindered by the effects of scattered and tangled code can only yield to more unseen problems. For example, developers can inadvertently retrofit new bugs or wrongly implement new features that deviate from original system requirement specifications. The goal of this thesis is twofold. First, we aim to detect quality concerns implemented at code level to differentiate them from functional ones when they are scattered across the codebase. Second, we aim to untangle quality concerns from unrelated changes to gain a detailed knowledge about the history of specific quality changes. This knowledge is crucial to support consistency between the requirements-and-design and to verify architecture conformance. From the practical stance, developers could gain a breadth of understanding about quality concerns and their relations with other artifacts. Thus, with more confidence, they could perform code modifications, improve module traceability, and provide a better holistic assessment of change impact analysis.

@inproceedings{krasniqi_generalizability_2023,
	address = {Melbourne, Australia},
	title = {Generalizability of {NLP}-based {Models} for {Modern} {Software} {Development} {Cross}-{Domain} {Environments}},
	isbn = {9798350301786},
	url = {https://ieeexplore.ieee.org/document/10189135/},
	doi = {10.1109/NLBSE59153.2023.00009},
	abstract = {Natural Language Processing (NLP) has shown to be effective for solving complex problems in the Software Engineering (SE) domain, such as building chatbots and its ability to translate multi-languages. Despite the advances allowed by NLP, there are technical loopholes that hinder its fullest potential within the SE domain. The open problem remains in their generalizability for modern software development tasks that typically operate in a dynamic environment, such as AWS and SaaS platforms. The problem with these setups is that they may not contain labeled data. This poses a challenge when applying most prominent data-centric NLP models such as BERT transformer models. This position paper highlights some of the most pressing challenges drawn between the intersection of NLP and SE domains. Our vision revolves around improving the NLP model generalizability for dynamic cross-domain environments that contain little or no labeled target-domain data. We discuss these challenges and propose a research roadmap to tackle this problem as a research community emanating from SE lenses.},
	urldate = {2023-07-30},
	booktitle = {2023 {IEEE}/{ACM} 2nd {International} {Workshop} on {Natural} {Language}-{Based} {Software} {Engineering} ({NLBSE}) co-located with {ICSE}},
	publisher = {IEEE},
	author = {Krasniqi, Rrezarta and Do, Hyunsook},
	month = may,
	year = {2023},
	keywords = {Conference Workshop Papers},
	pages = {11--13},
}

Natural Language Processing (NLP) has shown to be effective for solving complex problems in the Software Engineering (SE) domain, such as building chatbots and its ability to translate multi-languages. Despite the advances allowed by NLP, there are technical loopholes that hinder its fullest potential within the SE domain. The open problem remains in their generalizability for modern software development tasks that typically operate in a dynamic environment, such as AWS and SaaS platforms. The problem with these setups is that they may not contain labeled data. This poses a challenge when applying most prominent data-centric NLP models such as BERT transformer models. This position paper highlights some of the most pressing challenges drawn between the intersection of NLP and SE domains. Our vision revolves around improving the NLP model generalizability for dynamic cross-domain environments that contain little or no labeled target-domain data. We discuss these challenges and propose a research roadmap to tackle this problem as a research community emanating from SE lenses.

@inproceedings{krasniqi_automatically_2022,
	address = {Gothenburg Sweden},
	title = {Automatically {Capturing} {Quality}-{Related} {Concerns} in {Bug} {Report} {Descriptions} for {Efficient} {Bug} {Triaging}},
	isbn = {978-1-4503-9613-4},
	doi = {10.1145/3530019.3530021},
	abstract = {In the early phases of a project, software architects and developers design solutions to satisfy quality concerns. However, as a byproduct of the long-term maintenance effort, qualities tend to erode, causing quality-related bugs to surface across the codebase. In principle, quality-related concerns not only can be expensive and difficult to detect, but they can have a detrimental effect on the system operating as intended. Moreover, quality-related concerns can directly affect users' experiences at large. To address this problem, we build a quality-based bug classifier that leverages several feature selection techniques, TF-IDF, Chi-square, Mutual Information, and Extra Randomized Trees, including the incorporation of various machine learning algorithms. Our results indicate that Random Forest with the (TF-IDF+Chi-square) configuration achieved the best results for detecting six-quality related types, achieving a precision of 76\%, recall of 70\%, and F1 of 70\$\%. However, the same approach returned low precision of 48\%, recall of 15\%, and F1 of 23\% for detecting functional-related bugs. We argue that such low performance has resulted in an aftermath of overlapping content caused by functional and quality-related information which opens another challenging topic that we aim to expand in future work.},
	language = {en},
	urldate = {2022-09-29},
	booktitle = {2021 {ACM} 25th {International} {Conference} on {Evaluation} and {Assessment} in {Software} {Engineering} ({EASE})},
	publisher = {ACM},
	author = {Krasniqi, Rrezarta and Do, Hyunsook},
	year = {2022},
	keywords = {Conference Full Papers},
	pages = {10--19},
}

In the early phases of a project, software architects and developers design solutions to satisfy quality concerns. However, as a byproduct of the long-term maintenance effort, qualities tend to erode, causing quality-related bugs to surface across the codebase. In principle, quality-related concerns not only can be expensive and difficult to detect, but they can have a detrimental effect on the system operating as intended. Moreover, quality-related concerns can directly affect users' experiences at large. To address this problem, we build a quality-based bug classifier that leverages several feature selection techniques, TF-IDF, Chi-square, Mutual Information, and Extra Randomized Trees, including the incorporation of various machine learning algorithms. Our results indicate that Random Forest with the (TF-IDF+Chi-square) configuration achieved the best results for detecting six-quality related types, achieving a precision of 76%, recall of 70%, and F1 of 70$%. However, the same approach returned low precision of 48%, recall of 15%, and F1 of 23% for detecting functional-related bugs. We argue that such low performance has resulted in an aftermath of overlapping content caused by functional and quality-related information which opens another challenging topic that we aim to expand in future work.

@article{aljedaani_if_2022,
	title = {If {Online} {Learning} {Works} for {You}, {What} about {Deaf} {Students}? {Emerging} {Challenges} of {Online} {Learning} for {Deaf} and {Hearing}-{Impaired} {Students} during {COVID}-19: {A} {Literature} {Review}},
	volume = {22},
	issn = {1615-5289, 1615-5297},
	shorttitle = {If online learning works for you, what about deaf students?},
	url = {https://link.springer.com/article/10.1007/s10209-022-00897-5},
	doi = {10.1007/s10209-022-00897-5},
	abstract = {With the coronavirus (COVID-19) outbreak, educational systems worldwide were abruptly affected and hampered, causing nearly total suspension of all in-person activities in schools, colleges, and universities. Government officials prohibited the physical gatherings in educational institutions to reduce the spread of the virus. Therefore, educational institutions have aggressively shifted to alternative learning methods and strategies such as online-based platforms—to seemingly avoid the disruption of education. However, the switch from the face-to-face setting to an entirely online setting introduced a series of challenges, especially for the deaf or hard-of-hearing students. Various recent studies have revealed the underlying infrastructure used by academic institutions may not be suitable for students with hearing impairments. The goal of this study is to perform a literature review of these studies and extract the pressing challenges that deaf and hard-of-hearing students have been facing since their transition to the online setting. We conducted a systematic literature review of 34 articles that were carefully collected, retrieved, and rigorously categorized from various scholarly databases. The articles, included in this study, focused primarily on highlighting high-demanding issues that deaf students experienced in higher education during the pandemic. This study contributes to the research literature by providing a detailed analysis of technological challenges hindering the learning experience of deaf students. Furthermore, the study extracts takeaways and proposed solutions, from the literature, for researchers, education specialists, and higher education authorities to adopt. This work calls for investigating broader and yet more effective teaching and learning strategies for deaf and hard-of-hearing students so that they can benefit from a better online learning experience.},
	language = {en},
	number = {3},
	urldate = {2023-07-20},
	journal = {Universal Access in the Information Society},
	author = {Aljedaani, Wajdi and Krasniqi, Rrezarta and Aljedaani, Sanaa and Mkaouer, Mohamed Wiem and Ludi, Stephanie and Al-Raddah, Khaled},
	month = aug,
	year = {2022},
	keywords = {Journal Articles},
	pages = {1027--1046},
}

With the coronavirus (COVID-19) outbreak, educational systems worldwide were abruptly affected and hampered, causing nearly total suspension of all in-person activities in schools, colleges, and universities. Government officials prohibited the physical gatherings in educational institutions to reduce the spread of the virus. Therefore, educational institutions have aggressively shifted to alternative learning methods and strategies such as online-based platforms—to seemingly avoid the disruption of education. However, the switch from the face-to-face setting to an entirely online setting introduced a series of challenges, especially for the deaf or hard-of-hearing students. Various recent studies have revealed the underlying infrastructure used by academic institutions may not be suitable for students with hearing impairments. The goal of this study is to perform a literature review of these studies and extract the pressing challenges that deaf and hard-of-hearing students have been facing since their transition to the online setting. We conducted a systematic literature review of 34 articles that were carefully collected, retrieved, and rigorously categorized from various scholarly databases. The articles, included in this study, focused primarily on highlighting high-demanding issues that deaf students experienced in higher education during the pandemic. This study contributes to the research literature by providing a detailed analysis of technological challenges hindering the learning experience of deaf students. Furthermore, the study extracts takeaways and proposed solutions, from the literature, for researchers, education specialists, and higher education authorities to adopt. This work calls for investigating broader and yet more effective teaching and learning strategies for deaf and hard-of-hearing students so that they can benefit from a better online learning experience.

@inproceedings{krasniqi_analyzing_2021,
	address = {Honolulu, HI, USA},
	title = {Analyzing and {Detecting} {Emerging} {Quality}-{Related} {Concerns} across {OSS} {Defect} {Report} {Summaries}},
	isbn = {978-1-7281-9630-5},
	doi = {10.1109/SANER50967.2021.00011},
	abstract = {Quality-related concerns are often coined with the terms non-functional requirements, architecturally significant requirements, and quality attributes. Collectively, these qualities affect non-behavioral concerns of the software system, such as reliability, usability, security, or maintainability, among others. As a byproduct of a long-term maintenance effort, these system qualities tend to erode over time, causing system-wide failures that emerge via quality-related bugs. Quality-related bugs can have a detrimental impact on the system's sustained stability and can chiefly hinder its core functionality. Typically, for the developers to manually examine these high-impacted quality-related bugs can become a prohibitively expensive and impractical task to attain. This is often a case with bugs that are reported from medium or large-sized projects such as Eclipse. To alleviate this problem, we built a quality-based classifier to automatically detect these emerging quality-related concerns from textual descriptions of bug report summaries. Specifically, we leveraged a weighted combination of semantics, lexical, and shallow features in conjunction with the Random Forest ensemble learning method. Finally, we discuss the practical applicability of our classifier for mapping and visualizing quality-related concerns into the codebase with an example from the Derby project. To summarize, this work represents an effort and an early awareness to improve the underlying management of issue tracking systems and stakeholder requirements in open-source communities.},
	language = {en},
	urldate = {2022-09-29},
	booktitle = {2021 {IEEE} 28th {International} {Conference} on {Software} {Analysis}, {Evolution} and {Reengineering} ({SANER})},
	publisher = {IEEE},
	author = {Krasniqi, Rrezarta and Agrawal, Ankit},
	month = mar,
	year = {2021},
	keywords = {Conference Full Papers},
	pages = {12--23},
}

Quality-related concerns are often coined with the terms non-functional requirements, architecturally significant requirements, and quality attributes. Collectively, these qualities affect non-behavioral concerns of the software system, such as reliability, usability, security, or maintainability, among others. As a byproduct of a long-term maintenance effort, these system qualities tend to erode over time, causing system-wide failures that emerge via quality-related bugs. Quality-related bugs can have a detrimental impact on the system's sustained stability and can chiefly hinder its core functionality. Typically, for the developers to manually examine these high-impacted quality-related bugs can become a prohibitively expensive and impractical task to attain. This is often a case with bugs that are reported from medium or large-sized projects such as Eclipse. To alleviate this problem, we built a quality-based classifier to automatically detect these emerging quality-related concerns from textual descriptions of bug report summaries. Specifically, we leveraged a weighted combination of semantics, lexical, and shallow features in conjunction with the Random Forest ensemble learning method. Finally, we discuss the practical applicability of our classifier for mapping and visualizing quality-related concerns into the codebase with an example from the Derby project. To summarize, this work represents an effort and an early awareness to improve the underlying management of issue tracking systems and stakeholder requirements in open-source communities.

@inproceedings{krasniqi_recommending_2021,
	address = {Madrid, Spain},
	title = {Recommending {Bug}-fixing {Comments} from {Issue} {Tracking} {Discussions} in {Support} of {Bug} {Repair}},
	isbn = {978-1-6654-2463-9},
	doi = {10.1109/COMPSAC51774.2021.00114},
	abstract = {In practice, developers search for related earlier bugs and their associated discussion threads when faced with a new bug to repair. Typically, these discussion threads consist of comments and even bug-fixing comments intended to capture clues for facilitating the investigation and root cause of a new bug report. Over time, these discussions can become extensively lengthy and difficult to understand. Inevitably, these discussion threads lead to instances where bug-fixing comments intermingle with seemingly-unrelated comments. This task, however, poses further challenges when dealing with high volumes of bug reports. Large software systems are plagued by thousands of bug reports daily. Hence, it becomes time-consuming to investigate these bug reports efficiently. To address this gap, this paper builds a ranked-based automated tool that we refer it to as RetroRank. Specifically, RetroRank recommends bug-fixing comments from issue tracking discussion threads in the context of user query relevance, the use of positive language, and semantic relevance among comments. By using a combination of Vector Space Model (VSM), Sentiment Analysis (SA), and the TextRank Model (TR) we show how that past fixed bugs and their associated bug-fixing comments with relatively positive sentiments can semantically connect to investigate the root cause of a new bug. We evaluated our approach via a synthetic study and a user study. Results indicate that RetroRank significantly improved performance when compared to the baseline VSM.},
	language = {en},
	urldate = {2022-09-29},
	booktitle = {2021 {IEEE} 45th {Annual} {Computers}, {Software}, and {Applications} {Conference} ({COMPSAC})},
	publisher = {IEEE},
	author = {Krasniqi, Rrezarta},
	month = jul,
	year = {2021},
	keywords = {Conference Full Papers},
	pages = {812--823},
}

In practice, developers search for related earlier bugs and their associated discussion threads when faced with a new bug to repair. Typically, these discussion threads consist of comments and even bug-fixing comments intended to capture clues for facilitating the investigation and root cause of a new bug report. Over time, these discussions can become extensively lengthy and difficult to understand. Inevitably, these discussion threads lead to instances where bug-fixing comments intermingle with seemingly-unrelated comments. This task, however, poses further challenges when dealing with high volumes of bug reports. Large software systems are plagued by thousands of bug reports daily. Hence, it becomes time-consuming to investigate these bug reports efficiently. To address this gap, this paper builds a ranked-based automated tool that we refer it to as RetroRank. Specifically, RetroRank recommends bug-fixing comments from issue tracking discussion threads in the context of user query relevance, the use of positive language, and semantic relevance among comments. By using a combination of Vector Space Model (VSM), Sentiment Analysis (SA), and the TextRank Model (TR) we show how that past fixed bugs and their associated bug-fixing comments with relatively positive sentiments can semantically connect to investigate the root cause of a new bug. We evaluated our approach via a synthetic study and a user study. Results indicate that RetroRank significantly improved performance when compared to the baseline VSM.

@inproceedings{krasniqi_extractive_2021,
	address = {Madrid, Spain},
	title = {Extractive {Summarization} of {Related} {Bug}-fixing {Comments} in {Support} of {Bug} {Repair}},
	isbn = {978-1-66544-472-9},
	doi = {10.1109/APR52552.2021.00014},
	abstract = {When developers investigate a new bug report, they search for similar previously fixed bug reports and discussion threads attached to them. These discussion threads convey important information about the behavior of the bug including relevant bug-fixing comments. Often times, these discussion threads become extensively lengthy due to the severity of the reported bug. This adds another layer of complexity, especially if relevant bug-fixing  comments intermingle with seemingly unrelated  comments. To manually detect these relevant comments among various cross-cutting discussion threads can become a daunting task when dealing with high volume of bug reports. To automate this process, our focus is to initially extract and detect comments in the context of query relevance, the use of positive language, and semantic relevance. Then, we merge these comments in the form of a summary for easy understanding. Specifically, we combine Sentiment Analysis, and the TextRank Model with the baseline Vector Space Model (VSM). Preliminary findings indicate that bug-fixing comments tend to be positive and there exists a semantic relevance with comments from other cross-cutting discussion threads. The results also indicate that our combined approach improves overall ranking performance against the baseline VSM.},
	language = {en},
	urldate = {2022-09-29},
	booktitle = {2021 {IEEE}/{ACM} 2nd {International} {Workshop} on {Automated} {Program} {Repair} ({APR}) co-located with {ICSE}},
	publisher = {IEEE},
	author = {Krasniqi, Rrezarta},
	month = jun,
	year = {2021},
	keywords = {Conference Workshop Papers},
	pages = {31--32},
}

When developers investigate a new bug report, they search for similar previously fixed bug reports and discussion threads attached to them. These discussion threads convey important information about the behavior of the bug including relevant bug-fixing comments. Often times, these discussion threads become extensively lengthy due to the severity of the reported bug. This adds another layer of complexity, especially if relevant bug-fixing comments intermingle with seemingly unrelated comments. To manually detect these relevant comments among various cross-cutting discussion threads can become a daunting task when dealing with high volume of bug reports. To automate this process, our focus is to initially extract and detect comments in the context of query relevance, the use of positive language, and semantic relevance. Then, we merge these comments in the form of a summary for easy understanding. Specifically, we combine Sentiment Analysis, and the TextRank Model with the baseline Vector Space Model (VSM). Preliminary findings indicate that bug-fixing comments tend to be positive and there exists a semantic relevance with comments from other cross-cutting discussion threads. The results also indicate that our combined approach improves overall ranking performance against the baseline VSM.

@inproceedings{krasniqi_enhancing_2020,
	address = {London, ON, Canada},
	title = {Enhancing {Source} {Code} {Refactoring} {Detection} with {Explanations} from {Commit} {Messages}},
	isbn = {978-1-72815-143-4},
	doi = {10.1109/SANER48275.2020.9054816},
	abstract = {We investigate the extent to which code commit summaries provide rationales and descriptions of code refactorings. We present a refactoring description detection tool CMMiner that detects code commit messages containing refactoring information and differentiates between twelve different refactoring types. We further explore whether refactoring information mined from commit messages using CMMiner, can be combined with refactoring descriptions mined from source code using the well-known RMiner tool. For six refactoring types covered by both CMMiner and RMiner, we observed 21.96\% to 38.59\% overlap in refactorings detected across four diverse open-source systems. RMiner identified approximately 49.13\% to 60.29\% of refactorings missed by CMMiner, primarily because developers often failed to describe code refactorings that occurred alongside other code changes. However, CMMiner identified 10.30\% to 19.51\% of refactorings missed by RMiner, primarily when refactorings occurred across multiple commits. Our results suggest that integrating both approaches can enhance the completeness of refactoring detection and provide refactoring rationales.},
	urldate = {2022-09-29},
	booktitle = {2020 {IEEE} 27th {International} {Conference} on {Software} {Analysis}, {Evolution} and {Reengineering} ({SANER})},
	publisher = {IEEE},
	author = {Krasniqi, Rrezarta and Cleland-Huang, Jane},
	month = feb,
	year = {2020},
	keywords = {Conference Short Papers},
	pages = {512--516},
}

We investigate the extent to which code commit summaries provide rationales and descriptions of code refactorings. We present a refactoring description detection tool CMMiner that detects code commit messages containing refactoring information and differentiates between twelve different refactoring types. We further explore whether refactoring information mined from commit messages using CMMiner, can be combined with refactoring descriptions mined from source code using the well-known RMiner tool. For six refactoring types covered by both CMMiner and RMiner, we observed 21.96% to 38.59% overlap in refactorings detected across four diverse open-source systems. RMiner identified approximately 49.13% to 60.29% of refactorings missed by CMMiner, primarily because developers often failed to describe code refactorings that occurred alongside other code changes. However, CMMiner identified 10.30% to 19.51% of refactorings missed by RMiner, primarily when refactorings occurred across multiple commits. Our results suggest that integrating both approaches can enhance the completeness of refactoring detection and provide refactoring rationales.

@mastersthesis{krasniqi_detecting_2020,
	title = {Detecting {Emerging} {Quality}-{Related} {Concerns} across {Evolving} {Software} {Artifacts}},
	copyright = {ProQuest},
	url = {https://www.proquest.com/docview/2625007332},
	abstract = {To build successful and cost-effective software systems, in conjunction with functional requirements, software development practices advocate for more rigorous understanding of non-functional requirements often referred to as "quality concerns". Typically, during requirement elicitation phase, software architects primarily focus on satisfying and prioritizing functional requirements while neglecting quality concerns. When this requirement elicitation gap occurs, developers typically retrofit solutions by implementing quality concerns at the code-level. This poses a risk on the stability of entire software architecture---as developers may inadvertently make system-wide design decisions compromising architectural well-formalized design decisions. Aside from that, developers have to reason about which functional pieces of the code interact with which non-functional ones. The caveat is that when such interactions are poorly or vaguely understood, future modifications may lead to defects resulting in excessive maintenance costs. When defects are reported, they are generally addressed with adhoc bug-fixing code, often, resulting in code fragmentation. Seemingly, the architectural knowledge associated with quality concerns becomes fragmented across implemented code leading to architectural drift phenomena. Typically, architectural drift occurs due to the effect of both "scattered" and "tangled'' code"---code that leads to poor readability, maintainability, low reuse and, high impact and cost of changes. Understanding quality concerns under these effects is a resource intensive process even for experienced developers; Especially when developers perform system-wide tasks such as iteratively tracing monitoring quality concerns, refactoring or fixing bugs at the code-level. To promote a better understanding of quality concerns, an automated process to acquire even partial knowledge of these concerns would be highly desirable. This would steer developers towards building a proactive awareness about quality concerns across evolving software artifacts.This thesis adopts a comprehensive approach for detecting system-wide emerging quality-related concerns across various software artifacts. First, I introduce a novel three-pronged approach to detect a diverse set of quality-related concerns in bug report summaries---concerns which are then traced in buggy code. Second, I integrate textual and structural information to improve structural-based refactoring tools by promoting high level human explanations via analysis of commit messages. Finally, I implement a ranked-based bug-fixing search tool that recommends bug-fixing comments from lengthy discussion threads of past solved bugs to fix a new bug. These bug-fixing comments are ranked and recommended in the context of user query relevance, use of positive language, and semantic relevance. In summary, this thesis explores a series solutions by leveraging natural language information with different semantic-based strategies and machine learning-based techniques. Ultimately, these solutions serve as transformative advances for reducing the comprehension gap between how developers reason about quality-related concerns and how such concerns are intertwined and scattered across artifacts. In the broader context, this thesis makes an effort to further enhance comprehension of quality concerns during software maintenance and evolution, software reuse, code reuse, and supports consistency between design and the code.},
	language = {en},
	school = {University of Notre Dame},
	author = {Krasniqi, Rrezarta},
	month = oct,
	year = {2020},
	keywords = {MS Thesis},
}

To build successful and cost-effective software systems, in conjunction with functional requirements, software development practices advocate for more rigorous understanding of non-functional requirements often referred to as "quality concerns". Typically, during requirement elicitation phase, software architects primarily focus on satisfying and prioritizing functional requirements while neglecting quality concerns. When this requirement elicitation gap occurs, developers typically retrofit solutions by implementing quality concerns at the code-level. This poses a risk on the stability of entire software architecture—as developers may inadvertently make system-wide design decisions compromising architectural well-formalized design decisions. Aside from that, developers have to reason about which functional pieces of the code interact with which non-functional ones. The caveat is that when such interactions are poorly or vaguely understood, future modifications may lead to defects resulting in excessive maintenance costs. When defects are reported, they are generally addressed with adhoc bug-fixing code, often, resulting in code fragmentation. Seemingly, the architectural knowledge associated with quality concerns becomes fragmented across implemented code leading to architectural drift phenomena. Typically, architectural drift occurs due to the effect of both "scattered" and "tangled'' code"—code that leads to poor readability, maintainability, low reuse and, high impact and cost of changes. Understanding quality concerns under these effects is a resource intensive process even for experienced developers; Especially when developers perform system-wide tasks such as iteratively tracing monitoring quality concerns, refactoring or fixing bugs at the code-level. To promote a better understanding of quality concerns, an automated process to acquire even partial knowledge of these concerns would be highly desirable. This would steer developers towards building a proactive awareness about quality concerns across evolving software artifacts.This thesis adopts a comprehensive approach for detecting system-wide emerging quality-related concerns across various software artifacts. First, I introduce a novel three-pronged approach to detect a diverse set of quality-related concerns in bug report summaries—concerns which are then traced in buggy code. Second, I integrate textual and structural information to improve structural-based refactoring tools by promoting high level human explanations via analysis of commit messages. Finally, I implement a ranked-based bug-fixing search tool that recommends bug-fixing comments from lengthy discussion threads of past solved bugs to fix a new bug. These bug-fixing comments are ranked and recommended in the context of user query relevance, use of positive language, and semantic relevance. In summary, this thesis explores a series solutions by leveraging natural language information with different semantic-based strategies and machine learning-based techniques. Ultimately, these solutions serve as transformative advances for reducing the comprehension gap between how developers reason about quality-related concerns and how such concerns are intertwined and scattered across artifacts. In the broader context, this thesis makes an effort to further enhance comprehension of quality concerns during software maintenance and evolution, software reuse, code reuse, and supports consistency between design and the code.

@inproceedings{krasniqi_tracelab_2018,
	address = {Madrid},
	title = {{TraceLab} {Components} for {Generating} {Speech} {Act} {Types} in {Developer} {Question}/{Answer} {Conversations}},
	isbn = {978-1-5386-7870-1},
	doi = {10.1109/ICSME.2018.00085},
	abstract = {This artifact is a reproducibility package for experiments in speech act types generation. We have prepacked and created an easily-reusable artifact that consists of a set of reproducible components for generating speech act types. Prior to this artifact, the implementation was accessible but required managing various dependencies and predefined configurations for different scripts.  We have made available this artifact via our online appendix. The artifact includes the components, a detailed tutorial with screenshots that describe steps how to generate the experiment and an example virtual machine image.},
	urldate = {2022-09-29},
	booktitle = {2018 {IEEE} 34th {International} {Conference} on {Software} {Maintenance} and {Evolution} ({ICSME})},
	publisher = {IEEE},
	author = {Krasniqi, Rrezarta and McMillan, Collin},
	month = sep,
	year = {2018},
	keywords = {Conference Short Papers},
	pages = {713--713},
}

This artifact is a reproducibility package for experiments in speech act types generation. We have prepacked and created an easily-reusable artifact that consists of a set of reproducible components for generating speech act types. Prior to this artifact, the implementation was accessible but required managing various dependencies and predefined configurations for different scripts. We have made available this artifact via our online appendix. The artifact includes the components, a detailed tutorial with screenshots that describe steps how to generate the experiment and an example virtual machine image.

@inproceedings{krasniqi_tracelab_2017,
	address = {Shanghai},
	title = {{TraceLab} {Components} for {Generating} {Extractive} {Summaries} of {User} {Stories}},
	isbn = {978-1-5386-0992-7},
	doi = {10.1109/ICSME.2017.86},
	abstract = {This artifact is a reproducibility package for experiments in user stories summarization.  We implemented and packaged the artifact as a set of reusable TraceLab components. The existing implementation of the artifact was relatively difficult to use because it required the user to coordinate several different programming languages and dependencies. This artifact, available via our online appendix, provides the components, a detailed tutorial with screenshots that show exactly where to click and what to enter, and an example virtual machine image.},
	urldate = {2022-09-29},
	booktitle = {2017 {IEEE} {International} {Conference} on {Software} {Maintenance} and {Evolution} ({ICSME})},
	publisher = {IEEE},
	author = {Krasniqi, Rrezarta and Jiang, Siyuan and McMillan, Collin},
	month = sep,
	year = {2017},
	keywords = {Conference Short Papers},
	pages = {658--658},
}

This artifact is a reproducibility package for experiments in user stories summarization. We implemented and packaged the artifact as a set of reusable TraceLab components. The existing implementation of the artifact was relatively difficult to use because it required the user to coordinate several different programming languages and dependencies. This artifact, available via our online appendix, provides the components, a detailed tutorial with screenshots that show exactly where to click and what to enter, and an example virtual machine image.

@inproceedings{stringfellow_solving_2010,
	title = {Solving the {T}-joint {Problem} in {Reconstructing} 2-{D} {Objects}},
	doi = {https://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.296.8795},
	abstract = {This paper describes a solution to the T-joint problem in matching 2D fragments of an object. Matching fragments of an object is useful for solving puzzles or reassembling archaeological fragments. Many factors, such as the number of pieces and the complex shapes of pieces make this a difficult problem. Various approaches to this problem exist. This paper presents an approach to solving the T-joint problem, which comes up in assembling fragments. The work described in this paper starts with a 2D object that should be easy to extend to 3D problems.},
	language = {en},
	booktitle = {2010 {IMAGAPP} - {Proceedings} of the {International} {Conference} on {Imaging} {Theory} and {Applications} - {Proceedings} of the {International} {Conference} on {Information} {Visualization} {Theory} and {Applications}, {Angers}, {France}, {May} 17 - 21, 2010},
	author = {Stringfellow, Catherine and Simpson, Richard and Enloe, K. and Krasniqi, Rrezarta and Ngo, T. and Keown, R. and Hood, Jeffrey B.},
	editor = {Richard, Paul and Braz, José},
	year = {2010},
	keywords = {Conference Full Papers},
	pages = {23--28},
}

This paper describes a solution to the T-joint problem in matching 2D fragments of an object. Matching fragments of an object is useful for solving puzzles or reassembling archaeological fragments. Many factors, such as the number of pieces and the complex shapes of pieces make this a difficult problem. Various approaches to this problem exist. This paper presents an approach to solving the T-joint problem, which comes up in assembling fragments. The work described in this paper starts with a 2D object that should be easy to extend to 3D problems.