Server-Sent Events alternative in Flask - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding WebSocket as an alternative to Server-Sent Events

Which statement best describes why WebSocket can be a good alternative to Server-Sent Events (SSE) in Flask applications?

A WebSocket is a polling technique that repeatedly requests data from the server.

B WebSocket only supports one-way communication from server to client, similar to SSE.

C WebSocket allows two-way communication between client and server, unlike SSE which is one-way from server to client.

D WebSocket requires the client to refresh the page to receive new data.

💡 Hint

Think about the direction of data flow in WebSocket compared to SSE.

WebSocket supports full-duplex communication, meaning both client and server can send messages independently. SSE only allows server to send updates to the client.

❓ component_behavior

intermediate

Flask WebSocket server behavior

Given a Flask app using Flask-SocketIO, what will happen when the server emits a message to a connected client?

Flask

from flask import Flask
from flask_socketio import SocketIO, emit

app = Flask(__name__)
socketio = SocketIO(app)

@socketio.on('connect')
def handle_connect():
    emit('message', {'data': 'Welcome!'})

A The client will receive the message only after refreshing the page.

B The client must send a message first before receiving any data from the server.

C The server will raise an error because emit cannot be called inside the connect event.

D The client receives the 'Welcome!' message immediately after connecting without needing to request it.

💡 Hint

Consider what happens when a client connects to a WebSocket server.

When a client connects, the server can immediately send messages using emit. The client does not need to request data first.

📝 Syntax

advanced

Correct Flask WebSocket event handler syntax

Which option shows the correct syntax for a Flask-SocketIO event handler that listens for a 'chat message' event and sends a response?

A

@socketio.on('chat message')
def handle_message(msg):
    emit('response', {'data': msg})

B

@socketio.on_event('chat message')
def handle_message(msg):
    emit('response', {'data': msg})

C

@socketio.event('chat message')
def handle_message(msg):
    emit('response', {'data': msg})

D

@socketio.listen('chat message')
def handle_message(msg):
    emit('response', {'data': msg})

💡 Hint

Check the Flask-SocketIO documentation for the correct decorator to listen for events.

The correct decorator to listen for a named event is @socketio.on('event_name'). Other decorators or methods are invalid.

🔧 Debug

advanced

Debugging Flask WebSocket connection issue

A developer uses Flask-SocketIO but clients never receive messages. The server code is:

from flask import Flask
from flask_socketio import SocketIO, emit

app = Flask(__name__)
socketio = SocketIO(app)

@socketio.on('connect')
def on_connect():
    emit('message', {'data': 'Hello'})

if __name__ == '__main__':
    app.run()

What is the main reason clients do not receive messages?

A The server is started with app.run() instead of socketio.run(app), so WebSocket support is not enabled.

B The emit call inside the connect event is invalid and causes a runtime error.

C The client must send a 'connect' event manually before receiving messages.

D The Flask app is missing a route for '/' which prevents connections.

💡 Hint

Consider how Flask-SocketIO requires the server to be started.

Flask-SocketIO requires using socketio.run(app) to enable WebSocket support. Using app.run() starts a plain Flask server without WebSocket.

❓ state_output

expert

State behavior in Flask WebSocket with multiple clients

Consider a Flask-SocketIO server that keeps a counter of connected clients and broadcasts it on each connection and disconnection:

from flask import Flask
from flask_socketio import SocketIO, emit

app = Flask(__name__)
socketio = SocketIO(app)

connected_clients = 0

@socketio.on('connect')
def on_connect():
    global connected_clients
    connected_clients += 1
    socketio.emit('clients', {'count': connected_clients})

@socketio.on('disconnect')
def on_disconnect():
    global connected_clients
    connected_clients -= 1
    socketio.emit('clients', {'count': connected_clients})

If three clients connect one after another, then one disconnects, what is the sequence of 'count' values broadcasted?

A 3, 2, 1, 0

B 1, 2, 3, 2

C 0, 1, 2, 3

D 1, 1, 1, 0

💡 Hint

Track the value of connected_clients after each event.

Each connect increments the counter and broadcasts it: 1, then 2, then 3. One disconnect decrements it to 2 and broadcasts again.