Skip to content
Tagged articles

TCP

500 articles · Page 5 of 5
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.

TCPdriverinterrupts
0 likes · 31 min read
How Linux Sends Network Packets: From send() to the NIC Explained
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.

AlgorithmEurekaHTTPS
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.

BGPCloud NetworkingTCP
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.

HTTPHTTPSTCP
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.

SYN FloodTCPUDP
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.

TCPcachingload testing
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.

BackendOptimizationPython
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.

HTTPInterview questionsSecurity
0 likes · 51 min read
50 Common Computer Network Interview Questions and Answers
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.

LinuxPerformance TuningTCP
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.

LinuxPort SelectionTCP
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.

LinuxSocketTCP
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.

TCPTCP/IPconnection
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.

DMALinuxTCP
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 ManagementTCPfour-way termination
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.

RPCTCPkeepalive
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-AliveTCPWireshark
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.

BenchmarkJavaTCP
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.

JavaNettyTCP
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.

TCPheartbeatnetworking
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.

RTOSYN FloodTCP
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 kernelPort RangeSocket
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.

TCPcongestion controlflow control
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.

MSSMTUTCP
0 likes · 29 min read
Mastering TCP: Handshakes, Packet Structure, and Real‑World Wireshark Analysis
Open Source Linux
Open Source Linux
Jan 6, 2021 · Operations

Boost Nginx Performance: Essential Linux System Parameter Tweaks

This guide explains how to optimize Linux kernel parameters and Nginx settings—such as file descriptor limits, TCP queue lengths, temporary ports, worker processes, KeepAlive, and log buffering—to significantly improve server performance and handle high traffic loads.

LinuxNginxPerformance Tuning
0 likes · 8 min read
Boost Nginx Performance: Essential Linux System Parameter Tweaks
Architecture Digest
Architecture Digest
Jan 3, 2021 · Operations

Understanding How Many Concurrent TCP Connections a Server Can Actually Support

This article explains the true limits of concurrent TCP connections on a server, debunks common misconceptions about port numbers, details the TCP four‑tuple theory, outlines Linux file‑descriptor restrictions, shows how to tune kernel buffers with sysctl, and shares a real‑world test achieving one million active connections.

ConcurrencyLinuxTCP
0 likes · 6 min read
Understanding How Many Concurrent TCP Connections a Server Can Actually Support
ITPUB
ITPUB
Dec 31, 2020 · Operations

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

This article demystifies common misconceptions about server concurrency, explains the theoretical maximum TCP connections based on the four‑tuple, details Linux file‑descriptor and buffer limits, and walks through a practical experiment that achieves over one million simultaneous connections on a single machine.

ConcurrencyLinuxTCP
0 likes · 7 min read
How Many TCP Connections Can One Server Really Handle? A Deep Dive into Linux Limits
Open Source Linux
Open Source Linux
Dec 29, 2020 · Fundamentals

Mastering TCP: Handshakes, Flow & Congestion Control, Fast Open and More

This comprehensive guide explains TCP vs UDP, the three‑way handshake, four‑way termination, half‑open queues, SYN‑Flood attacks, header fields, timestamps, Fast Open, retransmission timeout calculations, flow control, congestion control, Nagle’s algorithm, delayed ACKs and keep‑alive mechanisms, providing essential knowledge for networking interviews and system design.

SecurityTCPcongestion control
0 likes · 35 min read
Mastering TCP: Handshakes, Flow & Congestion Control, Fast Open and More
Refining Core Development Skills
Refining Core Development Skills
Dec 23, 2020 · Fundamentals

Understanding Linux TCP Socket Internals and Port Range Configuration

This article explains how to adjust Linux kernel port ranges and file descriptor limits, explores the internal structures of TCP sockets, and walks through key kernel functions such as tcp_v4_rcv and __inet_lookup that locate sockets based on IP and port tuples, providing practical guidance for increasing TCP concurrency.

ConcurrencyLinux kernelPort Range
0 likes · 8 min read
Understanding Linux TCP Socket Internals and Port Range Configuration
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Dec 21, 2020 · Fundamentals

Illustrated Overview of TCP Protocol

This article presents an illustrated comic that explains the basic principles of the TCP protocol, highlighting its connection-oriented reliable transmission, congestion and flow control mechanisms, while noting that some details are simplified and encouraging readers to consult formal RFCs and the TCP/IP Illustrated volume for deeper study.

IllustratedTCPfundamentals
0 likes · 5 min read
Illustrated Overview of TCP Protocol
Liangxu Linux
Liangxu Linux
Dec 14, 2020 · Backend Development

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

This article explains the true limits of simultaneous TCP connections on a single Linux server, debunking common myths about the 65,535 port ceiling, detailing kernel and user‑level file‑descriptor restrictions, sysctl buffer settings, and a practical experiment achieving one million concurrent connections.

