This article walks through a real‑world Linux kernel bug investigation, showing how to detect a frozen process, use tools like ps, strace, pstack, and the /proc filesystem to trace system calls, identify the blocking kernel function, and pinpoint the root cause.
This guide explains how to enable core dumps on Linux, examine the generated core file, and pinpoint the exact source line that caused a crash using dmesg, addr2line, gdb, and strace, with step‑by‑step commands and example code.
A developer recounts a five‑day debugging saga where a new lock‑free network queue caused intermittent core dumps, ultimately traced to differing GCC optimization behaviors, and shares practical lessons on bug attitude, reproduction, static analysis, and effective logging.
Effective error logging provides crucial clues for troubleshooting, yet many logs lack context, consistency, or detail, making debugging time‑consuming; this article explains common error sources, fourteen typical causes, improvement measures, and practical guidelines—including formatting rules and code examples—to help developers write clear, actionable logs.
This step‑by‑step guide shows how to locate a Linux process frozen in uninterruptible sleep by using tools such as top, ps, WCHAN, /proc files, strace, pstack, and kernel stack traces to pinpoint the offending system call and its root cause.
When using the laravel-sms extension with Luosimao, SMS sending fails because the package uses an HTTPS endpoint while the official documentation specifies HTTP, and correcting the URL in the LuosimaoAgent.php file resolves the issue.
The article explains why Nginx silently discards request headers containing underscores, demonstrates the issue with a Spring Boot service and Postman, and shows how adding the 'underscores_in_headers on;' directive resolves the problem.
The article explains Android native crashes (NE) by describing .so file composition, the need for un‑stripped libraries, how to view and generate stripped/un‑stripped binaries, and detailed workflows using ndk‑stack, DropBox, BreakPad, objdump, addr2line, and minidump_stackwalk to reconstruct stack traces and pinpoint source lines.
This article explains why using plain print() for debugging can become confusing in larger Python projects and demonstrates how the Icecream library provides concise, informative output with minimal code, including installation, basic usage, custom prefixes, context information, and clean‑up techniques.
This guide lists frequent Python errors such as invalid syntax, unexpected EOF, invalid characters, index out of range, type mismatches, indentation issues, value errors, name errors, and attribute errors, providing clear definitions, common causes, and key vocabulary for each.
This guide introduces GoBoy, a multi‑platform Game Boy and Game Boy Color emulator written in Go, explains how to install it on macOS, Windows, and Linux, and details its usage, debugging commands, and saving features for a complete retro gaming experience.
This article analyzes a crash caused by NSInvocation argument out‑of‑bounds on iOS 13.3+, explains the underlying runtime changes, demonstrates how to reproduce the issue with a timer‑triggered message forwarding scenario, and provides a fix by correcting the method signature.
This guide walks you through powerful IntelliJ debugging techniques—including conditional breakpoints, the Drop Frame feature, multithread breakpoint control, remote JVM debugging setup, and on‑the‑fly expression evaluation—to help you troubleshoot complex Java applications efficiently.
This guide explains how to identify OutOfMemoryError crashes in Android applications caused by excessive thread‑pool creation, using tools like Android CPU Profiler, adb ps commands, and code hooks, and provides concrete steps to refactor OkHttp, RxJava, and SDK usage to prevent resource leaks.
JupyterLab now offers a visual debugger plugin and the xeus‑python kernel, allowing users to set breakpoints, inspect variables, and navigate execution directly in notebooks, with simple installation commands and future enhancements such as richer variable rendering and conditional breakpoints.
Faced with a legacy Dubbo service needing both Dubbo and HTTP protocols and a new Spring Cloud project requiring seamless Feign calls, this article details the challenges, the solution using Dubbo’s SPI Container extension, and how Arthas was employed to diagnose and resolve hidden loading errors.
This tutorial explains how to create a VS Code extension that automatically prefixes console.log statements with custom identifiers, covering project scaffolding, key file structures, activation events, command registration, implementation details, debugging, and publishing to the marketplace.
This article introduces a collection of essential Java tools—including jstack, jmap, jhat, jstat, jdb, jcmd, jps, jinfo, javap, javac, jconsole, and jvisualvm—explaining their purposes, common commands, and how they help diagnose memory leaks, CPU spikes, thread issues, and overall JVM performance.
IntelliJ IDEA 2020.3 introduces a revamped welcome screen, reader mode, easier window splitting, enhanced refactoring, upgraded debugging tools, AI‑powered code completion, Search Everywhere improvements, Java 15 support, built‑in database tools, Lombok integration, and a refined VCS menu, all aimed at boosting developer productivity.
This guide explains what strace is, how to use it for filtering system calls, profiling execution time, diagnosing configuration issues, and tracing network activity, providing concrete command examples and interpretation of output to help troubleshoot Linux processes efficiently.
Learn how to enhance Python debugging using the PySnooper library, covering quick installation, simple examples, advanced features like output redirection, variable watching, depth control, thread info, custom representations, and remote debugging tips, all illustrated with clear code snippets and screenshots.
This article explains why effective error logging is crucial for debugging, analyzes common causes of errors across system layers, and provides concrete guidelines and code examples for writing complete, specific, and actionable error logs that simplify issue identification and resolution.
This guide walks through Chrome DevTools features—including inspecting pseudo‑class styles, temporarily toggling classes, making pages editable, checking placeholder styles, testing performance and SEO, viewing network details, examining event handlers, searching code globally, recording runtime performance, using rendering diagnostics, and exploring application storage—providing step‑by‑step instructions with code snippets and visual examples.
This article compiles a curated list of practical VS Code techniques—from refactoring code and customizing view layouts to fast debugging, symbol navigation, terminal management, Git operations, and essential shortcuts—offering developers concrete ways to accelerate their workflow and write cleaner code.
This article describes how the author investigated recurring errors in a Java-based lecture hall system, identified thread pool leaks caused by improper use of AsyncHttpClient, and resolved the issue through command‑line diagnostics, code fixes, and system monitoring, improving stability.
This article explains several IntelliJ IDEA debugging tricks—including setting conditional breakpoints, using Drop Frame to rewind execution, managing multi‑thread breakpoints, configuring remote debugging, and evaluating or modifying expressions on the fly—to help developers debug complex Java applications more efficiently.
This article explains the fundamentals of Linux ftrace, details the event‑tracing mechanism and tracepoint macros, shows how to enable and filter events on ARM64 Android devices, and demonstrates a practical workflow for capturing low‑probability scheduling bugs in camera‑related processes.
This guide explains how to configure Android Studio and LLDB to perform native debugging of the Dalvik virtual machine on Android devices, covering both scenarios with and without app source code, required environment setup, useful LLDB commands, and step‑by‑step procedures for remote debugging.
After migrating from Docker to Docker Swarm and finally to Kubernetes, the author shares six practical kubectl troubleshooting techniques—including inspecting deployments, viewing events, streaming logs, exporting YAML, scaling pods, and port‑forwarding—to quickly identify and fix common cluster issues.
This article provides a comprehensive overview of Google’s V8 JavaScript engine, covering its architecture, compilation process, bytecode, hidden classes, inline caches, garbage collection, and debugging tools such as d8, with practical code examples and performance optimization tips for developers.
A web testing engineer recounts how a user‑reported gray banner on a Chrome browser led to a step‑by‑step investigation that ultimately uncovered the AdGuard extension as the culprit, illustrating practical troubleshooting techniques for front‑end issues in production.
This article walks through the ThinkPHP framework's initialization process, explains the underlying design patterns, shows how to trace method calls with debug_backtrace, and discusses configuration loading, container updates, debugging mode, and code redundancy, providing practical code examples for developers.
This article demonstrates how to locate and extract cover‑image URLs from a web page using Scrapy, explains handling absolute and relative URLs, shows the necessary XPath and meta‑passing code, and provides debugging tips to verify that the image URL is correctly transferred through the spider.
This article provides a detailed walkthrough of ThinkPHP's initialization process, explains how to trace method executions using debug_backtrace, analyzes the init method and container configuration updates, and offers practical suggestions for code optimization and debugging in backend development.
This article explains how to investigate a MySQL crash when core dumps are disabled by extracting the crash address from the error log, obtaining the matching binary, using GDB to map the address to source code, and decoding encoded function signatures to pinpoint the underlying bug.
This article explains what remote debugging is, why it is useful, introduces the JPDA architecture, details the JDWP command‑line options such as transport, server, suspend, address, and shows step‑by‑step how to start a Spring Boot service in remote‑debug mode and attach IntelliJ IDEA for debugging.
When starting a Spring Boot application, WARN messages about missing JAR files appear because Tomcat incorrectly scans Manifest Class-Path entries, and the article explains the root cause, debugging steps, and multiple ways to resolve the issue.
The article investigates a CPU load spike caused by a red‑black tree cycle inside Java's HashMap after JDK 8, detailing monitoring steps, stack‑trace analysis, heap dump inspection, and concluding with a recommendation to replace HashMap with ConcurrentHashMap in concurrent scenarios.
After noticing abnormal memory usage in a production service, the author traced a leak to a race condition in shared data during a C++ code refactor, demonstrated the debugging steps, explained why traditional tools like Valgrind help, and shared lessons on avoiding multithreaded memory leaks.
This guide shows how to quickly reformat code without opening settings, generate UML class diagrams, view and test Spring Boot endpoint mappings, navigate debugging execution points, and rename methods using IntelliJ IDEA Ultimate shortcuts, enhancing productivity for Java developers.
This article details a two‑month journey of reading MySQL 8.0.20 source code to uncover how the DELETE statement performs mark‑delete, describing the experimental setup, trace‑log analysis, query and delete phases, and the exact functions that set the deletion flag in InnoDB.
The article explains a puzzling bug where a Groovy‑created object's toString becomes empty after fastjson serialization, traces the issue to Java access modifiers, demonstrates the problem with sample code and console output, and resolves it by adding a public modifier.
This article explains why C heap memory leaks cause board resets after months of operation, describes heap allocation methods, the three key leak elements, common release misconceptions, and provides practical code‑review techniques to detect and eliminate leaks.
The article shares the author's personal experience of reading source code—starting with Java collections, moving to Spring and MyBatis, diving deep into Spring Boot and Quartz integration, and offering practical tips such as using official guides, books, blogs, design‑pattern knowledge, and IDE breakpoint debugging to master backend frameworks.
This article explains why iOS launch images often fail to update, reveals that the system caches multiple storyboard‑generated images in the app sandbox, and provides a step‑by‑step method to replace those cached files with custom‑generated ones, including code, orientation handling, and support for older iOS versions.
This guide walks you through Linux process fundamentals and equips you with practical commands—ps, strace, pstack, pstree, gdb, and /proc file inspection—to diagnose, trace, and debug running programs step by step.
This article examines the complexities of testing environments, outlines typical causes of failures such as resource constraints, external dependencies, and service bugs, and provides systematic troubleshooting methods, useful tools, and real‑world case studies to improve reliability and efficiency.
This article explains how Node.js child_process.spawn handles stdio options, why failing to attach 'data' listeners or consume pipe streams can cause the child to block, and demonstrates experiments, debugging techniques, and proper configuration such as using 'ignore' or 'pipe' to avoid deadlocks.
This article demonstrates how the open‑source Java diagnostic tool Arthas can be employed in various production scenarios—such as CPU spikes, class‑loading conflicts, method‑level monitoring, performance bottlenecks, and hot‑code replacement—to rapidly locate and resolve runtime problems without restarting services.
This guide details typical Laravel 7 installation problems—such as missing PHP extensions, version mismatches, 403 errors, cache and permission issues—and provides step‑by‑step Composer commands, code snippets, and troubleshooting solutions to help developers quickly resolve them.
This article explains why Python programs raise common built‑in exceptions, illustrates each with clear code examples, and shows practical techniques for catching, raising, and debugging these errors to write more robust code.
Explore essential IntelliJ IDEA techniques—including string highlighting with regex validation, batch replacement via Alt+J, interactive Java Streams debugging, enhanced auto‑completion for Stream APIs, and document block rendering—to boost your Java development productivity and streamline code editing workflows.
This article explains how to set up the environment, identify key MyBatis components such as SqlSession, Executor, StatementHandler, ParameterHandler, TypeHandler, and ResultSetHandler, and strategically place breakpoints to effectively read and understand MyBatis 3.5 source code within a Spring Boot 2.3.3 application.
Discover ten practical VS Code techniques—from fast refactoring and custom view layouts to debugging, symbol navigation, split editing, terminal renaming, Git shortcuts, search snapshots, and visual page building—that can dramatically improve your frontend development efficiency and productivity.
A production MySQL server was overwhelmed by a high‑volume query that ignored a crucial composite index because the leftmost key was missing, leading to full‑table scans, CPU saturation, and a half‑hour outage, and the post explains how the issue was diagnosed and fixed.
This article explains MySQL 8.0.20's lexical analysis, describing the lexer’s role, the state‑machine implementation, step‑by‑step debugging with LLDB on macOS, the init_state_maps function, key source code snippets, and the optimizations introduced in this version.
This comprehensive guide explains how to use IntelliJ IDEA's Debug mode—including launching the debugger, managing breakpoints, inspecting variables, evaluating expressions, employing smart step‑into, configuring conditional breakpoints, handling multithreaded debugging, and using drop‑frame and force‑return features—to efficiently trace and troubleshoot Java applications.
This article critically examines Fiddler Everywhere, comparing its free and Pro editions, highlighting missing capabilities, analyzing the product roadmap and update cadence, and concluding why the tool is unlikely to become popular despite its attractive pricing.
This article explains Java's Compare-And-Swap (CAS) mechanism, illustrates its usage with AtomicInteger code examples, walks through step‑by‑step debugging of CAS operations, and discusses its advantages, limitations such as the ABA problem and spin‑wait overhead.
An intermittent slowdown in a Java SaaS app, even during low traffic, was traced to a Log4j locking bug that blocked hundreds of threads; capturing a thread dump, analyzing it with fastthread.io, and upgrading to Log4j2 resolved the issue.
This tutorial shows Python developers how to configure the interpreter so that a short "peace mantra" is automatically printed before any script or interactive session runs, using usercustomize.py, PYTHONSTARTUP, and simple shell setup to help keep bugs at bay.
This article introduces ten practical IntelliJ IDEA plugins for Java developers, explaining their core features, shortcuts, and visual cues, so you can streamline code generation, dependency management, JSON conversion, decompilation, and more while avoiding common pitfalls.
This article explains the root cause of a memory‑leak bug in JDK8's ConcurrentLinkedQueue, demonstrates how to reproduce and visualize the issue with custom CLQ implementations, analyzes the removal algorithm, and shares practical debugging tips including a notorious IDEA debug pitfall and its resolution.
The article explains why effective error logging is crucial for troubleshooting, analyzes common sources of errors, and provides concrete guidelines and code examples for writing clear, complete, and actionable log messages that aid developers in quickly identifying and resolving issues.
This comprehensive tutorial walks you through installing PyCharm Community or Professional, creating and configuring Python projects, writing and running code, debugging, unit testing, version control integration, using plugins, and leveraging advanced features such as remote development and profiling, all illustrated with screenshots for macOS, Windows, and Linux.
This article explains how Android native exceptions (NE) are captured, processed, and logged as tombstone files, detailing the signal registration, debuggerd workflow, crash_dump execution, unwinder backtrace generation, and how developers can analyze the resulting data using tools like addr2line.
A Java Spring service method misused map.contains and REQUIRES_NEW transaction propagation, leading to unreleased DB connections and a CannotCreateTransactionException, and the article walks through the bug, its root causes, and concrete fixes including correct key checks and timeout settings.
jcmd, introduced in JDK 7, is a powerful built‑in Java diagnostic tool that lets you send commands to running JVMs, replace utilities like jstack and jmap, and perform tasks such as listing processes, printing thread stacks, retrieving heap information, and using Java Flight Recorder.
The article explains how to integrate Flutter into existing iOS projects using both source code and product (binary) approaches, detailing scripts, Podfile modifications, and build processes to enable seamless debugging and minimal native impact.
This article provides a comprehensive guide to using Arthas for Java backend debugging, covering installation, core trace and watch commands, OGNL expression syntax, practical examples for inspecting method calls, accessing static fields, and integrating with Spring context via advanced command techniques.
The article recounts the author's evolution from avoiding source code to actively reading JDK, Spring, MyBatis, Shiro and Quartz implementations, explains why reading code matters for interviews and personal growth, and shares practical methods—including official docs, books, blogs, and IDE breakpoint debugging with concrete Spring Boot‑Quartz examples.
The article details a step‑by‑step investigation of a Spring Boot application that unexpectedly used 7 GB of physical memory despite a 4 GB heap limit, revealing how native memory allocations, the Inflater class, and glibc memory pools caused off‑heap leaks and how proper configuration and library updates resolved the issue.
This article walks through a real‑world Dubbo debugging case where a NoClassDefFoundError was silently swallowed, showing how to use Arthas watch commands to capture the exception, analyze the root cause in static initializers, and fix the logging dependency conflict.
This article explains Python error handling using try...except...finally, demonstrates how to interpret tracebacks, and introduces debugging techniques such as print statements, assertions, and the pdb module, providing code examples and practical guidance for developers.
The article outlines a six‑step method for diagnosing sporadic JVM hangs in a high‑concurrency Xianyu service—starting with code review, live state capture, I/O checks, lock analysis, resource‑exhaustion assessment, and finally framework thread‑pool tuning—to uncover lost‑lock behavior and severe thread‑pool imbalance that cause prolonged lock waits despite low CPU load.
This guide explains the Linux packet‑receive path, shows how to verify UDP loss with tools like ethtool, ifconfig, and netstat, and provides step‑by‑step methods to identify NIC, driver, kernel, firewall, buffer‑size, and application causes while offering concrete commands to adjust ring buffers, sysctl parameters, and socket settings.
This article narrates a detailed, step‑by‑step debugging process for a sudden drop in data volume caused by Kafka partition bottlenecks, covering problem verification, code inspection, environment checks, logging, packet capture, load testing, and the final resolution of increasing partition size.
This article introduces essential JDK command‑line tools such as jps, jinfo, jstat, jmap, jhat and jstack, explaining their options, usage examples, and how they help developers monitor, diagnose and troubleshoot Java applications in production environments.
The article recounts a detailed troubleshooting process—including data verification, code review, DBA assistance, local debugging, environment comparison, logging, packet capture, service restarts, async‑to‑sync changes, load testing, and Kafka partition tuning—that ultimately identified a Kafka partition bottleneck as the cause of a sudden data‑volume decline after a new feature went live.
This article explains how to use Arthas's tt (TimeTunnel) command to record method parameters, return values, timestamps, and execution details, compare it with the watch command, and replay recorded calls, accompanied by field definitions and a practical Java demo.
This guide explains how to use Arthas's trace command to capture Java method call paths, measure execution time for each node, handle class and method patterns, and highlights its limitations with lambda expressions, providing practical code examples and output analysis.
This guide introduces a collection of classic Linux debugging utilities—including file, ldd, ltrace, hexdump, strings, readelf, objdump, strace, nm, and gdb—explaining their purpose, typical usage, and providing concrete command‑line examples to help developers troubleshoot binaries and libraries efficiently.
This comprehensive tutorial walks you through installing PyCharm, creating and running Python projects, debugging, testing, navigating large codebases, integrating version control, using plugins and external tools, and exploring professional features like Django support, all illustrated with step‑by‑step screenshots and shortcuts.
This article introduces the Arthas watch command, explains its four observation points and main parameters, and shows how to use OGNL expressions to monitor Java method invocations, including arguments, return values, and exceptions.
Android 11 Developer Preview 3 brings new debugging APIs, system‑level wireless ADB, faster incremental APK installation, data‑access auditing, plus updates to CameraX, Dagger integration, Kotlin object usage, high refresh‑rate rendering, and the latest AndroidX library releases.
This article explains how Arthas's redefine command enables hot‑updating of Java classes at runtime, outlines scenarios where redefinition fails, offers tips for uploading compiled .class files, and provides a concrete code example demonstrating the process.
This guide explains typical Laravel 7 installation problems—including missing PHP extensions, Composer version conflicts, 403 errors, cache issues, permission errors, and migration failures—provides step‑by‑step commands to install via Composer, generate the application key, configure the web server, and troubleshoot each error with clear solutions.
This guide explains why the Go trace viewer shows a blank page in Chrome, due to a disabled local API, and provides a step‑by‑step solution involving registering an origin‑trial token, modifying the trace source, and rebuilding the tool.
This article explains why a MyBatis query may return zero rows even though the identical SQL run directly in the database returns data, and shows how correcting line‑break placement in the XML mapper resolves the inconsistency.
Learn how to install and launch Alibaba’s open‑source Arthas tool, explore its dashboard, run essential commands like thread and watch, and see a practical Java demo, all in a concise step‑by‑step tutorial that gets you debugging Java processes fast.
Woodpecker is an open‑source iOS debugging platform that integrates UI inspection, object viewing, method monitoring, PO commands, and JSON capture into a plugin‑based architecture, enabling developers, testers, designers, and product teams to locate and resolve issues directly on the device without a computer.
This article explains why debugging is a core skill for developers, walks through essential IntelliJ IDEA debugging features, introduces command‑line debugging with jdb, and demystifies remote debugging by exploring the JPDA architecture and its underlying protocols.
This article compiles a series of frequent Jenkins pipeline problems—such as Git parameter handling, credential plaintext usage, Sonar scanning, JSON parsing, HTTP request handling, and build termination—and provides practical solutions, code snippets, and tips to help developers avoid pitfalls and streamline their CI/CD workflows.
This article explores the components of Chrome DevTools, explains the DevTools Protocol structure, details the frontend architecture, and provides step‑by‑step guidance for remote debugging, custom extensions, and session replay using WebSocket forwarding and server‑side recording.
This article compiles a series of real-world Jenkins pipeline problems—ranging from Git parameter handling and credential usage to Sonar scanning, JSON parsing, and pipeline control—offering concise solutions and code snippets to help DevOps engineers avoid common pitfalls and streamline their CI/CD workflows.
This article provides an in-depth analysis of MySQL's Metadata Lock (MDL) system, detailing lock types, data structures, acquisition, upgrade, downgrade processes, compatibility matrices, and practical debugging via custom print functions, with code examples and performance schema observations.
This article explains the benefits of reading source code and provides a step‑by‑step guide for setting up a Gradle‑based environment, downloading, importing, compiling, and debugging Spring Framework source code with practical code examples and IDE configuration tips.
This article introduces essential Java debugging skills, covering IntelliJ IDEA’s powerful debugging features, command‑line debugging with jdb, remote debugging setup, and the underlying JPDA architecture, providing developers with both practical tips and a deeper understanding of how Java debuggers work.
This article introduces Arthas, an open‑source Java diagnostic tool, explains its key features, demonstrates four practical troubleshooting scenarios with command examples, and shows how to start using it via an IDE plugin or direct download.
The article examines why a small fraction of developers earn six‑figure salaries while many remain average, outlining seven decisive abilities—raw coding, debugging, simplicity, accurate schedule prediction, low‑level system knowledge, strict key‑design focus, and avoiding perfectionism—that together create a massive performance gap.
