LLM-Based Reverse-Engineering Framework for Legacy RPG/400 Banking Systems: Literature Review with Simulated Sri Lankan Core-Banking Case Study

The extraction of abstract models from the source code is one of the main focuses of model-driven reverse engineering and is particularly important for legacy systems, which do not have updated documentation. Recovering abstract models from legacy systems is complex, given that the technical constructs combined with domain-level constructs are implemented through multiple layers of technology and system-specific rules. Current static analysis and heuristic-based approaches can struggle to separate these concerns. The recent emergence of large language models (LLMs) is promising with regard to modeling software, but behaviors and expected outcomes related to LLMs when performing reverse engineering tasks are challenging. This paper compares the performance of various LLMs on a reverse engineering task related to the recovery of abstract models from the source code. This comparison aims to identify the domain constructs represented through an intermediate representation of the source code. Three LLMs, namely ChatGPT, Claude, and Meta AI, were assessed on the same input representation, with each LLM performing the task of recovering abstract models through the use of a common prompt. Evaluation of the three LLM outputs was performed on a common open-source C\# project, which serves as the target for the LLM outputs to be evaluated against an established reference Platform-Independent Model. Evaluation of model outputs was performed according to precision, recall, and F1 score, measuring individual categories of model elements.

Organizations often rely on large applications that are classified as legacy systems due to their dependence on outdated programming languages or platforms. To modernize these systems, it is necessary to understand their architecture, functionality, and business rules. Our research aims to define a novel model-driven reverse engineering (MDRE) approach to extract Unified Modeling Language (UML) and Object Constraint Language (OCL) representations from source code using Large Language Models (LLMs).

Understanding and maintaining software systems often requires extracting high-level abstractions, such as domain models, from source code. MDRE-LLM addresses this challenge by integrating Large Language Models (LLMs) with traditional Model-Driven Reverse Engineering (MDRE) techniques, offering an innovative approach to automate and enhance domain model recovery. The tool supports flexible granularity strategies and validates LLM -generated models against deterministic baselines. MDRE-LLM addresses diverse use cases, including analyzing legacy systems with minimal documentation, rapidly compre-hending large-scale codebases, and validating LLM performance in reverse engineering tasks. These capabilities have the potential to improve software analysis and refactoring while advance AI-driven research and education by fostering systematic experimentation and collaboration. The tool and a webcast are available at https://zenodo.org/uploads/14072106.

Graphical actor-based models provide an abstract overview of the flow of data in a system. They are well-established for the model-driven engineering (MDE) of complex software systems and are supported by numerous commercial and academic tools, such as Simulink, LabVIEW or Ptolemy. In MDE, engineers concentrate on constructing and simulating such models, before application code (or at least a large fraction thereof) is synthesized automatically. However, a significant fraction of today’s legacy system has been coded directly, often using the C language. High-level models that give a quick, accurate overview of how components interact are often out of date or do not exist. This makes it challenging to maintain or extend legacy software, in particular for new team members.To address this problem, we here propose to reverse the classic synthesis path of MDE and to synthesize actor-based dataflow models automatically from source code. Here functions in the code get synthesized into nodes that represent actors manipulating data. Second, we propose to harness the modeling-pragmatic approach, which considers visual models not as static artefacts, but allows interactive, flexible views that also link back to textual descriptions. Thus we propose to synthesize actor models that can vary in level of detail and that allow navigation in the source code. To validate and evaluate our proposals, we implemented these concepts for C analysis in the open source, Eclipse-based KIELER project and conducted a small survey.

No abstract available

Binary reverse engineering is pivotal in the realm of cybersecurity, enabling critical applications such as malware analysis, legacy code hardening, and vulnerability detection. However, the challenge of recovering structural information from binaries, especially stripped ones, persists due to the significant loss of variable boundaries, types, names, and dataflow information during compilation. In this article, we introduce Hybrid REasoning for Structure Recovery (HyRES), an innovative hybrid reasoning technique that energizes static analysis, Large Language Model (LLM), and heuristic methods to recover data structures from stripped binaries. It analyzes the structure layout and proficiently infer its semantics via LLM, and utilizes semantics to perform semantic-enhanced structure aggregation, which overcomes the need for complete dataflow. HyRES outperforms State-of-the-Art (SOTA) solutions in terms of structure pointer identification and layout recovery. Specifically, HyRES achieves 65.1% higher recall and 33.4% higher accuracy than the SOTA, while also being 64.2% faster than existing SOTA solutions. Comprehensive experiments demonstrate HyRES’s superior performance and practical utility in real-world reverse engineering tasks, marking a significant advancement in binary analysis.

No abstract available

Legacy embedded firmware represents a critical security risk in modern infrastructure, yet traditional decompilation tools struggle with hardware-coupled code. While Large Language Models (LLMs) have shown promise in decompiling desktop software, their application to bare-metal firmware remains unexplored. We present a behavior-guided reverse engineering framework employing autonomous LLM agents that perform multi-step reasoning: reading disassembly, consulting MCU documentation, generating candidate code, compiling, simulating, analyzing trace differentials, and iteratively refining solutions across multiple attempts. This agentic approach, fundamentally different from single-shot API queries, enables the model to reason about complex firmware through tool use and self-correction. Using cycle-accurate simulation as our behavioral oracle, we evaluate two frontier coding agents, Claude Code (Opus 4.5) and OpenAI Codex (GPT-5.1-codex-max), across 52 real-world AVR firmware projects. Claude achieves a 54.4% metric-level pass rate compared to Codex’s 37.0%, winning 41 of 52 head-to-head comparisons. Despite this, both agents exhibit systematic failures in safety-critical constructs: volatile qualifiers, interrupt handlers, and Harvard architecture memory access. Our findings reveal a critical "safety gap" where high syntactic accuracy masks deep behavioral flaws, demonstrating the need for human oversight and hardware-in-the-loop verification for firmware decompilation. While our empirical study focuses on the AVR architecture, the methodology generalizes to other embedded platforms and is the subject of ongoing work.

No abstract available

No abstract available

Large language models (LLMs) have been increasingly used for a wide range of software engineering processes, including model-driven engineering (MDE). LLMs have been used to perform reverse engineering of code to models, to generate code from models, and to perform model transformations, as alternatives to rule-based techniques for these activities. In this paper we examine the energy-use implications of applying LLMs for code generation and reverse engineering within an MDE process. We also consider LMM capabilities for optimising software energy use.

Rust, a modern system programming language, introduces new types that prevent memory bugs and data races. This makes translating legacy system programs from C to Rust a promising approach to enhance their reliability. Since manual code translation is time-consuming, it is desirable to automate the translation. To yield satisfactory results, the translator should have the ability to perform type migration, i.e., removing C types and introducing Rust types in the code. In this work, we aim to automatically port an entire C program to Rust by translating each C function to a Rust function with a signature containing proper Rust types through type migration. This goal is challenging because (1) type migration cannot be achieved through syntactic mappings between type names, and (2) after type migration, function bodies should be correctly restructured based on the precise understanding of the functions’ behavior. To address these difficulties, we leverage large language models (LLMs), which possess knowledge of program semantics and programming idioms. However, naïvely instructing LLMs to translate each function produces unsatisfactory Rust code, containing unmigrated or improperly migrated types and a huge number of type errors. To resolve these issues, we propose three techniques: (1) generating candidate signatures, (2) providing translated callees’ signatures to LLMs, and (3) iteratively fixing type errors using compiler feedback. Our evaluation shows that the proposed approach yields a 63.5% increase in migrated types and a 71.5% decrease in type errors compared to the baseline (the naïve LLM-based translation) with modest performance overhead.

Enterprise systems developed on the IBM i (iSeries) platform still have a role to play in supporting mission-critical business processes across industries, but their structural inflexibility makes transformation to a cloud-native solution a big challenge. This review synthesizes existing methods for migrating such systems to cloud-native Java applications using phased modernization models, which allow progressive and risk-managed evolution. Key methodologies such as service decomposition, data migration strategies, and operational practices in accordance with microservices and DevOps ecosystems are critically discussed. Although architectural refactoring and adoption of microservices enhance the modularity, scalability and efficiency of deployment, successful transformation depends on the integration of data transition strategies, governance frameworks, and organizational maturity. The literature suggests that hybrid decomposition and phased migration are among the most promising approaches to the challenge of managing the complexity of tightly coupled legacy systems. Persistent challenges include reduced interoperability, aging codebases, limited refactoring support, a shrinking skilled workforce, and the lack of standard evaluation metrics and long-term empirical evidence. Emerging trends, including AI-assisted code transformation and data-driven modernization, represent promising future research directions.

To keep pace in the rapidly changing business landscape, organizations are migrating their legacy mainframe applications, which are business-critical and developed decades ago in the COBOL, PL/I, and Assembler programming languages (on IBM mainframe computers, such as the IBM zSeries mainframe computer). While reliable and efficient, legacy architectures can impede an organization's ability to pivot and integrate into the digital economy. The journey to modernization presents various paths, including rehosting, replatforming, refactoring, and rewriting, each with its unique technical requirements, risk profile, and organizational implications. Financial services and insurance have the strongest evidence of success with new architectures. Improvements in the domains of transaction processing performance, infrastructure cost, and the ability to deliver new digital capabilities have been seen. New architectures also enable technologies, such as AI and machine learning, microservices, and omnichannel customer experiences, which were not possible with legacy architectures. Key success factors include strong executive sponsorship, technical and business stakeholder engagement, reverse engineering, and good governance that embraces the intrinsic complexity. In particular, challenges often arise in migrating data, rediscovering undocumented business logic, overcoming organizational inertia, and maintaining service continuity during the transformation. This will be done through a permanent set of modernization programs, cloud-native architectures, enterprise-grade automated migration tooling, and composable and flexible architectural design patterns. Organizations that succeed will reconcile the imperatives of innovation and operations and develop cultures that foster continuous learning and adaptation. Organizational capabilities in renewing and refreshing legacy systems have become essential for organizations to thrive and survive in the face of digital disruption and strengthening competition.