LinuxNetwork ConnectionsTCP
0 likes · 7 min read
How Many TCP Connections Can One Server Really Handle? A Deep Dive
Efficient Ops
Efficient Ops
Dec 13, 2020 · Fundamentals

How SPDY Paved the Way for QUIC: From HTTP/1.1 to the Future of Web Transport

This article reviews the evolution of web communication protocols, detailing SPDY's pioneering features that influenced HTTP/2 and exploring QUIC's disruptive UDP‑based design, security mechanisms, multiplexing, connection migration, and other enhancements that reshape modern internet performance.

HTTP/2QUICSPDY
0 likes · 12 min read
How SPDY Paved the Way for QUIC: From HTTP/1.1 to the Future of Web Transport
JavaEdge
JavaEdge
Dec 12, 2020 · Backend Development

Why Does TCP Have Sticky and Half Packets? Causes and Effective Solutions

This article explains why TCP experiences sticky and half packets, analyzes the underlying causes such as buffer size mismatches and MTU limits, and presents practical solutions including short connections, fixed‑length framing, delimiter‑based framing, and length‑field framing, with their advantages and trade‑offs.

NettyTCPnetwork programming
0 likes · 5 min read
Why Does TCP Have Sticky and Half Packets? Causes and Effective Solutions
Java Captain
Java Captain
Dec 10, 2020 · Backend Development

Implementing a Real-Time Network Chatroom in Java Using TCP and Multithreading

This article explains how to build a real‑time network chatroom in Java using TCP sockets, multithreading, and a ConcurrentHashMap to manage user connections, detailing command handling for listing users, group chat, private messages, exiting, and server shutdown, with full source code examples.

ChatroomConcurrentHashMapJava
0 likes · 14 min read
Implementing a Real-Time Network Chatroom in Java Using TCP and Multithreading
Open Source Linux
Open Source Linux
Dec 10, 2020 · Fundamentals

Unraveling TCP: From Handshakes to Congestion Control and Security

This comprehensive guide walks through TCP fundamentals—including its differences from UDP, the three‑way handshake, four‑way termination, half‑open queues, SYN‑Flood attacks, packet header fields, Fast Open, timestamps, RTT/RTO calculations, flow and congestion control, Nagle's algorithm, delayed ACKs, and keep‑alive mechanisms—providing clear explanations and visual diagrams for each concept.

TCPnetworking
0 likes · 27 min read
Unraveling TCP: From Handshakes to Congestion Control and Security
ITPUB
ITPUB
Dec 8, 2020 · Operations

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

This article demystifies the true maximum number of concurrent TCP connections a single Linux server can sustain, explaining the theoretical limits of the TCP four‑tuple, the practical constraints imposed by file descriptor and memory settings, and walks through a real‑world experiment achieving one million connections.

ConcurrencyLinuxTCP
0 likes · 6 min read
How Many TCP Connections Can One Server Really Handle? A Deep Dive into Linux Limits
Liangxu Linux
Liangxu Linux
Dec 3, 2020 · Fundamentals

Mastering the Transport Layer: TCP, UDP, Sockets, and Port Mechanics

This article explains the role of the transport layer in the OSI model, compares TCP and UDP protocols, describes socket types and their APIs, clarifies port number usage, and details multiplexing, demultiplexing, and UDP packet structure with checksum calculation.

MultiplexingPort NumbersSockets
0 likes · 20 min read
Mastering the Transport Layer: TCP, UDP, Sockets, and Port Mechanics
Wukong Talks Architecture
Wukong Talks Architecture
Dec 3, 2020 · Fundamentals

Explaining UDP vs TCP in Simple Terms

This article uses everyday analogies to compare UDP and TCP, outlines their core characteristics, typical use cases, and describes how to add TCP-like reliability features to UDP such as connection establishment, ordering, loss recovery, flow control, and congestion control.

TCPUDPflow control
0 likes · 7 min read
Explaining UDP vs TCP in Simple Terms
MaGe Linux Operations
MaGe Linux Operations
Dec 2, 2020 · Fundamentals

Why HTTP/3 Matters: From TCP Roots to QUIC’s Future

This article traces the evolution of HTTP from its 1991 origins through HTTP/1.0, 1.1, HTTP/2, and finally HTTP/3, explaining how QUIC over UDP addresses TCP’s latency and security limitations while also highlighting remaining challenges.

HTTP/3QUICTCP
0 likes · 12 min read
Why HTTP/3 Matters: From TCP Roots to QUIC’s Future
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Nov 30, 2020 · Backend Development

Netty Architecture and Principles: An Introductory Tutorial

This tutorial provides a detailed introduction to Netty, covering its architecture, core concepts such as buffers, channels, selectors, reactor thread models, zero‑copy techniques, and includes practical TCP server/client code examples, helping readers understand and apply Netty for high‑performance Java network programming.

Java NIONettyReactor
0 likes · 42 min read
Netty Architecture and Principles: An Introductory Tutorial
ITPUB
ITPUB
Nov 23, 2020 · Fundamentals

