This article explains what microservices are, when they should be used, their pros and cons, communication patterns, why Node.js is a good fit, and provides a detailed NestJS‑based implementation with code examples for building, testing, and exposing a user‑management microservice through an API gateway.
This article provides a comprehensive overview of TCP and UDP protocols, covering TCP header fields, flow and congestion control mechanisms, three-way handshake and four-way termination, reliability guarantees, as well as a detailed comparison with UDP, including connection orientation, broadcast support, and header overhead.
Facing frequent packet loss and network jitter that disrupts video conferences, this article examines TCP/IP stack heartbeat and retransmission mechanisms, demonstrates how to configure Windows keepalive parameters, and provides code examples for custom socket options and non‑blocking connect timeouts to maintain session continuity within 60 seconds.
This comprehensive guide walks you through the OSI seven‑layer model, explains TCP and UDP fundamentals, details the three‑way handshake and four‑way termination, compares long and short connections, introduces heartbeat packets, and demonstrates how to build a custom protocol and a socket connection pool in Node.js.
This guide explains how to install iperf on Windows and Linux, configure it for TCP and UDP bandwidth testing, adjust UDP buffer settings, and interpret the resulting performance metrics, providing practical command examples and visual output for accurate network performance analysis.
This article explains the OSI seven‑layer model, the principles and handshake processes of TCP and UDP, the differences between them, the concept of long‑living socket connections with heartbeats, custom application‑layer protocols, and how to implement a reusable socket connection pool in Node.js.
This article walks developers through network protocol fundamentals, explaining the OSI seven‑layer model, TCP three‑handshake and four‑teardown processes, UDP characteristics, long‑vs‑short connections, heartbeat mechanisms, custom protocol design, and a practical Node.js socket connection‑pool implementation.
This article explains the OSI seven‑layer model, the differences between TCP and UDP, the three‑way handshake and four‑step termination processes, long‑living socket connections, heartbeat mechanisms, custom application‑layer protocols, and how to implement a socket connection pool using Node.js.
The SRE team diagnosed an in‑flight Wi‑Fi outage for the DeWu e‑commerce app by reproducing the problem, capturing packets with ping, traceroute and tcpdump, discovered a firewall rule misclassifying the domain as a download site, and resolved it through a vendor‑issued policy update, restoring connectivity on both ATG and SATCOM links.
This article explains Suricata's packet‑decoding pipeline, detailing how Ethernet frames, IP datagrams, TCP segments and UDP datagrams are parsed from raw traffic, and shows the relevant source‑code structures used in the open‑source IDS.
An in‑depth tutorial demonstrates building a Netty‑based TCP client with Spring Boot, covering project architecture, module layout, message‑queue simulation, detailed Java code for client creation, connection handling, and testing endpoints, providing a complete, production‑ready demo for IoT socket communication.
This article explains how Linux limits the number of open files and TCP connections on a server, details the key kernel parameters (fs.file-max, soft/hard nofile, fs.nr_open), provides configuration examples, and analyzes how memory and port ranges determine realistic connection capacities for both servers and clients.
This guide introduces Swoole, a high‑performance asynchronous PHP framework for IoT, and walks through installing the extension, building TCP and WebSocket servers, performing asynchronous file I/O, and leveraging coroutines with complete code examples.
This article presents a complete Netty‑based TCP client/server demo for IoT long‑connection messaging, explains the project architecture, module layout, business flow, and provides detailed Java code for a local message queue, multithreaded processing, client creation, handler logic, and testing endpoints.
This article explains how to identify the root causes of increased network latency on Linux servers by using tools such as hping3, traceroute, wrk, tcpdump, and Wireshark, demonstrating step‑by‑step measurements, analysis of TCP delayed acknowledgments, and practical recommendations for mitigating latency in production environments.
This article explains how TCP Window Full warnings indicate a full receiver window, how to interpret Wireshark's Expert Information, locate the relevant packets, calculate bytes in flight, and use graphs to diagnose and verify the impact on transfer speed.
This article explains the structure of HTTP/1.1 request and response messages, the limitations of TCP such as head‑of‑line blocking, the evolution from SPDY to HTTP/2 with binary framing, multiplexed streams, header compression, server push, ALPN negotiation, and practical Wireshark capture techniques for HTTP/2 traffic.
This article walks through a real‑world case of slow file copying between Beijing and Shanghai data centers, explains why Wireshark reports “TCP Window Full”, shows how to locate the relevant packets, calculate bytes‑in‑flight, and assess the impact on transfer speed using I/O graphs and window‑scaling analysis.
This article examines a real‑world case where TCP Window Full warnings appear during a Beijing‑to‑Shanghai file copy, explains how Wireshark derives the alert, shows how to manually verify bytes‑in‑flight, and discusses the impact on transfer speed and how to interpret related TCP metrics.
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.
This guide walks through Wireshark's powerful features—including precise packet filtering, time‑display adjustments, absolute sequence numbering, exporting filtered captures, traffic statistics, decoding mixed logs, TCP stream tracing, and MAC‑address vendor lookup—to help engineers troubleshoot and analyze network traffic efficiently.
This article explains Linux's socket networking framework, details BSD Socket APIs, the abstraction and VFS layers, protocol families, and provides comprehensive guides with code samples for creating, configuring, and using TCP and UDP sockets in C.
This article explains why home networks use private 192.168.x.x addresses, how NAT devices translate private IPs to a single public IP, the detailed SNAT/DNAT processes, the role of ports in NAPT, and how these mechanisms enable inbound connections through techniques like NAT hole punching and intranet penetration.
While TCP’s 16‑bit port range suggests a theoretical limit of 65,535 connections, real‑world server concurrency depends on factors like memory, file descriptor limits, port reuse, and operating‑system constraints, allowing modern Linux servers to support hundreds of thousands or even millions of simultaneous connections.
This comprehensive guide walks you through the TCP/IP protocol suite, covering the four-layer model, data link, network, transport, and application layers, and explains key protocols such as IP, ARP, ICMP, TCP, UDP, DNS, as well as connection management, flow control, and congestion control techniques.
This article explains how TCP full and half‑open connection queues work on Linux, why they overflow when the number of connections grows, and provides practical commands and kernel parameter adjustments such as backlog, somaxconn, and tcp_max_syn_backlog to resolve the issue.
This article presents a comprehensive Netty TCP demo project, covering its architecture, module layout, business flow, detailed Java code for message queuing, client execution, handler implementation, testing endpoints, and deployment considerations, providing a practical learning resource for backend developers.
This article explains how to diagnose low network throughput by examining sender, receiver, and intermediate bottlenecks, understanding TCP flow and congestion windows (rwnd and cwnd), using Linux ss commands, and interpreting Wireshark visualizations to pinpoint the root cause.
This article compiles a detailed interview guide covering TCP/UDP differences, three‑way handshake and four‑way termination, flow and congestion control, select/poll/epoll mechanisms, zero‑copy techniques, Redis advantages and persistence, MySQL MVCC and repeatable‑read semantics, as well as core C++ topics and common algorithm questions.
This article explains the fundamentals of network protocols, the OSI seven‑layer model, TCP three‑handshake and four‑teardown processes, differences between TCP and UDP, socket long‑connections, custom protocol design, and how to implement a reusable socket connection pool in Node.js.
The article explains how HTTP/3 abandons TCP in favor of the QUIC protocol built on UDP, detailing TCP's head‑of‑line blocking, handshake latency, middlebox rigidity, and how QUIC’s reliability, multiplexing, and fast handshakes address these issues while also noting deployment challenges.
The article explains that the 65,535 TCP port limit does not bound a Linux server’s concurrent connections, detailing how TCP connections are identified, the theoretical maximum of 2⁴⁸ connections for a server, and the practical constraints imposed by memory and file‑descriptor limits.
The article explains how TCP connections are identified by a four‑tuple, why the theoretical maximum client connections are 65,535 due to port limits, how servers can theoretically handle up to 2⁴⁸ connections, and why real‑world concurrency is constrained by memory, file descriptors and port reuse rather than the 65535 port count.
This article walks through a complete TCP connection example in Node.js, detailing server and client code, the three-layer Node.js architecture (JS, C++, C), the initialization process, Libuv’s event‑loop phases, task scheduling, I/O models, and how Node.js maintains non‑blocking, concurrent connections.
The article explains how modern browsers handle TCP connections and HTTP requests, covering persistent connections, the limits of HTTP/1.1 pipelining, the advantages of HTTP/2 multiplexing, and browser-imposed limits on simultaneous connections per host.
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.
This article explains what happens when a client attempts a TCP connection to an IP address that does not exist or to a valid IP where the target port is not listening, covering ARP failures, SYN retransmissions, RST responses, and the importance of solid networking fundamentals for interview preparation.
An in‑depth look at HTTP’s origins, its client‑driven request‑response design, the evolution of headers, length‑ and delimiter‑based streams, and the successive enhancements from HTTP/0.9 through HTTP/1.1 to HTTP/2, SPDY, and HTTP/3, explaining the motivations behind each change.
This guide walks through setting up a three‑host Linux environment, using Docker, hping3, sar, tcpdump and iptables to reproduce a SYN‑Flood DDoS attack, analyze its impact with network tools, and apply kernel and firewall tweaks to mitigate the attack.
This article walks through setting up a Starwift cloud‑native data warehouse on JD Cloud, configuring network access, installing the ClickHouse client on macOS, and demonstrates both TCP and HTTP Rust integrations with example code, while noting common dependency conflicts.
This article explores the design motivations behind HTTP, tracing its evolution from the early TCP‑based request‑response model through HTTP/0.9, 1.0, 1.1, to modern HTTP/2 and HTTP/3, highlighting key features like headers, caching, connection reuse, and protocol optimizations.
This article explores Linux kernel TCP connection handling by examining socket data structures, port range and file descriptor tuning, core functions like tcp_v4_rcv, and lookup mechanisms, while offering practical tips to boost client-side concurrent connections beyond traditional limits.
This article explains the fundamentals of Linux network latency, demonstrates how to measure round‑trip time using ping, traceroute, hping3 and wrk, walks through a Docker‑based test setup, and shows how to analyze packet captures with tcpdump and Wireshark to uncover causes such as TCP delayed ACK.
This article explains the essential concepts of TCP and UDP, covering the OSI model layers, socket communication, reliable transmission mechanisms such as stop‑and‑wait and sliding‑window, congestion control, connection establishment, and practical differences between TCP and UDP, providing a comprehensive networking fundamentals overview.
This article explains how TCP/IP functions as a collection of standard components—such as DNS, IP, ARP, TCP, UDP, and TLS—using a step‑by‑step example of a browser accessing zhihu.com, and clarifies each protocol's role, interactions, and quirks.
An in‑depth comparison of HTTP Keep‑Alive (application‑layer persistent connections) and TCP Keepalive (kernel‑level health checks), covering their implementation layers, usage, configuration, timeout handling, and impact on performance, with clear diagrams and code examples to help developers master both mechanisms.
The article explains how TCP connections are identified by a four‑tuple, clarifies the theoretical maximum of 65,535 client ports versus the far larger possible server connections, and discusses practical limits imposed by memory, file descriptors, and system configuration on Linux servers.
This comprehensive guide explains the TCP/IP model’s four layers, key protocols such as IP, ARP, ICMP, DNS, and the differences between TCP and UDP, and details connection setup, termination, flow and congestion control mechanisms like slow start, fast retransmit, and fast recovery.
This article explains how browsers handle TCP connections and SSL sessions when loading pages with many images, covering connection persistence, request multiplexing, HTTP pipelining limitations, per‑host connection limits, and the advantages of HTTP/2 multiplexing for efficient resource fetching.
BBRv2 improves upon the original BBR algorithm by more accurately measuring delivery rate, constraining inflight data with loss and ECN signals, and introducing a dynamic state machine that enhances fairness and coexistence with Reno/CUBIC, addressing the multi‑flow fairness and queueing issues that plagued BBRv1.
This article explains how an improperly configured MTU in a VPN environment caused MySQL SHOW DATABASES commands to hang, details the troubleshooting steps taken, and presents three practical solutions to resolve the MTU‑related packet loss.
This article provides a comprehensive, step‑by‑step explanation of TCP and related transport‑layer concepts, covering the OSI model, physical to application layers, socket and port mechanics, TCP header fields, reliable transmission techniques, flow and congestion control, connection setup/teardown, and a brief comparison with UDP.
This article explains how MySQL stores NULL values and clarifies the distinct mechanisms of HTTP Keep‑Alive (application‑level long connections) versus TCP Keepalive (kernel‑level health checks), detailing their implementations, usage, and practical considerations.
This article explains TCP fundamentals—including connection-oriented design, byte‑stream transmission, reliability, header structure, flag meanings, the three‑way handshake, four‑way termination, SYN‑Flood attacks, time‑wait handling, retransmission strategies, kernel tuning parameters, Nagle’s algorithm, and congestion control mechanisms such as slow start and congestion avoidance.
This comprehensive guide covers computer network fundamentals, including OSI and TCP/IP models, protocol layers, DNS resolution, HTTP/HTTPS details, TCP three‑way handshake and four‑way teardown, congestion control, security threats like XSS and CSRF, and practical mitigation techniques, providing a solid foundation for networking interviews and real‑world applications.
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.
This article explains how TCP and UDP operate at the transport layer, compares their reliability and speed, details the TCP three‑way handshake and four‑way termination processes, and outlines how each protocol handles data segmentation, ordering, and loss.
While UDP is often assumed to be faster than TCP, this article explains socket basics, the reliability mechanisms of TCP, scenarios where UDP can be slower, and how application-layer solutions like KCP or QUIC add reliability, helping readers understand when each protocol truly excels.
This article provides a comprehensive overview of TCP, UDP, and HTTP protocols, explaining their definitions, layered roles, connection establishment and termination processes, segment structures, and key differences in reliability and performance for network communication.
This article explains TCP's retransmission mechanisms—including timeout retransmission, fast retransmit, SACK and D‑SACK—along with sliding window operation, window sizing, and congestion control algorithms such as slow start, congestion avoidance, and fast recovery, providing a comprehensive network fundamentals guide.
This article explains the fundamentals of HTTP, how browsers build and send requests, the structure of request and response messages, and the performance improvements introduced by HTTP 2.0 and the QUIC protocol built on UDP.
This comprehensive guide explains the TCP/IP protocol suite, detailing each of its four layers, key protocols such as IP, TCP, UDP, ICMP, ARP, and DNS, and illustrates essential mechanisms like encapsulation, three‑way handshake, flow control, congestion control, and tools like ping and traceroute.
This article provides a comprehensive overview of TCP and UDP, explaining their roles in the transport layer, key differences, the three‑way handshake and four‑way termination processes, data transmission mechanisms, and typical use‑case scenarios for each protocol.
This article explains the TCP slow‑start algorithm, how its initial 10‑packet window translates to a practical 14 KB rule for web pages, and why keeping the first‑byte payload under this size dramatically reduces latency across various network conditions.
This article summarizes a series of technical Q&A from an OSChina event covering Linux networking fundamentals such as port limits, network namespaces, TCP connection handling, C10K problem, packet loss troubleshooting, TCP memory usage, high CPU causes, useful monitoring tools, kernel parameters, and practical socket examples.
This article explains how to identify the root causes of increased network latency on Linux servers, covering tools such as ping, traceroute, hping3, and wrk, demonstrating packet analysis with tcpdump and Wireshark, and showing how TCP delayed ACK and socket options affect response times.
This article explains the TCP keepalive mechanism, its purpose, default parameters, how to configure and verify it on Linux, its drawbacks, and the distinction between TCP keepalive and HTTP Keep-Alive, providing practical code examples and network analysis steps.
The article investigates frequent HttpClient connection‑pool exhaustion caused by excessive CLOSE_WAIT sockets in a high‑traffic Java service, explains the underlying TCP and HttpClient mechanisms, presents diagnostic commands and code snippets, and offers concrete configuration and architectural recommendations to prevent similar issues.
The article explains how TCP connections are identified by a four‑tuple, why the theoretical maximum of 65,535 client ports does not cap server concurrency, and how real‑world limits are governed by memory, file‑descriptor counts, and port reuse techniques.
This article explains how TCP connections behave when any of the three-way handshake or four-way termination packets are lost, detailing the kernel‑controlled retransmission mechanisms, timeout intervals, relevant sysctl parameters, and the exact sequence of events for each loss scenario.
This article explains the OSI seven‑layer model and the simplified four‑layer TCP/IP model, describes how data is encapsulated with headers at each layer, compares TCP and UDP characteristics, and details the TCP three‑way handshake, four‑way termination, and related security considerations.
This guide explains how to identify and troubleshoot TCP throughput limitations by examining sender, receiver, and network bottlenecks, understanding rwnd and cwnd values, using Linux tools like ss and Wireshark, and interpreting packet traces to pinpoint congestion or loss.
Although ping and TCP both rely on IP, they can follow different network routes due to routing protocols, equal‑cost multi‑path (ECMP) decisions, and five‑tuple hashing, which explains why a host may be reachable by ping but occasionally fail to establish a TCP connection.
This guide explains why TCP throughput may fall short of network capacity, covering sender, receiver, and network bottlenecks, how to read receiver window (rwnd) and congestion window (cwnd) values on Linux, and how to interpret Wireshark graphs to pinpoint the root cause.
In high‑concurrency scenarios, massive TIME_WAIT TCP connections can exhaust local ports, causing new connections to fail, but by understanding the TCP four‑handshake, adjusting socket reuse settings, and using keep‑alive, you can mitigate the issue.
This article explains why network throughput may fall short of the link capacity, describes the three typical bottlenecks (sender, receiver, and intermediate network), and provides practical methods to examine TCP window sizes, congestion control variables, and Wireshark visualizations for pinpointing the root cause.
This article explains the fundamentals of TCP, why raw TCP lacks message boundaries, how HTTP and RPC are built on top of TCP, and the practical reasons why both protocols coexist in modern software architectures.
This article provides a concise overview of TCP and UDP, explaining their roles in the transport layer, key differences such as connection orientation and reliability, the three‑way handshake and four‑way termination processes of TCP, and the characteristics and use cases of UDP.
This article provides a comprehensive overview of TCP and UDP, explaining their roles in the transport layer, key differences in reliability and speed, the three‑way handshake and four‑way termination processes of TCP, and how data transmission is handled by both protocols.
This guide explains TCP connection states, essential Linux commands, three‑way handshake, four‑way termination, simultaneous open/close, flag meanings, common error codes, and keep‑alive techniques to help you troubleshoot and secure network services effectively.
Under high‑concurrency loads, massive TIME_WAIT TCP connections can exhaust local ports, causing “address already in use” errors; this article explains the root causes, impact on services, and practical mitigation strategies such as keep‑alive headers, socket reuse, and reducing the TIME_WAIT timeout.
This article explains the fundamental differences between TCP and UDP, covering their purposes, reliability, speed, handshake mechanisms, data transmission processes, and termination procedures, and includes visual diagrams to illustrate each concept in.
This article provides a concise overview of TCP and UDP protocols, explaining their purposes, core differences, the TCP three‑way handshake and four‑way termination processes, data transmission mechanisms, and typical use‑case scenarios for each protocol.
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.
This article explains the end‑to‑end journey of a data packet in a TCP‑based chat application, identifies multiple points where packet loss can occur—from connection handshake to NIC queues—and offers practical Linux commands for diagnosing and mitigating these losses.
This article explains the evolution from raw TCP sockets to HTTP and RPC, highlighting why RPC remains useful despite HTTP's prevalence, covering TCP basics, message framing, service discovery, connection handling, serialization, and performance considerations.
This article explains how TCP packets travel from user space to the destination, highlights typical points where packet loss can occur—including connection establishment, flow‑control queues, NIC buffers, and end‑to‑end network hops—and shows how to diagnose and mitigate these issues using Linux tools.
This article explains why TCP and UDP can share the same port number, how multiple TCP processes handle binding, client port reuse, TIME_WAIT implications, and practical solutions like SO_REUSEADDR and tcp_tw_reuse to avoid address‑in‑use errors.
The article explains how TCP connections are identified by a four‑tuple, why the 65535 port limit does not directly cap concurrent connections, the theoretical maximum connections for client and server roles, and how real‑world limits are governed by memory, file descriptors, and port reuse on Linux systems.
This article provides a comprehensive overview of TCP and UDP, explaining their roles in the transport layer, key differences, the three‑way handshake, data transmission mechanisms, four‑way termination, and the characteristics of UDP, illustrated with diagrams for clarity.
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.
This article provides a comprehensive overview of TCP and UDP, explaining their roles in the transport layer, key differences such as connection orientation and reliability, the three‑way handshake and four‑way termination processes of TCP, and the typical use cases and limitations of each protocol.
The article explains how the Linux kernel implements the TCP three‑way handshake, detailing server listen queue allocation, client connect port selection and SYN transmission, SYN‑ACK processing, state transitions, request‑socket management, full‑connection queue handling, and the final accept call, plus tuning tips.
This article explains TCP connection states, common Linux network commands, the three‑way handshake, four‑way termination, simultaneous open/close, flag meanings, and practical troubleshooting techniques such as keep‑alive and error handling, providing a comprehensive guide for network engineers.
This article explains the evolution from HTTP/1.1 to HTTP/3, highlights the limitations of HTTP/2 such as head‑of‑line blocking and TCP‑based latency, and shows how QUIC’s UDP‑based design, 0‑RTT handshakes, connection migration, and advanced congestion‑control mechanisms overcome those challenges to deliver faster, more reliable web traffic.
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 how TCP connections are identified by a four‑tuple, why the 65535 port limit only applies to client‑side connections, the theoretical 2⁴⁸ limit for servers, and how actual concurrency is constrained by memory, file descriptors and port reuse.
This article explains that the 65535 TCP port limit does not directly cap concurrent connections, detailing how TCP connections are identified by a four‑tuple, the theoretical maximums for client and server sides, and why actual limits depend on memory, file descriptors, and port reuse.
This article examines how a MySQL connection is created from a Java web application, breaking down the TCP handshake, authentication, and variable‑setting steps with Wireshark captures, measuring latency, and demonstrating why connection pooling is essential to avoid hundreds of milliseconds of overhead per request.
This guide walks through Wireshark's powerful features for filtering packets by IP, protocol, and port, adjusting time display formats, viewing and modifying TCP sequence numbers, saving filtered captures, performing packet statistics, decoding logs, tracing TCP streams, and identifying device manufacturers via MAC addresses.