No abstract available

No abstract available

No abstract available

No abstract available

No abstract available

Migrating a mature enterprise integration environment to Azure involves more than replacing one middleware platform with another. Existing interfaces differ in orchestration complexity, business importance, technical dependencies, and suitability for cloud-based services. Applying one migration strategy to every interface can create unnecessary redesign work or carry legacy limitations into the target architecture. This paper presents an Integration Migration Decision Framework (IMDF) developed and applied during an enterprise migration from Microsoft BizTalk Server to Azure Integration Services. The framework assesses each interface using three dimensions: Orchestration Complexity, Business Criticality, and Cloud-Native Fitness. Based on these dimensions, each interface is assigned to one of four migration dispositions: lift-and-shift, re-architect, replace, or retain and reassess. The framework was applied to 200 interfaces processing approximately five million transactions per month across IBM AS/400, SAP S/4HANA, SaaS applications, SQL Server, and reporting platforms. The portfolio was classified into 25 lift-and-shift interfaces, 86 re-architected interfaces, 56 replacement candidates, and 33 retained or reassessed interfaces. All 200 interfaces were migrated through 16 waves over one year and eight months. The contribution of IMDF is not the introduction of new migration labels. Those labels overlap with established cloud migration strategies. The contribution is an integration-specific assessment method that connects technical complexity, business risk, cloud suitability, migration sequencing, and operational architecture. The paper also describes hybrid connectivity and staging database isolation patterns used to address legacy-system dependencies and recovery requirements.

No abstract available

No abstract available

Legacy mainframe programming languages have been foundational in the development and operation of large-scale business and scientific computing systems since the mid-20th century. These languages, including COBOL, Assembler, PL/I, FORTRAN, RPG, JCL, ALGOL, Natural, CLIST, and REXX, were designed to handle the robust data processing needs of enterprises and government institutions. COBOL, known for its English-like syntax, is still widely used in business applications, while Assembler offers low-level hardware control for highly efficient execution. PL/I and FORTRAN cater to both business data processing and scientific computations, respectively. RPG, originally created for report generation, evolved to support comprehensive data processing tasks. JCL, although a scripting language rather than a programming language, is crucial for job execution in batch processing environments on IBM mainframes. ALGOL has been influential in the development of many modern languages. Natural and REXX facilitate rapid application development and scripting, respectively. Despite the emergence of modern programming languages, these legacy languages remain vital for maintaining and understanding existing mainframe systems, underscoring their enduring significance in the history of computing

No abstract available

No abstract available

No abstract available

Enterprise software repositories contain complex, long-lived, and continuously evolving code assets whose behavior is distributed across services, frameworks, configuration files, database schemas, event streams, and deployment scripts. Conventional program comprehension tools provide useful static analysis, search, and dependency visualization capabilities, but they often fail to explain why a code element exists, how a change propagates across enterprise boundaries, and which downstream artifacts are likely to be affected by a modification. Large language models have recently demonstrated strong ability in source code understanding, documentation generation, and natural-language reasoning over program artifacts. However, direct application of generic LLMs to enterprise repositories is insufficient because enterprise comprehension requires contextual grounding, dependency-aware retrieval, architectural constraints, security awareness, and traceable impact prediction. This paper proposes RepoComprehend-LLM, a context-aware framework for LLM-based program comprehension in enterprise software repositories. The framework integrates repository mining, static dependency extraction, semantic code representation, retrieval-augmented generation, graph-based impact propagation, and confidence-calibrated explanation generation. Unlike isolated method-level summarization, the proposed framework generates hierarchical summaries at method, class, service, API, and business-capability levels; constructs multi-layer dependency graphs across code, configuration, database, event, and deployment artifacts; and predicts change impact using structural, semantic, historical, and developer-activity signals. The paper presents the architecture, methodology, scoring functions, evaluation protocol, implementation considerations, and enterprise governance controls for deploying such a framework in regulated software engineering environments. The central contribution is a research-oriented, implementation-ready approach that treats program comprehension as a context-aware, evidence-grounded, and continuously updated intelligence layer for software maintenance, modernization, and release risk assessment.

Software Engineering (SE) researchers are extensively applying Large Language Models (LLMs) to address challenges in SE tasks such as code clone detection, code summarization, and program comprehension. Despite promising results, LLMs have to be fine-tuned and customized with specific datasets for optimal performance. However, the proprietary nature of SE data, and the lack of LLMs trained on non-open source data is an open problem. While there exists work on applying Federated Learning (FL) for SE, integration of FL with LLMs for SE is unexplored. Hence, we propose a FedLLM for “code summarization” as developers spend more time in comprehending code. We setup a federated learning architecture and fine-tune LLM (Llama2 with 6.7B parameters) using Parameter Efficient Fine-Tuning (PEFT) for code summarization. We conducted our experiments on 40GB RAM GPU in an A100 architecture. Results show that FL-trained LLM is as effective as a centrally-trained one. We envision that leveraging non-open source data using FedLLM for SE could be an interesting research direction.

Code summarization plays a vital role in program comprehension and software maintenance by generating natural language descriptions to summarize the semantics of code. While Large Language Models (LLMs) have shown remarkable performance in this area, recent empirical studies reveal a critical limitation: LLMs are prone to hallucinations, producing summaries that are factually inaccurate or unfaithful to the source code, potentially misleading developers. In this paper, we propose to unveil, detect, and mitigate hallucinations in LLM-based code summarization. First, we construct Hallu-Eval, a novel dataset for unveiling hallucination phenomena and rigorously evaluating the effectiveness of hallucination detection and mitigation in LLM-based code summarization. It comprises both original code snippets to capture naturally occurring hallucinations and their semantically perturbed counterparts, which are designed to systematically induce challenging logical hallucinations, all complemented with manual hallucination annotations on a curated testbed of 800 code-summary pairs. Next, we propose Hallu-Det, a synergistic approach that combines direct entity-level detection to identify explicit hallucinations with a synonymous mutation-based refinement to reliably confirm or refute more ambiguous cases. Finally, we introduce Hallu-Shield, an inference-time mitigation approach that leverages an external value model to guide LLMs toward producing more faithful summaries without costly retraining of the LLM itself. Extensive experiments show that Hallu-Eval effectively triggers hallucinations, increasing the hallucination rate of models such as Qwen2.5-Coder-7B from 17% to 97% on perturbed code. Our detection approach, Hallu-Det, achieves the best performance among baselines, reaching an F1-score of 0.95 for summaries generated by Qwen2.5-Coder-7B. Moreover, our mitigation method, Hallu-Shield, reduces hallucination rates. For example, it lowers the rate from 66% to 59%, a 10.6% relative reduction, on DeepSeek-Coder-6.7B, while simultaneously improving summary quality, achieving a 74.0% win rate evaluated by an LLM-as-a-judge majority vote ensemble.

No abstract available

Research in source code summarization, that is the description of the functionality of a program with short sentences expressed in natural language, is a topic of great interest in the software engineering community, since it can help in automatically generating software documentation, and in general can ease the effort of the developers in understanding the code they are working on. In this work, which is conceived as a negative results paper, we study the existing neural models designed for this purpose, pointing out their high sensitivity to the natural elements present in the source code (i.e. comments and identifiers) and the related drop in performance when such elements are ablated or masked. We then propose a novel source code summarization approach based on the aid of an intermediate pseudo-language, through which we are able to fine-tune the BRIO model for natural language on source code summarization, and to achieve results comparable to that obtained by the state-of-the-art source code competitors (e.g. PLBART and CodeBERT). We finally discuss about the limitations of these NLP-based approaches when transferred in the domain of source code processing, and we provide some insights for further research directions.

Source code summarization is the task of writing natural language descriptions of source code. The primary use of these descriptions is in documentation for programmers. Automatic generation of these descriptions is a high value research target due to the time cost to programmers of writing these descriptions themselves. In recent years, a confluence of software engineering and artificial intelligence research has made inroads into automatic source code summarization through applications of neural models of that source code. However, an Achilles’ heel to a vast majority of approaches is that they tend to rely solely on the context provided by the source code being summarized. But empirical studies in program comprehension are quite clear that the information needed to describe code much more often resides in the context in the form of Function Call Graph surrounding that code. In this paper, we present a technique for encoding this call graph context for neural models of code summarization. We implement our approach as a supplement to existing approaches, and show statistically significant improvement over existing approaches. In a human study with 20 programmers, we show that programmers perceive generated summaries to generally be as accurate, readable, and concise as human-written summaries.

No abstract available

No abstract available

Understanding and maintaining source code is a critical aspect of software development. Source code comments play a crucial role to increase understandability and sustainability. However, creating and maintaining comprehensive comments alongside the source code can be labour intensive and lead to inconsistencies. This study investigates the effectiveness of Natural Language Processing (NLP) techniques in automating the source code summarization and comment generation processes to alleviate these challenges. We propose a novel evaluation framework that assesses the sufficiency and quality of generated comments in aiding source code comprehension. Leveraging state-of-the-art NLP models, our approach aims to summarize source code functionalities and generate descriptive comments automatically. Furthermore, we introduce a new index proposal tailored to evaluate the adequacy of generated comments in capturing the essence of source code. Software projects with a high Cyclomatic Complexity value need to be explained and well documented as they are projects with high complexity. In this study, different popular repositories were analysed and comments were generated for uncommented functions using natural language processing approaches. With the proposed index, both Cyclomatic Complexity value and productivity were evaluated. The successful results obtained from this study shows that automatic comment generation approaches can be used much more successfully in the near future.

