Tagged articles
select
75 articles · Page 1 of 1

TonyBaiOct 5, 2026 · Backend Development
The article traces the 10-year history of Go issue #16620, which sought to make sync.Cond selectable, explains the level-vs-edge-triggered conflict, reviews community workarounds, and details bradfitz's new Mutex.LockChan() demo that enables cancellable locking via select.
ConcurrencyGoGo proposal
0 likes · 14 min read


liandkAug 11, 2026 · Databases
SELECT is the most frequently used SQL command, handling about 80% of data‑related work; this guide explains its core role, basic operations such as selecting all rows, specific columns, distinct values, and row limits, shows practical code examples, and advises against using SELECT * for better performance.
Data RetrievalSQLSQL Basics
0 likes · 2 min read

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.
EpollI/O multiplexingLinux
0 likes · 31 min read

This article explains the concepts of synchronous vs. asynchronous and blocking vs. non‑blocking I/O, outlines the five Unix I/O models, and then compares select, poll, and epoll—including their internal mechanisms, performance trade‑offs, edge‑ and level‑triggered modes, and why epoll is considered the solution to the C10K problem.
EpollI/O multiplexingLinux
0 likes · 17 min read


ZhiKe AIJun 26, 2026 · Backend Development
An interviewer's question about the difference between epoll and select reveals a tangled web of OS‑level IO mechanisms; this article unpacks user‑space vs kernel‑space, DMA, zero‑copy, buffering, and maps the five Java IO models (BIO, NIO, AIO, etc.) to their underlying system calls.
EpollIOJava
0 likes · 17 min read

Using SELECT * in MySQL queries increases disk I/O, inflates network traffic, and prevents the optimizer from using covering indexes, leading to slower performance and unnecessary resource consumption.
MySQLSQLindexing
0 likes · 5 min read

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.
EpollIO MultiplexingLinux
0 likes · 35 min read

This article explains Go's lightweight concurrency model, covering Goroutine creation, Channel communication, Select multiplexing, synchronization with WaitGroup and Context, common concurrency patterns such as worker pools and pub/sub, and provides best‑practice recommendations for building high‑performance concurrent programs.
ContextGochannel
0 likes · 7 min read

Linux treats all I/O devices as files, enabling a single thread to monitor many descriptors via I/O multiplexing; while select and poll use linear scans and suffer size limits, epoll employs an event‑driven red‑black tree with edge‑triggered mode, offering scalable, high‑performance handling for thousands of concurrent connections.
EpollI/O multiplexingLinux
0 likes · 30 min read


Java OneMar 9, 2025 · Backend Development
This article explains the fundamentals of I/O in Unix and Java, covering the distinction between user and kernel space, the five Unix I/O models, the evolution from select/poll to epoll/kqueue, and how modern network frameworks like Reactor and Proactor leverage these mechanisms for high‑performance networking.
EpollIOJava
0 likes · 16 min read

This article examines frequent errors when using Go's select statement—such as omitting a default case, misunderstanding case order, handling nil channels, missing timeout logic, and duplicate cases—explaining their impact, offering best‑practice guidance, and providing corrected code examples for each scenario.
ConcurrencyGoerror handling
0 likes · 14 min read

This article explains the distinction between user space and kernel space, describes blocking and non‑blocking I/O, and compares select, poll, and epoll multiplexing techniques, including signal‑driven and asynchronous I/O models with code examples.
EpollIO modelsKernel Space
0 likes · 11 min read


ITPUBDec 26, 2024 · Databases
This article recounts a 2012 incident where a backend API slowed dramatically after hidden BLOB columns were added, and explains why using SELECT *—which blocks index‑only scans, forces extra I/O, increases deserialization, network, and client processing costs, and hampers schema maintenance—should be avoided in favor of explicit column lists.
Database PerformancePostgreSQLSQL
0 likes · 7 min read


21CTODec 16, 2024 · Databases
The article recounts a 2012 incident where a seemingly fast backend API became sluggish after hidden blob columns were added, explains how SELECT * forces full table scans, extra deserialization, network overhead, and unpredictable performance, and advises selecting only needed columns for optimal efficiency.
Database PerformancePostgreSQLquery optimization
0 likes · 7 min read

This article analyzes a Go program that deadlocks due to misuse of unbuffered channels and select, explains the underlying behavior of channels, blocking conditions, and select semantics, and provides a simple fix by buffering the stop channel while also covering Go's CSP roots and best‑practice guidelines.
ConcurrencyGobuffered-channel
0 likes · 20 min read

