BestHub
Sign in
Tagged articles

network programming

180 articles · Page 1 of 2
Deepin Linux
Deepin Linux
Jul 23, 2026 · Backend Development

Eliminate Select’s High CPU Usage: A Step‑by‑Step Epoll Source Dive in Pure C

The article walks developers through the root causes of high CPU consumption when using select/poll, explains why epoll solves these bottlenecks, and provides a complete, pure‑C implementation that covers socket setup, epoll creation, registration, event loops, level‑trigger vs edge‑trigger modes, and performance comparisons.

C programmingI/O multiplexingLinux
0 likes · 31 min read
Eliminate Select’s High CPU Usage: A Step‑by‑Step Epoll Source Dive in Pure C
BirdNest Tech Talk
BirdNest Tech Talk
Jun 8, 2026 · Backend Development

Beyond gopacket: Introducing goscapy, the Powerful Go Network Library

The article examines goscapy, a pure‑Go network library that brings Scapy‑style stream‑builder APIs, automatic checksum calculation, protocol inference and zero‑copy serialization to Go, and compares it in depth with gopacket, showing code examples, performance tricks, and practical use‑cases such as ARP and TCP SYN scanning.

GoPacket craftingScapy
0 likes · 18 min read
Beyond gopacket: Introducing goscapy, the Powerful Go Network Library
Java Architect Handbook
Java Architect Handbook
May 25, 2026 · Fundamentals

Interview Torture: What Are TCP Sticky/Unsticky Packet Issues and Why They Matter

The article explains that TCP's byte‑stream nature causes sticky and unpacked packet problems, analyzes why they occur, compares UDP, and presents four application‑layer solutions—especially the Header‑Body length‑field approach used by Netty—providing code examples and interview‑ready answers.

InterviewLengthFieldBasedFrameDecoderNetty
0 likes · 14 min read
Interview Torture: What Are TCP Sticky/Unsticky Packet Issues and Why They Matter
Liangxu Linux
Liangxu Linux
Apr 13, 2026 · Fundamentals

Master Linux Network Programming: From Echo Server to Mini HTTP Server

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.

C++LinuxSocket
0 likes · 4 min read
Master Linux Network Programming: From Echo Server to Mini HTTP Server
Data STUDIO
Data STUDIO
Mar 24, 2026 · Backend Development

7 Python Libraries That Can Transform Your Network Programming

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.

Async IODICOMPacket Parsing
0 likes · 15 min read
7 Python Libraries That Can Transform Your Network Programming
Deepin Linux
Deepin Linux
Mar 6, 2026 · Backend Development

Unlocking Ultra‑Low Latency: How RDMA Transforms High‑Performance Networking

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.

RDMAdistributed storagehigh-performance computing
0 likes · 31 min read
Unlocking Ultra‑Low Latency: How RDMA Transforms High‑Performance Networking
Golang Shines
Golang Shines
Feb 13, 2026 · Backend Development

Using Go’s Standard Library to Crawl with an HTTP Proxy

This guide demonstrates building a simple Go crawler that fetches a webpage using only the standard library, then extends it to route requests through an HTTP proxy, covering proxy parsing, custom client configuration, error handling, and essential Go best practices such as deferring response closure.

GoHTTP Proxynetwork programming
0 likes · 5 min read
Using Go’s Standard Library to Crawl with an HTTP Proxy
Code Wrench
Code Wrench
Feb 7, 2026 · Backend Development

How Go’s Netpoller Powers Millions of Connections – 5 Real‑World Cases

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.

Gohigh concurrencynetpoller
0 likes · 23 min read
How Go’s Netpoller Powers Millions of Connections – 5 Real‑World Cases
Deepin Linux
Deepin Linux
Nov 27, 2025 · Backend Development

How epoll Scales to Millions of Connections Using Red‑Black Trees and Ready Lists

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.

Linuxepollevent-driven
0 likes · 54 min read
How epoll Scales to Millions of Connections Using Red‑Black Trees and Ready Lists
php Courses
php Courses
Nov 7, 2025 · Backend Development

Master PHP’s fsockopen(): Syntax, Parameters, and Real‑World Example

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.

PHPSocketfsockopen
0 likes · 4 min read
Master PHP’s fsockopen(): Syntax, Parameters, and Real‑World Example
Deepin Linux
Deepin Linux
Sep 12, 2025 · Backend Development

Mastering Linux I/O Multiplexing: select, poll, and epoll Explained with Real Code

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.

IO MultiplexingLinuxSELECT
0 likes · 35 min read
Mastering Linux I/O Multiplexing: select, poll, and epoll Explained with Real Code
Lin is Dream
Lin is Dream
Aug 29, 2025 · Backend Development

