BestHub
Sign in
Tagged articles
600 articles
Page 4 of 6
Liangxu Linux
Liangxu Linux
Jun 25, 2022 · Information Security

Master Wireshark: Advanced Packet Filtering, Timing, and Decoding Techniques

This guide walks through Wireshark's powerful features—including precise packet filtering, custom time display formats, absolute sequence number handling, exporting filtered captures, packet count statistics, decoding logs, TCP stream tracking, and manufacturer identification—to help engineers troubleshoot and analyze network traffic efficiently.

TCPWiresharknetwork troubleshooting
0 likes · 6 min read
Master Wireshark: Advanced Packet Filtering, Timing, and Decoding Techniques
Open Source Linux
Open Source Linux
Jun 24, 2022 · Fundamentals

Why TCP Matters: A Deep Dive into Transport Layer Fundamentals

This article explains the essential concepts of TCP and UDP, covering the OSI layers, physical and data‑link networking, IP addressing, transport‑layer mechanisms such as sliding windows, congestion control, reliable transmission, connection establishment and termination, and compares the strengths and weaknesses of TCP versus UDP.

NetworkingReliabilityTCP
0 likes · 28 min read
Why TCP Matters: A Deep Dive into Transport Layer Fundamentals
Efficient Ops
Efficient Ops
Jun 13, 2022 · Fundamentals

Unveiling TCP: How Reliable Transport Works and Why It Matters

This comprehensive guide walks through the fundamentals of computer networking, detailing the OSI layers, the inner workings of TCP and UDP, reliable transmission techniques such as stop‑and‑wait, sliding windows, congestion control, connection setup and teardown, as well as security concerns, performance trade‑offs, and practical use‑case scenarios.

TCPUDPcongestion control
0 likes · 26 min read
Unveiling TCP: How Reliable Transport Works and Why It Matters
IT Architects Alliance
IT Architects Alliance
Jun 12, 2022 · Fundamentals

TCP Three-Way Handshake and Four-Way Termination Explained

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.

Four-way terminationReliabilityTCP
0 likes · 7 min read
TCP Three-Way Handshake and Four-Way Termination Explained
Open Source Linux
Open Source Linux
Jun 9, 2022 · Operations

How to Diagnose and Reduce Linux Network Latency with Ping, Traceroute, and Wireshark

This article explains how to identify the causes of increased network latency on Linux servers using tools such as ping, traceroute, hping3, wrk, tcpdump and Wireshark, demonstrates a practical case with two Nginx containers, analyzes TCP delayed ACK behavior, and provides actionable steps to measure, trace, and mitigate latency.

LinuxNetwork LatencyTCP
0 likes · 16 min read
How to Diagnose and Reduce Linux Network Latency with Ping, Traceroute, and Wireshark
Refining Core Development Skills
Refining Core Development Skills
Jun 6, 2022 · Fundamentals

Why Large File Downloads Still Need Integrity Verification Despite TCP Reliability

Although TCP provides reliable transmission, its guarantees have limits—such as incomplete CRC checks, process crashes before data reaches the transport layer, possible ISP tampering, and kernel‑level ACKs that don’t ensure user‑space receipt—so large downloads must still be validated for full integrity.

DownloadLinuxNetwork Reliability
0 likes · 4 min read
Why Large File Downloads Still Need Integrity Verification Despite TCP Reliability
MaGe Linux Operations
MaGe Linux Operations
May 13, 2022 · Backend Development

Build a Go HTTP Proxy from Scratch: Step-by-Step Guide

This tutorial explains proxy fundamentals, compares forward and reverse proxies, details HTTP and HTTPS proxy header differences, and provides a complete, runnable Go implementation that listens on port 8080 and transparently forwards client requests to target servers.

BackendCode ExampleGo
0 likes · 9 min read
Build a Go HTTP Proxy from Scratch: Step-by-Step Guide
IT Services Circle
IT Services Circle
May 10, 2022 · Fundamentals

The Drawbacks of TCP: Upgrade Difficulty, Connection Latency, Head‑of‑Line Blocking, and Migration Overhead

This article examines the inherent shortcomings of the TCP protocol, including the difficulty of upgrading the stack, the latency introduced by its three‑way handshake and TLS, head‑of‑line blocking caused by packet loss, and the high cost of connection migration when network conditions change.

LatencyNetwork ProtocolsQUIC
0 likes · 10 min read
The Drawbacks of TCP: Upgrade Difficulty, Connection Latency, Head‑of‑Line Blocking, and Migration Overhead
Coolpad Technology Team
Coolpad Technology Team
May 9, 2022 · Fundamentals