This article explains the separation of user and kernel space, compares blocking, non‑blocking, multiplexed, signal‑driven, and asynchronous I/O models, and details the select, poll, and epoll mechanisms used to efficiently handle multiple file descriptors in Linux.
EpollI/O multiplexingKernel Space
0 likes · 12 min read

This article explains how to implement non‑blocking channel operations in Go using the select statement with a default case, provides detailed code examples for both sending and receiving, and analyzes the benefits, challenges, and practical use cases in high‑performance concurrent systems.
Backend DevelopmentChannelsConcurrency
0 likes · 6 min read

This guide shows how to protect a long‑running Go function that checks a RabbitMQ cluster by using time.After and a select statement to automatically stop the infinite loop after a configurable timeout, improving robustness and maintainability.
BackendTimeoutgolang
0 likes · 5 min read

This article explains Linux file concepts, how file descriptors work, why simple blocking I/O fails at scale, and introduces I/O multiplexing techniques—including select, poll, and epoll—detailing their mechanisms, limitations, and practical code examples for high‑concurrency servers.
EpollI/O multiplexingfile-descriptors
0 likes · 13 min read

This article introduces SQL as the standard language for relational databases, explains how data is organized into tables with primary and foreign keys, and walks through essential keywords like SELECT, WHERE, and JOIN to query and relate data effectively.
Foreign KeyPrimary KeySQL
0 likes · 5 min read

Redis creator antirez released Smallchat, a compact open‑source C chat server of about 200‑300 lines, illustrating multiplexed I/O with select, global state handling, and client management, making it an ideal hands‑on example for C network‑programming beginners.
C++Chat ServerSmallchat
0 likes · 3 min read

This article explains the advantages of epoll over select for I/O multiplexing in Linux, covering its event-driven design, edge-triggered vs level-triggered modes, core APIs, practical code examples, and performance considerations for high‑concurrency network servers.
EpollIO MultiplexingLinux networking
0 likes · 53 min read

This article explains the evolution of I/O multiplexing in Java, covering the birth of multiplexing, the introduction of NIO with Selector, and detailed comparisons of select, poll, and epoll mechanisms, including their APIs, internal workings, and performance considerations for high‑concurrency network programming.
EpollI/O multiplexingNIO
0 likes · 44 min read

This guide explains Linux serial port device files, shows how to list them, and provides four C programming methods—polling, select‑based interrupt, SIGIO signal handling, and threaded reading—complete with code examples and detailed configuration steps.
C++Device FilesLinux
0 likes · 10 min read

This article explains how MySQL 8.0.32 expands the '*' in a SELECT statement into all table columns, detailing the lexical parsing, query preparation, and the functions Item_asterisk::itemize, Query_block::prepare, Query_block::setup_wild, and insert_fields through source‑code excerpts.
MySQLSQLquery preparation
0 likes · 10 min read

This article explains the five Linux I/O models—blocking, non‑blocking, I/O multiplexing, signal‑driven, and asynchronous—detailing their system calls, behavior, and performance characteristics while using vivid analogies to illustrate each model’s workflow.
EpollIO modelsasynchronous IO
0 likes · 10 min read

This article dissects Go’s select statement, explaining its I/O multiplexing purpose, compile‑time transformation via walkSelect and walkSelectCases, and the multi‑stage runtime algorithm in runtime.selectgo that handles various case patterns, lock ordering, polling randomness, and channel blocking behavior.
CompilerConcurrencyGo
0 likes · 33 min read

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.
EpollIO Multiplexingedge trigger
0 likes · 26 min read

This article investigates a MySQL crash triggered by a specific SELECT statement, analyzes the stack trace and optimizer behavior that leads to an invalid memory access, and presents three practical solutions including disabling DuplicateWeedout, upgrading MySQL, and normalizing table character sets.
DuplicateWeedoutMySQLOptimizer
0 likes · 7 min read

This article explains the concepts of synchronous and asynchronous execution, blocking and non‑blocking operations, user and kernel space, process switching, file descriptors, cache I/O, and compares various Linux I/O models such as blocking, non‑blocking, multiplexing, signal‑driven and asynchronous I/O, including the differences among select, poll and epoll.
EpollIOLinux
0 likes · 14 min read

