Tagged articles
network protocol
76 articles · Page 1 of 1
Despite IPv6's vast 128-bit address space and technical improvements like SLAAC and simplified routing, only 22% of websites have adopted it due to IPv4 workarounds (NAT, CIDR), infrastructure incompatibility, high migration costs, and ISP unreadiness; solutions include government mandates, native single-stack deployment, and stakeholder collaboration.
IPv4 exhaustionIPv6ISP adoption
0 likes · 11 min read

The article provides a technical breakdown of Huawei's UnifiedBus (Lingqu) interconnect protocol for AI supernodes, detailing its full‑stack design that unifies chip‑, board‑, and cabinet‑level communication, its three‑layer stack (PHY, Transaction, Service), resource‑scheduling and virtualization capabilities, and its deployment in Atlas950/960 SuperPod clusters.
AI supernodeAtlas950Huawei
0 likes · 5 min read


21CTOJun 19, 2026 · Fundamentals
The Linux 7.2 kernel removes the legacy AppleTalk networking stack—once popular on early Macs—citing decades‑old disuse, recent AI‑generated patch spam, and the maintenance burden, while preserving only minimal elements in modern protocols like Bonjour.
AI-generated patchesAppleTalkLinux kernel
0 likes · 4 min read

This article walks through TCP from the physical layer up to congestion control, explaining MAC and IP addressing, sockets and ports, reliable transmission mechanisms like stop‑and‑wait and sliding windows, the three‑way handshake, four‑way teardown, UDP differences, routing, packet fragmentation, and security considerations.
SocketTCPUDP
0 likes · 28 min read

The article examines the IETF’s IPv8 draft, which proposes a 2⁶⁴‑address space that could assign roughly 2.2 billion public IPs to each individual, explains its design as an IPv4 subset with ASN‑based prefixes and built‑in security, and evaluates the significant compatibility, hardware, and adoption challenges that make widespread deployment unlikely.
CGNATIETFIP addressing
0 likes · 7 min read

This article provides a comprehensive technical guide for Java interviewers, detailing HTTP’s security flaws, how HTTPS resolves them through SSL/TLS encryption, certificate verification, and hybrid cryptography, and includes handshake steps, performance comparisons, common follow‑up questions, and concise memory mnemonics.
HTTPHTTPSJava Interview
0 likes · 14 min read

This article explains TCP as a connection‑oriented, reliable byte‑stream transport protocol, detailing its header fields, state machine, three‑way handshake, four‑way termination, TIME_WAIT handling, Linux inspection commands, optimization techniques, and a comparison with UDP, all illustrated with concrete examples and diagrams.
LinuxSocketTCP
0 likes · 27 min read

This article demystifies Ethernet by explaining the roles of MAC and PHY within the network protocol stack, covering OSI and TCP/IP models, data encapsulation, ARP address resolution, hardware interfaces like MII/MDIO, and practical troubleshooting tips for real‑world network devices.
EthernetMacOSI model
0 likes · 36 min read

This article dives deep into Olric’s network communication architecture and RPC mechanism, explaining its layered transport design, request/response structures, pipeline and batch processing, client‑to‑cluster interactions, data migration and rebalancing, and provides Go code examples illustrating high‑throughput, safe distributed operations.
GoOlricRPC
0 likes · 6 min read

This comprehensive tutorial explains TCP's connection establishment and termination processes, covering protocol features, key flag definitions, step‑by‑step three‑way handshake and four‑way teardown, common interview questions, TIME_WAIT details, abnormal scenarios, and a Wireshark packet‑capture walkthrough.
Connection ManagementTCPhandshake
0 likes · 11 min read

This article explains how Java 24 and OpenJDK introduce HTTP/3 via JEP 517, describes the QUIC protocol that powers it, compares performance against HTTP/2, and provides Java benchmark code showing reduced latency and fewer TCP connections when using HTTP/3.
HTTP/3JavaQUIC
0 likes · 11 min read

This article explains the limitations of TCP and UDP for real‑time applications, introduces the KCP protocol as a UDP‑based solution that combines reliability with low latency, outlines its features, working principles, code usage, and real‑world deployment examples in gaming, video conferencing, live streaming, and IoT.
KCPUDPlow-latency
0 likes · 8 min read