Understanding TCP BBR Congestion Control and Bufferbloat

This article explains the design and operation of TCP BBR (Bottleneck Bandwidth and Round‑trip propagation time), its relationship to bufferbloat, the shortcomings of loss‑based congestion algorithms, and details the BBR phases, gain cycle, source code, advantages, disadvantages, and practical considerations for network engineers.

BBRBufferbloatTCP
0 likes · 21 min read
Understanding TCP BBR Congestion Control and Bufferbloat
Architecture Digest
Architecture Digest
May 6, 2022 · Fundamentals

Understanding Port Listening with Python Socket Examples

This article uses a conversational story to explain what it means to listen on a network port, covering TCP vs UDP, binding to specific IPs, reuse‑port options, IPv4 and IPv6 differences, and demonstrates the concepts with multiple Python socket code snippets.

IPv4IPv6Python
0 likes · 13 min read
Understanding Port Listening with Python Socket Examples
Open Source Linux
Open Source Linux
Apr 26, 2022 · Fundamentals

What Happens When You Hit Enter on a URL? Deep Dive into DNS, TCP, HTTP

When you type a URL and press Enter, the browser performs a series of steps—including URL parsing, DNS resolution across multiple caches, TCP three‑way handshake, HTTP request construction, server processing, and response handling—each involving specific protocols and layers that together deliver the requested web page.

DNSHTTPTCP
0 likes · 9 min read
What Happens When You Hit Enter on a URL? Deep Dive into DNS, TCP, HTTP
Liangxu Linux
Liangxu Linux
Apr 25, 2022 · Operations

How to Diagnose and Reduce Linux Network Latency with hping3, wrk, and Wireshark

This article explains how to identify the root causes of increased network latency on Linux servers—covering basic concepts of RTT and application latency, using tools such as ping, traceroute, hping3, wrk, tcpdump, and Wireshark, and demonstrates a practical case with Nginx containers to analyze and mitigate delays.

Network LatencyTCPWireshark
0 likes · 14 min read
How to Diagnose and Reduce Linux Network Latency with hping3, wrk, and Wireshark
Open Source Linux
Open Source Linux
Apr 25, 2022 · Backend Development

Master TCP/UDP, Sockets & Connection Pools in Node.js – From Basics to Advanced

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 DevelopmentConnection PoolNode.js
0 likes · 39 min read
Master TCP/UDP, Sockets & Connection Pools in Node.js – From Basics to Advanced
Liangxu Linux
Liangxu Linux
Apr 7, 2022 · Fundamentals

How Do Sockets Work? A Deep Dive into TCP/UDP Connection Lifecycle

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
How Do Sockets Work? A Deep Dive into TCP/UDP Connection Lifecycle
Open Source Linux
Open Source Linux
Apr 7, 2022 · Fundamentals

Why Does TCP Require a Three‑Way Handshake and a Four‑Way Teardown?

This article explains how TCP guarantees reliable transmission through a three‑way handshake for connection establishment and a four‑step termination process, detailing each packet’s flags, sequence numbers, and the reasons why these multi‑step procedures are essential for robust network communication.

Four-way terminationTCPThree-way handshake
0 likes · 7 min read
Why Does TCP Require a Three‑Way Handshake and a Four‑Way Teardown?
Efficient Ops
Efficient Ops
Apr 6, 2022 · Operations

How Many TCP Connections Can One Server Really Handle? A Deep Dive

This article demystifies the common confusion about a server’s maximum concurrent TCP connections, explaining the theoretical limits of the TCP four‑tuple, Linux file‑descriptor restrictions, kernel buffer settings, and demonstrates achieving one million active connections through careful configuration and tuning.

Server TuningTCPconcurrency
0 likes · 7 min read
How Many TCP Connections Can One Server Really Handle? A Deep Dive
IT Services Circle
IT Services Circle
Mar 12, 2022 · Fundamentals

Comprehensive Guide to TCP: Header Structure, Handshakes, Connection Management, and Socket Programming

This article provides an in‑depth tutorial on TCP, covering its header structure, three‑way handshake, reasons for three handshakes, four‑way termination, TIME_WAIT, SYN attacks, Linux kernel parameters, and practical socket programming examples, all illustrated with diagrams and code snippets.

Connection ManagementHandshakeNetworking
0 likes · 43 min read
Comprehensive Guide to TCP: Header Structure, Handshakes, Connection Management, and Socket Programming
IT Services Circle
IT Services Circle
Mar 9, 2022 · Fundamentals

A Curated Collection of Visualization Websites for Algorithms, Data Structures, MESI Protocol, and TCP Mechanisms