In this interview‑style tutorial, an Alibaba P7 engineer walks through the limitations of BIO, the non‑blocking NIO API, kernel‑level select/poll mechanisms, and the design of epoll, illustrating how each solves the C10K problem and how they are used in Java.
BackendEpollIO Multiplexing
0 likes · 16 min read

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.
EpollI/O multiplexingPython
0 likes · 19 min read

This article demonstrates how to use the FunTester framework to benchmark MySQL SELECT and UPDATE statements, providing sample scripts, execution results, and insights into performance tuning for typical workloads and discusses observed QPS values.
FunTesterJavaMySQL
0 likes · 7 min read

This article explains core Linux I/O concepts—including synchronous vs. asynchronous operations, blocking vs. non‑blocking behavior, user and kernel space separation, process switching, file descriptors, cache I/O, and the differences among select, poll, and epoll—providing a comprehensive overview for developers.
EpollI/O ModelsLinux
0 likes · 17 min read

This article explains the concepts of synchronous vs. asynchronous execution, blocking vs. non‑blocking operations, user and kernel space, process switching, file descriptors, cache I/O, and compares various Linux I/O models such as select, poll, epoll, signal‑driven and asynchronous I/O.
EpollIO modelsLinux
0 likes · 15 min read

This article explains the differences between synchronous and asynchronous execution, blocking and non‑blocking operations, user and kernel space, process switching, file descriptors, cache I/O, and compares various I/O models—including blocking, non‑blocking, multiplexing, signal‑driven, and asynchronous—while highlighting the characteristics of select, poll, and epoll.
EpollIO modelsblocking
0 likes · 15 min read

This article explains fundamental concepts of streams, I/O operations, blocking and non‑blocking behavior, compares blocking wait with busy polling, and then details five practical solutions—including multithreading, select, and epoll—while presenting Linux epoll API usage, code examples, and a comprehensive overview of seven common server concurrency models.
EpollIO MultiplexingLinux
0 likes · 32 min read

This article explains server‑side network concurrency models, the fundamentals of streams and I/O operations, compares blocking and non‑blocking approaches, and details practical solutions such as multithreading, busy‑polling, select and epoll with code examples and performance analysis.
Backend DevelopmentEpollIO Multiplexing
0 likes · 30 min read

This article explains how MySQL treats backslashes as escape characters in INSERT and SELECT queries, demonstrates the effect of different numbers of backslashes through practical tests, and clarifies the double‑escaping required when using LIKE patterns.
INSERTMySQLbackslash
0 likes · 6 min read

This article explains the drawbacks of traditional blocking network I/O, introduces non‑blocking reads, and walks through the evolution from multithreaded workarounds to kernel‑level multiplexing mechanisms such as select, poll, and epoll, showing code examples and performance considerations.
EpollIO Multiplexingblocking I/O
0 likes · 13 min read

This article walks you through using Navicat for MySQL to create databases and tables, design table structures, and perform native SQL SELECT queries—including filtering, multiple conditions, and column selection—illustrated with step‑by‑step screenshots and code examples.
MySQLNavicatSQL
0 likes · 7 min read

This article walks through a practical MySQL tutorial that identifies duplicate records, explains why naïve row‑by‑row deletion is slow, and provides efficient DELETE statements—including derived‑table tricks—to clean up large tables while preserving one record per duplicate group.
DELETEMySQLSQL
0 likes · 6 min read

This article explains how MySQL treats backslashes in INSERT and SELECT statements, demonstrates the resulting storage differences with practical examples, and clarifies the double‑escaping rules that developers must handle to avoid unexpected query results.
INSERTMySQLSQL
0 likes · 6 min read

This article explains the hidden costs of using SELECT * in MySQL—such as extra data transfer, increased I/O, and loss of covering‑index optimization—while detailing how proper column selection and composite indexes can dramatically boost query efficiency.
MySQLSQLdatabase optimization
0 likes · 9 min read

This article explains the multiple reasons why SELECT * slows down MySQL queries—including extra parsing, unnecessary data transfer, increased I/O, and loss of covering index optimization—while also covering index fundamentals, composite indexes, and practical tips for writing efficient SELECT statements.
MySQLSQLselect
0 likes · 9 min read

This article explains Redis's clean and elegant I/O multiplexing implementation, covering blocking I/O limitations, the reactor pattern, abstraction of select/epoll/kqueue into a unified API, key source functions, and platform‑specific module selection to achieve high‑performance single‑threaded networking.
EpollI/O multiplexingevent-loop
0 likes · 14 min read