This article provides a comprehensive English guide to the Transmission Control Protocol (TCP), covering its connection‑oriented design, reliability features, packet structure, three‑way handshake, data transfer process, flow and congestion control, four‑step termination, and example C++ socket code for establishing, sending, receiving, and closing TCP connections.
C++ SocketFlow ControlTCP
0 likes · 42 min read

This guide explains TCP's three-way handshake and four-way termination, covering protocol characteristics, key terminology, step‑by‑step packet flows, reasons behind each phase, TIME_WAIT details, abnormal scenarios, and common interview questions for networking fundamentals.
Four‑Way TeardownInterview questionsTCP
0 likes · 8 min read

This article explains how to design and implement a high‑performance custom network protocol in Rust, covering zero‑copy parsing, memory‑mapped packet pools, lock‑free event loops, and an efficient binary packet format to achieve ultra‑low latency and massive concurrency.
Rusthigh-performancelock-free
0 likes · 9 min read

The article analyzes a mysterious production stall caused by a TCP communication bug where the D4 and D5 stages are merged, leading to a mis‑aligned length field that makes the server read an incorrect payload size, and presents two concrete fixes.
BackendMinaTCP
0 likes · 11 min read

The article details a mysterious production stall at 70% caused by a TCP packet length field misalignment when the configuration name is "rabbit‑TD", explains the step‑by‑step investigation using server logs and packet captures, identifies the root cause of the merged D4/D5 packets, and proposes two concrete fixes to correct the length handling.
BackendTCPdebugging
0 likes · 10 min read

This article traces the evolution of HTTP from its 1991 origins through HTTP/2 and HTTP/3, explains how QUIC leverages UDP to reduce latency, and details QUIC's connection establishment, migration, head‑of‑line blocking mitigation, congestion control, and flow‑control mechanisms.
BackendHTTPHTTP/3
0 likes · 13 min read

This article explains the fundamental differences between UDP and TCP, details the TCP header fields, walks through the three‑way handshake and its necessity, describes the four‑way termination process, and illustrates the complete TCP state machine with diagrams and practical examples.
TCPfour-way terminationnetwork protocol
0 likes · 14 min read

This article explains the evolution from HTTP/1.1 to HTTP/3, detailing QUIC’s UDP‑based design, its 1‑RTT handshake, connection migration, head‑of‑line blocking elimination, congestion‑control enhancements, forward error correction, and stream‑ and connection‑level flow control.
Flow ControlHTTP/3QUIC
0 likes · 16 min read

This comprehensive guide covers TCP fundamentals—including differences from UDP, the three‑way and four‑way handshakes, half‑open queues and SYN flood attacks, header fields, Fast Open, timestamps, RTO calculation, flow and congestion control, Nagle algorithm, delayed ACKs, and keep‑alive mechanisms—providing clear explanations and practical examples for engineers.
Fast OpenFlow ControlSYN Flood
0 likes · 27 min read

By migrating the CatEar FM live‑streaming app’s WebSocket layer to Chromium’s Cronet network stack, the team unified cross‑platform code, added customizable DNS and proxy support, and cut handshake latency by roughly 150 ms on Android and 250 ms on iOS, paving the way for future HTTP/2 and HTTP/3‑based WebSocket transports.
CronetWebSocketcross-platform
0 likes · 14 min read

The article provides a detailed technical analysis of RoCE (RDMA over Converged Ethernet), its two protocol versions, packet overhead, congestion‑control mechanisms, Soft‑RoCE implementation, and the challenges and performance implications of deploying RoCE in modern HPC environments compared to InfiniBand and traditional Ethernet solutions.
HPCInfiniBandRDMA
0 likes · 17 min read

This article walks through implementing the Redis Serialization Protocol (RESP) in Go as part of the EasyRedis project, detailing the protocol format, parsing logic, connection handling, and a demo showing how standard redis-cli commands are encoded and processed.
RESPTCPnetwork protocol
0 likes · 11 min read