How I Built a Mini‑Netty from Scratch: Lessons in Java NIO Design

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.

Mini FrameworkNIONetty
0 likes · 7 min read
How I Built a Mini‑Netty from Scratch: Lessons in Java NIO Design
Lin is Dream
Lin is Dream
Aug 25, 2025 · Backend Development

How to Build a Mini‑Netty Pipeline that Decouples Decoding from Business Logic

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.

Design PatternsNettyhandler
0 likes · 15 min read
How to Build a Mini‑Netty Pipeline that Decouples Decoding from Business Logic
Lin is Dream
Lin is Dream
Aug 15, 2025 · Backend Development

Why Java NIO Beats BIO: Mastering Non‑Blocking Network Programming

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.

ByteBufferNIOSelector
0 likes · 23 min read
Why Java NIO Beats BIO: Mastering Non‑Blocking Network Programming
Open Source Tech Hub
Open Source Tech Hub
Jul 16, 2025 · Backend Development

Why epoll Beats select and poll: A Deep Dive into Linux’s High‑Performance I/O Multiplexing

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.

I/O multiplexingLinuxepoll
0 likes · 45 min read
Why epoll Beats select and poll: A Deep Dive into Linux’s High‑Performance I/O Multiplexing
Deepin Linux
Deepin Linux
Jul 14, 2025 · Backend Development

Unlocking Epoll: A Deep Dive into Linux’s High‑Performance I/O Mechanism

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.

ETI/O multiplexingLT
0 likes · 33 min read
Unlocking Epoll: A Deep Dive into Linux’s High‑Performance I/O Mechanism
Deepin Linux
Deepin Linux
Jul 5, 2025 · Backend Development

Mastering High-Concurrency C++ Servers: Multithreaded Network Programming Explained

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.

C++I/O multiplexingSocket
0 likes · 54 min read
Mastering High-Concurrency C++ Servers: Multithreaded Network Programming Explained
Liangxu Linux
Liangxu Linux
May 14, 2025 · Fundamentals

Can TCP and UDP Share the Same Port? A Deep Dive into Port Mechanics

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.

Interview QuestionPort SharingSO_REUSEADDR
0 likes · 17 min read
Can TCP and UDP Share the Same Port? A Deep Dive into Port Mechanics
php Courses
php Courses
Apr 25, 2025 · Backend Development

Understanding HTTP Protocol and Using Python requests Library

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.

HTTPPythonnetwork programming
0 likes · 9 min read
Understanding HTTP Protocol and Using Python requests Library
Deepin Linux
Deepin Linux
Apr 25, 2025 · Backend Development

Understanding epoll: Linux I/O Multiplexing, Design, and Practical Usage

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.

I/O multiplexingepollevent-driven
0 likes · 41 min read
Understanding epoll: Linux I/O Multiplexing, Design, and Practical Usage
Deepin Linux
Deepin Linux
Apr 18, 2025 · Backend Development

Deep Dive into Linux epoll: Design, Implementation, and Performance

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.

I/O multiplexingepollevent-driven
0 likes · 85 min read
Deep Dive into Linux epoll: Design, Implementation, and Performance
Cognitive Technology Team
Cognitive Technology Team
Mar 24, 2025 · Fundamentals

Understanding Sockets and epoll: Kernel Abstractions and High‑Concurrency Design

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.

IO MultiplexingSocketepoll
0 likes · 7 min read
Understanding Sockets and epoll: Kernel Abstractions and High‑Concurrency Design
Raymond Ops
Raymond Ops
Mar 11, 2025 · Backend Development

Master Go Socket and HTTP Programming: From Dial to Custom Requests

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.

GoSocketbackend
0 likes · 12 min read
Master Go Socket and HTTP Programming: From Dial to Custom Requests
Deepin Linux
Deepin Linux
Mar 1, 2025 · Backend Development

Comprehensive Guide to C++ Network Programming Interview Questions

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.

C++SocketsTCP
0 likes · 85 min read
Comprehensive Guide to C++ Network Programming Interview Questions
BirdNest Tech Talk
BirdNest Tech Talk
Jan 6, 2025 · Backend Development

Mastering Go’s net Package: Listener, Dial, and Conn Functions Explained

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.

.NETGoTCP
0 likes · 32 min read
Mastering Go’s net Package: Listener, Dial, and Conn Functions Explained
Liangxu Linux
Liangxu Linux
Dec 29, 2024 · Backend Development

Master epoll: Boost Linux Server Performance with Event‑Driven I/O

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.

