Topics
/
Protocols

Protocols

Formats of communication agreed-upon and used by hardware and software systems to exchange messages and transmit information: rules of semantics, syntax, synchronizing, and error recovery.

Filter by

40 items

HTTP

HTTP is a client-server application layer protocol designed to transfer information between networked devices.

WebSockets vs. HTTP

Pros and cons of HTTP and WebSocket protocols, and when best to use them.

HTTP/2

The second major version of the Hypertext Transport Protocol.

The Evolution of HTTP – HTTP/2 Deep Dive

This article covers the limitations of HTTP/1.0 and HTTP/1.1 and how those limitations led to the protocol's evolution to HTTP/2.

HTTP/3

HTTP/3 is the latest iteration of the original HTTP protocol, which powers the World Wide Web (WWW).

HTTP/2 vs HTTP/3: A comparison

A deep dive into the similarities and differences between HTTP/2 and HTTP/3, incl. strengths, weaknesses, the past, and the future.

HTTP/3 Deep Dive

A deep dive into HTTP/3, including evolution, use cases, and how to get started.

Long polling

Variant of the polling technique used to emulate a push mechanism where pushes are not possible or disallowed.

Long Polling - Concepts and Considerations

This article is deep dive into the technique known as “long polling”: how it came to be, how it's implemented, and how we use it at Ably.

MQTT

Lightweight, low-bandwidth pub/sub network protocol used for ordered, lossless, bi-directional connections.

MQTT: A Conceptual Deep-Dive

A conceptual deep-dive into MQTT, how it works, and its uses now and in the future.

Server-Sent Events

Server-push technology used for servers to automatically update clients subscribed to event-streams.

Server-Sent Events (SSE): A Conceptual Deep Dive

This article explores how SSE came to be, how it works under the hood, and why it’s rapidly being adopted by developers.

Socket.IO

Library that enables bidirectional, low-latency communication between web clients and servers, mainly over WebSockets.

Everything you need to know about Socket.IO

Socket.IO's main use cases, how to get started, ideal use cases, scope for support, where it fits in the realtime landscape.

Socket.IO vs. WebSocket: A comparison

We compare Socket.IO with WebSocket. Discover how they are different, their pros & cons, and their use cases.

Scaling Socket.IO - practical considerations

A review of Socket.IO’s advantages, limitations & performance. Learn about the challenges of using Socket.IO to deliver realtime apps at scale.

WebSocket

Communications protocol complementary to HTTP, allowing bidirectional message streaming over a single TCP connection.

WebSockets and Android apps - client-side considerations

Learn about the many challenges of implementing a dependable client-side WebSocket solution for Android.

WebSockets vs. HTTP

Pros and cons of HTTP and WebSocket protocols, and when best to use them.

The challenge of scaling WebSockets

Scaling WebSockets for a production system can be challenging in terms of load balancing, fallback strategy, and connection management. Here's how to tackle it.

WebRTC vs. WebSocket: Which one is the right choice for your use case?

We compare WebRTC with WebSocket. Discover how they are different, their pros & cons, and their use cases.

WebSockets - A Conceptual Deep Dive

A deep dive into everything going on under the hood of applications that use the WebSocket protocol.

Socket.IO vs. WebSocket: A comparison

We compare Socket.IO with WebSocket. Discover how they are different, their pros & cons, and their use cases.

WebSockets and Swift: client-side engineering challenges

Learn about the many challenges of implementing a dependable client-side WebSocket solution for Swift.

TypeScript and WebSockets: client-side engineering challenges

Learn about the many challenges of implementing a dependable client-side WebSocket solution for TypeScript.

Developing a dependable client-side WebSocket solution for Unity

Learn about the many challenges of implementing a dependable client-side WebSocket solution for Unity.

Realtime apps with React Native and WebSockets: client-side challenges

Learn about the many challenges of implementing a dependable client-side WebSocket solution for React Native.

Building realtime apps with Flutter and WebSockets: client-side considerations

Learn about the many challenges of implementing a dependable client-side WebSocket solution for Flutter apps.

Building realtime apps with PHP and WebSockets: client-side challenges

Learn about the many challenges of implementing a dependable client-side WebSocket solution in PHP.

How to stream Kafka messages to Internet-facing clients over WebSockets

This article explores how to stream Kafka messages to Internet-facing clients, over WebSockets, via a message broker.

Scaling realtime web apps with JavaScript and WebSockets

Learn about the many challenges of implementing a dependable client-side WebSocket solution for JavaScript.

Building dependable realtime apps with WebSockets and .NET

Learn about the many challenges of implementing a dependable client-side WebSocket solution for .NET.

Scaling realtime apps with Golang and WebSockets

Learn about the many challenges of implementing a dependable client-side WebSocket solution for Golang apps.

Scaling WebSockets for virtual events

Learn about the challenges of building dependable virtual event platforms & apps with WebSockets that scale to support millions of concurrent users.

Building dependable realtime apps with Python and WebSockets

Learn about the many challenges of implementing a dependable client-side WebSocket solution in Python.

Java and WebSockets: Building dependable realtime apps

Learn about the many challenges of implementing a dependable client-side WebSocket solution for Java.

Building realtime apps with Ruby and WebSockets: client-side engineering challenges

Learn about the many challenges of implementing a dependable client-side WebSocket solution in Ruby.

Building apps with Xamarin and WebSockets: engineering challenges

Learn about the many challenges of implementing a dependable client-side WebSocket solution for Xamarin.

WebSockets and Mono: client-side engineering complexities

Learn about the many challenges of implementing a dependable client-side WebSocket solution for Mono.

Building realtime apps with Node.js and WebSockets: client-side considerations

Learn about the many challenges of implementing a dependable client-side WebSocket solution for Node.js.

Objective-C and WebSockets: client-side challenges and how to navigate them

Learn about the many challenges of implementing a dependable client-side WebSocket solution for Objective-C.

WebSockets and iOS: client-side engineering challenges

Learn about the many challenges of implementing a dependable client-side WebSocket solution for iOS.

WebSockets and macOS clients: hard engineering challenges

Learn about the many challenges of implementing a dependable client-side WebSocket solution for macOS.

WebSockets and tvOS apps: client-side engineering aspects you need to consider

Learn about the many challenges of implementing a dependable client-side WebSocket solution for tvOS.

WebSockets and Cocoa: client-side engineering challenges

Learn about the many challenges of implementing a dependable client-side WebSocket solution for Cocoa.

Using WebSockets for iPadOS apps: hard engineering challenges

Learn about the many challenges of implementing a dependable client-side WebSocket solution for iPadOS.

WebSub

Open, event-driven push transport protocol for distributed pub/sub communications using webhooks.

WebSub – A deep dive

What WebSub is, how it works, and its challenges.