This article compiles a variety of online visualization tools—including algorithm and data‑structure animators, a MESI cache‑coherency simulator, and interactive TCP sliding‑window and flow‑control demos—to help learners intuitively understand core computer‑science concepts through animated models and hands‑on experimentation.

Data StructuresMESI ProtocolTCP
0 likes · 11 min read
A Curated Collection of Visualization Websites for Algorithms, Data Structures, MESI Protocol, and TCP Mechanisms
ELab Team
ELab Team
Feb 21, 2022 · Fundamentals

Why QUIC Beats TCP: Understanding UDP‑Based Transport and Its Benefits

The article examines the limitations of TCP and HTTP/2, explains how Google's UDP‑based QUIC protocol addresses issues such as head‑of‑line blocking, connection migration, and RTT estimation, and compares performance in both good and poor network conditions, highlighting its multiplexing, flow‑control, and security advantages.

HTTP/2Network ProtocolsQUIC
0 likes · 23 min read
Why QUIC Beats TCP: Understanding UDP‑Based Transport and Its Benefits
IT Services Circle
IT Services Circle
Feb 17, 2022 · Operations

Understanding the netstat Command and Its Common Options

This article explains the purpose, output format, and frequently used options of the cross‑platform netstat command, illustrating how to list active TCP/UDP connections, UNIX domain sockets, and various statistics, and notes modern replacements such as ss and ip.

LinuxNetwork MonitoringTCP
0 likes · 7 min read
Understanding the netstat Command and Its Common Options
BaiPing Technology
BaiPing Technology
Feb 14, 2022 · Mobile Development

How to Make Long‑TCP Connections as Simple as Short Requests on iOS

This article explains a technique for writing long‑TCP connection business code on mobile devices that is as efficient and concise as short‑link code, using request_id mapping, protobuf messages, and a lightweight SendCore layer with timeout handling.

Mobile NetworkingObjective‑CRequest ID
0 likes · 10 min read
How to Make Long‑TCP Connections as Simple as Short Requests on iOS
IT Services Circle
IT Services Circle
Feb 13, 2022 · Fundamentals

Does a TCP Connection Persist After Unplugging the Network Cable?

Unplugging a network cable does not immediately terminate a TCP connection; the kernel’s socket state remains ESTABLISHED, and the connection’s fate depends on data transmission, retransmission limits, TCP keepalive settings, and whether either side detects a failure.

KeepaliveLinuxSocket
0 likes · 10 min read
Does a TCP Connection Persist After Unplugging the Network Cable?
Sanyou's Java Diary
Sanyou's Java Diary
Feb 11, 2022 · Fundamentals

Mastering TCP: Sliding Window, Flow & Congestion Control Explained

This article continues the previous discussion on TCP handshakes and termination, then thoroughly explains nine essential TCP mechanisms—including sliding window, flow control, congestion control, delayed and piggyback ACKs, sticky packet handling, and keep‑alive—illustrated with diagrams and practical examples.

Flow ControlNetwork ProtocolsReliability
0 likes · 15 min read
Mastering TCP: Sliding Window, Flow & Congestion Control Explained
vivo Internet Technology
vivo Internet Technology
Jan 12, 2022 · Backend Development

Vivo Push Notification Platform: Architecture Evolution and Engineering Practices

The article details Vivo’s push notification platform, describing its evolution from cloud‑based beginnings to a self‑built, three‑region architecture that supports over 1 million concurrent connections, billions of daily messages, and incorporates optimizations such as adaptive heartbeats, advanced load‑balancing, distributed caching, multi‑layer rate limiting, circuit‑breaker mechanisms, and comprehensive content security.

Push NotificationSystem ArchitectureTCP
0 likes · 16 min read
Vivo Push Notification Platform: Architecture Evolution and Engineering Practices
NiuNiu MaTe
NiuNiu MaTe
Jan 8, 2022 · Fundamentals

Why TCP Can Close Connections in 2, 3, or 4 Handshakes – Hidden Mechanics Explained

This article explores TCP’s connection termination process, detailing the classic four‑way handshake, scenarios that reduce it to three or two handshakes, the concept of self‑connections, simultaneous opens, and practical implications for developers, including code examples and troubleshooting tips.

Connection terminationHandshakeSocket
0 likes · 23 min read
Why TCP Can Close Connections in 2, 3, or 4 Handshakes – Hidden Mechanics Explained
NiuNiu MaTe
NiuNiu MaTe
Jan 2, 2022 · Fundamentals

Why Receiving a TCP RST Doesn’t Always Close the Connection

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 kernelRSTSecurity
0 likes · 15 min read
Why Receiving a TCP RST Doesn’t Always Close the Connection
Refining Core Development Skills
Refining Core Development Skills
Dec 14, 2021 · Fundamentals

