International Journal of Advanced Research in Computer Science and Engineering
Title: International Journal of Advanced Research in Computer Science and Engineering Journal initials: IJARCSE Publisher: Wissira Research Lab LLC ISSN (online): 3071-0154 Publisher Address: Carmel, United States- 46074 Publisher Email: editor@wissira.us Copyright: Remain Journal Starting Year: 2025 Main Subject: Computer Science Scope: Future Technologies in Computer Science and Engineering Language: English Publication Format: Online (Open Access) Website: https://ijarcse.org International Journal of Advanced Research in Computer Science and Engineering (IJARCSE) is a scholarly, peer-reviewed, open-access journal dedicated to publishing high-quality research and innovative developments in Computer Science, Information Technology, and Engineering disciplines. The journal serves as a global platform for researchers, academicians, scientists, industry experts, and technology professionals to share original research, novel methodologies, practical applications, and emerging technological innovations. IJARCSE aims to advance scientific knowledge by promoting interdisciplinary research that integrates computing technologies with engineering solutions. The journal encourages contributions that address contemporary challenges, explore emerging trends, and develop innovative frameworks capable of transforming industries, organizations, and society. The journal publishes original research articles, review papers, survey articles, case studies, technical reports, short communications, and innovative application studies. All submitted manuscripts undergo a rigorous peer-review process to ensure originality, technical quality, scientific validity, and academic excellence. By adopting an open-access publishing model, IJARCSE ensures worldwide accessibility to scientific knowledge, fostering collaboration among researchers, institutions, and industry practitioners across the globe. Areas of Research and Specializations IJARCSE welcomes research contributions in, but not limited to, the following domains: Computer Science and Engineering Computer Science Computer Engineering Software Engineering Information Systems Programming Languages Compiler Design Operating Systems Distributed Computing Parallel Computing High-Performance Computing Artificial Intelligence and Machine Learning Artificial Intelligence Machine Learning Deep Learning Generative AI Explainable AI (XAI) Reinforcement Learning Neural Networks Intelligent Systems Cognitive Computing Autonomous Systems Data Science and Analytics Data Science Big Data Analytics Data Mining Predictive Analytics Business Intelligence Statistical Computing Data Visualization Decision Support Systems Knowledge Discovery Computational Intelligence Cybersecurity and Digital Security Cybersecurity Information Security Network Security Cloud Security Application Security Digital Forensics Ethical Hacking Privacy Engineering Threat Intelligence Security Risk Management Cloud Computing and Distributed Systems Cloud Computing Edge Computing Fog Computing Serverless Computing Grid Computing Multi-Cloud Architectures Cloud Infrastructure Virtualization Technologies Resource Optimization Distributed Applications Internet of Things (IoT) and Smart Technologies Internet of Things (IoT) Industrial IoT (IIoT) Smart Cities Smart Healthcare Smart Agriculture Smart Transportation Sensor Networks Cyber-Physical Systems Connected Devices Intelligent Automation Blockchain and Emerging Technologies Blockchain Technologies Distributed Ledger Technologies Smart Contracts Web3 Technologies Cryptocurrency Systems Decentralized Applications Digital Identity Systems FinTech Innovations Emerging Digital Ecosystems Software Development and Engineering Software Architecture Software Testing and Quality Assurance Agile Software Development DevOps Engineering Continuous Integration and Deployment Software Project Management Model-Driven Engineering Software Reliability Software Maintenance Networks and Communication Technologies Computer Networks Wireless Communication Mobile Computing 5G and 6G Technologies Network Optimization Network Protocols Wireless Sensor Networks Internet Architecture Communication Systems Computer Vision and Intelligent Media Computer Vision Image Processing Video Analytics Pattern Recognition Facial Recognition Systems Augmented Reality Virtual Reality Extended Reality (XR) Multimedia Systems Natural Language Processing and Human-Centered Computing Natural Language Processing Speech Recognition Conversational AI Human-Computer Interaction Human-Centered Design Language Technologies Sentiment Analysis Information Retrieval Recommender Systems Electrical, Electronics, and Embedded Systems Embedded Systems VLSI Design Microprocessors and Microcontrollers Digital Electronics Analog Electronics Communication Engineering Signal Processing Robotics and Automation Intelligent Control Systems Computational Science and Applied Engineering Computational Modeling Scientific Computing Simulation and Optimization Operations Research Engineering Analytics Mathematical Modeling Digital Twin Technologies Industrial Informatics Sustainable and Green Computing Green Computing Sustainable Information Systems Energy-Efficient Computing Sustainable Software Engineering Environmental Informatics Smart Energy Systems Sustainable Digital Transformation Interdisciplinary Research Computing for Healthcare Computing for Education Smart Governance Systems AI for Social Good Computational Social Science Technology and Society Digital Transformation Research Industry 4.0 and Industry 5.0 Types of Manuscripts Accepted Original Research Articles Review Articles Survey Papers Case Studies Technical Notes Industrial Research Papers Conceptual Frameworks Short Communications Application-Oriented Studies Interdisciplinary Research Papers
Articles are published under the Creative Commons Attribution NonCommercial 4.0 License (CC BY NC 4.0), allowing others to distribute, remix, adapt, and build upon the work for non-commercial purposes while crediting the original author.
Software Testing Optimization Using Genetic Algorithms
Software systems have grown so large and fast-moving that traditional testing strategies struggle to keep pace with delivery cycles and resource constraints. Search-Based Software Engineering (SBSE) reframes testing tasks as optimization problems; among SBSE techniques, Genetic Algorithms (GAs) offer a flexible, domain-agnostic way to explore vast test spaces and to trade off competing quality goals. This manuscript presents a practical, end-to-end GA framework for two high-impact testing problems—(i) test-suite prioritization for regression testing under execution-time budgets, and (ii) test-data generation for structural coverage. We formalize chromosome encodings, a multi-term fitness function combining predicted fault revelation (via APFD surrogate), structural coverage, mutation score, and execution time, and we design GA operators that preserve permutation constraints and encourage behavioral diversity using coverage-vector distances. A controlled simulation study across five subject programs (1.5k–38k LOC) compares GA against random and greedy baselines under identical budgets. The GA improves APFD by 10.6–24.8 percentage points over random and 4.1–9.3 points over greedy coverage ordering, while meeting or reducing execution time budgets. Non-parametric tests (Wilcoxon) indicate statistical significance (p < 0.01) with large effect sizes (|d| ≥ 0.8). We include an ablation showing that removing the diversity term degrades early fault detection and increases redundancy. Results demonstrate that a well-tuned GA is both effective and robust for time-boxed regression testing and for reaching hard-to-cover branches. We conclude with guidance for parameterization, threats to validity, and opportunities for multi-objective extensions (e.g., Pareto optimization) and CI/CD integration.
Copyright (c) 2026 The journal retains copyright of all published articles, ensuring that authors have control over their work while allowing wide dissenmination. https://creativecommons.org/licenses/by-nc/4.0
Low-Code Platforms for Rapid Prototyping in Enterprise Applications
Enterprises increasingly need to validate ideas quickly while minimizing risk and cost. Low-code development platforms (LCDPs) promise rapid prototyping by combining visual modeling, reusable components, and model-driven automation with enterprise-grade connectors and governance. This manuscript investigates whether—and under what conditions—low-code accelerates early-stage enterprise application delivery without undermining quality, security, or maintainability. We synthesize prior work on rapid application development, model-driven engineering, and platform governance, and present a mixed-methods study comprising a controlled build-off (6 low-code teams vs. 6 code-first teams), practitioner interviews, and a simulation of portfolio-level throughput under varying complexity and rework rates. Quantitative results indicate that low-code teams produced a functional prototype 30.4% faster (mean 7.8 vs. 11.2 days), reduced early defect density by 38.7%, and closed change requests 40.5% faster, while achieving higher usability scores (SUS +10.1%). Qualitative findings emphasize that gains are largest for CRUD-heavy workflows with standard integrations and clear UX patterns; benefits taper for compute-intensive logic, highly bespoke UI, or edge-case integrations where custom code dominates. The simulation suggests portfolio-level cycle-time improvements of 23–36% when rework rates are moderated through frequent stakeholder validation—an affordance of visual modeling and instant previews in low-code. We discuss governance guardrails (versioning, policy-as-code, access control), architectural patterns (strangler fig, event gateways), and DevOps integration strategies that preserve speed while safeguarding compliance. We conclude with a decision framework aligning platform features with enterprise constraints, and we outline limitations and directions for future research on scaling patterns and technical debt forecasting in low-code ecosystems.
Vehicle Detection Using OpenCV and Python
Vehicle detection is a cornerstone technology in modern intelligent transportation systems (ITS), enabling automated traffic monitoring, congestion analysis, and autonomous navigation. This study presents an exhaustive exploration of two complementary detection paradigms built with OpenCV and Python: a classical, background-subtraction pipeline grounded in Gaussian Mixture Models (GMM) and a contemporary, deep-learning–based detector leveraging the YOLOv4 architecture. The GMM pipeline models pixel-level intensity distributions over time, dynamically differentiating foreground objects from a learned background, followed by morphological filtering and contour analysis to generate candidate vehicle regions. In contrast, the YOLOv4 approach treats detection as a single-stage regression problem, dividing each frame into grid cells that simultaneously predict bounding boxes and class probabilities, achieving real-time performance with high accuracy. Both pipelines were implemented end-to-end in Python using OpenCV’s built-in functions and evaluated on two benchmark datasets—UA-DETRAC and KITTI—under diverse environmental conditions, including fluctuating illumination, weather variability, and occlusions.
Model-Driven Development for IoT Application Deployment
The explosive growth of Internet of Things (IoT) ecosystems has exposed the fragility of hand-crafted deployment pipelines that rely on ad-hoc scripts, heterogeneous device configurations, and scattered YAML artifacts. Model-Driven Development (MDD) promises a principled alternative by raising the level of abstraction: architects capture structure, behavior, resources, and quality objectives as models, and transformations generate deployable artifacts for edge, fog, and cloud tiers. This manuscript proposes IoTDeployML, a lightweight domain-specific modeling approach with three coordinated viewpoints—Domain, Deployment, and Policy—and a transformation toolchain that produces microcontroller firmware stubs (C/MicroPython), Node-RED dataflow graphs, container images, and Kubernetes/Helm manifests. We formalize deployment as a constrained mapping problem between application tasks and a resource graph annotated with latency/energy budgets, then operationalize it using model-to-model (M2M) transformations and model-to-text (M2T) code generation. A simulation study of a smart-campus scenario with 100 devices compares the proposed MDD pipeline against a baseline script-centric process. Across 30 randomized trials, MDD reduced time-to-deploy by ~60%, configuration errors by ~78%, service-level objective (SLO) violations by ~67%, and network bandwidth by ~24%; energy per message at the edge dropped by ~22%. Statistical analyses (normality checks, independent t-tests/ANOVA, effect sizes) show the improvements are significant (p < .01) with large effects. The paper details metamodels, transformation rules, orchestration hooks, and discusses threats to validity and practical adoption guidance.
Feature Engineering for Software Defect Prediction Models
Software defect prediction (SDP) remains a cornerstone of quality assurance in large-scale software engineering, where even marginal improvements in recall at low inspection budgets translate to substantial savings. While model choice often receives outsized attention, the decisive factor in robust SDP performance is feature engineering: how we represent source code, process signals, developer activity, and temporal dynamics. This manuscript presents a comprehensive, practical blueprint for feature engineering tailored to defect prediction. We consolidate static code metrics, process and change metrics, semantic representations learned from code and text, social/ownership signals, and temporally aware features into an auditable pipeline. We discuss leakage-safe preprocessing, class imbalance remedies, and feature selection strategies (filter, wrapper, and embedded) that preserve stability across versions and projects. A simulation study, using a realistic protocol with time-based splits and cross-project transfer, demonstrates that a well-engineered feature set can improve area under the precision–recall curve (AUC-PR) by 11–18% and top-20% cost-effectiveness by 9–15% compared to off‑the‑shelf metrics alone. Statistical analysis (Friedman/Nemenyi over ten versions) indicates significant gains for models using combined semantic–process features. The results generalize across tree ensembles and linear baselines, underscoring that careful feature work—not necessarily deeper models—drives dependable defect prediction performance.
CI/CD Pipeline Security Vulnerabilities and Mitigation Strategies
Modern software delivery pipelines compress development, testing, and deployment into automated continuous integration and continuous delivery (CI/CD) workflows. While this acceleration increases throughput, it also expands the attack surface: source code repositories, dependency resolvers, build runners, artifact registries, and deployment orchestrators are all potential entry points. This manuscript synthesizes the major vulnerability classes observed in CI/CD systems—secrets exposure, build tampering, dependency poisoning, misconfigured trust for forked workflows, runner/agent escape, and artifact misuse—and maps them to a defense-in-depth program that is feasible for organizations of varied maturity. We propose a “network-of-controls” methodology that quantifies residual risk as a function of layered mitigations (preventive, detective, and responsive) and demonstrate its utility with a Monte Carlo simulation of 48,000 pipeline runs across 50 teams over 12 weeks. Fig.1 CI/CD Pipeline Security,Source([1]) The simulated results show an aggregate reduction of pipeline security incidents from 15.7 to 4.0 per 1,000 runs (≈74.5% relative reduction) when organizations adopt a targeted set of mitigations: hermetic and reproducible builds, artifact signing and provenance checks, short-lived cloud credentials via OIDC, secrets scanning and sealed secrets, policy-as-code enforcement, and isolation via ephemeral, sandboxed runners. The study also discusses operational trade-offs—principally modest increases in build time and policy exceptions—against markedly lower incident rates and rollback frequency. We conclude with a practical, staged roadmap that helps teams prioritize controls in high-leverage order without stalling delivery speed.
CI/CD security, software supply chain, build integrity, artifact signing, secrets management, policy as code, pipeline hardening, dependency risk, provenance, runner isolation
Code Smell Detection Using Machine Learning in Static Analysis
Code smells—recurring design or implementation symptoms that indicate deeper problems—degrade maintainability, increase fault-proneness, and inflate long-term costs. Traditional smell detection relies on heuristics woven into static analysis rules or on expert judgment, both of which struggle to generalize across projects and languages. This manuscript presents a machine-learning (ML) approach that uses features derived from static analysis—object-oriented metrics, control-flow measures, dependency signals, and lightweight lexical cues—to detect prominent smells such as God Class, Long Method, Feature Envy, Data Class, and Shotgun Surgery. We design a reproducible pipeline covering dataset construction, feature extraction, imbalance handling, model training, evaluation, and statistical testing. A simulation study emulates multi-project conditions and cross-version drift to approximate realistic industrial scenarios. Four supervised learners—Logistic Regression, Random Forest, SVM (RBF), and XGBoost—are compared under stratified cross-validation and cross-project holdout. Performance is reported using F1-score (primary), with secondary examinations of calibration, error structure, and explainability (via model-agnostic feature attribution). Results show tree-based ensembles (Random Forest and XGBoost) consistently outperform linear and kernel baselines, particularly for class-imbalance-sensitive smells (e.g., Shotgun Surgery). Statistical analysis using non-parametric tests indicates significant differences among learners, and ablation suggests that combining structure-aware metrics with succinct lexical signals yields the best trade-off between accuracy and interpretability. We conclude with practical guidance for toolsmiths and teams: use ensemble ML as an assistive layer on top of static analysis, expose explainable rankings rather than hard flags, calibrate thresholds by smell type, and validate models cross-project to avoid overfitting to local coding styles.
code smell detection; static analysis; software metrics; machine learning; class imbalance; cross-project generalization; explainability
Version Control Best Practices in Large-Scale DevOps Environments
At scale, version control is not just a developer convenience—it is the backbone of reliable, auditable, and fast software delivery. Large organizations face unique challenges such as high commit throughput, cross-repo dependencies, evolving compliance needs, and the coordination of hundreds of contributors across microservices and platforms. This manuscript synthesizes practical best practices for version control in large-scale DevOps environments and evaluates their impact through a controlled simulation. We outline principles across branching strategy, merge policies, code review, commit hygiene, repository topology, automation, security, and compliance. The methodology models three contrasting strategies—(1) long-lived feature branching, (2) GitFlow with release/hotfix branches, and (3) trunk-based development with short-lived branches—under varied policies (required reviews, CI gating, signed commits, and feature flags). Using an agent-based simulation of 120 developers working on 12 services with realistic conflict and failure probabilities, we estimate their effects on key delivery metrics: lead time for changes, deployment frequency, change failure rate (CFR), mean time to restore (MTTR), and merge-conflict incidence. Results indicate that trunk-based development with strict CI gates, mandatory reviews, and feature flags shortens lead time by ~46–58%, increases deployment frequency by ~2.1×, and reduces CFR by ~38% relative to long-lived branching, with statistically significant improvements (ANOVA p < .01) across most outcomes. We conclude with a concise, operational checklist that organizations can adopt incrementally, along with limitations and avenues for future empirical validation in production settings.
DevOps; version control; branching strategy; trunk-based development; GitFlow; CI/CD; code review; feature flags; compliance; monorepo; polyrepo; release engineering
Test Automation Frameworks for Microservices-Based Applications
Microservices architectures accelerate delivery but multiply the surface area that must be validated—APIs, asynchronous events, idempotent workflows, distributed data, and resilience under partial failure. Conventional UI-heavy or single-service test suites struggle with flakiness, long cycle times, and blind spots where inter-service contracts drift. This manuscript proposes a unified, code-centric test automation framework tailored to microservices. The framework layers fast unit and component tests, consumer-driven contract (CDC) tests for synchronous and evented interfaces, containerized integration tests with ephemeral environments, and lightweight end-to-end, performance, security, and chaos checks. It standardizes on executable specifications, test data versioning, service virtualization, and observability-driven assertions (logs, metrics, and traces) wired into CI/CD. We evaluate the framework in a simulated e-commerce domain (six services, HTTP + Kafka) across 12 sprints, comparing it with (a) a baseline manual + UI/E2E approach and (b) a traditional API-automation stack. The proposed framework improved pre-production defect detection by 36.8%, cut CI test duration by 63.0%, reduced flaky tests by 74.4%, and lowered escaped defects per release by 78.6%—while enabling 92% contract coverage. Results suggest that embracing CDC, containerized integration, and observability-backed assertions in a layered pyramid materially improves feedback speed and reliability without over-investing in brittle end-to-end suites. We conclude with guidance for adoption, limits, and opportunities for future enhancement.
microservices testing, contract testing, Testcontainers, service virtualization, observability-driven testing, CI/CD, chaos engineering, ephemeral environments
Agile Development Methodologies in AI-Integrated Software Projects
Artificial intelligence (AI) components—models, data pipelines, feature stores, and feedback loops—introduce uncertainty and non-determinism into software delivery. Traditional Agile practices, designed around code-centric change, can struggle with the probabilistic and data-dependent nature of AI work. This manuscript examines how Agile methodologies can be adapted to AI-integrated software projects, and evaluates their impact on flow efficiency, quality, and model performance stability. We synthesize practice patterns from industry, articulate an “AI-adapted Scrum” and a “Kanban+MLOps” operating model, and contrast them with a baseline Scrum approach. A mixed-method methodology combines process modeling with a discrete-event Monte Carlo simulation of 42 synthetic projects and a statistical analysis of key delivery and ML-specific outcomes (lead time, deployment frequency, change failure rate, rework ratio, and 30-day accuracy retention). Results suggest that incorporating MLOps gates (data validation, model evaluation, fairness and drift checks), dual-track discovery/delivery, and explicit WIP limits for experimentation can reduce lead time by 29–37%, roughly double deployment frequency, and lower change failure rates by 40–50%, while improving short-term accuracy retention by ~7–9 percentage points. The paper concludes with a practical playbook—roles, ceremonies, definitions of done, and risk controls—for engineering leaders who must align Agile cadences with the iterative learning cycles of AI. Limitations and directions for future research are discussed, including external validity to highly regulated domains and long-horizon drift behavior.
Agile; Scrum; Kanban; MLOps; DataOps; ModelOps; model drift; CI/CD; experimentation; AI software engineering
AI-Assisted Code Completion in Modern IDEs: A Comparative Study
AI-assisted code completion has moved from pattern-matching snippets to context-aware suggestions generated by large language models (LLMs) trained on code and natural language. Modern integrated development environments (IDEs) embed these assistants as always-on pair programmers that promise productivity gains, fewer defects, and faster onboarding. Yet teams often struggle to compare tools rigorously across languages, tasks, and governance constraints. This paper presents a structured, simulation-backed comparative study of four representative approaches to completion inside contemporary IDEs: (i) a baseline syntactic engine (traditional Intellisense-style), (ii) a local LLM assistant (runs on developer hardware), (iii) a hybrid LLM assistant (cloud model with on-device/context filters and policy checks), and (iv) a cloud LLM assistant (fully managed, strongest model capacity). We frame the evaluation around research questions on productivity, quality, and risk, define standardized metrics (task success, keystroke savings, time-to-completion, post-run error rate, security-smell rate, and perceived usability), and report results from a controlled simulation fed by empirical distributions observed in typical enterprise tasks (CRUD services, data wrangling, tests, and refactoring micro-tasks). Descriptive statistics, bootstrap confidence intervals, and one-way ANOVA indicate that LLM-based assistants substantially reduce time-to-completion and increase keystroke savings versus the syntactic baseline. Cloud and hybrid assistants show the largest productivity deltas, while the hybrid approach exhibits the lowest simulated security-smell rate. Local LLMs deliver meaningful gains with improved data-control properties but trail on long-range reasoning and multi-file edits. We discuss implications for tool selection, integration patterns (prompt templates, test-first workflows, and guardrails), and limits (hallucinations, style drift, and privacy). The study closes with actionable guidance for teams to align assistant choice with repository scale, compliance posture, and developer ergonomics.
Parallel Sorting Algorithms for Multicore Systems Using OpenMP
Sorting is a core primitive in scientific computing, databases, information retrieval, and systems software. With the ubiquity of multicore CPUs, parallel sorting is now essential for meeting latency and throughput requirements at scale. This manuscript presents OpenMP-based designs of four representative sorting families—comparison sorts (parallel quicksort and mergesort), a data-parallel network sort (bitonic sort), and a non-comparison method (LSD radix sort)—and evaluates them under realistic workload and architecture constraints. We articulate algorithm–architecture co-design choices including partition concurrency, task granularity, memory layout, NUMA placement, branch predictability, and synchronization costs A rigorous methodology specifies datasets (uniform, nearly-sorted, and skewed distributions), input sizes, compiler flags, and OpenMP schedules (static/dynamic/guided) with thread affinity and first-touch allocation. Statistical analysis uses 30 independent repetitions per condition to estimate speedup, scalability, and effect sizes, and to compare the impact of schedule policy. On a 16-core x86-64 system, an OpenMP task-based quicksort attains the best time-to-solution on uniform 32-bit integer keys for large arrays, with mergesort close behind; a cache-aware LSD radix sort shows high single-thread performance but limited scaling due to memory bandwidth pressure; bitonic sort serves as a predictable, branch-free baseline with competitive scaling but a higher constant factor. The discussion synthesizes design guidelines for choosing and tuning OpenMP constructs—loops, tasks, and reductions—so that practitioners can map algorithmic parallelism to shared-memory hardware effectively.
Dynamic Programming Approaches in Multistage Decision Problems
Dynamic programming (DP) offers a principled way to solve multistage decision problems by decomposing global choice into a sequence of local choices linked through the state of the system. From routing and production planning to portfolio rebalancing and clinical scheduling, many high-stakes decisions exhibit three structural features: (i) a state that evolves over time, (ii) a decision at each stage that influences immediate reward and future evolution, and (iii) uncertainty that must be anticipated rather than merely reacted to. This manuscript synthesizes core DP ideas—principle of optimality, Bellman recursion, and value/policy iteration—alongside modern approximations that mitigate the curse of dimensionality. It provides a taxonomy (deterministic vs. stochastic, finite vs. infinite horizon, fully vs. partially observed), discusses structural properties (convexity, monotonicity, submodularity) that yield efficient policies, and shows how rollout and approximate dynamic programming (ADP) bridge exact theory and large-scale practice. To ground the discussion, we develop a canonical stochastic inventory control case with nonstationary Poisson demand, fixed and variable ordering costs, and service-level considerations. We compute an optimal base-stock policy via backward induction (finite horizon) and value iteration (discounted infinite horizon), and compare it against common heuristics: myopic order-up-to, classical (s, S), and rollout lookahead. A Monte Carlo simulation evaluates cost, variability, and service outcomes across demand regimes and capacity constraints. Results illustrate that exact DP dominates myopic behavior and that rollout/ADP can achieve near-optimal performance at a fraction of the computational burden when state spaces grow. Beyond inventory, we map the insights to shortest-path, project selection, maintenance/replacement, and admission-control problems. The paper closes with guidance on modeling choices, algorithm selection, and practical diagnostics for convergence and policy quality, highlighting limitations and directions for future research in high-dimensional and partially observed environments.
dynamic programming; multistage decision problems; Bellman equation; value iteration; policy iteration; approximate dynamic programming; rollout; inventory control; Markov decision process; stochastic optimization
Efficient String Matching Algorithms in DNA Sequence Analysis
String matching underpins nearly every task in computational genomics—from mapping next-generation sequencing (NGS) reads to reference genomes and detecting motifs to calling variants and scanning regulatory regions. The volume and heterogeneity of contemporary sequencing data place extreme demands on algorithmic efficiency, with practical constraints on time, memory, and accuracy under sequencing errors and biological variation. This manuscript surveys the algorithmic foundations of efficient string matching for DNA sequence analysis, distinguishes exact from approximate matching, and clarifies when to favor hash-based seeding, automata, or index-based approaches such as suffix arrays and FM-indexes. We complement the conceptual review with a controlled simulation that compares six representative techniques—Knuth–Morris–Pratt (KMP), Boyer–Moore, Rabin–Karp, a bit-parallel edit-distance method (Myers), an FM-index (Burrows–Wheeler–transform based), and a seed-and-extend strategy with spaced seeds—on synthetic read-mapping tasks. Evaluation emphasizes sensitivity, precision, F1-score, throughput (reads per second), and memory footprint. Results highlight trade-offs: FM-index and seed-and-extend approaches achieve the best F1 and throughput on noisy reads, while classical exact matchers are fast but brittle to mismatches/indels. We discuss statistical significance, effect sizes, and practical guidance for algorithm selection across read length, error profiles, and genome repetitiveness. We conclude with scope and limitations relevant to large genomes, long-read technologies, and structural variation, offering a roadmap for deploying efficient string matching in modern bioinformatics pipelines.
Randomized Algorithms for Fair Load Distribution in Distributed Systems
Fair load distribution is a persistent challenge in distributed systems where heterogeneous resources, bursty arrivals, and partial system knowledge can cause skewed utilization and tail-latency blowups. Randomization—through task placement, sampling, and contention resolution—provides lightweight mechanisms to break adversarial patterns and improve fairness without heavy global coordination. This manuscript examines randomized algorithms for fair load distribution across clusters of stateless and stateful services. After defining operational fairness and its measurement via Jain’s index, Gini coefficient, coefficient of variation, and tail latency, we review core techniques: uniform random assignment, the “power-of-d choices,” randomized work stealing, consistent hashing with virtual nodes, randomized dispatch queues, and gossip-style load exchange. We then outline a simulation methodology that varies arrival processes (Poisson and heavy-tailed), service-time distributions, scale-out dynamics, and heterogeneity. Statistical analysis compares algorithms using non-parametric tests and effect sizes. Results show that two- or three-choice sampling achieves near-equalized utilizations with modest coordination overhead; randomized work stealing excels in burst absorption; and consistent hashing with adequate virtual nodes preserves state locality while keeping imbalance low under churn. We conclude with design guidance: pick d-choice sampling for stateless RPC services at moderate load; combine consistent hashing and limited random probing for stateful shards; enable opportunistic stealing for bursty, CPU-bound workloads; and use randomized backoff and admission control to maintain fairness under overload. The scope and limitations section clarifies generalizability, sensitivity to realistic network effects, and implications for multi-tenant fairness and energy-aware scheduling.
Hybrid Scheduling Algorithm for Deadline-Aware Job Queues
Deadline-aware job queues are central to modern compute backends—ranging from real-time analytics pipelines to latency-sensitive microservices and soft real-time batch processing. Classical policies such as Earliest Deadline First (EDF) minimize deadline misses under ideal assumptions, while size-based policies such as Shortest Remaining Processing Time (SRPT) minimize mean response time but can starve large jobs or violate deadlines. This paper proposes HSA-DAJQ (Hybrid Scheduling Algorithm for Deadline-Aware Job Queues), a practical, preemptive policy that blends (i) laxity-aware urgency from EDF, (ii) SRPT-style remaining-time tie-breaking, (iii) aging for fairness, and (iv) lightweight admission control based on predicted tardiness. HSA-DAJQ maintains three priority bands—Urgent, On-Track, and Background—and promotes/demotes jobs by monitoring relative laxity L=d−t−r^L = d - t - \hat{r}, where dd is the deadline, tt is current time, and r^\hat{r} is the predicted remaining time. We implement HSA-DAJQ in a discrete-event simulator with preemptive-resume semantics, modest context-switch costs, and noisy runtime estimates using an online EWMA predictor. Across realistic, bursty workloads (mixtures of heavy-tailed and light-tailed job sizes) and under high utilization (ρ≈0.85\rho \approx 0.85), HSA-DAJQ reduces deadline-miss rate by 35–60% versus EDF and 70–85% versus MLFQ, while improving mean slowdown by 18–28% over SRPT-only baselines. Sensitivity analysis shows robustness to estimation error (CV ≈ 0.3–0.5) with bounded fairness loss due to aging. The algorithm operates in O(log⁡n)O(\log n) per event using heap-based queues and requires only two tunables (aging half-life and demotion/promotion laxity bands). We discuss design trade-offs, statistical testing (nonparametric comparisons with effect sizes), and limitations, and outline future extensions to heterogeneous multi-resource clusters.
Application of B-Trees in Real-Time Transaction Processing
Real-time transaction processing (RTTP) systems must complete database operations within strict latency budgets while sustaining high throughput, even under bursty, skewed workloads. Index structures dominate the critical path of these systems because almost every transactional read, write, or predicate check touches an index. This manuscript examines the practical application of B-Trees and close variants to RTTP, focusing on predictability, concurrency, and deadline-aware behavior. We begin by revisiting B-Tree fundamentals—node fan-out, height bounds, and page layout—and explain why those properties make B-Trees attractive for bounded-time access. We then review techniques that convert theoretical advantages into end-to-end deadline reliability: latch coupling, crabbing, B-link side pointers, optimistic and lock-free traversals, and append-friendly logging. Building on these ingredients, we propose a deadline-aware B-Tree (DABT) design that (1) pins upper levels in memory, (2) pre-splits hot pages during slack time, (3) uses deadline-aware latch acquisition with time budgets, and (4) aligns group-commit windows to transaction deadline bins. A discrete-event simulator and OLTP-style microbenchmarks (read-heavy and write-intensive mixes under Zipfian key skew) are used to evaluate baseline latch-coupled B-Trees, B-link trees, and DABT. Results show that DABT reduces p99 index latency by 29–44% relative to baselines, cuts deadline-miss rates by more than half, and improves overall throughput by ~11–20% without sacrificing serializability. We analyze statistical significance with repeated trials and report mean±SD across key metrics. The findings indicate that carefully engineered B-Tree variants remain a compelling choice for predictable, real-time OLTP on modern NVMe/DRAM systems.
Adaptive Ant Colony Optimization in Dynamic Path Planning
Dynamic path planning—finding safe, efficient routes while the environment changes—remains a core challenge in autonomous robotics, intelligent transportation, and logistics. Classical Ant Colony Optimization (ACO) is attractive for path planning due to its distributed search, positive feedback, and robustness to local optima; however, it degrades when costs, obstacles, or constraints change during execution because its pheromone model encodes stale information. This manuscript proposes an Adaptive Ant Colony Optimization (A-ACO) framework tailored for dynamic environments. The framework introduces four complementary mechanisms: (i) event-triggered pheromone aging that increases evaporation locally and temporarily after detected changes; (ii) memory-aware partial reinitialization that resets pheromone in neighborhoods of change while preserving global structure; (iii) online heuristic shaping using short-horizon obstacle forecasts to bias ants away from emergent hazards; and (iv) time-bounded anytime re-optimization that reuses incumbent solutions under iteration budgets for real-time response. We formalize the transition rule, pheromone update, and change-aware schedules, and we provide complexity insights. A simulation campaign on 2D occupancy grids with moving obstacles compares A-ACO against Adaptive Candidate System (ACS/ACO baseline), D* Lite, and RRT*, under three dynamics levels (low/medium/high). Across 90 runs per algorithm, A-ACO reduces average path cost by 6–13%, decreases replanning latency by 18–35%, and improves success rate by 2–7 percentage points relative to baselines, while maintaining collision rates near zero. A two-way mixed ANOVA (factor: algorithm; repeated factor: dynamics level) shows a significant main effect of algorithm on path cost and latency (p < .001), with A-ACO outperforming all comparators in post-hoc tests. The results suggest that local, event-aware pheromone management and predictive heuristic shaping are decisive for dynamic feasibility and responsiveness. We conclude with limitations (sensor noise, non-holonomic kinematics) and future directions (multi-robot coordination, risk-aware multiobjective extensions).
Quantum-Inspired Genetic Algorithms for Large-Scale Optimization
Large-scale optimization (LSO) problems—those with hundreds to thousands of decision variables—are prevalent in engineering design, logistics, telecommunications, and machine learning hyperparameter search. Classical evolutionary algorithms often struggle in this regime due to premature convergence and prohibitive search costs. This manuscript presents a Quantum-Inspired Genetic Algorithm (QIGA) that transfers three ideas from quantum computation into a purely classical algorithm: (i) Q-bit angle encoding that maintains a compact, uncertainty-aware distribution over decision values, (ii) rotation-gate adaptation that updates search probabilities toward promising regions while preserving exploration, and (iii) quantum observation that draws diverse candidate solutions from the encoded amplitudes at each generation. We further couple the core QIGA with (a) an island-model decomposition for ultra-high dimensionality, (b) surrogate-assisted local refinement for exploitation at low cost, and (c) a feasibility-aware penalty for constraints. We evaluate the approach on five canonical continuous benchmarks in 1,000 dimensions (Sphere, Rosenbrock, Rastrigin, Ackley, Griewank) under a fixed computational budget. Across 30 independent runs per function, QIGA achieves lower final objective values and higher success rates than classical GA, PSO, and DE baselines. A non-parametric Wilcoxon signed-rank test indicates statistically significant improvements for QIGA (adjusted p < 0.01) on all functions. We analyze the algorithm’s scaling behavior, the role of angle-space step control, and the contribution of island-level diversity. The results suggest that quantum-inspired probability evolution provides a robust inductive bias for LSO by decoupling representation capacity from point estimates and by enabling distribution-aware search moves. We conclude with practical guidelines for tuning and discuss extensions to constrained and mixed-variable problems.
Optimization of Search Algorithms for High-Dimensional Data Spaces
High-dimensional data now underpins modern applications such as semantic search, recommendation, fraud detection, drug discovery, and robotics. While exact search remains the gold standard, the “curse of dimensionality” renders classical index structures ineffective and brute-force search prohibitively expensive as dataset sizes and dimensions grow. This manuscript surveys and synthesizes optimization strategies for similarity search in high-dimensional spaces, emphasizing approximate nearest neighbor (ANN) approaches and system-level co-design. We first frame the problem through the geometry of high dimensions—distance concentration, hubness, and metric choice—and discuss why tree-based exact methods deteriorate. We then review the literature on hashing (e.g., LSH and multi-probe variants), quantization (e.g., product quantization and its orthogonalized forms), graph-based structures (e.g., HNSW and navigable small-world graphs), and hybrid pipelines that layer routing, compression, and re-ranking. Building on these insights, we propose a practical optimization recipe that couples (1) light metric learning and dimensionality normalization, (2) centroid-routed inverted lists with product-quantized payloads, (3) a shallow proximity graph over coarse centroids for fast, robust routing, (4) adaptive search budgets driven by uncertainty and early-exit criteria, and (5) hardware-aware kernels for SIMD/GPU acceleration. We validate the recipe via controlled simulation with synthetic 10M-point datasets in 256 dimensions and report recall-latency–memory trade-offs across LSH, IVF-PQ, HNSW, and a proposed hybrid. Results show the hybrid achieves the best combined recall@10 (97.5%) and mean latency (4.3 ms/query) while keeping index overhead moderate (2.4 GB beyond the 10 GB raw matrix). We conclude with actionable guidance for practitioners on algorithm choice, parameter tuning, and deployment patterns under varying workload profiles and cost constraints.
high-dimensional indexing; approximate nearest neighbor; product quantization; HNSW; locality-sensitive hashing; vector search; metric learning; hybrid indexing; GPU acceleration; recall-latency trade-off
AI-Orchestrated Microservice Security for High-Performance Scalable Systems
The use of microservice architectures to provide scalable, resilient and high-performance applications is becoming more popular in modern digital platforms. These architectures break down large systems into smaller independent services which interact via API and distributed networks. Microservices enhance the agility and scalability of applications, but they also create complicated security issues because of distributed communication, containerised deployments, and dynamic scaling capabilities. The established security models that have been used to support monolithic systems cannot be easily applied to the dynamic and distributed nature of microservice ecosystems. Consequently, this has led to problems with organizations in terms of tracking of service interactions, detection of real time threats, and ensuring secure communication among services without affecting performance. Artificial Intelligence (AI) has become one of the weapons to overcome these challenges. Through a combination of the AI-controlled orchestration and microservice security models, systems will be able to automatically identify anomalies, anticipate possible threats, and dynamically assign security resources without negatively affecting system performance. AI-coordinated security allows smart tracking of API traffic, threat mitigation policies, policy adaptation to access control and life-long learning about the behavior of the system. These functions lead to important high-resilience of the system, and provide the security of scaling in the cloud native environment. The proposed research suggests an AI-based microservice security architecture that can be used in high-performance scalable systems. The suggested framework integrates machine learning-driven anomaly identification, smart orchestration engine, secure API gateways, and distributed monitoring systems. The architecture monitors service interactions and identifies abnormal patterns, takes mitigation measures including rate limiting, service isolation, and automated firewall configuration. The system has the ability to use predictive analytics and behavioral models to ensure that the accuracy of threat detection remains low and the latency and throughput remain low. The experiment analyzes the validity of the suggested framework using the simulated workloads and the work performance benchmarking. The experiment outcomes reveal a high level of performance and security resilience of the system. The AI-planned architecture has a better threat detection accuracy, decreased incident recovery time, better resource use, and scalability than the conventional rule-based security systems. The findings suggest that the orchestration with the assistance of AI has the potential to be essential in ensuring the modern distributed systems and facilitating the large scale digital infrastructures. The results of the study add to the existing research on smart cybersecurity systems of cloud-native systems. The solution to the problem proposed is effective in the case of organizations that are running high-performance microservice systems such as financial, e-commerce and telecommunications networks and other large enterprise services. Combining AI with microservice orchestration systems, companies can develop responsive, self-protecting systems that can react to changing cyber risks without any impact on their performance.
Artificial Intelligence, Microservice Architecture, Cloud Security, API Security, Intelligent Orchestration, Distributed Systems, Anomaly Detection, High-Performance Computing, Cybersecurity Automation, Scalable Systems
Copyright (c) 2025 The journal retains copyright of all published articles, ensuring that authors have control over their work while allowing wide dissenmination. https://creativecommons.org/licenses/by-nc/4.0
Comparative Study of Bio-Inspired Algorithms for Task Scheduling
Task scheduling in heterogeneous, resource-constrained computing environments—such as cloud, grid, and edge platforms—remains a challenging combinatorial optimization problem. Bio-inspired algorithms (BIAs) have emerged as strong candidates for near-optimal scheduling thanks to their robustness, adaptivity, and favorable compute-quality trade-offs. This manuscript presents a comparative study of five widely used BIAs—Genetic Algorithm (GA), Particle Swarm Optimization (PSO), Ant Colony Optimization (ACO), Artificial Bee Colony (ABC), and Grey Wolf Optimizer (GWO)—applied to static, non-preemptive task scheduling under multi-objectivecriteria: makespan, energy, monetary cost, resource utilization, and SLA violations. We formalize a unifying problem model, detail encoding and operators for each metaheuristic, and describe a controlled simulation design with heterogeneous virtual machines (VMs), synthetic workloads (independent tasks and DAGs), and realistic constraints (VM pricing tiers and power models). Statistical analysis across 30 independent runs per algorithm shows that GA and GWO consistently achieve the best makespan-cost-energy balance, with GA slightly superior on makespan and SLA, while GWO offers competitive performance with fewer parameters to tune. PSO performs strongly but is more sensitive to parameter settings; ABC offers a favorable convergence-stability profile; ACO shows strengths in balanced utilization but lags on makespan for large, highly skewed workloads. The findings highlight practical guidance on algorithm choice, parameterization, and stopping criteria for production-grade schedulers.
task scheduling; bio-inspired algorithms; genetic algorithm; particle swarm optimization; ant colony optimization; artificial bee colony; grey wolf optimizer; cloud computing; multi-objective optimization
Real-Time Sports Analytics Dashboard Using Kafka and Apache Flink
Sports organizations increasingly seek millisecond-level insights for coaching, broadcasting, and fan engagement. Traditional batch and micro-batch pipelines struggle with late/out-of-order events, backpressure under bursty play sequences, and the need for exactly-once semantics across multiple derived metrics. This manuscript designs and evaluates a real-time sports analytics dashboard built on Apache Kafka and Apache Flink. The architecture ingests heterogeneous, high-frequency telemetry (player tracking, ball trajectories, play-by-play events) into Kafka topics with schema-managed messages, and uses stateful, event-time Flink jobs for low-latency computation of player movement features, possession-level aggregates, complex event pattern detection (e.g., fast breaks), and live predictive inference (e.g., win probability and shot quality). We emphasize event-time processing, watermarks with bounded out-of-orderness, checkpointing to provide end-to-end exactly-once semantics, and Flink’s keyed state to maintain per-player and per-possession context. A simulation study using synthetic yet realistic basketball telemetry (≈4.75M position events across multiple games) compares the proposed design against a micro-batch baseline. Results show substantial reductions in median and tail latency (≈81.5% and 80.5%), higher throughput (≈29.2%), improved completeness under disorder (≈5.5%), and better complex-event detection recall (≈13.6%). We conclude with deployment guidance, limitations (e.g., clock skew, model drift), and future extensions such as reinforcement-learning-based tactics evaluation and multi-modal enrichment with computer-vision triggers.
real-time analytics, Kafka, Apache Flink, event-time processing, sports analytics, streaming machine learning, complex event processing, dashboard
Big Data Clustering Using Spark MLlib and HDFS
Clustering at web scale strains conventional machine‐learning stacks because algorithms must iterate over terabytes of data while respecting storage locality, memory limits, and network constraints. Apache Spark and the Hadoop Distributed File System (HDFS) provide a practical foundation for unsupervised learning at this scale: Spark’s in-memory, iterative computing model drastically reduces disk I/O relative to classic MapReduce, and HDFS supplies fault-tolerant, high-throughput storage with data locality awareness. This manuscript presents an end-to-end approach for big data clustering using Spark MLlib on HDFS. After motivating use cases and reviewing relevant work, we detail a methodology that covers data ingestion, feature engineering, dimensionality reduction, algorithm selection (K-Means, Bisecting K-Means, Gaussian Mixture Models), hyper-parameter tuning, and distributed evaluation (Silhouette, Davies–Bouldin, and Calinski–Harabasz indices). We then describe a simulation study that emulates both synthetic, multi-density clusters and a semi-structured behavioral dataset, executed on a modest multi-node cluster with HDFS‐resident Parquet inputs. Results show that MLlib’s K-Means with k-means|| initialization provides strong baselines and the best time-to-insight for large, moderately separated clusters; Bisecting K-Means yields more stable partitions on highly imbalanced cluster sizes; and Gaussian Mixture Models capture elliptical structure but at increased computational cost. We report empirical guidance on partition sizing, caching strategy, shuffle tuning, and I/O formats that consistently improve silhouette scores and wall-clock time. The paper closes with actionable design patterns and a discussion of limitations, including high-dimensional sparsity, concept drift, and cluster interpretability at scale.
big data, clustering, Spark MLlib, HDFS, K-Means, Gaussian Mixture Model, Bisecting K-Means, scalability, silhouette score, distributed computing
Sentiment Analysis of Multilingual Tweets Using Hybrid AI Models
Social media platforms produce vast, multilingual streams of short, noisy text where sentiment is often signaled through code-switching, slang, emojis, and cultural references. While large multilingual transformers (e.g., mBERT, XLM-R) have improved cross-lingual sentiment classification, performance still degrades on low-resource languages, code-switched text, and sarcasm. This manuscript presents a hybrid AI approach that combines (i) a strong multilingual transformer encoder, (ii) lightweight language-specific lexical/emoji features, (iii) code-switch and script-aware preprocessing, and (iv) stacked ensembling with a shallow meta-learner. Using a balanced corpus of 200k tweets across five languages—English, Hindi, Spanish, Arabic, and Bengali—with three sentiment classes (positive, negative, neutral), we benchmark baselines (TF–IDF + SVM; mBERT; XLM-R) against two hybrid variants. Our proposed model fuses sentence-level transformer embeddings with affective lexicon counts, emoji sentiment priors, punctuation patterns, and a code-switch intensity score, then feeds them to a gradient-boosting meta-classifier on top of a fine-tuned transformer head. In simulated experiments with stratified splits (70/10/20), the proposed hybrid improves average macro-F1 by 4.0 points over a fine-tuned XLM-R baseline, with significant gains (p < .05) for code-switched and emoji-heavy tweets. Error analysis shows reduced confusion between neutral vs. mildly positive and improved robustness to script mixing (Latin–Devanagari). We discuss model design, training regime, and statistical validation, and we highlight implications for multilingual customer analytics, public-health monitoring, and civic sentiment tracking.
multilingual sentiment analysis, hybrid AI, transformers, code-switching, lexical features, emoji sentiment, stacked ensembling, social media analytics
Data Lake Architecture for Scalable Enterprise Analytics
Enterprises are ingesting petabyte-scale, heterogeneous data from operational systems, clickstreams, IoT sensors, partner feeds, and third-party datasets. Traditional data warehouses—while powerful for structured reporting—struggle to absorb this volume, variety, and velocity without forcing premature schema design and costly ETL rework. Data lakes emerged to decouple storage and compute, preserve raw fidelity, and enable schema-on-read analytics. Yet many data lake programs stall due to fragmented governance, opaque lineage, slow query performance from small-file proliferation, and rising cloud spend. This manuscript presents a pragmatic, cloud-agnostic reference architecture for building a scalable, well-governed enterprise data lake that integrates streaming and batch pipelines, open table formats, federated query engines, and ML workloads. Fig.1 Data Lake Architecture,Source([1]) We adopt a design-science methodology: (1) articulate requirements from stakeholder use cases; (2) propose an architecture comprising layered storage zones, a unified catalog, declarative data quality, and standard security controls; and (3) evaluate the architecture via simulation on synthetic and semi-synthetic workloads ranging from 5 TB to 80 TB with concurrent users. Statistical analysis shows that partition selectivity, file size normalization, and metadata indexing (e.g., clustering) are the dominant predictors of latency and cost. The results demonstrate near-linear scale-out for ETL throughput, 35–62% latency reduction from small-file compaction, and predictable cost per TB under concurrency bursts. The paper concludes with implementation guidelines and a prioritized control plane checklist to help organizations deploy quickly without sacrificing governance.
data lake; lakehouse; enterprise analytics; open table formats; catalog; governance; streaming; partitioning; compaction; performance optimization
Healthcare Predictive Analytics Using BigQuery and TensorFlow
Healthcare organizations generate vast quantities of heterogeneous data—electronic health records (EHRs), claims, laboratory results, imaging metadata, device telemetry, and patient-reported outcomes. Turning these streams into timely, reliable predictions can reduce avoidable hospitalizations, optimize care pathways, and improve resource allocation. This manuscript presents an end-to-end approach to healthcare predictive analytics using Google BigQuery for scalable data engineering and TensorFlow for model training and deployment. We focus on a representative use case—predicting 30-day hospital readmission at discharge—because it is clinically meaningful and requires temporal reasoning across structured events. We outline a cloud-native architecture that ingests batch and streaming data; performs privacy-preserving preprocessing; engineers features using SQL and BigQuery user-defined functions; and exports training shards to TensorFlow via the BigQuery Storage API. We compare three models: a regularized logistic regression baseline, a gradient-boosted tree model, and a sequence-aware deep neural network (LSTM-based). The simulation study uses a large synthetic cohort with realistic class imbalance and missingness patterns to evaluate scalability, latency, and learning curves without exposing protected health information (PHI). Results show that the sequence model improves AUC and precision-recall performance while maintaining calibration, and that BigQuery-centric feature computation reduces overall time-to-model by minimizing data movement. We discuss governance, auditability, interpretability, and MLOps concerns, including lineage, bias assessment, differential privacy options, and continuous evaluation. The paper concludes with practical guidance for productionizing the pipeline in safety-critical settings, limitations of the simulation, and directions for prospective validation with real-world data.
healthcare analytics, BigQuery, TensorFlow, predictive modeling, readmission risk, EHR, deep learning, MLOps, calibration, privacy
Streaming Data Analytics for Smart Traffic Signal Optimization
Urban road networks are becoming increasingly congested due to rising vehicle populations, inefficient traffic management strategies, and inconsistent signal timings. Traditional fixed-time traffic signal systems fail to adapt to real-time conditions, resulting in long queues, increased travel times, and higher carbon emissions. With advancements in Internet of Things (IoT) sensors, vehicular communication systems, and cloud-edge computing, streaming data analytics has emerged as a promising solution for intelligent traffic signal optimization. This study proposes a real-time traffic signal optimization framework leveraging streaming data analytics to dynamically adjust signal timings based on live vehicular flow, queue lengths, and predicted congestion levels. The proposed system ingests high-velocity data from roadside sensors, GPS-enabled vehicles, and surveillance cameras, processes it in real time using distributed stream processing engines, and applies adaptive control algorithms to optimize green-light intervals. Simulation experiments conducted on a realistic traffic network model in SUMO (Simulation of Urban Mobility) demonstrate a 35% reduction in average vehicle waiting time, a 28% improvement in throughput, and a 21% reduction in CO₂ emissions compared to static timing strategies. This work highlights the importance of low-latency analytics pipelines, predictive congestion modeling, and machine learning-driven decision-making for next-generation smart cities.
Streaming Data Analytics, Smart Traffic Management, IoT Sensors, Adaptive Traffic Signals, Real-Time Data Processing, SUMO Simulation, Intelligent Transportation Systems
AI-Powered Recommendation Engines for E-Commerce Personalization
E-commerce markets are increasingly won on the strength of personalization. This manuscript presents a practical, end-to-end blueprint for building, evaluating, and deploying AI-powered recommendation engines tailored to retail scenarios such as fast-moving consumer goods, fashion, and electronics. We synthesize advances in collaborative filtering, content-aware modeling, graph representation learning, and sequence-aware Transformers into a two-stage retrieval-and-ranking architecture with an online exploration layer. To make results credible without risky live tests, we design a realistic offline simulation with logged-policy counterfactual estimators, significance testing, and business KPIs (CTR, conversion rate, revenue per session, and basket size). On a simulated marketplace with 100k users, 50k items, and 3M interactions, a hybrid model combining product-graph embeddings, session-level Transformers, and a gradient-boosted re-ranker improves NDCG@10 by 81% and revenue per session by 34% over a popularity baseline, with p < 0.01. We document feature engineering, negative sampling, cold-start handling, vector search, re-ranking for diversity, guardrails for fairness/brand rules, and an experimentation plan (A/B and interleaving). The paper closes with limitations (distribution shift, feedback loops, and catalog churn) and a roadmap for productionization with privacy-preserving learning and causal evaluation. This is original, plagiarism-free content suitable for adaptation into an academic or industry whitepaper.
E-commerce personalization, recommendation systems, collaborative filtering, deep learning, graph embeddings, Transformers, bandits, counterfactual evaluation
Real-Time Stock Price Forecasting Using Big Data Pipelines
Real-time stock price forecasting is no longer just a modeling problem—it is a systems problem. Predictive performance depends as much on a low-latency, fault-tolerant data pipeline as on model choice. This manuscript presents an end-to-end approach for forecasting next-interval prices (and uncertainty bands) using a streaming big-data architecture that ingests tick-level market data and exogenous signals, engineers microstructure-aware features on the fly, and serves probabilistic deep learning forecasts with millisecond latency. We unify three strands: (i) robust ingestion/processing with distributed logs and stream processors, (ii) online learning with drift-aware model updates, and (iii) risk-aware evaluation that ties forecast quality to trading utility under realistic constraints. The literature review traces the evolution from ARIMA/GARCH to LSTM/Transformer families and highlights how scalable stream processing (e.g., Kafka-like logs, Spark/Flink operators) made “always-learning” models viable. Our methodology deploys a dual-path feature stack—ultra-low-latency order-flow features and slightly slower enriched signals (options-implied volatility, news/sentiment)—merged by a temporal attention forecaster trained with quantile loss. A walk-forward protocol with rolling re-calibration and change-point monitoring combats concept drift. Simulation research replays historical limit-order-book (LOB) streams at real time, benchmarking classical baselines (ARIMA, GBM), machine learning (XGBoost), and deep learning (LSTM, Transformer with temporal fusion). The statistical analysis shows the proposed pipeline improving RMSE/MAE by 8–15% over strong baselines while keeping p99 end-to-end latency under 80 ms on commodity cloud instances. Results illustrate that (a) microstructure features dominate sub-minute horizons, (b) probabilistic forecasts enable superior drawdown control, and (c) lightweight online fine-tuning maintains edge during volatility regimes. We conclude with deployment guidance, limitations (microstructure regime shifts, data quality, and tail events), and directions for future research in adaptive uncertainty calibration and multi-asset transfer learning.
real-time forecasting, big data pipelines, limit order book, streaming analytics, LSTM, Transformer, concept drift, quantile regression, feature store, market microstructure