This article explains the fundamentals of TCP sockets, why raw TCP lacks message boundaries, how custom protocols add headers to solve the sticky‑packet problem, and compares HTTP and RPC as application‑layer protocols, highlighting their histories, use‑cases, and performance trade‑offs.
The article explains how TCP, the long‑standing transport for HTTP/1.x and HTTP/2, suffers from head‑of‑line blocking and handshake latency, why protocol ossification hinders upgrades, and how HTTP/3’s QUIC built on UDP overcomes these issues while introducing its own deployment challenges.
This article explains the significance of HTTP/3 for web performance, outlines its standardization history, compares it with HTTP/1.1 and HTTP/2, presents benchmark results, and discusses practical adoption considerations such as QUIC, 0‑RTT, and current implementation support.
The article details how the Xianyu team built a feature‑complete, extensible, high‑performance Flutter rich‑text editor called Mural by defining a Slate‑inspired protocol layer, mapping it to a custom widget/render object tree, handling cursor and WidgetSpan selection, using diff‑based updates, and providing a plug‑in architecture for extensions.
To enable Xianyu sellers to create rich product descriptions, the team built a high‑performance, extensible Flutter rich‑text editor using Slate’s protocol, layering protocol, capability extensions, rendering, and business extensions to support custom emojis, themes, ordered paragraphs, and native‑level interactions.
This article explains the OSI seven‑layer model, the differences between TCP and UDP, the mechanics of TCP three‑way handshake and four‑step termination, how sockets work in Node.js, and how to implement custom protocols and a socket connection pool for high‑concurrency applications.
This article explains the Chrome DevTools Protocol (CDP), its architecture of frontend, backend, protocol and channels, and provides step‑by‑step instructions with code examples for launching a CDP server, connecting a client, and performing remote debugging of JavaScript, CSS and DOM through WebSocket or other transports.
This article explains what sockets are, how they relate to TCP/IP and HTTP, introduces the origin and purpose of WebSocket, compares it with traditional sockets, and details the WebSocket handshake, data framing, and differences from HTTP for real‑time bidirectional communication.
This article explains the relationships among WebSocket, Engine.IO, and Socket.IO, details Engine.IO’s features, handshake, upgrade and disconnect mechanisms, and provides practical code examples for building real‑time communication in Node.js applications, including packet encoding, transport options, and debugging techniques.
This article explains how Redis uses the simple text‑based RESP protocol for client‑server communication, details each reply type, shows how to capture traffic with tcpdump, and dives into the internal C structures and error codes that power Redis commands.
This article provides a thorough introduction to the Domain Name System (DNS), covering its hierarchical design, query workflow, caching mechanisms, message structure, resource record types, and common security threats along with mitigation techniques, offering essential knowledge for networking fundamentals.
This article explains Redis's high‑performance RESP protocol, its simple design principles, how commands are serialized over TCP, and demonstrates Java examples for both a mock server and client, while detailing the various response types defined by the protocol.
This article traces the evolution of HTTP from its earliest version through HTTP/2, explains the limitations of each iteration, and demonstrates how QUIC's UDP‑based design, 0‑RTT connections, connection migration, and flexible congestion control overcome those issues to become the next‑generation web transport protocol.
This article explains the end‑to‑end workflow of Douyu’s fast live streaming system, detailing how FLV tags are converted to RTP packets and back, covering WebRTC’s SDP/ICE/DTLS handshake, FLV and RTP header structures, payload formats for audio (OPUS) and video (H.264), and the server‑side processing pipeline.
This comprehensive guide explains the NVMe specification, covering terminology, SSD architecture, PCIe register layout, queue structures, arbitration mechanisms, data addressing methods, command formats, controller operation, reset procedures, interrupt handling, and advanced features such as firmware updates and end‑to‑end data protection.
This article provides a systematic overview of the SDP (Session Description Protocol) used in WebRTC, covering its historical background, syntax, key fields, media descriptions, Plan B vs Unified Plan styles, and numerous extensions such as codec parameters, ICE candidates, DTLS, and simulcast, with practical examples and code snippets.
The article explains gRPC fundamentals, illustrating service definition in .proto files, synchronous and asynchronous client and server implementations with CompletionQueue and CallData state machines, streaming RPC patterns, HTTP/2 protocol details, metadata handling, and the structure of generated stub and service code.
This article explains the RTMP protocol’s handshake process, chunking and message formats, details command flows such as connect, createStream, publish and play, and describes how the Nginx‑RTMP module implements live streaming, acceleration, authentication, recording and HLS slicing.
This article provides a concise yet comprehensive guide to HTTP and its response status codes, explaining each class of codes (1xx‑5xx) and highlighting the most common codes developers encounter when building web applications.
This article traces the development of the HTTP protocol from its earliest 0.9 version through HTTP/1.1, HTTP/2, and finally HTTP/3 built on QUIC, highlighting how each iteration improved speed, efficiency, and mitigated head‑of‑line blocking while introducing new challenges.
This article introduces the high‑performance NVMe storage protocol, its architecture, advantages over traditional SATA/SAS, the evolution of NVMe‑oF with RDMA and Fibre Channel, and provides links to related technical resources and download materials.
This article explains the Simple Network Management Protocol (SNMP), covering its three versions, system architecture—including NMS, agents, managed objects, and MIB—along with query, set, trap, and inform operations, message formats, security levels, and default UDP ports used for network management.
This article provides a comprehensive guide to TCP’s core mechanisms, covering connection establishment via the three‑way handshake, graceful termination with the four‑step teardown, half‑open and half‑close scenarios, simultaneous open/close, initial sequence numbers, and detailed state‑transition diagrams, all illustrated with diagrams.
This article explains the complete process from entering a URL to rendering a web page, covering URL parsing, DNS resolution, TCP three‑way handshake and four‑way teardown, HTTP request/response structure, and browser rendering, while also clarifying TIME_WAIT and related socket states.
This article introduces the open‑source EMQX MQTT broker, explains the MQTT protocol basics, and provides an in‑depth analysis of the broker's connection and session processes—including their state structures, message flows for connect, subscribe, unsubscribe, ping, disconnect, and QoS 0/1/2 publishing—supported by illustrative code snippets and diagrams.
This article explains the fundamentals of the HyperText Transfer Protocol, covering the OSI model layers, TCP three‑way handshake, bandwidth versus latency, and the evolution from HTTP/0.9 through HTTP/1.0, 1.1, and HTTP/2, highlighting key improvements such as persistent connections, pipelining, chunked transfer, and server push.
This article explains the fundamentals of HTTPS by clarifying key terms like HTTP, SSL/TLS, and encryption, describing how HTTP works over TCP, comparing short and persistent connections, and outlining the security, compatibility, extensibility, and performance requirements that drive HTTPS design.
This article reviews the evolution of HTTP from version 1.1 to HTTP/2 and HTTP/3, explaining key features such as persistent connections, pipelining, binary framing, header compression, multiplexing, and QUIC's advantages, while also highlighting the remaining drawbacks like head‑of‑line blocking, TCP connection limits, and security concerns.
This article explains how Redis communicates over TCP using a simple, fast‑parsing, human‑readable protocol, details the unified request format introduced in Redis 1.2, and illustrates request and response structures—including single‑line, error, bulk, and multi‑bulk replies—with concrete examples.
The article thoroughly explains HTTP/2, detailing its optional clear‑text or TLS connection setup, multiplexed frames and streams, HPACK header compression, server‑push mechanism, application‑layer flow control, and the protocol’s lingering challenges such as TLS handshake latency and TCP head‑of‑line blocking that HTTP/3 seeks to resolve.
This article provides a comprehensive overview of the Domain Name System, explaining how hostnames map to IP addresses, the hierarchical distributed design of DNS servers, query processes, caching mechanisms, packet structures, common attack vectors, and defensive measures such as DNSSEC.
This article explains the core characteristics of the HTTP protocol—including its flexibility, reliability, application‑layer nature, request‑response model, and statelessness—and then details short and long connection management, related header fields, head‑of‑line blocking, and practical performance‑enhancing techniques such as concurrent connections and domain sharding.
This article explains HTTP's core characteristics—flexibility, reliability, application‑layer nature, request‑response model, and statelessness—then dives into short‑ and long‑connection management, head‑of‑line blocking, and practical optimization techniques such as concurrent connections and domain sharding.
This article traces the evolution of HTTP from its 1991 origins through HTTP/1.0, 1.1, SPDY, and HTTP/2, explaining why the shift to UDP‑based QUIC in HTTP/3 promises faster, more secure web delivery while also highlighting the new protocol’s challenges.
This article presents an illustrated comic that explains the basic principles of the TCP protocol, highlighting its connection-oriented reliable transmission, congestion and flow control mechanisms, while noting that some details are simplified and encouraging readers to consult formal RFCs and the TCP/IP Illustrated volume for deeper study.
This article explains the fundamental distinctions between HTTP GET and POST requests, covering how parameters are transmitted, browser and server behaviors, length limits, security implications, underlying TCP mechanics, and performance trade‑offs, while also debunking common misconceptions often seen in interview answers.
This article presents a comprehensive overview of Ctrip's live streaming solution, covering the evolution of live streaming, core streaming principles, encoding and protocol choices such as RTMP, HLS, WebRTC, the front‑end framework built with Android, ReactNative and native modules, encountered integration challenges, and the final architectural summary.
This article details the process of adapting the Netty MQTT codec to the t‑io framework, covering the migration from MQTT 3.1.1 to MQTT 5, code adjustments, ByteBuf-to-ByteBuffer conversion, custom WriteBuffer handling, and the resulting client demonstrations.
This article provides a detailed walkthrough of MySQL protocol analysis using Wireshark, covering SSL disabling, packet capture commands, step‑by‑step examination of handshake, authentication, database selection, query execution packets, and an in‑depth look at related source‑code functions and command enums.
This article explains the TCP/IP layered model, differences between TCP and UDP, the three‑way handshake and four‑step termination, how HTTP builds on TCP, common HTTP status codes, message format, and the step‑by‑step process that occurs from entering a URL to loading a web page.
This article details the architecture, protocol design, permission control, reliability mechanisms, and scaling strategies of a long‑connection gateway built with OpenResty, Kafka, and Redis, illustrating how to share persistent connections across multiple business services while ensuring high performance and fault tolerance.
This article provides a comprehensive overview of the AMQP 0‑9‑1 protocol, explaining its core components—publishers, exchanges, queues, and consumers—detailing each exchange type, queue properties, message acknowledgment, routing rules, and practical usage considerations for reliable backend messaging.
This comprehensive guide explains TCP fundamentals—including its differences from UDP, the three‑way handshake, four‑way termination, half‑open queues, SYN flood attacks, header fields, Fast Open, timestamps, retransmission timers, flow and congestion control, Nagle's algorithm, delayed ACKs, and keep‑alive mechanisms—providing clear diagrams and practical insights for developers.
This article explains how the WebSocket API provides bidirectional, message‑oriented communication, compares its latency and overhead with XHR and SSE, discusses compression and custom protocols, and offers practical deployment and tuning guidelines for long‑lived connections.
This article explains the WebSocket protocol (RFC 6455), covering its HTTP upgrade handshake, binary frame format, message fragmentation, multiplexing and compression extensions, and the required header fields for establishing a secure, bidirectional communication channel between client and server.
This article details the TCP three‑way handshake, the four‑step connection termination process, and the full set of eleven TCP connection states, illustrating each step with clear explanations and diagrams for better network protocol comprehension.
This article provides an in‑depth overview of TCP, explaining its core differences from UDP, the three‑way handshake and four‑way termination processes, half‑open queues and SYN‑Flood attacks, Fast Open, timestamp usage, retransmission timeout calculation, flow and congestion control mechanisms, as well as Nagle’s algorithm, delayed acknowledgments and TCP keep‑alive.
This article explores the AMQP 0.9.1 protocol in depth, covering its core concepts, model components, layered architecture, lifecycle of exchanges, queues, channels, and bindings, as well as command classes, transport details, and practical usage patterns for building robust messaging systems.
This article explains the MySQL client‑server handshake, details the sequence of packets exchanged during a TCP connection, and provides a complete Python implementation that builds a raw TCP socket to connect, authenticate, and communicate with a MySQL server without using a high‑level driver.
This article explains the MySQL communication protocol, result‑set structure, client library interfaces, and the difference between store‑result and streaming modes, then details how UPSQL Proxy 2.4.0 adopts streaming to reduce latency and memory usage in distributed database environments.
This article explains core network concepts—including protocols, packet structures, the OSI and TCP/IP layer models, TCP three‑way handshake, sliding windows, congestion control, packet sticking and splitting, as well as HTTP/HTTPS basics and their headers—providing a solid foundation for troubleshooting and designing distributed services.
This article explains how to implement a Swift‑centric conversion framework that maps Realm.Object instances to plain business models and vice versa by defining protocols, leveraging Mirror for reflection, handling basic and complex types, and providing generic solutions for collections and optionals.
This article explores the components of Chrome DevTools, explains the DevTools Protocol structure, details the frontend architecture, and provides step‑by‑step guidance for remote debugging, custom extensions, and session replay using WebSocket forwarding and server‑side recording.
This article explores the true meaning of HTTP’s stateless nature, clarifies common misconceptions, examines how cookies and sessions add state, and demonstrates through a simulated shopping scenario why additional mechanisms are needed to maintain user context across requests.
This article provides a comprehensive Q&A overview of NVMe over TCP, covering its specification status, required host components, performance characteristics, namespace limits, OS support, comparisons with NVMe/RDMA and FC, and practical deployment considerations in data‑center environments.
This article analyses the architecture of high‑traffic instant‑messaging services such as WeChat and Momo, detailing long‑connection handling, short‑vs‑long HTTP/TCP protocols, custom binary messaging, smart routing, load‑balancing, sharding, replication, and the engineering trade‑offs required for massive scalability and reliability.
This article details the eight-step NVMe read I/O workflow over PCIe, covering the protocol layers, submission and completion queues, doorbell registers, data transfer mechanisms like PRP, and a trace‑based walkthrough of each host‑SSD interaction.
The article analyses practical drawbacks of S3 static‑website hosting, the complexities of CDN query‑string caching, and protocol incompatibilities such as HEAD + Range and If‑Match handling, offering concrete lessons and mitigation strategies for cloud operations teams.
This article explains the fundamentals of TCP/IP networking, including the protocol layering model, the TCP three‑way handshake and four‑way termination, differences between TCP and UDP, and how HTTP operates as a short‑lived, stateless protocol built on top of TCP.
This article introduces Apache Thrift, explaining its open‑source RPC framework, IDL‑based code generation, protocol and transport layers, and its advantages for high‑performance data exchange in mobile advertising engines, while noting practical considerations such as static schema updates and usage of TFileTransport.
This article provides a comprehensive overview of the HTTP/2 protocol, explaining its binary framing, multiplexing, header compression, request prioritization, and server push features, and offers step‑by‑step guidance for upgrading Nginx to support HTTP/2 along with detection methods.
This article introduces the GB28181 national video surveillance standard, explains its SIP‑based signaling architecture, details the SIP methods and message flows, describes the system components and hierarchical deployment, and outlines the registration and real‑time streaming processes required for implementation.
This guide introduces Bitchat, a Netty‑based IM framework, showing how to start the server and client, use built‑in commands for login, user listing and private messaging, explains its architecture, custom protocol, health‑check mechanisms, and how to handle business logic with asynchronous thread pools.
This article provides a comprehensive IPv6 introduction covering core concepts, supported operating systems, address formats, and essential network tools, and also examines how mobile applications automatically downgrade from IPv6 to IPv4 in dual‑stack environments, offering practical insights and real‑world testing examples.
This article explains how Redis stores all values as byte arrays, clarifies the five primary data structures, describes cluster slot mapping and node‑key relationships, and covers single‑threaded execution, transactions, pipelines, and the Redis protocol in detail.
This article provides a comprehensive overview of HTTP/2, explaining its binary framing, multiplexing, and the various frame types such as DATA, HEADERS, PRIORITY, RST_STREAM, SETTINGS, PUSH_PROMISE, PING, GOAWAY, WINDOW_UPDATE, and CONTINUATION, with specific focus on how Go's HTTP server implements these features.
This article provides an in‑depth exploration of the NVMe over Fabrics protocol, detailing its design goals, data encapsulation scheme, IO transmission process, command extensions such as Connect and Property Get/Set, and the associated Linux reference implementation for RDMA and Fibre Channel transports.
The article explains the emergence of the NVMe over Fabrics protocol, its performance advantages for SSDs, the role of RDMA and other transport layers, and how shared, cloud‑native storage architectures are reshaping enterprise IT infrastructure.
This comprehensive tutorial walks through capturing HTTP traffic with Wireshark and tcpdump, decodes raw TCP packets, explains request and response structures, explores encoding, MIME types, methods, status codes, and advanced topics such as proxies, caching, cookies, redirection, and connection management, giving developers a solid understanding of how HTTP works under the hood.
This article introduces the MQTT protocol, compares several broker implementations, and details functional and performance testing methods—including connection, publishing, subscription tests, and throughput measurements—to evaluate MQTT broker suitability for IoT platforms.
This article explains the RESP protocol used by Redis, details its five data types, demonstrates pipeline handling with raw sockets, examines the parsing and command‑packing logic of the redis‑py client, analyzes the pipeline implementation and limitations of redis‑py‑cluster, and speculates on upcoming RESP3 features.
This article provides a comprehensive overview of the MQTT CONNECT packet, covering its fixed and variable header structures, protocol name, level, flags, keep‑alive settings, session handling, will message behavior, payload composition, and the server's validation and response process.
This article explains how the protocol formerly known as HTTP-over-QUIC was officially renamed to HTTP/3, outlines the role of the IETF QUIC working group, the distinction between iQUIC and gQUIC, and highlights key interoperability milestones and resources.
The article provides a comprehensive overview of the Network Data Management Protocol (NDMP), explaining its architecture, core concepts, backup mechanisms, version differences, supported backup software, and various network topologies such as 2‑way, 3‑way, and remote configurations for efficient NAS data protection.
This article explains Dubbo's system roles, layered architecture, supported protocols, default settings, source modules, and the detailed processes of service exposure and consumption, providing a comprehensive overview for backend developers.
This article traces the history, requirements, design, and implementation of a cloud‑phone platform that enables remote real‑device debugging using ADB over TCP, ZMQ‑based proxies, and Golang services to achieve high‑performance, secure, and scalable debugging across separated deployments.
This article uses animated analogies to demystify TCP’s three‑way handshake, data transmission nuances, and four‑way connection termination, explaining states like SYN_SENT, SYN_RCVD, ESTABLISHED, and TIME_WAIT, while also covering retransmission, flow control, and packet ordering in an easy‑to‑understand visual format.
This article uses simple animations and analogies to demystify TCP’s three‑way handshake, data transmission nuances, and the four‑way connection termination, explaining key states like SYN_SENT, SYN_RCVD, and TIME_WAIT while also covering retransmission, duplicate‑ack handling, and window sizing.
This article explains the WebSocket protocol, compares it with traditional Ajax polling, shows client‑side JavaScript and server‑side Python implementations, details the handshake, frame parsing, and message framing, and highlights its suitability for real‑time applications.
This article explains the basic principles of the TCP protocol, covering its purpose in ensuring reliable data transmission, packet size limits, sequence numbering, how packets are reassembled by the operating system, the slow‑start mechanism with ACK handling, and methods for detecting and retransmitting lost packets.
HTTP/2 replaces the text‑based HTTP/1.x with a binary, multiplexed protocol that reduces latency, eliminates head‑of‑line blocking, compresses headers, enables server push, and improves security, offering REST APIs faster, more efficient communication while preserving familiar semantics for developers.
The article explains TCP as a connection‑oriented protocol, contrasts it with UDP, details the three‑way handshake and four‑way termination processes using clear steps and analogies, and includes illustrative diagrams to aid comprehension.
Learn how TCP’s three-way handshake and four-way termination work in detail, illustrated with Wireshark packet captures, and understand why each step is necessary through clear explanations and real‑world analogies that demystify network connection establishment and closure.
This article explains the TLS handshake protocol in depth, covering its overall flow, the generation of security parameters, the role of asymmetric algorithms, message structures, performance considerations, and mechanisms like session caching and abbreviated handshakes to ensure secure communication.
This article explains the purpose, classification, and detailed meanings of all HTTP status codes, helping developers interpret server responses and troubleshoot client‑server communication issues effectively.
This article provides a comprehensive introduction to TCP, covering its header structure, optional fields, the role of MSS and TSO, mechanisms for reliability and retransmission, as well as detailed explanations of flow control, sliding windows, and congestion control algorithms.
The article provides a detailed technical analysis of WeChat's communication protocol, describing its SYNC‑based state synchronization, short and long connection designs, packet structures, SyncKey handling, multi‑device login, and differences between mobile and web clients, offering insight for developers and engineers.
This article explains the Simple Network Management Protocol (SNMP), its purpose, advantages, core components, message structure, security features of SNMPv3, basic operations, and provides a step‑by‑step guide to installing and configuring net‑snmp on a Linux system.
This comprehensive guide reviews the essential elements of HTTP requests and responses, explains version differences, clarifies the distinctions between HTTP, Socket, and TCP, and provides practical iOS implementation details for developers seeking a deeper understanding of web communication.
This article explains the purpose and structure of the HTTP protocol, using a humorous story and Java code examples to illustrate request‑response mechanics, URL syntax, headers, and servlet interfaces, helping developers grasp how browsers and servers communicate over the web.
This article explains how HTTP relies on TCP/IP, clarifies the stateless nature of HTTP, and compares long and short connections—including their TCP handshakes, keep‑alive mechanisms, advantages, disadvantages, and appropriate usage scenarios for web and database communications.
This article breaks down the core architecture, request protocols, and memory management mechanisms of Memcached and Redis, comparing their server models, highlighting their strengths and trade‑offs, and offering practical guidance for selecting and tuning these distributed caching solutions.
HTTP/2 upgrades the foundational HTTP protocol by switching to binary framing, compressing headers with HPACK, enabling true multiplexing over a single TCP connection, and supporting server push, all of which dramatically improve network efficiency and reduce latency compared to the legacy HTTP/1.1.