No abstract available

Numerous methodologies have been introduced for code summarization and associated activities, including the utilization of large language model (LLM)-based code summarization, to aid software developers in the comprehension and maintenance of software systems. Code comment is one of the communication channels and practices that can assist developers in developing and maintaining software systems. The interpretation and comprehension of code comments can present significant challenges due to factors such as diverse writing styles and varying levels of background knowledge and experience among developers within a team. Self-admitted technical debt (SATD) is commonly indicated in code comments. This research investigates the efficacy of applying large language models to identify SATD and summarize code comments containing SATD to support code maintenance. We employed three widely used pre-trained LLMs, i.e., BART, Flan-T5, and T5 as summarizers. The experimental results indicated that 75 % of the natural language summaries generated by BART are readable with the appropriate structure and vocabulary used. However, almost all generated summaries are irrelevant to the original code comments while the T5 model can identify SATD and include it in the generated summaries. These findings highlight the potential and the limitations of using pre-trained LLMs for code comment summarization and SATD identification, paving the way for future improvements in this domain.

Code summarization is the process of automatically generating brief and informative summaries of source code to aid in software comprehension and maintenance. In this paper, we propose a novel model called READSUM, REtrieval-augmented ADaptive transformer for source code SUMmarization, that combines both abstractive and extractive approaches. Our proposed model generates code summaries in an abstractive manner, taking into account both the structural and sequential information of the input code, while also utilizing an extractive approach that leverages a retrieved summary of similar code to increase the frequency of important keywords. To effectively blend the original code and the retrieved similar code at the embedding layer stage, we obtain the augmented representation of the original code and the retrieved code through multi-head self-attention. In addition, we develop a self-attention network that adaptively learns the structural and sequential information for the representations in the encoder stage. Furthermore, we design a fusion network to capture the relation between the original code and the retrieved summary at the decoder stage. The fusion network effectively guides summary generation based on the retrieved summary. Finally, READSUM extracts important keywords using an extractive approach and generates high-quality summaries using an abstractive approach that considers both the structural and sequential information of the source code. We demonstrate the superiority of READSUM through various experiments and an ablation study. Additionally, we perform a human evaluation to assess the quality of the generated summary.

Code comments are the most important medium for documenting program logic and design. Nevertheless, as modern software undergoes frequent updates and modifications, maintaining the accuracy and relevance of comments becomes a labor-intensive endeavor. Drawing inspiration from the remarkable performance of Large Language Model (LLM) in comprehending software programs, this paper introduces a program analysis based and LLM-driven methodology for identifying inconsistencies in code comments. Our approach capitalizes on LLMs' ability to interpret natural language descriptions within code comments, enabling the extraction of design constraints. Subsequently, we employ program analysis techniques to accurately identify the implementation of these constraints. We instantiate this methodology using GPT 4.0, focusing on three prevalent types of constraints. In the experiment on 13 open-source projects, our approach identified 160 inconsistencies, and 23 of them have been confirmed and fixed by the developers.

We propose Project Context for Code Summarization with LLMs (ProConSuL), a new framework to provide a large language model (LLM) with precise information about the code structure from program analysis methods such as a compiler or IDE language services and use task decomposition derived from the code structure. ProConSuL builds a call graph to provide the context from callees and uses a two-phase training method (SFT + preference alignment) to train the model to use the project context. We also provide a new evaluation benchmark for C/C++ functions and a set of proxy metrics. Experimental results demonstrate that ProConSuL allows to significantly improve code summaries and reduce the number of hallucinations compared to the base model (CodeLlama-7B-instruct). We make our code and dataset available at https://github.com/TypingCat13/ProConSuL.

Code comment, i.e., the natural language text to describe the semantic of a code snippet, is an important way for developers to comprehend the code. Recently, a number of approaches have been proposed to automatically generate the comment given a code snippet, aiming at facilitating the comprehension activities of developers. Despite that state-of-the-art approaches have already utilized advanced machine learning techniques such as the Transformer model, they often ignore critical information of the source code, leading to the inaccuracy of the generated summarization. In this paper, to boost the effectiveness of code summarization, we propose a two-stage paradigm, where in the first stage, we train an off-the-shelf model and then identify its focuses when generating the initial summarization, through a model interpretation approach, and in the second stage, we reinforce the model to generate more qualified summarization based on the source code and its focuses. Our intuition is that in such a manner the model could learn to identify what critical information in the code has been captured and what has been missed in its initial summarization, and thus revise its initial summarization accordingly, just like how a human student learns to write high-quality summarization for a natural language text. Extensive experiments on two large-scale datasets show that our approach can boost the effectiveness of five state-of-the-art code summarization approaches significantly. Specifically, for the well-known code summarizer, DeepCom, utilizing our two-stage paradigm can increase its BLEU-4 values by around 30% and 25% on the two datasets, respectively.

The recent use of large language models (LLMs) in code generation and code summarization tasks has been widely adopted by the software engineering community. New LLMs are emerging regularly with improved functionalities, efficiency, and expanding data that allow models to learn more effectively. The lack of guidelines for selecting the right LLMs for coding tasks makes the selection a subjective choice by developers rather than a choice built on code complexity, code correctness, and linguistic similarity analysis. This research investigates the use of machine learning classification and ranking methods to select the best-suited open-source LLMs for code generation and code summarization tasks. This work conducts a comparison experiment on four open-source LLMs (Mistral, CodeLlama, Gemma 2, and Phi-3) and uses the MBPP coding question dataset to analyze code-generated outputs in terms of code complexity, maintainability, cyclomatic complexity, code structure, and LLM perplexity by collecting these as a set of features. An SVM classification problem is conducted on the highest correlated feature pairs, where the models are evaluated through performance metrics, including accuracy, area under the ROC curve (AUC), precision, recall, and F1 scores. The RankNet ranking methodology is used to evaluate code summarization model capabilities by measuring ROUGE and BERTScore accuracies between LLM code-generated summaries and the coding questions used from the dataset. The study results show a maximum accuracy of 49% for the code generation experiment, with the highest AUC score reaching 86% among the top four correlated feature pairs. The highest precision score reached is 90%, and the recall score reached up to 92%. Code summarization experiment results show Gemma 2 scored a 1.93 RankNet win probability score, and represented the highest ranking reached among other models. The phi3 model was the second-highest ranking with a 1.66 score. The research highlights the potential of machine learning to select LLMs based on coding metrics and paves the way for advancements in terms of accuracy, dataset diversity, and exploring other machine learning algorithms for other researchers.

Legacy Banking Systems must be upgraded. Large banks today rely upon core systemsdeveloped decades ago. Those systems are expensive to support and difficult to change. This means that banks need to modernize their legacy banking systems so they can be agile, resilient and cost-effective. In this paper, a systematic approach to migrating large legacy systems has been identified. Drivers have been defined with both the structure and operation of legacy systems and have surveyed migration methods and have developed a quantifiable cost model to associate migration design with expense. This paper also provides decision-making matrices and tables to guide in the selection of strategy and identify "best practices" for implementing such strategies such as automation of development and operations, cost management of finance, testing and governance. The analysis includes specific enterprise examples and references to peer-reviewed research and industry reports. Key takeaways are to perform modernization in a physical and use detailed financial models to measure the potential value of migration.

This study, titled "Financial Benefits of Cloud Migration in Financial Institutions," explores the economic viability, structural shifts, and operational enhancements of migrating core banking architectures from legacy on-premise servers to cloud infrastructure. Modern banking systems face rising data hosting rates, physical maintenance costs, and scaling limitations under traditional structures. This research investigates the financial benefits of converting capital-heavy Capital Expenditure (CapEx) to flexible Operating Expenditure (OpEx). A 5- year capital budgeting analysis (2021-2025) of a bank-led cloud migration program is conducted using capital budgeting metrics: Net Present Value (NPV), Internal Rate of Return (IRR), Payback Period (PBP), and Benefit-Cost Ratio (BCR). Quantitative metrics demonstrate that cloud migration reduced annual IT spend from 170 Crores to 102 Crores by 2025, while improving core system uptime to 99.99% and transaction latency to 35 milliseconds. The financial model yields a positive NPV of 392.4 Crores and an IRR of 45.1%, far exceeding the 10% cost of capital. The study concludes that cloud-based digital transformation is highly financially feasible, offering private commercial banks substantial cost savings, operational scalability, and a major competitive edge in the retail finance market. Keywords: Cloud Migration, Financial Benefits, CapEx to OpEx, Hybrid Cloud, System Latency, Cost-Benefit Analysis.

No abstract available