The article explains why SELECT * slows down MySQL queries by increasing parsing cost, network traffic, and preventing index covering, and demonstrates how explicit column selection and well‑designed composite indexes can dramatically reduce I/O and improve query speed.
Database PerformanceIndex OptimizationMySQL
0 likes · 10 min read

This article explains the hidden costs of using SELECT * in MySQL queries, explores how unnecessary columns, large data types, and loss of covering‑index opportunities degrade performance, and shows how composite indexes and proper indexing strategies can dramatically speed up data retrieval.
MySQLSQLdatabase optimization
0 likes · 10 min read

The article explains low‑level I/O fundamentals—kernel versus user space, blocking (BIO) versus non‑blocking (NIO) models, and the evolution to multiplexing with select, poll, and epoll—showing how these mechanisms address the C10K problem and are exposed in Java through NIO and Netty APIs.
I/OJava NIOMultiplexing
0 likes · 17 min read

The article explains how MySQL processes SELECT and UPDATE statements, detailing each execution stage—from client authentication and cache lookup to parsing, optimization, and execution—while highlighting the additional redo log and binlog handling required for UPDATE operations and offering practical code examples.
MySQLSQL executionUpdate
0 likes · 14 min read


JavaEdgeNov 3, 2020 · Backend Development
This article compares Linux's select, poll, and epoll mechanisms, explaining their internal workings, limitations such as FD_SETSIZE and linear scanning, and why epoll's event‑driven design offers superior scalability and performance for high‑concurrency network servers.
EpollI/O multiplexingLinux
0 likes · 7 min read

This article explains why Redis, a single‑threaded server, adopts I/O multiplexing to avoid blocking, compares blocking I/O with multiplexed models, and details the internal implementation of select, epoll, and kqueue wrappers that power Redis's high‑performance event loop.
EpollI/O multiplexingevent-loop
0 likes · 14 min read

This article explains the fundamentals of blocking and non‑blocking I/O, compares select, poll, and epoll mechanisms, introduces the Reactor model and its variants, and shows how to solve the C10K problem with processes, threads, thread pools, and event‑driven architectures, complete with code examples.
Backend DevelopmentEpollI/O multiplexing
0 likes · 28 min read

This article explains Go's channel primitive, comparing unbuffered and buffered channels, demonstrates how to avoid deadlocks with proper goroutine coordination, and shows typical patterns such as select, closing channels, and building concurrency controllers for robust backend services.
ConcurrencyGobuffered
0 likes · 14 min read

This article examines several production incidents where using SELECT * caused dramatic performance degradation in Oracle databases, detailing shadow‑table differences, LOB handling, temporary‑table transformations, wide‑table scans, and memory‑intensive joins, and explains why the rule to avoid SELECT * is essential.
OracleSQLperformance
0 likes · 6 min read

This article announces a monthly giveaway of the newly upgraded 5th edition of Ben Forta's SQL Essentials book, outlines its features, author background, and target readers, and provides a detailed tutorial on using the SELECT statement to retrieve single and multiple columns with example code.
Ben FortaBookSQL
0 likes · 8 min read

This article compares the three I/O multiplexing mechanisms—select, poll, and epoll—by analyzing their time complexities, limitations, trigger modes, performance characteristics, and implementation details, helping developers choose the most suitable method for different Linux networking scenarios.
EpollIO MultiplexingLinux
0 likes · 14 min read

This article explains why using SELECT * in MySQL queries degrades performance, covering increased parsing cost, unnecessary data transfer, loss of covering index optimization, and how proper column selection and index design can dramatically improve query speed.
Covering IndexDatabase PerformanceSQL Optimization
0 likes · 10 min read

This article compares the three I/O multiplexing mechanisms—select, poll, and epoll—detailing their time‑complexities, limitations, implementation details, trigger modes, and performance trade‑offs to help developers choose the most suitable method for different Linux networking scenarios.
EpollIO MultiplexingLinux
0 likes · 13 min read

This article explains why using SELECT * in MySQL queries reduces performance, detailing increased parsing cost, network overhead, I/O for large columns, and loss of covering index optimization, and also expands on index concepts such as composite indexes and their impact on query efficiency.
Covering IndexDatabase PerformanceIndex Optimization
0 likes · 11 min read

Although many developers hear the advice to avoid using SELECT * in SQL, this article delves into the underlying reasons—such as increased parsing cost, unnecessary data transfer, extra I/O, and loss of covering-index optimization—while also explaining index concepts and best practices for MySQL performance.
Database PerformanceIndex OptimizationMySQL
0 likes · 10 min read