ETI/O multiplexingLT
0 likes · 22 min read
Master epoll: Boost Linux Server Performance with Event‑Driven I/O
Deepin Linux
Deepin Linux
Dec 25, 2024 · Fundamentals

An Introduction to RDMA: Principles, Programming, and Applications

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.

Data CenterRDMAhigh-performance computing
0 likes · 30 min read
An Introduction to RDMA: Principles, Programming, and Applications
BirdNest Tech Talk
BirdNest Tech Talk
Dec 1, 2024 · Fundamentals

Step-by-Step Guide to RDMA Programming with the ibverbs API

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.

C++RDMAibverbs
0 likes · 5 min read
Step-by-Step Guide to RDMA Programming with the ibverbs API
BirdNest Tech Talk
BirdNest Tech Talk
Nov 20, 2024 · Backend Development

How to Build High‑Performance RDMA Applications in Go with rsocket

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.

GoRDMAhigh performance
0 likes · 13 min read
How to Build High‑Performance RDMA Applications in Go with rsocket
Linux Kernel Journey
Linux Kernel Journey
Oct 13, 2024 · Fundamentals

Unveiling the TCP Connection Process: Inside the Linux Socket System Calls

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.

Linux kernelTCPnetwork programming
0 likes · 42 min read
Unveiling the TCP Connection Process: Inside the Linux Socket System Calls
IT Services Circle
IT Services Circle
Aug 28, 2024 · Backend Development

Interview Experience and Technical Guide: HTTP Versions, Java Network Programming, OS I/O, Database Concurrency, Bloom Filter, Reflection, Annotations, and Synchronization

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.

Bloom filterDatabaseHTTP
0 likes · 21 min read
Interview Experience and Technical Guide: HTTP Versions, Java Network Programming, OS I/O, Database Concurrency, Bloom Filter, Reflection, Annotations, and Synchronization
Open Source Tech Hub
Open Source Tech Hub
Aug 8, 2024 · Backend Development

Mastering libevent: Install, Test, and Build High‑Performance Network Apps

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.

C librarycross‑platformevent-driven
0 likes · 12 min read
Mastering libevent: Install, Test, and Build High‑Performance Network Apps
Open Source Tech Hub
Open Source Tech Hub
Jul 5, 2024 · Backend Development

What’s New in Swoole v6.0? Multithreading, Coroutines, and Async I/O for PHP

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.

PHPmultithreadingnetwork programming
0 likes · 7 min read
What’s New in Swoole v6.0? Multithreading, Coroutines, and Async I/O for PHP
MaGe Linux Operations
MaGe Linux Operations
Jun 20, 2024 · Backend Development

Master Go’s net.Dial: From Socket Basics to HTTP Clients

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.

GoHTTPnet.Dial
0 likes · 11 min read
Master Go’s net.Dial: From Socket Basics to HTTP Clients
FunTester
FunTester
Jun 3, 2024 · Backend Development

Implementing Unix Domain Socket Communication in Java with junixsocket

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.

IPCUnix socketbackend
0 likes · 6 min read
Implementing Unix Domain Socket Communication in Java with junixsocket
Ops Development & AI Practice
Ops Development & AI Practice
May 30, 2024 · Fundamentals

Mastering UDP in Go: Build Low‑Latency Network Apps with Simple Code

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.

DatagramGoReal‑time communication
0 likes · 10 min read
Mastering UDP in Go: Build Low‑Latency Network Apps with Simple Code
Selected Java Interview Questions
Selected Java Interview Questions
May 19, 2024 · Backend Development

Netty Interview Questions and Answers: Core Concepts and Features

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.

Nettyasynchronous IObackend
0 likes · 10 min read
Netty Interview Questions and Answers: Core Concepts and Features
Deepin Linux
Deepin Linux
Apr 13, 2024 · Fundamentals

Understanding POSIX: Concepts, Network APIs, and Semaphore Programming in C

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.

C++POSIXUnix
0 likes · 26 min read
Understanding POSIX: Concepts, Network APIs, and Semaphore Programming in C
DaTaobao Tech
DaTaobao Tech
Apr 8, 2024 · Backend Development

Netty Core Concepts and Architecture Overview

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.

I/O ModelsNettyReactor pattern
0 likes · 27 min read
Netty Core Concepts and Architecture Overview
MaGe Linux Operations
MaGe Linux Operations
Feb 25, 2024 · Backend Development

Mastering TCP Socket APIs: Server & Client Functions Explained

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.

Four-way HandshakeSocket APITCP
0 likes · 14 min read
Mastering TCP Socket APIs: Server & Client Functions Explained
Open Source Tech Hub
Open Source Tech Hub
Feb 8, 2024 · Backend Development