The modernization of legacy core banking systems has become a strategic imperative for financial institutions in India, driven by rapid advancements in digital payments, regulatory mandates, and growing customer expectations. This paper explores the multifaceted challenges associated with transitioning from legacy architectures to next-generation digital platforms, particularly in the context of Indian banking. It presents a structured analysis of technical, operational, and organizational barriers such as data model incompatibility, downtime risk, skill shortages, and regulatory compliance. Drawing on recent case examples—including public sector migration efforts and cloud adoption strategies—the study highlights the tension between maintaining operational continuity and embracing innovation. It also contextualizes these transformations within India’s evolving regulatory environment, including recent RBI directives on IT governance and data localisation. The proposed framework emphasizes scalable, cloud-agnostic architectures that are resilient, secure, and interoperable with national digital infrastructure like UPI and Aadhaar. By aligning modernization efforts with regulatory compliance and digital innovation, this study aims to support Indian banks in building future-ready systems. The findings offer practical insights for policymakers, CIOs, and enterprise architects navigating the legacy-to-digital transition in India’s unique financial ecosystem.

Monolithic designs and rigid frameworks of the legacy core banking systems make the growth of the financial services industry difficult, along with the flexibility and the generation of new technologies. This article presents a comprehensive strategy for the migration of legacy banking systems to their cloud-native microservices architecture counterparts. The architecture design patterns, data migration methods, and models for systematic transition are part of the framework that assists banks and other financial organizations in making their systems resilient, their operations effective, and their ability to innovate at an increased speed. The strangler pattern provides step-by-step replacement options that create the least amount of turmoil while still permitting ongoing validation. Event-driven architectures are targeted at real-time data analytics, required for financial services today. Domain-driven design ensures that the boundaries of the services align with business concepts. Replication mechanisms and incremental migration procedures are two ways in which solutions to data transition address consistency problems. The phased migration models must compromise between goals of innovation and requirements for risk management by carrying out thorough assessments, pilot implementations, core functionality migration, and ongoing optimization. Only those financial institutions that will successfully undergo this change will have technology platforms capable of driving innovation while continuing to meet reliability and compliance standards that form the premise of regulated financial services.

No abstract available

The process of updating legacy software through the .NET Framework to .NET Core migration requires substantial resources but remains essential. This paper evaluates the process of manual code refactoring against Large Language Model (LLM)driven code refactoring for such a migration. The evaluation framework consisted of three dimensions, which assessed code quality and efficiency, and developer experience. The research demonstrates that LLM-driven refactoring reduces development time yet demands thorough verification, which transforms developers into oversight managers. The manual approach produces better initial quality but takes longer to complete. The most effective strategy for legacy system modernization involves a human-in-the-loop approach, which uses LLMs for tasks within a robust automated testing framework. The research provides a systematic evaluation of trade-offs to help practitioners make decisions about AI-assisted software engineering.

Legacy core banking systems, which are for the most part monolithic and rigid, have come under increasing pressure to develop in order to be more agile and scalable in the high-speed financial world of today. In this paper a cloud-native modernization framework that uses AWS-based microservices to modernize legacy banking infrastructure is presented. The framework promotes DevOps best practices by breaking down monolithic applications into independently deployable microservices, improving operational reactivity and time-to-market for new features, and responding to the application demand at any given time. Leveraging AWS services including AWS Lambda, Amazon ECS, API Gateway, and DynamoDB, the model provides strong resilience, elastic resource management, and better security posture. The framework solves problems of data consistency, transaction management, and regulatory requirements in a decentralized environment. Experimental results also show that the support for system responsiveness, availability and maintainability is substantially enhanced. This research opens the door for banks to embrace agile cloud-native architectures, delivering innovation and customer-focused services for the digital future.

Background: Legacy systems remain critical to enterprise operations but often suffer from rigidity, scalability limitations, and high maintenance costs. The rise of hybrid cloud environments offers new opportunities for modernization while preserving core business logic. However, integrating legacy systems with hybrid cloud platforms introduces architectural and operational complexity. Enterprises require systematic approaches to reduce integration risk and ensure consistency. Traditional ad-hoc migration methods lack formalization. Therefore, structured modernization approaches are essential. Aim: This study aims to propose a model-driven approach for integrating legacy systems into hybrid cloud environments. The objective is to enhance interoperability, scalability, and maintainability while minimizing disruption to existing enterprise operations. The approach seeks to abstract system complexity using formal models. It also aims to provide a reusable and technology-independent integration framework. By leveraging model-driven engineering, the solution targets reduced development effort. Ultimately, the aim is to support sustainable enterprise modernization. Method: The proposed method employs Model-Driven Engineering (MDE) to define platform-independent and platform-specific models. Legacy system components are analyzed and transformed into standardized models. These models guide automated or semi-automated integration into hybrid cloud architectures. The approach defines transformation rules, integration layers, and deployment workflows. A conceptual architecture and workflow are designed to support implementation. Case-based evaluation is used to assess feasibility. Results: The model-driven approach demonstrates improved consistency and traceability during system integration. Results indicate reduced integration complexity and enhanced adaptability to cloud changes. Enterprises benefit from clearer separation between business logic and infrastructure concerns. The approach supports gradual migration rather than full system replacement. Performance and maintainability are improved through modular integration. The framework shows strong potential for reuse across domains. Conclusion: The study concludes that a model-driven approach is effective for hybrid cloud integration of legacy systems. It provides a structured and scalable pathway for enterprise modernization. The approach mitigates common risks associated with cloud migration. By leveraging abstraction and automation, enterprises can achieve smoother transitions. The framework supports long-term system evolution. Future work can extend automation and validation mechanisms.

Legacy software systems remain central to banking, healthcare, insurance, government, retail, telecommunications, and enterprise resource planning environments, yet many of these systems evolve for years without corresponding architectural documentation. The absence of reliable architectural knowledge increases maintenance cost, slows digital transformation, weakens software reliability, and creates substantial risk during cloud migration, microservices decomposition, regulatory remediation, and DevOps modernization. Traditional software architecture recovery techniques rely heavily on static dependencies, clustering heuristics, call graphs, package structures, and manual expert interpretation. Although these methods provide useful structural views, they often fail to capture the semantic intent, business capability alignment, hidden cross-cutting concerns, and modernization feasibility of legacy modules. This paper proposes an intelligent architecture recovery framework that combines Large Language Models (LLMs) and Graph Neural Networks (GNNs) to recover, explain, and operationalize architectural knowledge from legacy software repositories. The proposed framework constructs a heterogeneous software knowledge graph from source code, build files, configuration artifacts, database scripts, dependency metadata, API traces, commit history, and documentation fragments. LLMs are used to infer semantic roles, business capabilities, domain concepts, anti-patterns, and modernization constraints from code and natural language artifacts, while GNNs learn structural and semantic representations of software entities to identify architectural components, boundary violations, dependency risks, and migration candidates. The paper presents a research-oriented framework, algorithmic workflow, graph schema, training strategy, evaluation protocol, and modernization decision model. Unlike purely review-based studies, the contribution of this paper is a proposed recover-and-modernize architecture intelligence pipeline that transforms legacy software comprehension into actionable modernization recommendations. The framework is intended to support architects and engineering teams in microservices decomposition, cloud migration planning, technical debt prioritization, service boundary discovery, impact analysis, and reliability improvement. The study argues that hybrid LLM-GNN architecture recovery can bridge the gap between structural reverse engineering and semantically grounded modernization governance.

As wholesale banking has morphed in response to regulatory pressures, the movement of enterprise data to cloud has not only been a desire of technology but it is now a regulatory mandate. Under pressure by regulators and market forces the banks have to ensure that their strategies of shifting large volumes of sensitive financial information to cloud environments are secure, reliable and compliant. An enterprise data migration using a phased process provides a roadmap where the risk is lowered in various stages, business continuity is achieved and continuous compliance validation is maintained through the migration diversion. In contrast to single approaches or big bang approaches, phased approaches allow banks to break migration into manageable phases- pilot workloads, core systems, and legacy decommissioning, and apply tight control on governance, auditing and alignment to regulations. This paper looks at how staged migration policies can assist wholesale institutions in achieving compliance requirements to their frameworks (including Basel III, GDPR, AML/KYC, and PCI DSS) whilst leveraging the scalability, flexibility and efficiency of cloud adoption. Important technical and operational factors such as data classification and encryption protocols, cross-border data transfer risks and hybrid-cloud deployment modalities are incorporated in the discussion. Governance, risk, and compliance (GRC) alignment may therefore receive special consideration where a step-by-step migration results in ongoing control, reporting, and regulatory compliance. Comparative tables demonstrate the difference between the big bang and phased strategies, regulatory- driven categories of data, and compliance-driven KPIs to assess the level of success in transformation. This article presents phased enterprise data migration as a future-proof solution to cloud transformations of wholesale banking through the combination of strategic insight and practical considerations. The results imply that not only phased strategies reduce the risks of non-compliance, but they also increase the institutional resilience and lead to innovation and competitiveness in the digital-first financial environment.

The increasing sentiment of digitization in the financial industry is swiftly transitioning core banking technologies towards faster, reliable, and resilient systems. This is being demanded at scales that have never been experienced before, especially under unpredictable and high‐volume transaction demands. Established legacy-based monolithic architectures now face more challenges to support the increasing demands for near-real-time processing and elastic scalability. The challenges are seen in significantly rising latencies, heavy change management procedures for every modification required, and excessive system downtimes during deployment. The move towards a hybrid, cloud‐native architecture, based on microservices and serverless principles is seen as a step that can allow institutions to create modular platforms that can provide further benefits: significantly increase end‐to‐end execution latencies, allow independent scaling of transactional elements and components, and continually drive innovation. This paper presents a systematic exploration of the principles and technical approaches for next‐gen core banking design. It identifies suitable and medium-level reference hybrid architecture for financial institutions to achieve subsystems processes of <300ms transactions, with multi‐thousands TPS. It analyzes suitable architecture deployment using microservices, EVENT‐DRIVEN, serverless edge execution scenarios, distributed data localities, among others for the core banking to achieve overalls. Through a detailed discussion on digital frameworks, architectures, and current best-of-breed use cases, the research provides references on how next-gen core banking architectures reshape deployment areas including security, data management, and compliance functionalities. It emphasizes the growing need for financial institutions and organizations to address functional areas and challenges that reduce operational friction points and enhance costs-effectiveness alongside differentiating, low‐latency customer engagements with continued agility for compliance and advanced security mechanisms.

