Polling is an essential technique in computer communication that enables regular monitoring of a device’s status or of changes in data. At its core, polling means that a device or system repeatedly checks another device to see whether there is new data or changes that require attention. The method is often used in both hardware and software where information needs to be kept up to date without waiting for an external device to send a notification.
Polling works by having a central unit, such as a server or an application, send requests to another device at regular intervals to obtain updated information. This can be useful in situations where data needs to be kept reasonably up to date, such as network monitoring, sensor control or user interfaces that show status information. Although polling can be resource-intensive, as it involves repeated requests, it is a reliable method of keeping systems synchronised and up to date, which matters for both the user experience and system performance.
Polling is a technique in data communication in which a device regularly checks the status or data of another device or server. The method is often used in situations where a constant connection is not practical and information needs to be updated at regular intervals. Polling can be useful in applications where real-time data is not critical, but where keeping the system up to date is important, such as certain types of network monitoring or data collection from sensors. Although polling can be less efficient than more advanced methods such as push notifications, it is a simple and reliable way of keeping devices synchronised.
More about Polling
Polling is a fundamental technique in computer communication used to monitor the status of devices or systems by regularly querying them for updates. The method is important in situations where changes need to be tracked continuously, such as network monitoring, hardware interaction and application performance.
Technically, polling involves a central unit, such as a server or a controller, sending requests to connected devices at regular intervals to obtain their status or data. This can take place via various communication protocols, depending on the system’s architecture. Polling is a simple and effective method of checking that all devices are working correctly, although changes are only detected at the next query, so the response time depends on the interval.
Polling can be implemented in different forms, each supporting different types of interaction:
Periodic polling: Here, the system sends requests at fixed intervals. This is useful in situations where a constant update frequency is important, such as monitoring systems that require regular status updates.
Event-triggered polling: In this form, polling is started in response to specific events, for example when a screen is opened or a job has been submitted. This can be more efficient in systems where changes occur irregularly, as it reduces unnecessary communication and saves resources.
Adaptive polling: The system automatically adjusts the polling frequency based on previous activity or expected changes. This makes it possible to optimise resource consumption and improve the system’s responsiveness.
One of the greatest strengths of polling is its simplicity and reliability. With a central unit controlling the communication, the system can easily be monitored and maintained. However, constant polling can lead to increased network traffic and resource consumption, especially in large systems with many devices. Balancing the polling frequency is therefore important for achieving good performance.
The flexibility of polling is another important advantage. It can be adapted to different systems and needs, which makes it a versatile solution in many technological contexts. By adjusting the polling parameters, system administrators can tailor the communication to specific requirements and constraints.
In practice, polling is one of the oldest and most widely used techniques in computing. It is used in network monitoring, where servers regularly check the status of connected devices to make sure that everything is working correctly. It is used in hardware interaction, where a computer can query a printer to see whether it is ready to receive a new job. Polling also enables effective management of resources in distributed systems by keeping all components synchronised.
In summary, polling is a technique that combines simplicity, flexibility and reliability in a solution that makes communication between devices more manageable and controllable. Its ability to work without complex set-up, combined with the option of adjustment, makes it an important tool in the modern digital world, even though push-based techniques are often preferred where updates need to arrive immediately.
Frequently asked questions about Polling
What is the difference between polling and event-driven programming?
Polling and event-driven programming are two different methods of handling events in software development. Polling is a technique in which a program regularly checks a resource or device to see whether a change or event has occurred. This typically takes place in a loop or timer that repeatedly requests status updates, which can lead to inefficient use of resources, as the system spends CPU time and network traffic even when nothing has changed.
In contrast, event-driven programming is based on events that trigger specific actions when they occur. In this model, the program waits passively until an event takes place, such as a user interaction or a change in a resource, and then responds by executing a predefined action. This makes event-driven programming more efficient, as the system uses resources only when necessary and can remain idle when there are no events to handle.
Compared with polling, which can be resource-intensive because of the constant checking, event-driven programming is more resource-efficient, as it is activated only by specific events and thus reduces unnecessary CPU usage. This makes event-driven programming particularly well suited to applications where resource optimisation is critical, such as mobile devices or systems with limited resources.
How does polling affect performance in a mobile app?
Polling in a mobile app can have a significant impact on performance, as it involves the app regularly checking for updates or new data from a server at fixed intervals. This process requires the app to communicate repeatedly with the server, which can lead to increased battery and data consumption, especially if the polling frequency is high.
Each request wakes the device’s radio, which then stays in a high-power state for a while, so frequent polling can drain the battery noticeably. For this reason, both iOS and Android restrict how often apps can run in the background: iOS does not allow continuous background polling, and periodic background work on Android via WorkManager runs at most every 15 minutes. This can be particularly problematic for users with limited battery life or data plans, as constant polling can lead to unwanted costs and faster battery drain.
Alternatives to polling, such as push notifications, can be more efficient, as they activate the app only when new data is available, which reduces the need for constant communication with the server. This makes push notifications a more energy-efficient solution, as they minimise battery and data consumption by being active only when needed. Compared with polling, which requires repeated activity, push notifications can improve the user experience by offering a more power-saving and data-efficient method of keeping the app up to date.
Which techniques can optimise polling in web applications?
Polling in web applications can be optimised by using techniques that reduce the load on both the client and the server side. One of the most effective methods is to implement “long polling”, in which the client sends a request to the server, which holds the connection open until there is new data to send back. This reduces the number of requests and thus network traffic, as a response is only sent when there is relevant data. While no data is available, the connection is idle, but the server still has to keep it open, which uses some resources.
In addition, “WebSockets” can be used as a more efficient solution, in which a persistent connection between client and server is maintained. This enables two-way communication in real time without repeated HTTP requests. WebSockets are particularly useful in applications that require fast updates of data, such as chat applications or live notifications. This method reduces latency and improves the user experience by ensuring that data is delivered immediately when it becomes available.
Compared with traditional polling, in which the client repeatedly sends requests to the server at fixed intervals, both long polling and WebSockets are far more efficient when updates need to arrive quickly. They reduce unnecessary network traffic and server load, which makes them good solutions for modern web applications that require high performance and low resource consumption. With ordinary polling, throttling can also limit how often the client sends requests, for example when the app is running in the background.
How can polling be implemented efficiently in a real-time application?
Polling in real-time applications can be implemented efficiently by minimising resource consumption while ensuring fast responses, which is essential for maintaining a good user experience. An efficient polling mechanism is active only when necessary, for example only while the relevant screen is visible, and can adjust its frequency based on the application’s current needs.
To reduce the load on servers and networks, polling can be implemented with an adaptive approach in which the interval between requests is adjusted dynamically based on changes in data or user activity. This can be achieved by increasing the interval when there are no changes and reducing it when there are frequent updates. Techniques such as ETags or If-Modified-Since also allow the server to answer with a short “not modified” response when nothing has changed.
Compared with technologies such as WebSockets, which require a constantly open connection, polling can be a practical choice in scenarios where a delay of several seconds is acceptable, where the infrastructure does not support persistent connections, or where simplicity is a priority. When changes are rare and need to arrive immediately, however, push-based techniques are usually more efficient, as polling then sends many requests that return nothing new. Used appropriately, polling can keep the total network traffic and server load manageable, which makes it a practical solution for many applications.
What is long polling?
Long polling is a variant of polling in which the client sends a request to the server, but the server does not respond immediately if there is no new data. Instead, the connection is held open until there is something new to send or until a time limit is reached.
When the client receives the response, it immediately sends a new request. This provides faster updates than ordinary polling and fewer empty responses, because data is sent as soon as it is ready. Long polling does, however, require more open connections on the server. Modern alternatives such as WebSockets and Server-Sent Events are often more efficient for real-time communication.
How can polling affect the user experience in an app?
Polling in an app can have a significant impact on the user experience, as it involves the app regularly checking the server for updates or new data at fixed intervals. This process can lead to increased data consumption and battery drain, as the app is repeatedly active and communicating with the server, even when there is no new information to fetch.
In addition, infrequent polling can result in delays in data updates, as the app only receives new information at the predetermined intervals, which can make the experience feel less responsive for the user. Polling more often reduces the delay, but increases the consumption of battery and data. This can be particularly problematic in applications where real-time data is critical, such as chat apps or financial services, where users expect information to be updated immediately.
Compared with technologies such as WebSockets, which keep a connection open between client and server and thus allow immediate data transfer, polling can be less efficient and more resource-intensive. WebSockets offer a more streamlined and often more energy-efficient solution, as data is sent only when there is an actual change, which reduces unnecessary network activity and improves the overall user experience. On mobile devices, however, an open connection is usually closed when the app moves to the background, so push notifications are typically used there.
Polling for dummies
Polling is a simple method that computers and other devices use to stay up to date with what is happening around them. Imagine a computer as a curious person who keeps asking, “Has anything new happened?” to the various devices or systems it is connected to. For example, a computer can ask a printer whether it is ready for the next job, or ask a server whether any new messages have arrived. This constant asking is called “polling”. It is a way of making sure that the device always has the latest information, even though it can be a bit like asking a friend for news again and again. It is a simple but effective way of keeping things up to date, although it can use some extra energy and time, because the device has to keep asking.