Tencent’s newly open‑sourced TQUIC, a high‑performance, lightweight, cross‑platform QUIC library written in Rust, offers fast transmission, high performance, extensive congestion‑control algorithms, multi‑path support, and strong security, and has already boosted core services such as video, advertising, gaming, and cloud CDN, demonstrating its broad scenario value and robust architecture.
QUICRusthigh-performance
0 likes · 7 min read

Tencent has open‑sourced TQUIC, a Rust‑based, high‑performance, lightweight cross‑platform QUIC library that supports multiple congestion‑control algorithms, multi‑path networking, and memory‑safe operation, delivering 2‑30% faster transmission and up to 20% higher processing speed while improving latency‑sensitive services such as video, gaming, advertising, and e‑commerce.
QUICRustcross-platform
0 likes · 7 min read

This article explains the fundamentals of network protocols—including the OSI model, TCP three‑way handshake and four‑way termination, UDP characteristics, long versus short socket connections, custom application‑layer protocols, and how to implement a reusable socket connection pool in Node.js.
Backend DevelopmentUDPconnection pool
0 likes · 17 min read

This article explains the fundamentals of TCP, why pure TCP communication faces boundary issues, how HTTP and RPC are built on TCP as application‑layer protocols, and compares their architectures, service discovery, serialization, and performance to clarify when each should be used.
Backend DevelopmentHTTPRPC
0 likes · 15 min read

This article explains TCP connection basics, the three‑way handshake and four‑way termination, compares short and long connections, discusses keep‑alive mechanisms, and outlines when to use each approach in network and HTTP communication.
HTTPKeep-AliveLong Connection
0 likes · 12 min read

The guide walks through building a real‑time instant‑messaging system—using a multiplayer monster‑battle demo—to compare polling, long‑polling, SSE and WebSocket, explains the WebSocket handshake and frame format, shows a custom Node.js server implementation, and advises adopting mature IM SDKs for production.
Long PollingNode.jsSSE
0 likes · 23 min read

This article chronicles the development of the OpenFlow SDN protocol, detailing each version’s enhancements to the control and data planes, the architecture of switches and controllers, and the key concepts such as flow tables, group tables, meter tables, and message types.
ControllerFlow TableOpenFlow
0 likes · 25 min read

This comprehensive guide delves into TCP’s core mechanisms—including header fields, segmentation and reassembly, the three‑way handshake and four‑step termination, sliding‑window flow and congestion control, retransmission strategies, and connection design patterns—providing a solid foundation for network engineers and developers.
Flow ControlTCPcongestion control
0 likes · 26 min read

This article explains the ARP protocol's role in translating IPv4 addresses to MAC addresses, details its packet structure, operation flow, security risks like spoofing and MAC conflicts, and provides Linux commands and configuration tips for managing ARP, Proxy ARP, ARP Probe, and Gratuitous ARP.
ARPAddress ResolutionLinux
0 likes · 19 min read

The article explains that during TCP's three‑way handshake, if a client receives a SYN‑ACK with an unexpected acknowledgment number, it must send an RST to abort the stale connection, because silently discarding the packet would cause long retransmission delays and prevent the new connection from being established.
RSTSYN-ACKTCP
0 likes · 5 min read

This article explains how to visualize and dissect TCP/IP packet structures using Wireshark, walks through each OSI/TCP‑IP layer, and details the fields of the TCP header such as ports, sequence numbers, flags, and checksum, providing a practical understanding of network protocol fundamentals.
TCPTCP/IP ModelWireshark
0 likes · 9 min read

This article explains how QUIC implements reliable transmission on top of UDP by using monotonic packet numbers, stream IDs and offsets, independent flow‑control windows, and integrated TLS, thereby eliminating TCP’s retransmission ambiguity, head‑of‑line blocking, and improving congestion control and connection migration.
Flow ControlQUICTCP
0 likes · 19 min read

This article explains how TCP ensures reliable connections through the three-way handshake process—including SYN, SYN‑ACK, and ACK exchanges—and describes the four-step termination sequence with FIN and ACK flags, while also clarifying why three handshakes are necessary instead of two.
TCPfour-way terminationnetwork protocol
0 likes · 7 min read