The modernization of financial institutions has catalyzed the transition from monolithic legacy systems to highly distributed, API-centric core banking architectures. While this evolution enables unprecedented scalability and integration, it introduces profound complexities in Quality Engineering (QE). Traditional validation methodologies, particularly within User Acceptance Testing (UAT) and API integration phases, are inherently unscalable, labor-intensive, and prone to missing complex, systemic defects. This paper proposes a highly scalable, AI-driven Quality Engineering architecture designed for the end-to-end validation of core banking systems. By converging Machine Learning (ML) defect prediction models, dynamic service dependency graphs, and automated decision intelligence, the proposed framework drastically optimizes the UAT ecosystem. Empirical evaluations utilizing simulated high-frequency banking telemetry demonstrate that the integration of advanced ensemble techniques (Random Forest and Gradient Boosting) paired with graph-based test case prioritization reduces UAT cycle times by 68% while achieving a defect detection F1-score of 0.93. The architecture seamlessly integrates predictive quality assurance into the agile software lifecycle, ensuring that core banking upgrades, API deployments, and complex UAT scenarios are executed with maximum integrity, minimal automation economics overhead, and fortified cybersecurity resilience. Ultimately, this research provides a comprehensive blueprint for financial institutions seeking to achieve autonomous, predictive, and infinitely scalable quality engineering.

The migration to cloud within banking systems is complicated by the closely linked architectures, rules and regulations, and the significant operational risk. This study explores how AI-assisted Change Impact Analysis (CIA) can help make the process of migration safer and more efficient. The proposed solution is beneficial as it is based on AI methods like predictive analytics and dependency models. The AI-assisted processes are more likely to show accuracy in detecting the effects of changes, ease manual work, and be better prepared to comply. The results of the numerical analysis and case studies in the industry show that AI-enhanced CIA can greatly enhance the processing speed, prediction accuracy, and risk mitigation. Hence, it can be used to modernise banking IT infrastructures. There are critical recommended actions for the banks, including the upskilling of employees, ensuring quality data inputs and stakeholders’ interactions.

Automated translation of legacy code to modern programming languages is the need of the hour for modernizing enterprise systems. This work specifically addresses automated COBOL to Java translation. Traditional rule-based tools for this perform statement-wise translation, overlooking possible modularization and refactoring of the source COBOL code to translate to human-readable target Java code. Our investigation reveals that state-of-the-art Large Language Models (LLMs) in the domain of code encounter difficulties with regard to logical correctness and readability when directly translating low-resource COBOL code to Java. To address these challenges, we propose an LLM-based workflow, leveraging temperature sampling and refinement-based strategies, to not only ensure logical correctness of the translation but also maximize the readability of the target Java code. We exploit the fact that, due to their extensive exposure to human-written Java codes during pre-training, the LLMs are more equipped with profound comprehension and capability for refining translated Java codes than COBOL to Java translation. With a dataset sourced from CodeNet, we perform sequential refinement of the translated high-resource Java code with execution-guided logic feedback followed by LLM-based readability feedback. We demonstrate that this yields better performance in terms of logical correctness (81.99% execution accuracy) and readability (0.610 score), than LLM based translation with test cases and readability guidance (60.25% and 0.539) or refinement of the translation task itself (77.95% and 0.572).CCS CONCEPTS• Computing methodologies → Machine translation; Neural networks; • Software and its engineering → Software evolution; Maintaining software.

Cobol remains widely used in mainframe environments, making the migration of legacy applications to modern languages such as Java essential for improving maintainability, reducing technical debt, and addressing knowledge loss as experienced developers retire. Large Language Models (LLMs) show promise for automating this migration, but their effectiveness is limited by cobol's domain-specific syntax and the scarcity of high-quality training data. We propose enhancing cobol-to-Java translation by augmenting source code with natural language summaries, enabling LLMs to leverage their stronger natural language understanding capabilities. We evaluate this approach on two complementary datasets: an open-source CodeNet benchmark (727 samples) and a curated enterprise-grade benchmark (571 samples). Results with different LLMs show substantial improvements for low-quality baseline translations: summary augmentation improves 36% of eligible CodeNet samples and 50% of low-scoring enterprise benchmark samples, demonstrating effectiveness on the most challenging cases. We further develop routing strategies that dynamically select between baseline and summary-augmented pipelines to balance translation quality and computational cost. Results on enterprise benchmark show that a simple threshold-rule routing strategy achieves up to 8.75% improvement in translation quality with 0.7 additional LLM calls per sample. Overall, this work presents a practical and scalable method for enterprise cobol-to-Java modernization, reducing manual review and refinement effort.

Modern enterprise systems often rely on legacy COBOL applications whose rigid, monolithic structure and globally scoped variables impede maintainability and cloud-native adoption. In this paper, we present a hybrid COBOL‑to‑Java translation pipeline that combines static program analysis with large language models (LLMs) to deliver scalable, consistent, and idiomatic Java code at enterprise scale. This translation pipeline is a core component of IBM’s watsonx Code Assistant for Z (WCA for Z) product. Our Class Designer and Method Designer modules perform global analysis to infer Java classes, hierarchies, and method signatures from COBOL data divisions and control‑flow graphs, generating metadata that guides the LLM‑based translation of procedural logic. We evaluate our pipeline on 20 GenAPP programs and 10 proprietary customer applications, comparing it against three standalone LLMs using an automated LLM‑as‑Judge framework. We show that our translation pipeline delivers a typical (median) structural quality score of over 80% and a functional score above 75%, while also reducing variability in results and enforcing uniform naming and design across all modules. Our translation pipeline, deployed across numerous client environments as part of IBM’s WCA for Z, provides a cost-effective solution for application modernization—bridging the COBOL skills gap and accelerating enterprise-wide transformation.

COBOL remains one of the most widely deployed programming languages in mission-critical business systems, yet the pool of developers who can maintain it is shrinking. Automated translation to modern languages like Java is an increasingly attractive modernisation strategy, but systematic evaluation of available approaches remains limited. Here, we evaluate state-of-the-art open source COBOL-to-Java translation approaches, across a benchmark of 326 small open source programs, and investigate LLM-based strategies for repair and maintainability improvement of resultant translations. The evaluated tools present a clear correctness-maintainability trade-off: COBOL4J, a rule-based COBOL-to-Java translator, achieves the highest functional correctness, based on test-pass rates, at 86.4%, but generates verbose, unmaintainable output. XMAiNframe-7B, a COBOL fine-tuned LLM, strikes the best balance across both dimensions with 55.2% functional accuracy; and Qwen2.5-Coder-7B, a general-purpose model, performs weakest on functional correctness at 22.4%. We find that the post-hoc repair pipeline, with the best-performing iterative prompting strategies, eliminates most compilation errors across all three tools on the tested dataset. Post-hoc refactoring reduces COBOL4J’s verbose output from an average of 15 functions per file, to only 1.2, however, half the time at the cost of correctness. Our findings show that production-grade COBOL modernisation is best approached as a hybrid pipeline: using rule-based translation to ensure baseline functional correctness, followed by domain-specialised LLM refinement to improve structure and maintainability. The derived bug taxonomy analysis can be used to guide targeted prompt design and improve future COBOL-to-JAVA translator development.

Background: Software migration across programming languages is a critical yet labor-intensive task, often requiring deep code understanding and manual intervention. Aims: In this study, we aim to develop a fully automated agent for end-to-end code translation and validation. Method: First, we generate code comments from Java source code using various large language models (LLMs) to enhance code comprehension and facilitate cross-language translation. Second, leveraging these AI-generated comments, we automatically generate equivalent C# code, demonstrating the potential of AI in software migration and interoperability. Third, we complete both Java and generated C# code and prepare them to execute. Fourth, we apply automated unit testing to assess functional correctness and ensure the reliability of AI-generated code. Results: Our results show that a fully automated LLM agent may effectively bridge programming languages with minimal human input. This approach opens new possibilities for scalable, AIdriven software modernization and cross-platform development. Conclusions: We recommend that such an LLM agent should be used to support human experts during the generation of reliable and correct code.

Deep learning (DL) approaches for program translation have been extensively researched over recent years. These have been shown to be an effective alternative to manually-coded translators. At the same time, questions remain regarding the reliability and verifiability of DL approaches. Precise program translation approaches based on model-driven reverse engineering (MDRE) have also been researched. In this paper we provide the first detailed comparison of the results of the DL and MDRE approaches on tasks of COBOL translation to Python, Java and C\#.

