A MySQL fatal error citing Errcode 28 can stem from inode exhaustion caused by a flood of cron-generated emails, not just lack of disk space, and the article walks through diagnosing the issue with df, df -i, and locating the offending Postfix maildrop directory.
This article categorizes typical reasons why C/C++ programs generate core dumps, such as unreasonable program design, misuse of system libraries, memory leaks, type errors, thread ID handling, infinite loops, and improper initialization or cleanup, and provides illustrative case analyses for each scenario.
This article classifies the typical reasons why C/C++ programs generate core dumps, explains how to use gdb and other techniques to locate the faults, and provides concrete case studies covering error handling, multithreading issues, and third‑party library pitfalls.
This article outlines five essential abilities—embracing new languages, mastering debugging, creating time‑saving tools, speeding up repetitive tasks, and adopting systemic thinking—that high‑performing software engineers need to boost productivity and deliver impactful, well‑engineered solutions.
This article outlines a practical workflow for diagnosing and fixing memory leaks in Node.js applications, covering essential concepts of V8 garbage collection, recommended tooling such as devTool, heapdump, and memwatch, and detailed steps for reproducing issues, capturing heap snapshots, analyzing them, and applying fixes.
This article chronicles a developer’s detailed workday, documenting the discovery, analysis, and resolution of numerous JavaScript bugs in IE7, the communication with teammates, and the systematic debugging process that ultimately led to fixing a critical comma‑induced error in the code.
This article explains how Java exceptions provide a consistent mechanism for identifying and responding to errors, and outlines three key principles—specificity, early throwing, and delayed catching—illustrated with a fictional JCheckbook class to demonstrate robust, user‑friendly debugging practices.
When a PHP process suddenly consumes near‑100% CPU, this guide shows how to locate the exact file, function and line causing the spike by inspecting Zend executor globals with GDB, using both manual commands and a ready‑made .gdbinit script.
This article explains the JavaScript with statement, its syntax and intended convenience, then details why it is discouraged by highlighting severe performance degradation, ambiguous scope resolution, debugging difficulties, and potential bugs illustrated through multiple code examples and analysis.
The article explains how the newly released WeChat web development tool lets developers debug web authorization flows directly on a computer, eliminating the need to switch between mobile devices and simplifying the testing process.
This article describes how Baidu's QA team identified and resolved a memory‑leak issue in the Bigpipe Broker backend by analyzing a live process with pmap and GDB, extracting reference‑count problems, and fixing the atomic_add misuse that caused the leak.
This case study details how a Baidu QA team diagnosed a long‑standing memory‑growth issue caused by improper use of Protocol Buffers, identified the problematic merged_data structure, applied a scoped_ptr reset fix, and validated the improvement with monitoring and unit tests.
This article details a query‑diff test that revealed a 1% floating‑point precision difference after a module upgrade, describes the systematic investigation of environment, compilation, and CPU instruction‑set variations (AVX vs SSE), and presents conclusions and recommendations for preventing similar issues.
This article explains how implicit lock requests in PostgreSQL can lead to surprising lock waits, demonstrates debugging steps with lock_debug and a reporting script, and offers practical tips like lock_timeout and statement_timeout to prevent prolonged blocking scenarios.
This article explains Node.js memory architecture, how the V8 engine allocates and frees memory across code, stack, and heap, demonstrates using process.memoryUsage() to monitor RSS, heapTotal and heapUsed, describes V8’s Scavenge and Mark‑Sweep garbage collectors, and provides practical techniques for detecting and debugging memory leaks with heap snapshots and profiling tools.
The article shares a quirky yet effective debugging habit where developers explain code line‑by‑line to a small rubber duck, forcing coherent thinking that often leads to breakthroughs, and encourages readers to adopt a similar personal tool for clearer problem solving.
This article outlines six practical habits for developers—self‑checking code before blaming tools, continuous learning, embracing refactoring, acting professionally, using static analysis, and genuinely caring about code quality—to improve productivity and reduce bugs in any software project.
This article explores how structured planning, interface‑first design, pseudocode, and GTD‑style debugging can dramatically improve a developer's efficiency and productivity while emphasizing the importance of rest and continuous learning.
This guide explains how QQ Browser’s WeChat debugging tool lets developers run and test their server code locally without an external domain, by generating a public URL that forwards messages from the WeChat server to the local program.
This guide shows how to use Tencent Bugly to automatically de‑obfuscate Android crash stacks by uploading mapping files, accurately locate exception line numbers through source archiving, and reconstruct user operation paths with custom logs for faster bug resolution.
This article shares twenty practical software development lessons—from starting with a minimal version and iterating, to effective debugging, teamwork, and continuous learning—offering actionable guidance that seasoned programmers have distilled over more than a decade of experience.
This article presents a comprehensive set of logging best‑practice rules—from defining log levels and classifications to using RequestIDs, monitoring alerts, and managing log size—aimed at improving system reliability, troubleshooting speed, and operational efficiency.
This article outlines eight progressive levels of PHP problem‑solving ability—from checking error messages and configuring php.ini to using strace, tcpdump, xhprof, gdb, and even reading PHP core source—providing a clear roadmap for developers to ace interviews and handle real‑world issues.
An extensive exploration of Android M’s Doze feature covers its evolution, activation conditions, restricted app behaviors, whitelist management, debugging commands, internal state machine, source code breakdown, network restrictions, GCM handling, and techniques for programmatically exiting Doze, offering developers practical insights for power‑saving optimization.
The article outlines practical techniques for debugging live Java systems, emphasizing comprehensive distributed logging, global exception handling, proactive JStack usage, BTrace tracing, and custom JVM agents to quickly identify and resolve production issues.
The author recounts a real‑world incident where consolidating many Redis GET calls into a single MGET reduced network latency but unexpectedly increased overall response time, leading to timeout errors; they detail the investigation using Redis slowlog, code analysis, and proper pagination techniques to resolve the hidden performance bottleneck.
This article surveys the architecture of long‑connection push systems for internet apps, distinguishes connection types, outlines client and server handling strategies, reviews mainstream backend solutions, and shares practical insights on security, API design, operations, queue services, debugging, and NoSQL usage.
This guide walks through identifying a Java process that spikes CPU usage, locating the offending thread with Linux tools, extracting its stack trace, pinpointing the problematic code in a socket utility class, and outlining the steps to resolve the infinite‑loop issue.
Software maintenance and debugging sharpen analytical and coding skills, expose developers to diverse tools and legacy systems, improve performance optimization and database knowledge, foster client relationships and referrals, provide steady income, and allow quick, focused work that deepens business understanding while avoiding large‑scale outsourcing.
Software bugs are often whimsically named after famous scientists, with Bohrbug representing reproducible errors, Heisenbug describing elusive issues that disappear under observation, Mandelbug denoting complex, chaotic faults, and Schroedinbug reflecting paradoxical bugs that seem both present and absent, each illustrating distinct debugging challenges.
After weeks of puzzling over intermittent socket disconnections in a persistent‑connection server, the author finally traced the fault to a missing timeout/notification when the remote service drops while awaiting an authentication code—a revelation sparked by a noisy office party, a spilled cola, and a missed elevator.