This article walks developers through the fundamentals of the OSI model, TCP three‑way handshake and UDP characteristics, explains socket concepts, demonstrates Node.js server and client implementations with heartbeats and custom protocols, and details how to build and use a socket connection pool with the generic‑pool library.
Backend DevelopmentNode.jsSocket
0 likes · 39 min read

This article describes how Trip.com’s backend engineers introduced QUIC to the Trip.com App, redesigned the Nginx‑based server architecture for multi‑process deployment, solved connection‑migration challenges with a custom load‑balancing layer, and enabled 0‑RTT support using shared ticket keys, achieving roughly a 20% reduction in request latency.
0-RTTConnection MigrationNginx
0 likes · 16 min read

This article explains the complete lifecycle of socket communication—from creation within the TCP/IP stack, through connection establishment, data transmission with TCP and UDP, to graceful termination—detailing control information, packet sizing, ACK mechanisms, sliding windows, and practical inspection using netstat.
SocketsTCPTCP/IP stack
0 likes · 11 min read

This article explains the background of Alibaba Cloud's Performance Testing Service (PTS), details HTTP/2 flow‑control mechanisms, analyzes a bug where WINDOW_UPDATE frames caused a window size overflow, shows how the issue was diagnosed and fixed, and provides reference resources.
Flow Controlbug fixcloud native
0 likes · 7 min read

XQUIC is Alibaba's open‑source, standards‑compliant QUIC implementation that delivers lightweight binaries, high‑performance transport, and cross‑platform support, enabling faster, more reliable data transfer for mobile apps and cloud services while fostering community collaboration through open source.
AlibabaMobile NetworkingQUIC
0 likes · 11 min read

This article explains the purpose of the TCP RST flag, how the kernel and application layers detect it, the various scenarios that trigger RST, why an RST may not terminate a connection, and the security implications of RST attacks.
Linux kernelRSTTCP
0 likes · 15 min read


21CTODec 16, 2021 · Backend Development
This article explains the evolution of HTTP, compares HTTP/1.1, HTTP/2, and HTTP/3, and presents benchmark results from three global data centers showing how HTTP/3’s QUIC‑based multiplexing and 0‑RTT dramatically reduce page load latency.
HTTP/3QUICWeb Performance
0 likes · 13 min read

This article explains TCP fundamentals, covering its role in the OSI model, header structure, three‑way handshake, four‑way termination, typical connection problems, and how various TCP states transition, providing a solid foundation for both client and server developers.
Connection ManagementTCPhandshake
0 likes · 22 min read

This article explains the fundamentals of the Transmission Control Protocol, its reliable byte‑stream characteristics, the detailed three‑way handshake process, and why three steps are required to prevent duplicate or stale connections in network communication.
Connection establishmentTCPnetwork protocol
0 likes · 5 min read

RSocket is a binary, back‑pressure‑aware protocol that supports four interaction models—fire‑and‑forget, request‑response, request‑stream, and request‑channel—using multiplexed frames with odd/even stream IDs for true bidirectional communication, and provides a reactive, resumable API suitable for microservices, IoT, and broker‑based architectures.
BackendReactive Streamsbroker
0 likes · 8 min read

This article introduces RSocket's efficient binary protocol, its four interaction models, bidirectional communication, internal frame and payload design, architecture, practical use cases like brokers and RPC, and how it integrates with reactive programming concepts such as Reactive Streams.
Reactive Programmingnetwork protocolrsocket
0 likes · 9 min read

The article explains RTMP’s multiplexed, packetized streaming over TCP, detailing its chunk structure, message types, handshake, and connection workflow, then demonstrates livego’s publishing and pulling processes, discusses typical latency sources, and offers mitigation strategies and reference resources for developers.
GoLivegoRTMP
0 likes · 28 min read


ITPUBApr 21, 2021 · Fundamentals
This article explains TCP's connection‑oriented behavior, detailing the three‑way handshake for establishing a connection, the four‑step termination process, various state transitions, half‑open/half‑close scenarios, simultaneous open/close, initial sequence numbers, and the role of RST and TIME_WAIT.
Connection ManagementTCPfour-way termination
0 likes · 19 min read