HarmonyOS NEXT is a distributed operating system developed to support HarmonyOS native apps. To support the new and independent Harmony ecosystem, developers are required to migrate their applications from Android to HarmonyOS. However, HarmonyOS utilizes ArkTS, a superset of TypeScript, as the programming language for application development. Hence, migrating applications to HarmonyOS requires translating programs across different program languages, e.g., Java, which is known to be very challenging, especially for concurrency programs. Java utilizes shared memory to implement concurrency programs, while ArkTS relies on message passing (i.e., Actor model). This paper presents an LLM-based concurrent Java program to ArkTS converter.Our converter utilizes large language models (LLMs) for efficient code translation, integrating ArkTS’s SharedArrayBuffer API to create ThreadBridge, a library that replicates Java’s shared memory model. Using LLM’s Chain-of-Thought mechanism, the translation process is divided into specialized chains: the TS chain, concurrency chain, and synchronization chain, each handling TypeScript syntax, concurrency patterns, and synchronization logic with precision.This study offers solutions to bridge concurrency model differences between Java and ArkTS, reducing manual code rewriting and speeding up adaptation for HarmonyOS NEXT. Experiments show the converter successfully compiles 66% of 53 test samples, with 69% accuracy for compiled results. Overall, the approach shows promise in converting concurrent Java programs to ArkTS, laying the foundation for future improvements.

Programming language translation is essential in modern software development, facilitating cross-platform compatibility and the adaptation of legacy systems. This study examines the performance of large language models (LLMs), such as ChatGPT, in Python-to-Java code translation. Using a dataset of ten diverse algorithmic problems and advanced prompt engineering techniques, we evaluate the models effectiveness in maintaining computational accuracy (CA) and preserving method correctness (PMC). Results indicate that LLMs perform well on standard tasks but encounter challenges in complex scenarios involving advanced data structures and recursion. These findings uncover the potential of LLMs in code translation while highlighting the need for improved prompt strategies and domain-specific fine-tuning for complex tasks.

Code translation converts source code from one programming language to another while preserving functional behavior, and is critical for legacy migration and cross-platform development. Recent prompt-based LLM approaches such as UniTrans and TRANSAGENT show promise, but their repair stage relies almost exclusively on runtime test feedback, which is insufficient for diagnosing uncompilable code or silent structural errors. We propose MERIT (Multi-Signal Error Repair via Intelligent Translation), a repair framework that jointly exploits four complementary signals: abstract syntax tree (AST) structural comparison against a same-language reference, a language knowledge base, error pattern matching, and LLM self-reflection. Across TransCoder and HumanEval-X, six translation directions among Python, Java, and C++, and five LLMs of varying capability (Claude Sonnet 4.6, Grok-4, Grok-3, GPT-4.1, and CodeLlama-7B), MERIT consistently improves every model, yielding relative gains of $\mathbf{1. 3 \% - 1 3. 1 \%}$ in compilation accuracy ($\boldsymbol{C A}$) and $\mathbf{1. 3 \% - 2 5. 7 \%}$ in execution accuracy $(E A)$, and it outperforms the single-signal baseline UniTrans by 3.0-3.6 percentage points on CodeLlama-7B under identical settings. A leave-one-out ablation, an ordersensitivity incremental ablation, and an error-cause analysis jointly confirm that the four signals are complementary and nonredundant. Multi-signal repair is therefore substantially more effective than single-signal repair, and MERIT is model-agnostic and easy to deploy.

: Code migration between programming languages is a costly and complex task, often requiring significant manual effort to ensure functional correctness and maintainability. In this paper, we evaluate the effectiveness of approaches for automated source code translation across widely used languages (C++, C, Java, JavaScript, Python) as well as lesser-used languages (Haskell, Pascal) using Large Language Models (LLMs). Despite using four models in our experiments, our approach is LLM-agnostic and does not require any costly fine-tuning of the used LLMs or other LLM-specific optimizations. Instead, our approach incorporates multiple LLM-based translation techniques, in particular, an iterative refinement process guided by self-consistency checks. We analyze the quality of the generated code, identifying common translation errors, highlighting areas where models struggle, and evaluating cost efficiency. Our findings contribute to a generalized, high-quality, cost-optimizing approach for automated code migration, capable of increasing translation and serving as a foundation for automatic code migration. Hence, we present a promising path toward reducing the economic and technical barriers to code migration across the programming language spectrum.

Financial institutions continue to rely on decades-old mainframe systems written in COBOL to support critical operations. As expert developers retire and modernization projects accelerate, banks face a dual challenge: preserving functional knowledge while ensuring smooth migration to modern languages such as Java. This paper reports on the design of an orchestrated multi-LLM pipeline that automatically generates functional and technical documentation from COBOL source code within secure, air-gapped environments. The approach combines expert-validated pre-processing, structured prompt engineering, and a hybrid evaluation process mixing LLM-as-a-Judge with human review to assess fidelity, readability, and business relevance. The experience gathered from a large-scale implementation at BNP Paribas shows that while single-LLM configurations maximize factual fidelity, orchestrated multi-LLM setups better interpret and capture business semantics—an essential prerequisite for COBOL-to-Java migration. These observations highlight practical trade-offs between accuracy and abstraction in zero-fine-tuning settings and outline a governance-aligned path for integrating generative AI into regulated financial institutions.

Migrating legacy COBOL tax software to modern programming languages requires preserving business semantics in addition to producing syntactically correct translations. Small deviations in thresholds, deduction rules, arithmetic expressions, or boundary conditions may lead to incorrect financial computations. This paper presents TaxVerif, a verification-oriented migration framework that combines invariant extraction, assertion-guided translation, and mutation-based semantic validation. Candidate invariants are extracted from COBOL programs, translated into executable assertions, and used to verify Java-like translations under bounded execution. The evaluation includes an invariant-extraction benchmark, a controlled synthetic mutation benchmark, and a real-code benchmark using open-source COBOL programs with lexical, structural, and graph-based features. The results show that invariant-guided verification substantially improves semantic-error detection over syntax-based validation, while strict evaluation on unseen programs and unseen mutation types remains significantly more challenging, emphasizing the need for semantic verification in legacy-code migration.

Parity testing validates software modernization: the legacy system supplies every expected output, so the oracle is sound. One decision is delegated, increasingly to a language model and often the very model that translated the code: which inputs to try. How much divergence such suites let through is unmeasured, and whether a model validating its own translation misses more is unknown; we pre-registered that self-validation hypothesis. We measure both in Python-to-Java function migration with five models, each acting as both translator and validator, with expected values always from executing the legacy source and divergence established by differential execution on a large type-directed input set together with the generated suites. Of the parity suites that passed, 40.8% were on divergent translations, and 7.7% on translations that diverge on an input a reviewer would call unremarkable. We could not detect a self-validation penalty. Validator strength and translator subtlety dominate instead: misses are worst when a weak validator checks a strong translator's code, the configuration a cost-conscious pipeline prefers. A passing parity suite is evidence about where testing has looked, not a verdict of behavioural equivalence, and should be reported with its escape rate attached.

Large Language Models (LLMs) show great potential for automating code-related tasks. However, sound assessments are necessary to understand their true capabilities, particularly in code translation, where reliability is crucial. We introduce Polyglot, an automated, multi-language framework for evaluating the translation quality of LLMs between different programming languages. Leveraging the IBM CodeNet Project, an extensive collection of coding problems in multiple languages, we assess translation quality using syntactic correctness, execution reliability, semantic preservation, and static code metrics. Our evaluation focuses on translating C to Java, Python, and Rust, languages that follow distinct paradigms and represent alternatives to modernize C-based systems. We evaluate open-source LLMs using three prompting strategies to understand the impact on translation performance. Our findings highlight that while LLMs show promising results for simple code translation, their limitations regarding complex logic and distinct language paradigms require further analysis.

We address a major challenge in COBOL comprehension — programs often exceed 15,000 lines of code (loc), which can overwhelm developers and cause critical business logic to be lost in summarization. To solve this, we integrate flowcharts and vector DB-based chunking for enhanced visualization and traceability. Our approach shows measurable improvements in translation accuracy, developer productivity, and explainability. This pipeline reduces hallucination rates by 70%. Increases bleu scores by 15.8 points, and improves developer productivity by 45%, based on our pilot studies in the banking domain.

Recent advances in large language models (LLMs) have led to substantial improvements in automatic code translation across programming languages. However, translating large or complex legacy code, such as monolithic COBOL programs, remains a challenge due to the limited context window of transformer-based models and their diminished ability to preserve long-range dependencies. In this work, we consider COBOL-to-Java translation as a case study and propose a hierarchical chunking strategy that decomposes long code segments into smaller, semantically coherent chunks, each fitting within a predefined Lines of Code (LoC) constraint. We formalize the problem of minimizing the number of chunks under an LoC constraint and present both a greedy heuristic and a dynamic programming based lower bound. Experiments on real-world COBOL applications demonstrate that our approach significantly improves the translation quality compared to non-chunked baselines.

Automated code generation using large language models (LLMs) has attracted significant attention due to its potential to enhance software development. However, ensuring both accuracy and efficiency in generated code remains challenging. Prior research has mainly advanced along two directions: (i) enhancing models through architectural improvements, larger parameter scaling, and domain-specific fine-tuning; and (ii) refining prompt engineering techniques to better structure inputs and guide outputs. In this work, we pursue the latter direction and introduce a prompt engineering–based approach for Java code generation. Rather than directly generating Java code from natural language specifications, we propose a two-step pipeline: (i) generating intermediate Python code and, (ii) translating Python into Java. This design leverages the strong performance of LLMs on Python while enabling systematic optimization of the translation stage. To achieve this, we propose a set of translation strategies combining prompt engineering principles—including explicit instructions, syntax guidance, and domain keyword constraints—with advanced reasoning strategies such as Zero-shot Chain of Thought (Zero-shot-CoT) to efficiently generate Java code. Experiments on the HumanEval-X benchmark using the CodeGeeX3 model show that the proposed strategies significantly improve the accuracy of Java code generation. We further evaluate across diverse programming tasks, including file operations, HTTP APIs, database connectivity, parallel computing, and graphical applications, confirming the robustness of our approach. Finally, we validate the generality of our findings using ChatGPT (GPT-4o), observing substantial improvements over baseline prompt designs.

