A Structured Review of Algorithm Performance and Complexity in Modern JavaScript Runtimes

JavaScript performance is a complex study in contradictions. What began as a simple browser scripting tool now powers fast production servers and yet the mismatch between its theoretical complexity and actual runtime behavior remains hard to miss. For example, a simple O(n log n) sort can run 8× slower in JavaScript than in C++ at times or nearly match it in others as it is entirely dependent on hidden runtime states like a JIT warm-up and hidden class transitions. We decided to perform a structured review of 47 studies from the last two decades to find exactly where this instability comes from and the literature revealed a highly varied and uneven picture in which engine optimizations that work for V8 often fail on SpiderMonkey even though the “constant factors” ignored by Big-O notation (garbage collection pauses, deoptimization spikes, type checks) usually dominate the execution time. While it looks technically correct, our analysis shows that JIT compilation and garbage collection add instability which classical methods cannot predict. Here we cataloged 15 recurring anti-patterns and proposed a runtime-aware complexity metric that explicitly includes warm-up costs and allocation pressure. In the end, we believe that the community needs to move beyond simple “managed vs. native” benchmarks and start viewing the runtime as an active part in algorithmic complexity. Current evidence is pretty scarce on computing and energy efficiency, but what does exist, all of it points in the same direction. So in modern JavaScript, the engine matters as much as the algorithm.