Why Practice and Implementation Matter in Learning Computer Networks

The article argues that both hands‑on practice and deep understanding of network implementations are essential for computer‑science students and engineers, illustrating the gap with theory‑only learning, presenting the pyramid learning model, recommending Linux tools, coding exercises, and detailed studies of TCP, epoll, and I/O performance.

LinuxPracticeTCP
0 likes · 13 min read
Why Practice and Implementation Matter in Learning Computer Networks
Programmer DD
Programmer DD
Dec 8, 2021 · Fundamentals

Why HTTP/3 Matters: From TCP’s Limits to QUIC’s Revolution

This article traces the evolution of HTTP from its early TCP‑based origins through HTTP/1.0, 1.1, SPDY, HTTP/2, and finally to HTTP/3, explaining how QUIC over UDP addresses latency, head‑of‑line blocking, and security challenges of previous versions.

HTTPNetworkingQUIC
0 likes · 13 min read
Why HTTP/3 Matters: From TCP’s Limits to QUIC’s Revolution
Efficient Ops
Efficient Ops
Dec 5, 2021 · Backend Development

How I Boosted a Python Service to 50k QPS: Real‑World Performance Tuning Steps

This article details a step‑by‑step performance optimization of a Python backend service, covering requirement analysis, architecture redesign with caching and Redis queues, load‑testing results, TCP TIME_WAIT issues, and kernel parameter tweaks that ultimately raised throughput to 50,000 QPS with zero errors.

LinuxLoad TestingPerformance Optimization
0 likes · 9 min read
How I Boosted a Python Service to 50k QPS: Real‑World Performance Tuning Steps
JavaEdge
JavaEdge
Dec 5, 2021 · Fundamentals

Understanding TCP: OSI Layers, Header Fields, Handshakes and Common Issues

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 ManagementHandshakeTCP
0 likes · 22 min read
Understanding TCP: OSI Layers, Header Fields, Handshakes and Common Issues
QQ Music Frontend Team
QQ Music Frontend Team
Nov 21, 2021 · Fundamentals

Why QUIC Is the Future of Web Protocols: From HTTP/1.1 to HTTP/3

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.

QUICTCPUDP
0 likes · 17 min read
Why QUIC Is the Future of Web Protocols: From HTTP/1.1 to HTTP/3
Liangxu Linux
Liangxu Linux
Nov 1, 2021 · Backend Development

How Linux Sends Network Packets: From send() to the NIC Explained

This article walks through the complete Linux kernel path for sending a network packet, covering the send() system call, TCP processing, IP routing, queueing, driver interaction, DMA mapping, and the role of hard and soft interrupts, while answering common performance questions.

InterruptsTCPdriver
0 likes · 31 min read
How Linux Sends Network Packets: From send() to the NIC Explained
Su San Talks Tech
Su San Talks Tech
Oct 18, 2021 · Backend Development

Demystifying Socket I/O: From Creation to Blocking in TCP Communication

This article explains the fundamentals of I/O, details how sockets are created, bound, listened to, and accepted, describes the client-side connect process, and clarifies why read, write, accept, and connect operations can block, laying the groundwork for deeper Netty studies.

Backend DevelopmentBlockingNetty
0 likes · 10 min read
Demystifying Socket I/O: From Creation to Blocking in TCP Communication
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Oct 12, 2021 · Backend Development

Backend Interview Questions and Answers: HTTP, HTTPS, TCP, Virtual Memory, Eureka, Hystrix, Zookeeper, and Longest Substring Algorithm

This article compiles a series of backend interview questions covering HTTP header fields, HTTPS handshake, TCP connection states, virtual and physical memory concepts, TCP connection limits, Eureka architecture and consistency, Hystrix fault‑tolerance mechanisms, Zookeeper's Zab protocol and leader election, and provides a Java solution for finding the longest substring without repeating characters.

HTTPSTCPalgorithm
0 likes · 19 min read
Backend Interview Questions and Answers: HTTP, HTTPS, TCP, Virtual Memory, Eureka, Hystrix, Zookeeper, and Longest Substring Algorithm
Efficient Ops
Efficient Ops
Oct 10, 2021 · Fundamentals

Why BGP Matters: From Basics to Cloud Routing Explained

This article introduces the Border Gateway Protocol (BGP), explains its role as the core decentralized routing protocol of the Internet, compares it with IGP and EGP, describes why and when BGP is needed in cloud environments, and details its TCP‑based operation, message types, and path‑vector mechanics.