With the rapid advancement of large language models (LLMs), code translation has become a critical yet challenging task in software engineering. Existing evaluations of this task remain unreliable due to two key limitations: the absence of specialized function-level code translation benchmarks and flawed evaluation pipelines. Specifically, current pipelines lack post-processing mechanisms to extract target code from LLMs’ inherently unstable output formats, directly resulting in non-executable translations and false negatives in evaluation. To address these issues, we introduce FuncTransEval, an enhanced multilingual benchmark. It comprises 400×4 functions across four programming languages (Python, C++, Java, and JavaScript) and 12 bidirectional translation pairs, each paired with executable unit tests for fine-grained functional validation. Using FuncTransEval, we systematically assess LLMs’ true capabilities in code translation and identify their core limitations: inadequate understanding of the implicit information such as function logic, type specifications, and cross-language differences. To mitigate these shortcomings, we propose ICAM-Trans (Implicit-Context-Aware Multi-Agent Framework for function-level code translation). ICAM-Trans is a hierarchical, autonomous multi-agents architecture that explicitly uncovers and leverages these implicit contextual information during translation. It employs a Translation Orchestrate Agent (TOA) to autonomously coordinate four specialized Context Analysis Agents (CAAs), which conduct pre-translation analyses on different aspects. Insights from these analyses guide a Context-Aware Translation Agent (CTA) to generate semantically faithful target code. Experiments on FuncTransEval demonstrate that ICAM-Trans consistently outperforms strong baselines, validating its effectiveness in achieving high-fidelity and interpretable function-level code translation.

Automated code translators can now produce repository-scale translations from Java to Python, yet a substantial fraction of translated functions remain semantically incorrect. Repairing such defects differs from traditional automated program repair (APR) because the correctness specification is based on the source language and no target-language test suite exists to guide fault localization. We observe that the original Java code is the most authoritative specification for repair and propose AnchorRepair, a dual-agent framework that treats the Java source as first-class diagnostic evidence. The Diagnosis Agent operates in a ReAct-style loop and autonomously invokes seven cross-lingual analysis tools, producing a structured root-cause diagnosis by contrasting the Java specification against the Python translation across control flow, data flow, and call graph dimensions. A Patch Agent then generates a corrected Python function conditioned on this diagnosis and the retrieved Java context. We evaluated AnchorRepair on 82 real translation defects from four Apache Commons projects. With DeepSeek-V3.2 as the backend, AnchorRepair repairs 40 defects (48.8%), a 12-point absolute improvement over the LLM-Only baseline (28/82) and substantially outperforming TransAgent (17/82) and D4C (21/82). The framework generalizes across LLM backends without modification and achieves repair coverage comparable to a general-purpose coding agent at less than half the cost. Our source code and all experimental results are publicly available at https://github.com/JJS-TJ/AnchorRepair.

No abstract available

Business rules extraction is an important activity in situations in which a software system becomes obsolete and needs to be replaced by a newer system, since the replacing system needs to satisfy the business rules embedded in the legacy software system. In this paper, we investigate an approach in which the computational business rules of a legacy software system can be extracted given previously generated output of the system and without requiring access to the system’s source code. Furthermore, extracted computational business rules are validated automatically with minimal involvement of domain experts through Test-Driven Development (TDD) such that test cases are constructed from historic output of the system. The proposed approach is applied to extract the computational business rules of a large-scale governmental payroll legacy software system. The study results demonstrate that the suggested approach extracted computational business rules van meet a substantial number of test cases. Thus, the efforts involving domain experts can be reduces to analyze such instances.

Computer systems implement business processes from different organizations. Among the currently operating computer systems, much of it is classified as legacy system. Typically, legacy systems are complex applications that are still active, due to the high cost of modernization and a high degree of criticality. In recent years, were published several works addressing the importance of legacy systems modernization, emphasizing the extraction of the business process model implemented in these systems. Within this context, a key step is to extract knowledge from source code and / or systems execution logs, aiming to use this information in reverse engineering processes. In this work are presented and analyzed methods based on source code manipulation and system’s execution logs mining, which can be used to extract knowledge from legacy systems, prioritizing business rules identification. A comparison between the two different approaches is presented, as well as their positive and negative characteristics. Our results include a list of desired features and a proposal of a method for legacy systems reverse engineering and business rules identification.

We report on the automated modernization of a business-critical terminal operating system deployed across multiple sites of a major European port infrastructure company, comprising a heterogeneous technology stack accumulated over many years of continuous development: over 22,000 source files, about 10,000 of them C#, a multi-layered web forms UI, a complex Oracle database, and extensive operational documentation. Most current LLM-assisted modernization approaches rely on cloud-based models, raising intellectual property and security concerns that prevent adoption in industrial settings. We present a hybrid pipeline in which local LLMs extract a formal four-view specification that keeps proprietary source code entirely on-premises, while cloud models generate target implementations from specifications only, never accessing the legacy codebase. The pipeline extracts structural domain models, behavioral rules, process state machines, and screen presentations across 48 bounded contexts via a two-pass LLM extraction approach. Against a curated reference on a CRM probe, the best local model reaches a structural fidelity of 0.83, while two of seven candidates fail to emit parseable JSON at all; prompt engineering raises the semantic purity of the extracted domain model from 0.71 to 0.94, whereas legacy documentation adds almost nothing. Following a test-first approach, 5,451 behavioral tests were generated from specifications alone before any target implementation, and two runnable application stacks (Python/FastAPI and .NET 8 Blazor) were produced. We report concrete lessons on prompt engineering, structured output generation, and the practical boundaries between automation and manual intervention.

An enterprise system operates business by providing various services that are guided by set of certain business rules (BR) and constraints. These BR are usually written using plain Natural Language in operating procedures, terms and conditions, and other documents or in source code of legacy enterprise systems. For implementing the BR in a software system, expressing them as UML use-case specifications, or preparing for Merger & Acquisition (M&A) activity, analysts manually interpret the documents or try to identify constraints from the source code, leading to potential discrepancies and ambiguities. These issues in the software system can be resolved only after testing, which is a very tedious and expensive activity. To minimize such errors and efforts, we propose BuRRiTo framework consisting of automatic extraction of BR by mining documents and source code, ability to clean them of various anomalies like inconsistency, redundancies, conflicts, etc. and able to analyze the functional gaps present and performing semantic querying and searching.

No abstract available

No abstract available

No abstract available

No abstract available

Migrating a legacy monolithic application to a microservice architecture is a complex, multi-stage process requiring careful service boundary identification and an orchestrated transition plan. This paper presents a comprehensive AI- accelerated methodology for domainification—the systematic alignment of microservices with business domains—and for building configuration-first microservice platforms that preserve system flexibility. Modern AI techniques automate and optimize each migration phase: (1) Graph-based code analysis using node embeddings and Graph Neural Networks (GNNs) uncovers tightly coupled functionality clusters, (2) Natural Language Processing (NLP) on source code (identifiers, comments, documentation) identifies semantic groupings and candidate boundaries, and (3) Reinforcement Learning (RL) formulates extraction sequencing as a decision problem, recommending an optimal incremental order that maximizes cohesion and minimizes risk. Crucially, each service is implemented as a configurable engine: business rules and policies are externalized to configuration files or metadata, enabling new requirements via configuration rather than code. This paper provides a detailed system architecture for the AI-assisted pipeline. Rigorous evaluation on benchmarks demonstrates superior modularization (higher cohesion, lower inter-service coupling) compared to baselines. A case study on a large- scale e-commerce platform shows major gains in time-to-market and agility: policy changes once requiring full development cycles are now deployed within hours. This study addresses key non-functional needs such as security (consistent authentication, API gateway policies), data consistency (saga patterns, careful partitioning), and the vital role of human expertise through a human-in-the-loop paradigm. The result is a repeatable, low-risk pathway for modernization that combines advanced AI-driven analysis with configuration-centric design to achieve both structural and business agility.

No abstract available

No abstract available

No abstract available

No abstract available

No abstract available

No abstract available

There are many organizations, especially in domains such as banking, insurance, airline that are looking for tools to identify and extract business rules from legacy mainframe code. Existing works have considered execution paths for a single business variable as the granularity of business rules which limits the identification of complex rules. In our work, we address this limitation and provide a tool called A-COBREX, which implements a novel technique to identify business rules involving multiple business variables from the source code. We have evaluated the same on 27 programs with ground truth annotations. It has a recall of 74.12% and precision of 62.21% for fuzzy match between ground truth and extracted rules. The screencast is available at https://youtu.be/adriX4q41PA, and the tool at https://github.com/SaravananKrishnan/BRE.

Businesses are replete with applications created decades ago and are still relevant functionality wise. However, they pose significant evolution and integration challenges - the former because of paucity of skilled workforce and the latter due to high impedance mismatch with modern technology stack. The two constitute principal reasons leading to contemplation of modernization of these applications. Typical approach is to migrate existing code to the desired technology stack as a language transformation endeavor under functional equivalence. However, traditional parser-based approaches and lift-and-shift modernization methods typically add to the technology debt, thus making evolution of the modernized code even more challenging. To overcome the various lacunae in current practice in software modernization, we propose the stagewise refinement approach using LLM. In this paper, we focus on the stage of human-in-theloop automation aided generation of functionality description specifically for Common Business-Oriented Language (COBOL) code. We illustrate the utility and efficacy of the proposed approach through validation on a small but complex business application.