This tutorial introduces RSocket—a reactive, binary, multiplexed protocol—and demonstrates how to install the RSC client, create a Spring Boot RSocket server, and implement all four interaction models (request‑response, fire‑forget, stream, and channel) with complete code examples.
Backend DevelopmentJavaReactive Streams
0 likes · 7 min read

This practical guide explains WebSocket fundamentals, demonstrates how to integrate and debug them in a project with webpack proxy and Nginx settings, implements heartbeat and reconnection logic for stability, and compares native WebSocket to Socket.io’s richer but heavier real‑time framework.
Frontend DevelopmentNginxSocket.IO
0 likes · 5 min read

This article explains the TCP protocol’s header structure, the purpose of each field, how the three‑way handshake establishes a reliable connection, why three steps are needed, and the four‑step process used to gracefully close a TCP session, including verification with Wireshark.
Four‑Way TeardownTCPnetwork protocol
0 likes · 13 min read

The article explains the fundamental differences between HTTP and HTTPS, outlines how HTTPS adds SSL/TLS encryption to the standard HTTP protocol, describes the step‑by‑step communication process—including certificate verification, key exchange, and encrypted data transfer—and compares ports, security, and connection details.
HTTPHTTPSSSL
0 likes · 6 min read

The article explains DHCPv6 fundamentals—including its multicast communication, message formats, and common message types—and walks through the complete IPv6 address acquisition process on Tencent Cloud CVM, detailing the Solicit‑Advertise‑Request‑Reply sequence for first‑time assignment and the Confirm‑Reply flow after a reboot.
Address AllocationCVMDHCPv6
0 likes · 10 min read

Microsoft announced on its official tech blog that it has open‑sourced MsQuic, its internal cross‑platform implementation of the experimental QUIC transport protocol, which underpins HTTP/3 and is already integrated into Windows, Microsoft 365, .NET Core, and SMB, offering performance and security improvements.
HTTP/3MicrosoftMsQuic
0 likes · 3 min read

This guide explains the fundamentals of the Network Time Protocol, the hierarchy of NTP strata, three synchronization modes, and provides step‑by‑step Linux commands to install, configure, start, and verify an NTP server as well as client setup.
NTPServer configurationnetwork protocol
0 likes · 8 min read

This article presents a comprehensive guide to HTTP performance optimization, covering encoding efficiency, channel utilization, transport path enhancements, and security improvements, enabling developers and operators to reduce latency, save bandwidth, and handle massive concurrency effectively.
HTTPTLSWeb Performance
0 likes · 17 min read

The article explains ICMPv6 fundamentals, details its message format and error/informational types, then walks through a complete ping6 exchange between two cloud VMs, illustrating each OSI‑layer step—from payload creation and neighbor discovery to routing, encapsulation, reply generation, and caching.
ICMPv6IPv6Neighbor Discovery
0 likes · 11 min read

The article explains how Baidu App adopts the Happy Eyeballs protocol—using both RFC 6555 and RFC 8305—to seamlessly transition from IPv4 to IPv6 by concurrently querying DNS, alternating address order, and employing short‑delay fallbacks in its ijkplayer, Cronet, OkHttp, and WKWebView components.
CronetHappy EyeballsIPv6
0 likes · 6 min read

RSocket is a binary, reactive‑streams‑based point‑to‑point protocol offering asynchronous, back‑pressure‑aware, multiplexed communication with four interaction models, making it a high‑performance alternative to HTTP for distributed systems, though it remains in candidate status and has a steep learning curve.
Backend CommunicationJavaReactive Streams
0 likes · 5 min read

The article uses a humorous long‑distance‑call scenario to illustrate why TCP requires a three‑way handshake for reliable connection establishment and a four‑step termination, then details the packet format, flag meanings, handshake steps, and related security considerations.
SYN attackTCPfour-way termination
0 likes · 11 min read

This article explains what QUIC is, outlines HTTP/3’s advantages over HTTP/2, and provides step‑by‑step instructions with code samples for compiling Node.js’s QUIC implementation and running a simple QUIC server and client to observe protocol behavior.
HTTP/3Node.jsQUIC
0 likes · 8 min read