This article explains the Linux kernel's wait‑queue mechanism, the sleep and wake‑up logic behind socket events, and how the IO‑multiplexing models select, poll, and epoll are implemented, including their core code paths, performance trade‑offs, and edge versus level triggering.
EpollIO MultiplexingLinux
0 likes · 24 min read

This article explains the principles of event‑driven programming, compares traditional linear execution with event‑driven models, and details various I/O models—including blocking, non‑blocking, multiplexing, signal‑driven, and asynchronous—providing Python code examples and discussing their advantages and use cases.
Pythonasynchronousevent-driven
0 likes · 26 min read

This guide demonstrates how to use Selenium WebDriver with Java to delete an existing shipping address and add a new one, including handling dropdown selections for province, city, and area, with complete code examples and step‑by‑step explanations.
Javaautomationselect
0 likes · 4 min read

This comprehensive guide explains how SQL's declarative nature, the mismatch between syntax and execution order, table references, various join types, derived tables, GROUP BY behavior, and key keywords like DISTINCT, UNION, ORDER BY, and OFFSET work together to help readers master SELECT statements.
JoinsSQLdatabase-fundamentals
0 likes · 20 min read

This article explains the five Linux I/O models—blocking, non‑blocking, I/O multiplexing, signal‑driven, and asynchronous—using a fishing metaphor, shows how Java’s BIO/NIO/AIO map to OS mechanisms, and clarifies why most of them are still synchronous despite different implementations.
I/OLinuxasynchronous
0 likes · 12 min read

This article examines Redis's I/O multiplexing mechanism, explaining why it uses non‑blocking models, detailing the Reactor pattern, comparing select, epoll, and kqueue, and providing a thorough walkthrough of the underlying C code that implements event creation, addition, deletion, and polling across platforms.
Backend DevelopmentEpollI/O multiplexing
0 likes · 11 min read

This article explains the lifecycle of data in I/O operations, compares blocking, non‑blocking, and asynchronous models, introduces zero‑copy techniques, and details how select, poll, and epoll enable efficient multiplexed I/O handling in server applications.
EpollI/OLinux
0 likes · 20 min read


ITPUBAug 10, 2017 · Databases
This article shares five actionable SQL techniques—concatenating fields, removing duplicate rows, leveraging WHERE clauses, using COUNT flexibly, and selecting only necessary columns—to improve query readability and efficiency in relational databases.
COUNTSQLWHERE
0 likes · 9 min read


ITPUBNov 13, 2016 · Fundamentals
This article uses a relatable mailbox story to explain Linux socket I/O models—including synchronous blocking, synchronous non‑blocking, I/O multiplexing with select, signal‑driven I/O, and asynchronous I/O—detailing their mechanisms, advantages, drawbacks, and typical code patterns.
I/O ModelsSignal-drivenSocket
0 likes · 13 min read

This article provides a comprehensive guide to HTML form elements, covering radio and checkbox handling, hidden and submit inputs, dropdown (select) creation and manipulation, dynamic option insertion methods, and the use of image maps, with special attention to cross‑browser quirks and JavaScript techniques.
FormsHTMLfrontend
0 likes · 11 min read


21CTOOct 28, 2015 · Databases
This article explains why using SELECT * is problematic and demonstrates a simple technique—adding a computed column that triggers a divide‑by‑zero error—to block SELECT * queries while still allowing column‑specific selections.
Best PracticesSQLcomputed column
0 likes · 3 min read

An in‑depth comparison reveals how Nginx’s epoll‑based I/O model delivers higher concurrency, better efficiency, reduced memory copying, and non‑blocking operation, while Apache’s traditional select model is limited by FD_SETSIZE, linear scanning, and greater kernel‑user space copying overhead.
ApacheBackendEpoll
0 likes · 2 min read

This article explains the concepts of blocking and non‑blocking I/O in Linux device drivers, compares their implementations, demonstrates how select and poll are used for asynchronous access, and provides sample driver code illustrating both approaches.
Linuxblocking I/Odevice driver
0 likes · 7 min read

This article examines various network server architectures—from blocking sockets and multithreaded designs to select‑based and libev‑driven event loops—highlighting their trade‑offs, performance implications, and practical implementation details for building efficient high‑concurrency services.
C++event-drivenlibev
0 likes · 13 min read