What Is Workerman and How to Use Its Connection Class in PHP

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.

Async IOPHPnetwork programming
0 likes · 4 min read
What Is Workerman and How to Use Its Connection Class in PHP
Sanyou's Java Diary
Sanyou's Java Diary
Jan 18, 2024 · Big Data

Inside Kafka’s Network Layer: How Messages Are Sent and Received

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.

Java NIOKafkaMessage Receiving
0 likes · 22 min read
Inside Kafka’s Network Layer: How Messages Are Sent and Received
Nullbody Notes
Nullbody Notes
Jan 15, 2024 · Backend Development

Build Your Own Redis Pipeline Client in Go

This article walks through implementing a Redis pipeline client in Go, explaining how to reuse a single TCP socket for multiple requests, preserve send‑receive order, and handle sending, receiving, heartbeats, and reconnection with a concise 200‑line codebase.

ClientTCPnetwork programming
0 likes · 9 min read
Build Your Own Redis Pipeline Client in Go
php Courses
php Courses
Dec 27, 2023 · Backend Development

Using PHP’s fsockopen() Function to Open Network Connections

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.

PHPSocketbackend
0 likes · 4 min read
Using PHP’s fsockopen() Function to Open Network Connections
dbaplus Community
dbaplus Community
Nov 29, 2023 · Backend Development

How Redis Achieves High‑Performance Networking with a Single‑Threaded Event Loop

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.

backend developmentepollevent loop
0 likes · 23 min read
How Redis Achieves High‑Performance Networking with a Single‑Threaded Event Loop
21CTO
21CTO
Nov 27, 2023 · Backend Development

Explore BOTLIB: A Minimal C Telegram Bot Framework by Redis Creator

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.

Bot FrameworkC++Telegram bot
0 likes · 4 min read
Explore BOTLIB: A Minimal C Telegram Bot Framework by Redis Creator
Nullbody Notes
Nullbody Notes
Nov 27, 2023 · Backend Development

Build a Simple Go RPC Framework – A Beginner-Friendly Project

This article walks Go beginners through designing and implementing a lightweight RPC framework called easyrpc, covering protocol design, message serialization, network communication, graceful server shutdown, client stub generation with reflect.MakeFunc, and concurrent request handling, with full source code on GitHub.

Code ExampleGoRPC
0 likes · 16 min read
Build a Simple Go RPC Framework – A Beginner-Friendly Project
Top Architect
Top Architect
Sep 22, 2023 · Backend Development

Understanding Java I/O: BIO, NIO, AIO, and Netty – A Comprehensive Guide

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.

File I/OJava I/ONIO
0 likes · 32 min read
Understanding Java I/O: BIO, NIO, AIO, and Netty – A Comprehensive Guide
Deepin Linux
Deepin Linux
Aug 25, 2023 · Fundamentals

Linux Network Packet Reception: From NIC to Kernel and Protocol Stack

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.

LinuxNAPIPacket Reception
0 likes · 27 min read
Linux Network Packet Reception: From NIC to Kernel and Protocol Stack
Senior Tony
Senior Tony
Aug 9, 2023 · Backend Development

Why Netty Powers Modern Java Back‑ends: A Deep Dive into Its Architecture

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.

NettyReactor patternTCP
0 likes · 9 min read
Why Netty Powers Modern Java Back‑ends: A Deep Dive into Its Architecture
Liangxu Linux
Liangxu Linux
Jul 16, 2023 · Backend Development

Ensuring TCP Connections Stay Alive for 60 Seconds During Unstable Networks

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.

SocketWindowskeepalive
0 likes · 22 min read
Ensuring TCP Connections Stay Alive for 60 Seconds During Unstable Networks
Liangxu Linux
Liangxu Linux
Jul 3, 2023 · Fundamentals

What Exactly Is a Socket? From Plug Analogy to Kernel Implementation

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.

Linux kernelSocketSystem Programming
0 likes · 17 min read
What Exactly Is a Socket? From Plug Analogy to Kernel Implementation
Sanyou's Java Diary
Sanyou's Java Diary
Jun 19, 2023 · Backend Development

Master Netty: 32 Essential Interview Questions and Answers

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.

Nettyasynchronous IOnetwork programming
0 likes · 49 min read
Master Netty: 32 Essential Interview Questions and Answers
vivo Internet Technology
vivo Internet Technology
May 17, 2023 · Mobile Development

Deep Dive into OkHttp: Core Principles, Interceptor Chain, and Practical Usage

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.