BGPTCPcloud networking
0 likes · 12 min read
Why BGP Matters: From Basics to Cloud Routing Explained
NiuNiu MaTe
NiuNiu MaTe
Oct 4, 2021 · Fundamentals

Master the Basics: 19 Essential TCP/IP and HTTP Interview Questions Explained

This comprehensive guide answers 19 core networking interview questions, covering the TCP/IP five‑layer model, HTTP fundamentals, GET vs POST, ping, status codes, differences among HTTP/1.0, 1.1, 2, 3, HTTPS, TCP connection handshake and teardown, sliding windows, flow control, half‑ and full‑connection queues, packet framing, and the browser request lifecycle.

HTTPHTTP2HTTPS
0 likes · 23 min read
Master the Basics: 19 Essential TCP/IP and HTTP Interview Questions Explained
Wukong Talks Architecture
Wukong Talks Architecture
Sep 30, 2021 · Fundamentals

Computer Network Fundamentals: OSI/TCP‑IP Layers, TCP/UDP Differences, Handshakes, and Related Mechanisms

This article provides a comprehensive overview of computer networking fundamentals, covering OSI and TCP/IP layer models, the functions of each layer, detailed comparisons between TCP and UDP, the three‑way handshake, four‑way termination, SYN‑flood attacks, congestion control, and practical mitigation techniques.

Four-way terminationNetwork ProtocolsSYN Flood
0 likes · 21 min read
Computer Network Fundamentals: OSI/TCP‑IP Layers, TCP/UDP Differences, Handshakes, and Related Mechanisms
MaGe Linux Operations
MaGe Linux Operations
Sep 28, 2021 · Operations

Why Do TIME_WAIT Connections Accumulate and How to Fix Them?

The article explains why massive TIME_WAIT TCP connections appear during high‑concurrency scenarios, their impact on server ports and new connections, and provides practical analysis and solutions such as keep‑alive headers, socket reuse, and reducing the TIME_WAIT duration.

TCPTIME-WAITnetwork
0 likes · 9 min read
Why Do TIME_WAIT Connections Accumulate and How to Fix Them?
Selected Java Interview Questions
Selected Java Interview Questions
Sep 21, 2021 · Backend Development

Performance Optimization of a High‑Concurrency Web Service: From Bottleneck Identification to TCP Time‑Wait Tuning

This article documents a step‑by‑step performance optimization of a high‑traffic web module, covering requirement analysis, bottleneck detection in database and TCP connections, cache integration, load‑testing results, Linux kernel parameter tuning, and the final achievement of 50k QPS with sub‑60 ms latency.

Load TestingTCPcaching
0 likes · 8 min read
Performance Optimization of a High‑Concurrency Web Service: From Bottleneck Identification to TCP Time‑Wait Tuning
Big Data Technology & Architecture
Big Data Technology & Architecture
Sep 2, 2021 · Big Data

Understanding Network Flow Control and Flink's Backpressure Mechanisms

This article explains the concepts and background of network flow control, compares static rate limiting with dynamic feedback backpressure, describes TCP's sliding‑window mechanism, and details how Flink implements both TCP‑based and credit‑based backpressure to handle mismatched upstream‑downstream speeds in streaming applications.

Credit-basedFlinkNetwork Flow Control
0 likes · 16 min read
Understanding Network Flow Control and Flink's Backpressure Mechanisms
Liangxu Linux
Liangxu Linux
Aug 29, 2021 · Operations

Boosting a Python Service to 50k QPS: My Step‑by‑Step Performance Tuning

Through a detailed case study, the author documents the process of optimizing a Python‑based web module—identifying bottlenecks, redesigning architecture with Redis queues, tuning MySQL, adjusting Linux TCP settings, and iteratively load‑testing until achieving 50,000 QPS with sub‑70 ms latency and zero errors.

BackendOperationsPython
0 likes · 9 min read
Boosting a Python Service to 50k QPS: My Step‑by‑Step Performance Tuning
Senior Brother's Insights
Senior Brother's Insights
Aug 24, 2021 · Fundamentals

How Many HTTP Requests Can a Single TCP Connection Handle?

An in‑depth look at the relationship between TCP and HTTP explains how many HTTP requests a single TCP connection can carry, covering keep‑alive, HTTP/1.0 vs 1.1 behavior, pipelining, HTTP/2 multiplexing, browser connection limits, and practical keep‑alive trade‑offs.

HTTPHTTP/2Keep-Alive
0 likes · 7 min read
How Many HTTP Requests Can a Single TCP Connection Handle?
Wukong Talks Architecture
Wukong Talks Architecture
Aug 7, 2021 · Fundamentals

