A Comparison of Push and Pull Techniques for Ajax

Ajax applications are designed to have high user interactivity and low user-perceived latency. Real-time dynamic web data such as news headlines, stock tickers, and auction updates need to be propagated to the users as soon as possible. However, Ajax still suffers from the limitations of the Web’s request/response architecture which prevents servers from pushing real-time dynamic web data. Such applications usually use a pull style to obtain the latest updates, where the client actively requests the changes based on a predefined interval. It is possible to overcome this limitation by adopting a push style of interaction where the server broadcasts data when a change occurs on the server side. Both these options have their own trade-offs. This paper explores the fundamental limits of browser-based applications and analyzes push solutions for Ajax technology. It also shows the results of an empirical study comparing push and pull.

💡 Research Summary

The paper investigates two fundamental approaches for delivering real‑time data to browser‑based Ajax applications: the traditional pull (polling) method and various push techniques that attempt to overcome the inherent request‑response limitation of HTTP. After outlining the problem—Ajax can update parts of a page without a full reload, yet it still relies on the client to initiate every data exchange—the authors review related work on server‑initiated communication, including Comet, long‑polling, HTTP streaming, and the newer WebSocket protocol. Each technique is described in terms of its protocol mechanics, browser compatibility, and typical deployment challenges.

To provide empirical evidence, the authors design a controlled experiment that simulates a real‑time stock‑ticker service. They implement three pull intervals (1 s, 5 s, 10 s) and two push variants (long‑polling and streaming) on an Apache Tomcat 9 server, testing with Chrome and Firefox browsers. The load is varied across four concurrency levels: 100, 500, 1,000, and 5,000 simultaneous users. For each configuration the study measures average response latency, server CPU utilization, memory consumption, network traffic volume, and client‑side rendering overhead.

Results show a clear trade‑off. Push mechanisms achieve sub‑200 ms latency regardless of user count, whereas pull latency scales directly with the polling interval, ranging from 500 ms to over 2 s. However, push incurs significantly higher server CPU load—up to 70 % at 1,000 concurrent users—because the server must maintain many long‑lived connections. Memory usage also rises proportionally with the number of open sockets, leading to more frequent garbage‑collection pauses at the highest loads. In contrast, pull keeps CPU and memory footprints modest (below 30 % CPU, stable memory) but generates 2–3× more network traffic due to redundant requests, especially when the data changes infrequently. On the client side, push reduces rendering work because updates arrive only when needed, yet the implementation complexity grows due to connection‑recovery logic and varying browser support.

The discussion interprets these findings in the context of application requirements. For latency‑critical services such as chat, live notifications, or financial trading platforms, push is indispensable, but developers must provision sufficient server resources, employ connection‑pooling or load‑balancing, and possibly fall back to long‑polling for older browsers. For content‑driven sites where updates are sparse (news feeds, blogs), a pull strategy remains cost‑effective; adaptive polling intervals can mitigate latency while preserving predictable server load.

Finally, the authors propose a hybrid model: use periodic pull for baseline data and trigger server‑initiated push only for high‑priority events. They also outline future research directions, including standardized WebSocket‑based push protocols, serverless architectures that auto‑scale connection handling, and power‑aware optimizations for mobile networks. The paper thus provides both a theoretical framework and practical guidance for choosing between pull and push in modern Ajax development.