Top 26 WebSockets Interview Questions And Answers

Question 1

What is WebSockets?

Accepted Answer

**WebSocket** is a technology that allows a client to establish two\-way _full\-duplex_ communication with the server.

The key word in that definition is two-way: with WebSocket, both the client and the server can trigger communication with one another, and both can send messages, at the _same time_.  By a contrast In a traditional HTTP system communication can only be initiated in one direction: from the client to the server.

Question 2

Explain what is _Server-Sent Events (SSE) / EventSource_?

Accepted Answer

Alongside with short and long polling, **SSE** is a technique for sending messages is the  Server\-Sent Events API, which allows the server to push updates to the client by leveraging the JavaScript `EventSource`. EventSource opens a persistent, one\-directional connection with the server _over HTTP_ using a special text/event\-stream header and listens for messages, which are treated like JavaScript events by your code.

Server-Sent Events (SSE) are great for apps where you don’t need to send the server any data—for example, a Twitter-style news feed or a real-time dashboard of stock quotes. Another pro is that Server-Sent Events work over HTTP and the API is relatively easy to use.

However:
* SSE is not supported by older browsers,
* most browsers limit the number of SSE connections you can make at the same time.

Question 3

What is _Short Polling_ and what problems do we have with it?

Accepted Answer

**Short Polling** or Ajax Polling is a technique when we have the client ping the server repeatedly, say, every 500ms (or over some fixed delay). That way, you get new data every 500ms: 1. client requests a webpage from a server using regular HTTP. 2. The client receives the requested webpage and executes the JavaScript on the page which requests a file from the server at regular intervals (e.g. 0.5 seconds). 3. The server calculates each response and sends it back, just like normal HTTP traffic. ![](https://i.stack.imgur.com/qlMEU.png)
There are a few obvious downsides to this: * there’s a 500ms delay, * it consumes server resources with a barrage of requests, and most requests will return empty if the data isn’t frequently updated.

Question 4

Why use WebSocket over HTTP?

Accepted Answer

A **WebSocket** is a continuous connection between client and server. That continuous connection allows the following:

1.  Data can be sent from server to client at any time, without the client even requesting it. This is often called server\-push and is very valuable for applications where the client needs to know fairly quickly when something happens on the server (like a new chat messages has been received or a new price has been udpated). A client cannot be pushed data over http. The client would have to regularly poll by making an http request every few seconds in order to get timely new data. Client polling is not efficient.

2.  Data can be sent either way very efficiently. Because the connection is already established and a webSocket data frame is very efficiently organized, one can send data a lot more efficiently that via an HTTP request that necessarily contains headers, cookies, etc...

Question 5

What do you mean by _lower latency interaction_?

Accepted Answer

**Low latency** means that there is very little delay between the time you request something and the time you get a response. As it applies to webSockets, it just means that data can be sent quicker (particularly over slow links) because the connection has already been established so no extra packet roundtrips are required to establish the TCP connection.

Question 6

Mention some advantages of _SSE_ over WebSockets

Accepted Answer

**Advantages of SSE over Websockets:**

*   Transported over simple HTTP instead of a custom protocol
*   Can be poly\-filled with javascript to "backport" SSE to browsers that do not support it yet.
*   Built in support for re\-connection and event\-id
*   Simpler protocol
*   No trouble with corporate firewalls doing packet inspection

**Ideal use cases of SSE:**

*   Stock ticker streaming
*   twitter feed updating
*   Notifications to browser

Question 7

Explain key features of Socket.io

Accepted Answer

**Socket.io** is a library which enables real\-time and full duplex communication between the Client and the Web servers.

*   It helps in broadcasting to multiple sockets at a time and handles the connection transparently.
*   It works on all platform, server or device ensuring the equality, reliability, and speed.
*   It automatically upgrades the requirement to WebSocket if needed.
*   It is a custom real\-time transport protocol implementation on top of other protocols.
*   It requires both libraries to be used Client side as well as a server\-side library.
*   IO works on work\-based events. there are some reserved events which can be accessed using the Socket on server side like Connect, message, Disconnect, Ping and Reconnect.
*   There are some Client based reserved events like Connect, connect\- error, connect\-timeout and Reconnect etc.

Question 8

Explain what is _Long Polling_?

Accepted Answer

Using **Long polling** (or Ajax Long Polling) method the server receives a request, but doesn’t respond to it until it gets **new data** from another request.

Long polling is more _efficient_ than pinging the server repeatedly since it saves the hassle of parsing request headers, querying for new data, and sending often-empty responses.

However
* the server must now keep track of multiple requests and their order,
* requests can time out, and new requests need to be issued periodically.

Steps:

1.  A client requests a webpage from a server using regular HTTP (see HTTP above).
2.  The client receives the requested webpage and executes the JavaScript on the page which requests a file from the server.
3.  The server does not immediately respond with the requested information but waits until there's **new** information available.
4.  When there's new information available, the server responds with the new information.
5.  The client receives the new information and immediately sends another request to the server, re\-starting the process.

![](https://i.stack.imgur.com/zLnOU.png)

Question 9

Name and explain what different communication techniques on the web do you know?

Accepted Answer

*   **AJAX** \- `request` → `response`. Creates a connection to the server, sends request headers with optional data, gets a response from the server, and closes the connection. *Supported in all major browsers.*

*   **Long poll** \- `request` → `wait` → `response`. Creates a connection to the server like AJAX does, but maintains a keep\-alive connection open for some time (not long though). During connection, the open client can receive data from the server. The client has to reconnect periodically after the connection is closed, due to timeouts or data eof. On server side it is still treated like an HTTP request, same as AJAX, except the answer on request will happen now or some time in the future, defined by the application logic.

*   **WebSockets** \- `client` ↔ `server`. Create a TCP connection to the server, and keep it open as long as needed. The server or client can easily close the connection. The client goes through an HTTP compatible handshake process. If it succeeds, then the server and client can exchange data in both directions at any time. It is efficient if the application requires frequent data exchange in both ways. WebSockets do have data framing that includes masking for each message sent from client to server, so data is simply encrypted.

*   **WebRTC** \- `peer` ↔ `peer`. Transport to establish communication between clients and is transport\-agnostic, so it can use UDP, TCP or even more abstract layers. This is generally used for high volume data transfer, such as video/audio streaming, where reliability is secondary and a few frames or reduction in quality progression can be sacrificed in favour of response time and, at least, some data transfer. Both sides (peers) can push data to each other independently. While it can be used totally independent from any centralised servers, it still requires some way of exchanging endPoints data, where in most cases developers still use centralised servers to "link" peers. This is required only to exchange essential data for establishing a connection, after which a centralised server is not required.

*   **Server\-Sent Events** \- `client` ← `server`. Client establishes persistent and long\-term connection to server. Only the server can send data to a client. If the client wants to send data to the server, it would require the use of another technology/protocol to do so. This protocol is HTTP compatible and simple to implement in most server\-side platforms. This is a preferable protocol to be used instead of Long Polling.

Question 10

WebSockets vs Rest API for real time data? Which to choose?

Accepted Answer

The most efficient operation for what you're describing would be to use a webSocket connection between client and server and have the server send updated price information directly to the client over the webSocket ONLY when the price changes by some meaningful amount or when some minimum amount of time has elapsed and the price has changed.

Here's a comparison of the networking operations involved in sending a price change over an already open webSocket vs. making a REST call.

**webSocket**

1.  Server sees that a price has changed and immediately sends a message to each client.
2.  Client receives the message about new price.

**Rest/Ajax**

1.  Client sets up a polling interval
2.  Upon next polling interval trigger, client creates socket connection to server
3.  Server receives request to open new socket
4.  When connection is made with the server, client sends request for new pricing info to server
5.  Server receives request for new pricing info and sends reply with new data (if any).
6.  Client receives new pricing data
7.  Client closes socket
8.  Server receives socket close

As you can see there's a lot more going on in the Rest/Ajax call from a networking point of view because a new connection has to be established for every new call whereas the webSocket uses an already open call. In addition, in the webSocket cases, the server just sends the client new data when new data is available \- the client doens't have to regularly request it.

A webSocket can also be faster and easier on your networking infrastructure simply because fewer network operations are involved to simply send a packet over an already open webSocket connection versus creating a new connection for each REST/Ajax call, sending new data, then closing the connection. How much of a difference/improvement this makes in your particular application would be something you'd have to measure to really know.

Top 26 WebSockets Interview Questions

What is WebSockets?

Why use WebSocket over HTTP?

Explain what is Server-Sent Events (SSE) / EventSource?

What is Short Polling and what problems do we have with it?

What do you mean by lower latency interaction?

Name and explain what different communication techniques on the web do you know?

WebSockets vs Rest API for real time data? Which to choose?

Explain what is Long Polling?

Mention some advantages of SSE over WebSockets

Explain key features of Socket.io

What is the difference between WebSockets vs. Server-Sent Events/EventSource?

What are the differences between Socket.io and WebSockets?

What is Sec-WebSocket-Key for?

Why would you choose Server-Sent Events over WebSockets?

Explain how does WebSockets protocol work under the hood

What is WebSockets Frame?

When to use WebRTC over WebSockets?

Would WebSockets be able to handle 1,000,000 concurrent connections?

Can you suggest how to load balance Web Sockets?

What are pros and cons of Azure Web PubSub vs SignalR?

What is the fundamental difference between WebSockets and pure TCP?

What is the mask in a WebSocket frame?

Explain why CDN (in)availability may be a problem for using WebSockets?

How to use CHAP Authentication (Challenge Response Authentication) for webSockets?

How would you secure WebSockets communication on your project?

How can WebSockets be better than Long-Polling in term of performance?