Master TCP Handshake & Teardown: Linux TIME_WAIT Tuning Explained

This article explains the TCP three‑way handshake and four‑way termination processes, clarifies the TIME_WAIT state, shows how to inspect socket states with netstat, and provides practical Linux sysctl settings to reduce excessive TIME_WAIT sockets and improve network performance.

LinuxTCPTIME_WAIT
0 likes · 7 min read
Master TCP Handshake & Teardown: Linux TIME_WAIT Tuning Explained
Efficient Ops
Efficient Ops
Nov 11, 2020 · Fundamentals

Why Does TCP Need a Three‑Way Handshake? A Simple Analogy Explained

The article uses a humorous long‑distance video‑chat scenario to illustrate why TCP requires a three‑way handshake for connection establishment and a four‑step termination, explaining each packet exchange, flag meanings, and related concepts such as half‑open connections and SYN‑flood attacks.

SYN attackTCPfour-way termination
0 likes · 11 min read
Why Does TCP Need a Three‑Way Handshake? A Simple Analogy Explained
Architecture Digest
Architecture Digest
Oct 31, 2020 · Fundamentals

Ten Essential TCP/IP Topics Every Engineer Should Know

This article systematically explains the TCP/IP protocol suite, covering the four-layer model, data link, network, transport, and application aspects, and dives into key protocols such as IP, ARP, ICMP, DNS, as well as TCP connection management, flow control, and congestion control mechanisms.

CongestionControlDNSICMP
0 likes · 21 min read
Ten Essential TCP/IP Topics Every Engineer Should Know
Programmer DD
Programmer DD
Oct 30, 2020 · Backend Development

How Dubbo’s Single Long Connection Leads to Congestion and What You Can Do

This article examines a production incident where Dubbo services became congested, explains the underlying communication process with detailed code analysis, identifies key protocol and service parameters affecting performance, conducts experiments on connection count and TCP buffers, and offers practical recommendations to optimize Dubbo throughput.

DubboJavaTCP
0 likes · 26 min read
How Dubbo’s Single Long Connection Leads to Congestion and What You Can Do
Top Architect
Top Architect
Oct 26, 2020 · Fundamentals

Comprehensive Overview of the TCP/IP Model and Core Network Protocols

This article provides a detailed introduction to the TCP/IP model, explaining each layer—from the physical and data link layers up to the application layer—along with key protocols such as IP, ARP, ICMP, TCP, UDP, DNS, and the mechanisms of connection establishment, termination, flow control, and congestion control.

TCPTCP/IPUDP
0 likes · 21 min read
Comprehensive Overview of the TCP/IP Model and Core Network Protocols
Liangxu Linux
Liangxu Linux
Oct 19, 2020 · Information Security

Exploiting Linux’s DelayedACKLost Counter to Infer TCP Sequence Numbers

An imaginative tale reveals how two covert agents exploit the Linux kernel’s DelayedACKLost counter via /proc/net/netstat, using it to infer TCP sequence numbers and perform a side‑channel hijack, while illustrating the underlying delayed ACK mechanism, related kernel functions, and the security implications of this hidden metric.

Delayed ACKLinuxSide-channel
0 likes · 8 min read
Exploiting Linux’s DelayedACKLost Counter to Infer TCP Sequence Numbers
MaGe Linux Operations
MaGe Linux Operations
Sep 23, 2020 · Backend Development

GET vs POST: Uncover the Real Differences Behind HTTP Requests

This article explains the fundamental distinctions between GET and POST HTTP methods, covering how parameters are transmitted, caching behavior, URL length limits, security implications, and the underlying TCP packet flow, while debunking common myths and highlighting practical considerations for developers.

GETHTTPPOST
0 likes · 7 min read
GET vs POST: Uncover the Real Differences Behind HTTP Requests
The Dominant Programmer
The Dominant Programmer
Sep 20, 2020 · Backend Development

Integrating Protobuf with Netty for Java Object Transmission

This guide walks through building a Netty server and client that exchange Java objects using Protobuf serialization, covering .proto definition, code generation with protoc, pipeline configuration with Netty's Protobuf handlers, and full example implementations for both sides.

Code ExampleJavaNetty
0 likes · 8 min read
Integrating Protobuf with Netty for Java Object Transmission
vivo Internet Technology
vivo Internet Technology
Sep 2, 2020 · Fundamentals

Understanding DNS and WebSocket: From Dig Commands to Real‑Time Connections

This article provides a systematic, hands‑on guide to DNS fundamentals—including dig queries, hierarchical lookups, Wireshark packet analysis, traditional DNS drawbacks, and HTTPDNS solutions—followed by a deep dive into WebSocket mechanics, handshake, frame structure, and security considerations, all illustrated with practical examples and code.

DNSHTTPDNSOkHttp
0 likes · 21 min read
Understanding DNS and WebSocket: From Dig Commands to Real‑Time Connections