21CTOMay 22, 2019 · Fundamentals
This article explains web crawlers—what they are, their classifications, typical use cases, and step‑by‑step workflow—covers the robots protocol, then delves into HTTP and HTTPS fundamentals, request/response structures, common methods, headers, status codes, and the security trade‑offs of HTTPS.
HTTPStatus Codesnetwork protocol
0 likes · 10 min read

This article walks through the fundamentals of TCP, explaining its place in the OSI model, the three‑way handshake, window updates, data exchange, and the four‑way termination, while providing complete Python server and client code and Wireshark packet captures to illustrate each step.
TCPWiresharkfour-way termination
0 likes · 12 min read

This article explains the principles behind TCP's three‑way handshake and four‑way teardown, covering connection establishment, data transfer, termination, header fields, state diagrams, sequence‑number wraparound, SYN‑flood attacks, mitigation techniques, and a practical Redis packet‑capture analysis, all illustrated with diagrams and code snippets.
Four‑Way TeardownLinuxSYN Flood
0 likes · 23 min read

This article provides a thorough overview of the HTTP protocol, covering network architecture basics, the request/response model, detailed structures of request and response messages, and extra topics such as HTTP/1.1 vs HTTP/1.0, HTTPS differences, and long‑connection handling.
HTTPRequest/Responsefundamentals
0 likes · 5 min read

Tencent CDN’s implementation of HTTP/2 Server Push predicts and preloads dependent resources via link tags or headers, creates PUSH_PROMISE frames, and streams assets before the main response, yielding measurable latency reductions on real‑world pages when used with proper sizing, priority, and cache awareness, while avoiding slow‑start and buffer issues.
CDNFrontend OptimizationHTTP/2
0 likes · 16 min read

This article provides a comprehensive deep‑dive into RPC functional goals, call classifications, component breakdown, Java‑based implementation details, protocol encoding, transport considerations, execution control, and exception handling, offering practical guidance for building a reliable distributed RPC framework.
Framework DesignRPCnetwork protocol
0 likes · 15 min read

This article explains why TCP requires a three‑way handshake to establish connections and a four‑step termination process, using a relatable video‑call scenario and detailed protocol diagrams to illustrate the underlying mechanisms and practical rules for confirming audio transmission.
TCPfour-way handshakenetwork protocol
0 likes · 10 min read

This article introduces the QUIC transport protocol, explains its design goals and key features, details a practical iOS implementation using Chromium and Stellite libraries, presents code examples, and compares QUIC’s download latency against HTTP/2 on Wi‑Fi and 4G networks.
ChromiumQUICStellite
0 likes · 19 min read

This article introduces JD's Smart IoT system, detailing its cloud‑mobile‑device architecture, the JOYLINK communication protocol, device provisioning methods, security mechanisms, service discovery, long‑connection strategies, standardized services, IFTTT engine, and open components for developers.
Device ManagementIoTJOYLINK
0 likes · 14 min read


21CTOJul 12, 2017 · Backend Development
This article outlines the principles and components of a scalable game server architecture, covering login management, region selection, gateway handling, communication protocols, publish‑subscribe, RPC, server merging, and the evolution from single‑threaded to cloud‑native designs.
Backend Developmentarchitecturedistributed systems
0 likes · 24 min read

This article breaks down the TCP three‑way handshake and four‑way termination processes, explaining each packet exchange, the role of sequence numbers, the TIME_WAIT state, and why these steps are essential for reliable full‑duplex communication.
TCPTIME_WAITfour-way termination
0 likes · 8 min read

This article examines MySQL's network communication stack—from the high‑level MySQL packet protocol down to the socket layer—detailing session creation, NET/VIO handling, result‑set transmission, metadata overhead, and performance measurements using MySQL 5.7.
MySQLMySQL5.7database
0 likes · 10 min read

This article explains how to design and implement an efficient Golang‑based server‑client monitoring solution called OWL, covering data packet structures, network protocols, client and server architecture, concurrency handling with goroutines, and practical code examples for high‑throughput operations.
Server-Clientgolanghigh-concurrency
0 likes · 12 min read