Automated program repair (APR) has emerged as a promising solution to mitigate the escalating cost and complexity of software maintenance, yet current approaches suffer from inefficiencies in problem localization and excessive token consumption when employing large language models (LLMs). To address this gap, this study proposes KeBugFix, a novel LLM-based framework that integrates code retrieval and feature extraction to enhance repair performance while minimizing computational overhead. The KeBugFix framework is composed of two stages: (1) an enhanced bug localization phase that utilizes SourceGraph, a semantic code search tool, in conjunction with LLM-driven keyword extraction to augment issue descriptions with relevant file paths; (2) an autonomous iterative repair phase involving two interacting agents–THOUGHT and ACTION–that emulate human-like reasoning and execution workflows. Evaluation was conducted on the SWE-bench Verified dataset, encompassing 500 manually validated software defects across 12 popular open-source Python repositories. Experimental results demonstrate that KeBugFix significantly outperforms the SWE-agent baseline. It reduces average input token usage from 480,000 to 220,000 and cuts LLM API calls by 60.5%, while slightly improving the repair success rate from 23.4% to 24.2%. Additionally, inference latency was reduced by 8.9%, reflecting improved operational efficiency without compromising accuracy.

In today’s rapidly evolving digital landscape, modernizing legacy systems is imperative for organizations to remain competitive and agile. This study introduces an innovative framework titled “Intelligent Legacy System Modernization: A Framework for Automated Application Migration using AI/ML/GenAI/LLM.” The framework leverages advanced artificial intelligence (AI), machine learning (ML), generative AI (GenAI), and large language models (LLM) to facilitate the seamless migration and modernization of outdated software systems. By integrating these cutting-edge technologies, the proposed solution automates the migration process, reduces manual intervention, and minimizes the risks associated with legacy system dependencies. The framework is designed to analyze, interpret, and transform legacy codebases into modern architectures, ensuring enhanced performance, scalability, and maintainability. Furthermore, it incorporates predictive analytics to foresee potential issues during migration, enabling proactive problem-solving. Through a series of experiments and case studies, the framework demonstrates significant improvements in migration speed and cost efficiency, while maintaining high levels of accuracy and system reliability. This research also highlights the challenges encountered during the integration of AI/ML tools in legacy environments and offers strategies to overcome these obstacles. Overall, the proposed intelligent modernization framework not only optimizes application migration processes but also provides a robust foundation for future technological advancements, ensuring that legacy systems can evolve in tandem with emerging digital innovations.

Manual test case generation for agile software development is a critical bottleneck that is costly, inconsistent, and error-prone. This study introduces a prompt-engineering and multi-level orchestration framework to automate this process. The proposed approach explicitly targets the automated generation of high-level acceptance test cases, addressing a gap in existing research that predominantly focuses on unit-level or reactive testing. The proposed tool, AI-Based Desktop Test Generator (AIDTG), employs a dual-LLM engine (Gemini 1.5 and GPT-4) to transform high-level functional descriptions from the Product Backlog into structured validation scenarios. Unlike prior LLM-based testing approaches, the framework integrates schema-aware prompt engineering and dual-model orchestration to ground the generation process in both functional intent and technical data constraints. The methodology is distinguished by its context-aware prompt engineering, which injects a frozen database schema to ground the models, and its ability to format outputs for the TestRigor BDD 2.0 platform. This schema-grounded and orchestrated workflow enables the systematic translation of informal User Stories into executable Behavior-Driven Development (BDD) acceptance tests, reducing ambiguity and improving semantic correctness. Experimental results on a real-world dataset of fifty User Stories show the framework reduces manual test design effort by eighty per cent, achieves a four point seven five (out of five) average quality rating from human experts, and produces BDD scripts with a ninety-one point nine per cent functional correctness pass rate. These results demonstrate that orchestrated, schema-aware Generative AI can operate as a reliable co-assistant for QA teams, improving efficiency while maintaining high standards of quality and executability.

LLM-based testing can expose subtle reliability issues in numerical software, but monolithic prompts make it hard to inspect which guidance drives effectiveness. We study whether Agent Skills can make such workflows more explainable by factoring procedural knowledge into composable testing components. Using numerical inconsistency detection as a case study, we decompose an LLM-based differential-testing pipeline into Skills for program generation and feedback-guided mutation, then evaluate four Skill configurations. Our results show that the feedback-guided mutation Skill setting yields the largest improvement on inconsistency rate (+12 percentage points), while enriching Skills with additional procedural knowledge slightly decreases performance (−3 percentage points). An exploratory evaluation with agent-native execution reveals scalability challenges for high-iteration Skill workflows.

The rapid digital transformation of banking in Sri Lanka creates both opportunities for data-driven services and challenges in security, compliance, and system scalability. This study proposes a cloud-native big data architecture on Amazon Web Services (AWS) integrated with Machine Learning Operations (MLOps) to address these challenges for a leading Sri Lankan commercial bank. Using a single-case study design, we assessed the bank's legacy infrastructure via interviews with nine stakeholders (IT, data science, corporate-level Executives and business users. The proposed modular architecture integrates heterogeneous data sources into an S3-based data lake, supports batch and streaming ingestion (AWS Glue, Kinesis), offers analytical serving via Athena/Redshift, and embeds an ML Ops pipeline (ML flow, Sage Maker, EKS) with feature store and monitoring (Prometheus). Security and governance are enforced through IAM, KMS, Lake Formation, CloudTrail and Guard Duty to meet local data residency and GDPR-aligned controls. Empirical evaluation of the pilot reports a 30% reduction in IT operational costs, a 4× improvement in data processing throughput, and a reduction in fraud detection time from hours to under 5 minutes, while enabling weekly model updates and reproducible model lineage. We discuss implementation challenges, stakeholder training needs, and regulatory coordination. Contributions of this work include:  1.    A practical AWS-based reference architecture tailored to Sri Lankan banking constraints.2.    An integrated MLOps pattern for regulated environments3.    An evaluation demonstrating measurable operational and analytic gains.The paper concludes with recommendations for phased cloud migration, governance checklists, and future research directions, including quantitative ROI studies and multi-bank comparative analyses.

Digital transformation has dramatically reshaped the banking sector by enhancing operational efficiency, customer experience, and financial transparency. This study compares digital transformation adoption in state-owned versus private commercial banks in Sri Lanka, focusing on accounting and finance innovations. A qualitative research approach was adopted, and data were collected from the annual reports of 2021–2023 of four leading banks: two state-owned, State Bank A and State Bank B, and two private, Private Bank C and Private Bank D. A thematic analysis was performed to assess digital adoption trends, technological advancement, and regulatory challenges. The results indicate that private banks have a higher rate of digital adoption compared to government Banks, due to investments in AI, blockchain, and customer-focused digital platforms. On the other hand, state-owned banks face the challenge of legacy systems and lower digital literacy, which delays adoption. Key challenges remain in cybersecurity risks, regulatory compliance, and cost-intensive technology upgrades. Hence, the research prescribes that government-owned banks focus more on infrastructure modernization and financial literacy programs, while private banks should align their AI and blockchain adoption with compliance standards. This has important implications for policymakers, banking executives, and FinTech developers as they shape future digital banking strategies for Sri Lanka.

This paper provides a comprehensive systematic review of the digital transformation strategies in legacy banking and payments infrastructure. As the financial services industry increasingly adopts digital technologies, traditional banking systems are being disrupted by emerging solutions such as artificial intelligence (AI), blockchain, cloud computing, and machine learning. The review explores the key drivers of this transformation, including technological advancements, regulatory pressures, and shifting customer expectations. It highlights various strategies for modernizing core banking systems, integrating fintech partnerships, and upgrading digital payment infrastructures to meet the demands of the digital age. The paper also addresses the significant challenges faced by legacy banking systems, such as outdated infrastructure, organizational resistance, and security concerns. Furthermore, it examines future trends such as the integration of quantum computing, 5G, and distributed ledger technologies, and the role of AI and automation in reshaping financial operations. The paper concludes with strategic considerations for the long-term success of digital transformation in the banking sector, emphasizing agility, scalability, and sustainability. This review provides valuable insights for financial institutions seeking to adapt to an increasingly digital landscape, ensuring their competitiveness and relevance in the future of banking.

No abstract available

This study investigates digital resilience in Sri Lankan banks, focusing on practical strategies to address challenges specific to the sector. Digital resilience, the ability to withstand, adapt to, and recover from digital disruptions, is critical in safeguarding financial systems against threats. However, limited technological infrastructure, regulatory ambiguities, and operational constraints hinder comprehensive resilience in emerging markets like Sri Lanka. A qualitative research design, grounded in phenomenology, was employed to explore shared experiences and perceptions of banking professionals. Semi-structured interviews with nine participants from key roles in cybersecurity, risk management, and IT operations provided in-depth insights. Thematic analysis identified two main areas: the current state of digital resilience and barriers to its enhancement. Findings revealed that Sri Lankan banks benefit from robust regulatory frameworks and institutional initiatives. However, human vulnerabilities, reliance on legacy systems, regulatory uncertainties, and vendor non-compliance remain significant obstacles. The study proposes actionable strategies, including establishing a Digital Resilience Community of Practice, adopting regulatory sandboxes for piloting emerging technologies, and blockchain-based solutions for vendor compliance tracking. These approaches aim to enhance sector-wide resilience while addressing systemic challenges. This research contributes to global discourse by emphasizing the need for context-specific strategies in emerging markets. Future studies should validate these findings through larger-scale research and cross-country comparisons to refine and extend their applicability.