AndroidDesign PatternsHTTP
0 likes · 16 min read
Deep Dive into OkHttp: Core Principles, Interceptor Chain, and Practical Usage
MaGe Linux Operations
MaGe Linux Operations
Apr 9, 2023 · Backend Development

Build a Go HTTP Proxy from Scratch: Full Guide with Code

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.

Code ExampleHTTP Proxybackend
0 likes · 11 min read
Build a Go HTTP Proxy from Scratch: Full Guide with Code
AI Cyberspace
AI Cyberspace
Apr 4, 2023 · Fundamentals

Mastering Linux Socket I/O: Blocking, Non‑Blocking, and Epoll Explained

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.

C++I/OLinux
0 likes · 20 min read
Mastering Linux Socket I/O: Blocking, Non‑Blocking, and Epoll Explained
vivo Internet Technology
vivo Internet Technology
Mar 15, 2023 · Backend Development

Analysis of Java NIO and Tars Framework Network Programming

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.

Java NIOReactor patternTars
0 likes · 18 min read
Analysis of Java NIO and Tars Framework Network Programming
php Courses
php Courses
Nov 13, 2022 · Backend Development

Implementing a Simple RPC Framework in PHP Using Sockets

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.

PHPRPCSockets
0 likes · 6 min read
Implementing a Simple RPC Framework in PHP Using Sockets
Top Architect
Top Architect
Aug 30, 2022 · Backend Development

Understanding IO Multiplexing: select, poll, and epoll in Linux with Code Examples

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.

IO MultiplexingSELECTedge trigger
0 likes · 26 min read
Understanding IO Multiplexing: select, poll, and epoll in Linux with Code Examples
Tencent Cloud Developer
Tencent Cloud Developer
Aug 23, 2022 · Backend Development

Understanding Asio Coroutine Implementation in C++20

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.

AsioC++C++20
0 likes · 26 min read
Understanding Asio Coroutine Implementation in C++20
Liangxu Linux
Liangxu Linux
Jul 3, 2022 · Backend Development

How Nginx Leverages epoll in a Multi‑Process Architecture

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.

Nginxbackend developmentepoll
0 likes · 19 min read
How Nginx Leverages epoll in a Multi‑Process Architecture
ITPUB
ITPUB
Jun 7, 2022 · Backend Development

How Redis Achieves High Performance with a Single‑Threaded Event Loop

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.

Redisepollevent loop
0 likes · 22 min read
How Redis Achieves High Performance with a Single‑Threaded Event Loop
IT Services Circle
IT Services Circle
Jun 1, 2022 · Backend Development

Key Knowledge Points for C++ Backend Development (Image Overview)

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.

C++DatabasesLinux
0 likes · 3 min read
Key Knowledge Points for C++ Backend Development (Image Overview)
FunTester
FunTester
May 22, 2022 · Backend Development

Why Netty Beats JDK NIO: A Hands‑On Comparison and Code Walkthrough

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.

AsynchronousNIONetty
0 likes · 13 min read
Why Netty Beats JDK NIO: A Hands‑On Comparison and Code Walkthrough
Liangxu Linux
Liangxu Linux
May 17, 2022 · Backend Development

How Nginx Leverages epoll in a Multi‑Process Architecture

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.

Nginxepollmulti-process
0 likes · 18 min read
How Nginx Leverages epoll in a Multi‑Process Architecture
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.

Code ExampleGoHTTP Proxy
0 likes · 9 min read
Build a Go HTTP Proxy from Scratch: Step-by-Step Guide
Refining Core Development Skills
Refining Core Development Skills
Apr 11, 2022 · Backend Development

How Nginx Uses Epoll in a Multi‑Process Architecture

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.

LinuxNginxbackend
0 likes · 18 min read
How Nginx Uses Epoll in a Multi‑Process Architecture
Wukong Talks Architecture
Wukong Talks Architecture
Mar 7, 2022 · Backend Development

From Java NIO to Netty: A Practical Guide to High‑Performance Network Programming

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.

AsynchronousJava NIOReactor
0 likes · 17 min read
From Java NIO to Netty: A Practical Guide to High‑Performance Network Programming
IT Architects Alliance
IT Architects Alliance
Dec 9, 2021 · Backend Development

Java NIO Network Programming and Netty Architecture Overview

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.

NIONettyReactor pattern
0 likes · 15 min read
Java NIO Network Programming and Netty Architecture Overview
Sohu Tech Products
Sohu Tech Products
Dec 8, 2021 · Backend Development

Understanding Redis I/O and Thread Models: From Blocking to Multi‑Reactor Designs

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.

Reactor patternRedisThread Model
0 likes · 19 min read
Understanding Redis I/O and Thread Models: From Blocking to Multi‑Reactor Designs