Polling as fallback in Flask - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

Polling fallback behavior in Flask app

Consider a Flask app that uses polling as a fallback to update client data. What will the client see if the polling interval is set too high?

Flask

from flask import Flask, jsonify
import time

app = Flask(__name__)

last_update = time.time()
data = {'value': 0}

@app.route('/data')
def get_data():
    global last_update, data
    if time.time() - last_update > 5:
        data['value'] += 1
        last_update = time.time()
    return jsonify(data)

A The client sees stale data for longer than 5 seconds due to high polling interval.

B The client sees data updates immediately without delay.

C The client sees updated data every 5 seconds as expected.

D The client receives an error because polling is too frequent.

💡 Hint

Think about what happens if the client polls less often than the server updates.

If the polling interval on the client is longer than the server's update interval, the client will see stale data until the next poll happens.

📝 Syntax

intermediate

Correct polling implementation in Flask route

Which Flask route code correctly implements a polling endpoint that returns an incrementing JSON counter?

A

from flask import Flask, jsonify
app = Flask(__name__)
data = {'count': 0}
@app.route('/poll')
def poll():
    data['count'] += 1
    return jsonify(data)

B

from flask import Flask, jsonify
app = Flask(__name__)
count = 0
@app.route('/poll')
def poll():
    count += 1
    return jsonify({'count': count})

C

from flask import Flask, jsonify
app = Flask(__name__)
count = 0
@app.route('/poll')
def poll():
    count = count + 1
    return jsonify({'count': count})

D

from flask import Flask, jsonify
app = Flask(__name__)
count = 0
@app.route('/poll')
def poll():
    global count
    count += 1
    return jsonify({'count': count})

💡 Hint

Remember to declare global variables inside functions when modifying them.

Option D correctly declares count as global before modifying it. Option D and D cause UnboundLocalError. Option D modifies a mutable dict without global but does not use a counter variable.

❓ state_output

advanced

Polling state update timing in Flask

Given this Flask polling endpoint, what is the value of data['value'] after 10 seconds if the client polls every 1 second?

Flask

from flask import Flask, jsonify
import time

app = Flask(__name__)

last_update = time.time()
data = {'value': 0}

@app.route('/data')
def get_data():
    global last_update, data
    if time.time() - last_update > 3:
        data['value'] += 1
        last_update = time.time()
    return jsonify(data)

A data['value'] will be 3

B data['value'] will be 5

C data['value'] will be 0

D data['value'] will be 10

💡 Hint

Calculate how many 3-second intervals fit into 10 seconds.

The server increments data['value'] every 3 seconds. In 10 seconds, it increments 3 times (at ~3s, ~6s, ~9s). The client polling every 1 second will see these updates.

🔧 Debug

advanced

Debugging polling endpoint with stale data

A Flask polling endpoint returns stale data even though the server updates it every second. What is the most likely cause?

Flask

from flask import Flask, jsonify
import time

app = Flask(__name__)

last_update = time.time()
data = {'count': 0}

@app.route('/poll')
def poll():
    global last_update
    if time.time() - last_update > 1:
        data['count'] += 1
        last_update = time.time()
    return jsonify(data)

A The Flask app is missing a route decorator.

B The data dictionary is immutable and cannot be updated.

C The variable last_update is not declared global inside the function, so it never updates.

D The time module is not imported, causing errors.

💡 Hint

Check variable scope inside the function.

Without declaring last_update as global, the assignment inside the function creates a local variable, so the global last_update never changes, causing stale data.

🧠 Conceptual

expert

Why use polling as fallback in Flask apps?

In a Flask web app, why might polling be used as a fallback method for updating client data instead of WebSockets?

A Polling is more efficient and uses less bandwidth than WebSockets.

B Polling works in all browsers and network setups, even when WebSockets are blocked or unsupported.

C Polling allows real-time two-way communication better than WebSockets.

D Polling requires less server resources because it keeps connections open.

💡 Hint

Consider browser and network compatibility.

Polling is a fallback because it works universally, even when WebSockets are blocked by firewalls or unsupported by browsers. However, it is less efficient than WebSockets.