50 Common Computer Network Interview Questions and Answers

An extensive compilation of 50 essential computer networking interview questions covering HTTP status codes, request methods, network architecture, DNS resolution, TCP/UDP protocols, security concepts like CSRF and XSS, and detailed explanations of TCP handshakes, congestion control, and encryption mechanisms.

Computer NetworksHTTPProtocols
0 likes · 51 min read
50 Common Computer Network Interview Questions and Answers
Ops Development Stories
Ops Development Stories
Aug 4, 2021 · Operations

Mastering TCP Handshakes, Queues, and Linux Tuning for High‑Performance Servers

This article explains TCP’s connection establishment and termination processes, details the roles of half‑ and full‑connection queues in Linux, demonstrates how to simulate and detect queue overflows using tools like netstat, ss, hping3 and ab, and provides kernel tuning parameters to mitigate SYN flood and TIME_WAIT issues.

LinuxNetworkingQueue
0 likes · 23 min read
Mastering TCP Handshakes, Queues, and Linux Tuning for High‑Performance Servers
Refining Core Development Skills
Refining Core Development Skills
Jul 22, 2021 · Backend Development

Deep Dive into the TCP Three‑Way Handshake: Kernel Queues, Syncookies and Code Walkthrough

This article explains the complete kernel‑level implementation of the TCP three‑way handshake, covering server listen queue allocation, client connect state handling, SYN/SYN‑ACK processing, syncookie protection, timer management, socket creation, and the accept path, with detailed code examples.

BackendLinuxNetworking
0 likes · 16 min read
Deep Dive into the TCP Three‑Way Handshake: Kernel Queues, Syncookies and Code Walkthrough
Efficient Ops
Efficient Ops
Jul 6, 2021 · Operations

Mastering TCP TIME-WAIT: When to Optimize and How

This article explains the purpose of the TCP TIME-WAIT state, the scenarios it protects against, common misconceptions, and practical Linux kernel tweaks—such as fast recycle, socket reuse, and tw_buckets settings—to manage TIME-WAIT efficiently on high‑concurrency servers.

LinuxTCPTIME-WAIT
0 likes · 8 min read
Mastering TCP TIME-WAIT: When to Optimize and How
Refining Core Development Skills
Refining Core Development Skills
Jun 17, 2021 · Fundamentals

How Linux Determines the Client Port for TCP Connections

On Linux, the client port used in a TCP connection is selected either by the kernel during the connect system call—randomly scanning the ip_local_port_range while respecting reserved ports—or by a prior bind call, with detailed kernel functions such as inet_hash_connect and __inet_hash_connect governing the process.

LinuxNetworkingPort Selection
0 likes · 21 min read
How Linux Determines the Client Port for TCP Connections
Senior Brother's Insights
Senior Brother's Insights
Jun 10, 2021 · Fundamentals

Demystifying Network Layers: From Physical to Application

This article provides a clear, step‑by‑step explanation of network layering, covering the purpose and function of each layer—from the physical medium up to the application protocols—while illustrating concepts with diagrams and practical examples.

ARPApplication LayerIP addressing
0 likes · 14 min read
Demystifying Network Layers: From Physical to Application
Byte Quality Assurance Team
Byte Quality Assurance Team
Jun 2, 2021 · Fundamentals

Evolution of HTTP: From 0.9 to HTTP/3 and QUIC

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.

HTTPQUICTCP
0 likes · 8 min read
Evolution of HTTP: From 0.9 to HTTP/3 and QUIC
Efficient Ops
Efficient Ops
May 26, 2021 · Fundamentals

From SPDY to QUIC: How Google’s Innovations Reshaped Web Protocols

This article reviews Google’s pioneering SPDY protocol, its key features and impact on HTTP/2, then explores the disruptive QUIC protocol built on UDP, detailing its connection setup, Diffie‑Hellman encryption, multiplexing, connection migration, and other enhancements that boost web performance.

Diffie-HellmanHTTP/2QUIC
0 likes · 12 min read
From SPDY to QUIC: How Google’s Innovations Reshaped Web Protocols
Programmer DD
Programmer DD
May 26, 2021 · Fundamentals

Why Does TCP Keep Connections in TIME_WAIT? Uncovering the Hidden Bottleneck

This article explains the purpose of the TCP TIME_WAIT state, how it prevents packet loss and connection errors, examines its duration based on the Maximum Segment Lifetime, and analyzes why high‑QPS load testing tools like ab may appear to bypass TIME_WAIT, revealing the impact on server resources.

