This guide walks beginners through progressive Linux network programming projects—starting with an Echo server, advancing to a concurrent chatroom, and culminating in a simple HTTP server—to solidify core concepts like TCP handshakes, socket I/O, and protocol handling.
This article reviews seven Python libraries—trio, asyncssh, zeroconf, dpkt, socketify.py, pynetdicom, and mitmproxy—explaining their core features, providing code examples, and showing how each abstracts low‑level networking complexities to enable faster, more reliable network applications.
This article explains the fundamentals of Remote Direct Memory Access (RDMA), its low‑latency, zero‑copy and kernel‑bypass mechanisms, programming interfaces, and real‑world applications in data‑center networks, high‑performance computing, and distributed storage, providing developers with practical guidance and code examples.
This article explains why Go programs often fail to reach C10M concurrency, analyzes five real‑world incidents, reveals the inner workings of Go's netpoller, and provides concrete code‑level optimizations, configuration tweaks, and load‑testing practices to achieve stable million‑connection services.
This article explains the inner workings of Linux's epoll mechanism, detailing how red‑black trees manage registered file descriptors and how a ready‑list delivers events in O(1) time, covering core APIs, data structures, insertion‑deletion logic, and the full kernel‑space to user‑space flow.
This tutorial walks through creating a Go‑based internal file transfer service from scratch, covering custom frame protocol design, Protobuf command handling, zero‑copy sendfile, chunked read/write with resume support, CRC32 integrity checks, and performance‑tuning techniques.
This article explains how PHP's fsockopen() function works, detailing its syntax, parameters, return values, and providing a complete example that demonstrates opening a TCP connection, sending an HTTP request, and handling the response, including notes on SSL usage.
This article introduces the P4 language and explains how a P4‑programmable switch is built, detailing its parser, ingress/egress pipelines, deparser, and the P4Runtime control interface, while highlighting the protocol‑independent, target‑independent, and high‑performance advantages for modern networks.
This article explains the concepts, advantages, limitations, and practical usage of Linux I/O multiplexing mechanisms—select, poll, and epoll—through analogies, detailed explanations, code examples, and common interview questions, helping developers choose the right tool for high‑concurrency network programming.
This article concludes the "From Zero Hand‑write Mini Netty" series, walking through the evolution from a simple single‑thread NIO program to a multi‑threaded, pluggable Mini‑Netty framework with heartbeat, decoding, and responsibility‑chain processing, and outlines future plans for a full‑featured Netty chat application.
This article explains how to design server‑side read/write idle detection and heartbeat mechanisms in a Mini‑Netty framework, covering the theory of heartbeats, idle event handling, a priority‑queue scheduler, and complete starter code with Java NIO examples.
This article explains how to redesign a Java NIO server by introducing a Netty‑style pipeline that separates decoding, logging, authentication, and business handling into independent handlers, improving extensibility, maintainability, and performance while providing complete sample code and initialization steps.
This article explains the root causes of TCP sticky and half‑packet issues, designs a length‑field message protocol and a generic decoder, provides complete Java NIO code for a mini Netty framework, and discusses its startup process and current limitations.
This article explains what network programming is, why it matters beyond HTTP, compares BIO and NIO models, dives into Java NIO's design with selectors, channels, and ByteBuffer methods, provides full server/client code examples, and shows how Netty simplifies high‑performance networking.
This article explains the limitations of traditional I/O models such as blocking I/O, non‑blocking I/O, select and poll, introduces epoll’s design, core data structures, operation modes, system‑call interface, and provides practical code examples and optimisation tips for high‑concurrency network servers.
This article explores Linux’s epoll interface in depth, covering its core architecture, LT and ET trigger modes, underlying red‑black tree and linked‑list data structures, callback workflow, practical code examples, and best‑practice guidelines for high‑concurrency network applications.
This article explains Netty's internal mechanisms for buffering outbound data, flushing it to the network, handling inbound responses with NIO selectors, outlines the overall Netty workflow, and clarifies the roles of Backlog and KeepAlive parameters in TCP connections.
This comprehensive guide explores C++ multithreaded network programming for high‑concurrency servers, covering threads, processes, socket basics, TCP/UDP protocols, thread pools, synchronization primitives, lock‑free structures, I/O multiplexing techniques, and a practical high‑performance chat server implementation.
This article breaks down the interview question "Can TCP and UDP use the same port?" by examining protocol-level port spaces, client‑side TCP and UDP port sharing rules, server‑side TCP reuse with SO_REUSEADDR, and UDP reuse with SO_REUSEPORT, complete with code examples and practical implications.
This article introduces the fundamentals of the HTTP protocol, explains its request and response structures, and provides a comprehensive guide to using Python's requests library for sending GET, POST, PUT, DELETE requests, handling headers, parameters, JSON responses, timeouts, and exceptions.
This article explains the limitations of traditional I/O models, introduces epoll as a high‑performance Linux I/O multiplexing mechanism, details its design principles, API usage, kernel data structures, and provides practical coding examples and optimization tips for building scalable backend services.
epoll is a high‑performance Linux I/O multiplexing mechanism that replaces select/poll by using an event‑driven design with a red‑black tree and ready list, supporting edge‑ and level‑triggered modes, efficient data transfer via mmap, and providing superior scalability for high‑concurrency network applications.
Socket provides a file‑descriptor based network communication abstraction in the OS, while epoll uses a red‑black‑tree and ready‑queue mechanism to deliver O(log N) scalable I/O event handling, together forming the core design that enables high‑concurrency servers to efficiently manage thousands of connections.
This article explains Go's socket programming workflow, the versatile net.Dial function for TCP, UDP, and ICMP connections, provides complete ICMP and TCP example programs, and then covers HTTP client usage with net/http, including basic methods, form posts, and custom request handling.
This article provides an extensive overview of C++ network programming concepts frequently asked in interviews, covering sockets, TCP/UDP differences, I/O multiplexing models, handshake mechanisms, packet framing issues, concurrency strategies, code examples for servers and clients, and performance optimization techniques.
This article demonstrates how to use DPDK's Graph API for L3 packet forwarding, introduces a custom ACL node, and presents performance comparisons of different packet‑transfer mechanisms and batch sizes within the graph pipeline.
This comprehensive guide walks through Go’s net package, detailing how Listener functions create servers, how Dial functions initiate client connections, the nuances of network and address formats, and the behavior of various Conn types such as TCPConn, UDPConn, IPConn, and RawConn, complete with code examples and best‑practice tips.
This article explains how epoll works as Linux's high‑performance I/O multiplexer, compares it with select and poll, details its three‑step workflow, data structures, code examples, and the trade‑offs between level‑triggered and edge‑triggered modes for building scalable network servers.
This article explains RDMA technology, covering its core principles, programming model with Verbs API, various communication modes, and its impact on data‑center networking, high‑performance computing, and distributed storage, highlighting its low‑latency, zero‑copy advantages over traditional TCP/IP.
This article debunks the common myth that a server can only handle 65,536 TCP connections by exploring the theoretical four‑tuple limits, practical constraints like file descriptors, port ranges, and memory/CPU usage, and explains how the true upper bound is far larger.
This article explains the fundamentals of socket programming in Python by demonstrating how to build a lightweight UDP-based chatroom, covering socket creation, common methods, and complete server‑client examples with code snippets for multi‑user communication.
This tutorial walks through the complete RDMA programming workflow using the ibverbs API, covering device initialization, memory registration, completion queue and queue pair creation, state transitions, send/receive operations, completion handling, and resource cleanup with concrete C code examples.
This guide walks you through the hardware requirements, cost considerations, and step‑by‑step configuration of a simulated RDMA network using Soft‑RoCE on both Red Hat/CentOS and Ubuntu, including verification with ibv tools and performance testing.
This article explains the fundamentals of RDMA, compares libibverbs and rdma_cm with the user‑space rsocket API, and walks through a complete Go implementation using the smallnest/rsocket library, including both server and client code examples and practical deployment tips.
This article walks through using Python’s requests library with the stream=True parameter to efficiently filter valid URLs during web crawling, presenting two methods, code examples, execution time comparisons, and a clear explanation of the stream option’s role.
This article dissects the Linux kernel's TCP connection workflow, explaining how the three‑way handshake prevents stale SYN packets, and walks through the socket(), bind(), listen() and connect() system calls with detailed code analysis of the underlying kernel functions and data structures.
This article explains what TCP sticky packets are, why they occur due to rapid sending, slow reading, or buffer limits, and presents practical solutions such as fixed‑length framing, delimiters, padding, and the Nagle algorithm to ensure reliable data parsing.
This tutorial series for newcomers explains TCP timeout retransmission, window management, and congestion control, combining theory with practical experiments using tcpdump, netstat, iptables, and Scapy, and demonstrates how Linux kernel parameters affect retransmission behavior and performance.
The article shares a graduate's interview experience and provides a comprehensive technical guide covering HTTP/1.x vs HTTP/2 differences, Java socket and HTTP server code, OS I/O buffering vs direct I/O, database concurrency control, Bloom filter principles, Java reflection, annotation usage, and synchronized locking semantics.
This guide introduces libevent, a lightweight C library for high‑performance event notification, explains its core concepts and features, provides step‑by‑step installation and compilation instructions, demonstrates sample programs like hello‑world and http‑server, and outlines common use cases in networking.
Swoole v6.0 introduces multithreaded coroutine support, async file I/O via io_uring, new thread‑related classes, upgraded Boost Context, numerous bug fixes and kernel optimizations, expanding PHP’s capabilities beyond traditional web workloads to high‑performance networking, game servers, and micro‑services.
This article explains Go's socket programming workflow, detailing the traditional steps of creating, binding, listening, and communicating over sockets, then shows how net.Dial simplifies connections for TCP, UDP, and ICMP, and demonstrates practical HTTP client usage with code examples.
This article demonstrates how to use the junixsocket library to add Unix domain socket support to Java applications, providing Maven dependency details, full server and client code examples, and cross‑language testing with a Go server implementation.
This article explains the characteristics and ideal use cases of UDP, then walks through step‑by‑step Go code for creating UDP connections, sending and receiving datagrams, and a complete client‑server example, helping developers leverage UDP’s low latency and lightweight nature for real‑time communication, streaming, and IoT scenarios.
This article provides a comprehensive set of Netty interview questions and detailed answers covering its architecture, Reactor pattern, core components such as Channel, ChannelHandler, ChannelPipeline, ByteBuf advantages, EventLoop groups, codecs, handling of packet framing, and graceful shutdown procedures.
This article walks through the concepts of forward and reverse proxies, explains HTTP and HTTPS proxy protocols, and provides a complete, step‑by‑step Golang implementation with code samples and diagrams for building a functional HTTP proxy server.
This article explains the POSIX standards, their role in providing portable Unix-like system interfaces, demonstrates network client‑server programming with POSIX sockets, analyzes key socket functions and the TCP three‑way handshake, and introduces POSIX named and unnamed semaphores with example code for synchronization and producer‑consumer patterns.
Netty is a high‑performance network framework whose three‑layer architecture—Core, Protocol Support, and Transport Service—combined with a Reactor‑based logical design, diverse I/O models, advanced memory management, zero‑copy techniques, and optimized data structures, enables efficient custom protocol handling and scalable server development.
This article explains the core concepts of I/O in operating systems, covering blocking I/O, non‑blocking I/O, and I/O multiplexing, their workflows, advantages, disadvantages, and practical analogies to help developers choose the right model for their applications.
This article explains the TCP socket programming interface, detailing server and client API functions, their purposes, the three‑way handshake, state transitions, data transmission, segmentation, sticky‑packet issues, and the four‑way termination process, providing code examples and diagrams for clear understanding.
Workerman is an open‑source, high‑performance PHP application container that provides a low‑level service framework for building TCP/UDP, WebSocket, HTTP, and custom protocol servers, and this guide explains its core concepts, the Worker and Connection classes, and a simple usage example with code.
This article walks through Kafka’s network‑layer internals, detailing how the client prepares, pre‑sends, and actually sends messages, then reads and parses responses, with code snippets that illustrate the Selector, KafkaChannel, and related classes in Java NIO.
Learn how to create a basic UDP chat application in Python using the built‑in socket library, covering UDP protocol basics, environment setup, server and client code, execution steps, and tips for extending the program with multithreading or error handling.
This article explains the PHP fsockopen() function, detailing its syntax, parameters, return values, and provides a complete example that demonstrates opening a TCP connection, sending an HTTP request, handling errors, and reading the response, including notes on SSL connections.
This article explains how Redis uses Linux epoll and a single‑threaded event loop to handle millions of connections efficiently, covering the creation of the epoll object, server initialization, event registration, the main processing loop, and the mechanisms for reading, writing, and managing pending tasks.
Redis founder antirez has open‑sourced BOTLIB, a lightweight C library for building Telegram bots, featuring clear code structure, global chat state management, client handling, and a step‑by‑step event loop, making it an ideal learning project for C network programming enthusiasts.
This article explains the historic C10K problem of handling ten thousand concurrent connections, compares traditional BIO with modern I/O models such as NIO, select, poll, epoll, and AIO, and provides Java and C++ code examples illustrating how each model improves scalability and performance.
This article provides a comprehensive overview of Java I/O models—including blocking (BIO), non‑blocking (NIO), asynchronous (AIO)—explains their differences, demonstrates file and network programming with code examples, and introduces Netty as a high‑performance framework for building scalable server applications.
This article explains how Linux receives network packets, detailing the NIC’s DMA transfer, hardware and software interrupt handling, NAPI scheduling, kernel processing, and the subsequent traversal through the IP and transport layers up to the user‑space application.
This article explains what Netty is, why it’s essential for Java back‑end development, details its core components and high‑performance mechanisms such as the Reactor model, Zero‑Copy and object pooling, and shows how Netty handles TCP framing issues with practical decoding solutions.
This article explains how TCP/IP heartbeat and retransmission mechanisms work, shows how to configure Windows keep‑alive parameters, demonstrates using libwebsockets’ keep‑alive settings, and provides non‑blocking socket + select code to detect connection failures and enforce a 60‑second reconnection window for video conferencing applications.
This article explains how unstable network conditions cause TCP disconnections in video conferencing, then details TCP/IP heartbeat mechanisms, ACK handling, keepalive parameter tuning, libwebsockets integration, packet loss retransmission, and non‑blocking socket connect timeout control with code examples.
This article explains the concept of sockets using a plug analogy, details their usage in TCP/UDP communication, explores the kernel's sock structures and inheritance tricks, and describes how sockets expose network functionality to user‑space programs through file descriptors and queues.
This comprehensive guide covers Netty fundamentals, core components, thread models, zero‑copy techniques, channel pipelines, codecs, bootstrapping, IO models, TCP framing, large file transfer, heartbeat mechanisms, SSL/TLS, default thread counts, WebSocket support, performance advantages, differences from Tomcat, server architecture, threading models, long‑connection handling, message‑sending methods, heartbeat types, memory management, and high‑availability strategies, providing Java developers with everything needed to ace Netty interview questions.
This article introduces the basic concepts of I/O and explains three Unix network programming models—blocking I/O, non‑blocking I/O, and I/O multiplexing—detailing their workflows, advantages, disadvantages, and practical analogies for better comprehension.
By dissecting OkHttp’s source, the article explains its layered architecture, the interceptor‑chain implementation of the Chain‑of‑Responsibility pattern, and shows how developers can add custom interceptors—such as authentication headers—to uniformly handle requests, retries, caching, and network I/O in Java and Android.
Developer Yeo Kheng Meng created doschgpt, a ChatGPT client that runs on a 1984 IBM 5155 MS‑DOS machine by using Open Watcom, a Packet Driver, manual HTTP POST construction, and a Go HTTPS proxy to bridge modern OpenAI services.
Learn how to implement a functional HTTP/HTTPS proxy in Go, covering proxy concepts, forward and reverse types, protocol specifics, header transformations, and a complete, runnable code example that listens on TCP, parses requests, connects to target servers, and forwards traffic.
This article explains the two‑stage socket I/O process in Linux, compares blocking, non‑blocking, and I/O multiplexing techniques, details the select, poll, and epoll APIs with their advantages and drawbacks, and provides complete C code examples for a high‑performance TCP server and client.
The article explains Java NIO’s non‑blocking channels, buffers, and selectors, then shows how the open‑source Tars RPC framework builds a multi‑reactor, multi‑thread network model on top of NIO—detailing server socket setup, event dispatch, session management, and read/write processing.
This article explains the concept of Remote Procedure Call (RPC), demonstrates how to build a lightweight PHP RPC server and client with socket programming, shows the full source code, execution steps, and explains the custom protocol used for cross‑language method invocation.
This article explains Segment Routing (SR) and its SRv6 extension, covering their inheritance from MPLS, the SRv6 packet format, SID structure, node roles, endpoint instructions, and how Best‑Effort and Traffic‑Engineering policies are implemented and forwarded in modern networks.
This article provides an in‑depth explanation of Linux I/O multiplexing models—including select, poll, and epoll—detailing their mechanisms, advantages, limitations, and practical C code examples, while also covering edge‑triggered vs level‑triggered behavior and offering a complete epoll server implementation.
The article explains how Asio implements C++20 coroutine support by converting callback‑based async operations into awaitables with use_awaitable, launching them via co_spawn and co_spawn_entry_point, handling result propagation and thread dispatch, and providing parallel composition operators (&&, ||) for concurrent awaiting.
This article provides a comprehensive, code‑driven walkthrough of Netty's internal networking architecture, covering NioEventLoopGroup, selectors, channels, pipelines, bootstrap configuration, binding mechanics, and how new connections and user requests are processed in a Java server environment.
This article explains Nginx's network design, showing how the master process only creates and binds listening sockets while worker processes each create an epoll instance, register events, and handle accept, read, and write operations, illustrating the complete flow from code snippets to multi‑process coordination.
This article explains how Redis uses Linux epoll and a single‑threaded event‑driven architecture to handle tens of thousands of connections efficiently, detailing the initialization of the server, the event‑loop mechanics, and the processing of client commands from accept to reply.
This article presents a series of images that quickly review essential C++ backend development topics, highlighting low‑level concepts such as memory management, inter‑process communication, network programming, and the importance of databases and Linux, while comparing C++ to Java backend routes.
This article compares traditional Java IO, JDK NIO, and the Netty framework, explaining their thread models, selector mechanisms, and performance trade‑offs, while providing complete server‑client code examples that demonstrate how Netty simplifies high‑performance network programming.
This article explains Nginx's network design, detailing how the master process only creates and binds listening sockets while multiple worker processes each create their own epoll instance, register events, and handle client connections through accept, connection initialization, and event‑driven I/O.
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.
This article explains why traditional select/poll struggle with massive connections, how epoll's event-driven design using a red‑black tree and ready‑list dramatically improves scalability, details its two trigger modes, and provides a complete C demo illustrating a high‑performance reactor model.
This article explains Nginx's multi‑process design, detailing how the master process handles socket binding and listening while each worker creates its own epoll instance, registers events, and processes connections through a well‑structured event loop with code examples from the source tree.
This article introduces Netty, explains Java's BIO/NIO/AIO models, compares reactor threading architectures, details Netty's internal thread and handler pipeline design, and provides a complete example of building a high‑performance HTTP server with Netty.
This article dissects Go's net package, showing how its Listen, Accept, Read and Write functions combine goroutines with epoll to deliver synchronous‑style code that avoids costly thread switches, and walks through the underlying source code and runtime mechanisms step by step.
This article explains the limitations of traditional blocking I/O, introduces Java NIO with selectors, compares the two models using a kindergarten analogy, critiques raw JDK NIO, and demonstrates how Netty simplifies and optimizes network development with concise server and client code examples while promoting a comprehensive Netty learning book.
This article introduces Python's socket module, explains core concepts such as IP, ports, and protocols, demonstrates essential socket functions, and provides complete client‑server code for a simple full‑duplex TCP chat application, enabling readers to quickly start network programming in Python.
Explore the comprehensive step-by-step process of Netty server startup, covering channel creation, initialization, reactor registration, and binding, while demystifying the asynchronous flow and internal mechanisms that power high-performance network applications.
This article explains how to use Python's socket module together with I/O multiplexing techniques such as select, poll, epoll, and the high‑level selectors module to build non‑blocking, scalable network servers that can handle multiple client connections concurrently.
This article provides a comprehensive overview of Java NIO network programming, explaining BIO, NIO, and AIO models, the core components Channel, Buffer, and Selector, and how Netty leverages the Reactor pattern with multi‑threaded boss and worker groups for high‑performance asynchronous I/O.
This article explains Redis's high‑performance I/O architecture by tracing the evolution from blocking, non‑blocking, and multiplexed network models to various Reactor‑based thread designs, illustrating each model with Java pseudo‑code and diagrams to clarify why Redis adopts a single‑threaded Reactor with optional multi‑threaded I/O extensions.
The article thoroughly examines Redis’s high‑performance architecture, detailing the evolution from blocking to non‑blocking I/O, the Reactor pattern’s single‑ and multi‑reactor models, Redis’s I/O multiplexing thread design, and how its hybrid single‑thread core with auxiliary I/O threads mitigates bottlenecks under heavy traffic.
This article explains the four main I/O models—blocking, non‑blocking, multiplexed (event‑driven) and asynchronous—detailing their mechanisms, kernel interactions, performance implications, and how they differ in handling data readiness for network programming.
This article explains how Netty abstracts Java NIO's event registration by using SelectionKey interestOps, detailing the registration of OP_ACCEPT and OP_READ events, the underlying doRegister and doBeginRead implementations, and the flow of events through the Netty pipeline with illustrative code snippets.
This guide explains how WebSockets enable full‑duplex communication over a single TCP connection, compares popular Go WebSocket libraries, and provides complete client‑server code examples for TCP, UDP, and HTTP‑based WebSocket implementations, helping developers build real‑time applications such as chat, games, and monitoring tools.
This article walks through converting a Go‑based TCP private‑protocol server to support WebSocket on the same port, covering library selection, client and server implementation, request upgrading, and a complete usage example with code snippets.
This article explains the hierarchical design of network libraries, detailing the roles of Session, Connection, Channel, and Socket layers, their interactions, code examples, and how they can be combined or extended for various backend services.
This tutorial shows how to use Python's Scapy library to craft and send ARP requests for network discovery, perform ARP spoofing attacks, and implement TCP SYN port scanning by interpreting packet flags, providing complete code examples and practical security insights.
This article explains the basic network programming pattern, introduces epoll as an I/O multiplexing solution for high‑concurrency servers, and demonstrates how Redis 5.0 integrates epoll through its event‑loop abstraction with detailed code examples and debugging tips.
This article explains Netty's role as a mature I/O framework, outlines the end‑to‑end remote‑call workflow of a distributed service, details protocol design, shares performance‑tuning tricks, and presents best practices for building scalable, low‑latency backend systems.