LinuxPerformance TestingSocket
0 likes · 8 min read
Why Does TCP Keep Connections in TIME_WAIT? Uncovering the Hidden Bottleneck
Tencent IMWeb Frontend Team
Tencent IMWeb Frontend Team
May 25, 2021 · Backend Development

How to Ensure Reliable Push Messaging in Live Online Classrooms

This article examines the challenges of message loss in live‑streamed online classrooms, analyzes why pushes can fail, and proposes a comprehensive reliability strategy—including TCP fundamentals, multi‑channel redundancy, sequence‑based ordering, hole‑pulling, and configurable back‑end mechanisms—to achieve near‑100% delivery.

Distributed SystemsMessage ReliabilityTCP
0 likes · 19 min read
How to Ensure Reliable Push Messaging in Live Online Classrooms
Liangxu Linux
Liangxu Linux
May 16, 2021 · Fundamentals

Mastering TCP: Handshakes, Teardowns, and State Machines Explained

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.

HandshakeNetworkingTCP
0 likes · 18 min read
Mastering TCP: Handshakes, Teardowns, and State Machines Explained
ITPUB
ITPUB
May 13, 2021 · Fundamentals

Unveiling Linux’s Network Send Path: From send() to the Wire

This article provides a deep, step‑by‑step analysis of how Linux 3.10 processes a send() call—from user‑space socket handling through TCP, IP routing, queueing, driver DMA mapping, and both hard and soft interrupt handling—answering why CPU time appears in sy/si, why NET_RX softirqs dominate, and what memory copies occur during transmission.

DMALinuxNetwork Stack
0 likes · 32 min read
Unveiling Linux’s Network Send Path: From send() to the Wire
Alibaba Cloud Native
Alibaba Cloud Native
May 3, 2021 · Backend Development

Why Dubbo Fails Under C10K Load and How to Fix It

This article details a large‑scale C10K performance test of Dubbo, analyzes why service calls time out under thousands of concurrent consumers, identifies heartbeat‑induced Netty thread saturation and TCP full‑connection‑queue overflow as root causes, and presents concrete optimizations that dramatically improve latency and stability.

Backend PerformanceC10KDubbo
0 likes · 13 min read
Why Dubbo Fails Under C10K Load and How to Fix It
ITPUB
ITPUB
Apr 21, 2021 · Fundamentals

Understanding TCP: From Three‑Way Handshake to Four‑Way Teardown and State Transitions

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 ManagementFour-way terminationTCP
0 likes · 19 min read
Understanding TCP: From Three‑Way Handshake to Four‑Way Teardown and State Transitions
Architect's Journey
Architect's Journey
Apr 15, 2021 · Operations

What Seven Days of Testing Reveal About TCP Memory Overhead

After a week-long series of experiments measuring TCP connections in various states—including ESTABLISH, client‑to‑server, server‑to‑client, and non‑ESTABLISH scenarios—the author quantifies per‑connection memory usage and shows how modern kernels reclaim buffers and reduce overhead, especially for TIME_WAIT.

LinuxTCPkernel
0 likes · 4 min read
What Seven Days of Testing Reveal About TCP Memory Overhead
37 Mobile Game Tech Team
37 Mobile Game Tech Team
Apr 8, 2021 · Fundamentals

Why Does HTTP Need Three Handshakes? A Deep Dive into HTTP Versions and Performance

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.

TCPWebperformance
0 likes · 13 min read
Why Does HTTP Need Three Handshakes? A Deep Dive into HTTP Versions and Performance
Laravel Tech Community
Laravel Tech Community
Mar 28, 2021 · Backend Development

v0.0.7 Update: Adding Keepalive Timeout to TCP RPC Server

Version v0.0.7 introduces a configurable keepalive timeout for the TCP RPC server, automatically closing idle client connections after a set period, reducing resource usage and preventing memory leaks while allowing the client to transparently reconnect when needed.

KeepaliveRPCServer
0 likes · 3 min read
v0.0.7 Update: Adding Keepalive Timeout to TCP RPC Server
MaGe Linux Operations
MaGe Linux Operations
Mar 22, 2021 · Fundamentals

Decoding HTTP Requests with Wireshark: Handshake, TCP Options, and Keep‑Alive Explained

This tutorial walks through capturing and analyzing an HTTP request using Wireshark, detailing the environment setup, three‑way TCP handshake, key TCP header fields such as window scaling and SACK, the four‑step termination (including merged ACK/FIN), and the role of HTTP Keep‑Alive across different protocol versions.

Keep-AliveTCPThree-way handshake
0 likes · 12 min read
Decoding HTTP Requests with Wireshark: Handshake, TCP Options, and Keep‑Alive Explained
Refining Core Development Skills
Refining Core Development Skills
Feb 24, 2021 · Backend Development

Achieving One Million TCP Connections: Theory, Kernel Tuning, and Practical Implementation in C/Java/PHP

This article explains TCP concurrency theory, details two experimental approaches for reaching one million simultaneous connections using multi‑IP or multi‑port strategies, and provides step‑by‑step kernel tuning, source code, and validation commands for C, Java, and PHP implementations.

JavaKernel TuningTCP
0 likes · 16 min read
Achieving One Million TCP Connections: Theory, Kernel Tuning, and Practical Implementation in C/Java/PHP
Code Ape Tech Column
Code Ape Tech Column
Feb 2, 2021 · Backend Development

Implementing Heartbeat and Reconnection Mechanisms with Netty in Java

This article explains the concept of TCP heartbeat, demonstrates how to use Netty's IdleStateHandler to implement client‑server heartbeat detection, and provides a complete Java example with reconnection logic, retry policies, and detailed code snippets for building a robust long‑connection service.

HeartbeatJavaNetty
0 likes · 18 min read
Implementing Heartbeat and Reconnection Mechanisms with Netty in Java
Top Architect
Top Architect
Feb 1, 2021 · Backend Development

Implementing Heartbeat Mechanism and Reconnection Logic with Netty

This article explains how to implement a TCP heartbeat mechanism using Netty's IdleStateHandler, details client and server handler implementations, and demonstrates a robust reconnection strategy with customizable retry policies, providing complete Java code examples for each component.

HeartbeatNetworkingTCP
0 likes · 19 min read
Implementing Heartbeat Mechanism and Reconnection Logic with Netty
Code Ape Tech Column
Code Ape Tech Column
Jan 25, 2021 · Fundamentals

Mastering TCP: Handshake, Flow Control, Congestion Control and More

This comprehensive guide explains TCP fundamentals—including the differences between TCP and UDP, the three‑way handshake, four‑way termination, half‑open queues, SYN‑Flood attacks, header fields, Fast Open, timestamps, retransmission timeout calculation, flow and congestion control, Nagle's algorithm, delayed ACKs, and keep‑alive mechanisms—providing clear examples and diagrams for each concept.

Flow ControlHandshakeNetworking
0 likes · 29 min read
Mastering TCP: Handshake, Flow Control, Congestion Control and More
Architecture Digest
Architecture Digest
Jan 23, 2021 · Fundamentals

Understanding Linux TCP Socket Implementation and System Tuning

This article explains how Linux manages TCP sockets at the kernel level, demonstrates how to adjust port ranges and file‑descriptor limits, and shows the key data structures and lookup functions that enable high‑concurrency TCP connections, providing practical guidance for scaling client connections.

Linux kernelNetworkingPort Range
0 likes · 8 min read
Understanding Linux TCP Socket Implementation and System Tuning
Programmer DD
Programmer DD
Jan 18, 2021 · Fundamentals

Why HTTP/3 Is the Next Leap for the Web: From TCP to QUIC

This article traces the evolution of the HTTP protocol from its early days through HTTP/1.0, 1.1, SPDY, HTTP/2, and finally to HTTP/3, explaining how QUIC over UDP addresses TCP's latency and security limitations while also highlighting remaining challenges.

HTTP/3QUICTCP
0 likes · 15 min read
Why HTTP/3 Is the Next Leap for the Web: From TCP to QUIC
Liangxu Linux
Liangxu Linux
Jan 17, 2021 · Fundamentals

Understanding TCP: Handshakes, Flow & Congestion Control Explained

This article provides a comprehensive overview of TCP fundamentals, comparing it with UDP, detailing the three‑way handshake and four‑way termination, explaining SYN flood attacks, describing the TCP header fields, fast open, timestamps, retransmission timeout calculations, flow and congestion control mechanisms, as well as Nagle's algorithm, delayed ACKs, and keep‑alive behavior.

Flow ControlHandshakeTCP
0 likes · 29 min read
Understanding TCP: Handshakes, Flow & Congestion Control Explained
Python Crawling & Data Mining
Python Crawling & Data Mining
Jan 17, 2021 · Fundamentals

Mastering TCP: Handshakes, Packet Structure, and Real‑World Wireshark Analysis

This article provides a comprehensive guide to TCP, covering its definition, connection-oriented nature, reliability, byte‑stream model, detailed packet header fields, three‑way handshake, four‑way termination, MTU/MSS concepts, Python simulation scripts, Wireshark capture techniques, common pitfalls, and practical networking programming steps.

HandshakeMSSMTU
0 likes · 29 min read
Mastering TCP: Handshakes, Packet Structure, and Real‑World Wireshark Analysis