BestHub
Sign in
Tagged articles

debugging

1053 articles · Page 11 of 11
High Availability Architecture
High Availability Architecture
Dec 11, 2016 · Artificial Intelligence

Why Machine Learning Is Hard: Debugging Challenges and Exponential Difficulty

The article explains that while machine learning has advanced with abundant courses, textbooks, and frameworks, engineers still face hard debugging problems due to algorithmic, implementation, data, and model dimensions, leading to exponential difficulty and long feedback loops that demand intuition and systematic testing.

Artificial Intelligencedebuggingmachine learning
0 likes · 8 min read
Why Machine Learning Is Hard: Debugging Challenges and Exponential Difficulty
Qunar Tech Salon
Qunar Tech Salon
Dec 9, 2016 · Mobile Development

Understanding and Tackling Memory Leaks in Android Applications

This article explains what memory leaks are on Android, outlines their common sources, introduces various detection tools such as Lint, StrictMode, LeakCanary, Android Memory Monitor, MAT and adb commands, and provides practical strategies for locating and fixing leaks in mobile apps.

AndroidMemory LeakMobile Development
0 likes · 9 min read
Understanding and Tackling Memory Leaks in Android Applications
ITPUB
ITPUB
Oct 19, 2016 · Frontend Development

15 Chrome DevTools Tricks to Supercharge Your Frontend Workflow

Discover 15 powerful Chrome DevTools shortcuts—from quick file search and regex source scanning to multi‑cursor editing, color picking, device emulation, and workspace file editing—that dramatically boost debugging speed and productivity for web developers.

Chrome DevToolsdebuggingtips
0 likes · 9 min read
15 Chrome DevTools Tricks to Supercharge Your Frontend Workflow
Meituan Technology Team
Meituan Technology Team
Oct 1, 2016 · Backend Development

Debugging Spring MVC @Service Bean Injection Issues with JMap and JHat

The article explains how a Spring MVC service bean was duplicated across root and child WebApplicationContexts, causing a null‑injected instance that triggered a NullPointerException, and shows how JMap and JHat were used to locate the two beans and resolve the issue by adjusting component‑scan filters or removing the @Service annotation.

JavaSpring MVCbean-injection
0 likes · 14 min read
Debugging Spring MVC @Service Bean Injection Issues with JMap and JHat
ITPUB
ITPUB
Sep 27, 2016 · Backend Development

Building a Linux C++ Memory Leak Detector with Custom New/Delete

This article explains how to implement a memory‑leak detection subsystem for Linux C++ programs by overloading the global new/delete operators, recording allocation sites with file and line information, handling mismatched deletions, supporting dynamic monitoring, and addressing nested‑delete and mutex re‑entrancy issues.

C++LinuxMemory Leak Detection
0 likes · 30 min read
Building a Linux C++ Memory Leak Detector with Custom New/Delete
ITPUB
ITPUB
Sep 26, 2016 · Operations

8 Essential Tips for Writing Robust Bash Shell Scripts

This article shares eight hard‑earned recommendations for crafting reliable Bash scripts, covering interpreter selection, debugging flags, static analysis tools, variable expansion, proper scoping, signal trapping, thoughtful design, and recognizing when to switch to more suitable languages.

DevOpsbashbest practices
0 likes · 10 min read
8 Essential Tips for Writing Robust Bash Shell Scripts
dbaplus Community
dbaplus Community
Aug 22, 2016 · Backend Development

Debugging Rare Core Dumps in High‑Concurrency Nginx: From GDB to ASan

This article details a real‑world investigation of extremely low‑probability core dumps and memory leaks in a heavily modified Nginx/OpenSSL stack, covering debugging strategies, custom traffic‑control testing, distributed load generation, use of valgrind and AddressSanitizer, performance profiling with perf, and the mindset needed to solve such high‑concurrency bugs.

High ConcurrencyNginxaddresssanitizer
0 likes · 21 min read
Debugging Rare Core Dumps in High‑Concurrency Nginx: From GDB to ASan
Tencent Music Tech Team
Tencent Music Tech Team
Jul 20, 2016 · Mobile Development

Overview of Android TV Development

Android TV, now dominating China’s rapidly expanding smart‑TV market, offers a large shared screen experience and extensive I/O options, while development mirrors Android phone projects using Android Studio and Gradle, with debugging on boxes or tablets, and requires careful handling of limited CPU/memory, background‑process behavior, and wired‑network connectivity.

Android TVDevelopment Toolsdebugging
0 likes · 8 min read
Overview of Android TV Development
Aotu Lab
Aotu Lab
Jul 8, 2016 · Frontend Development

Unlock Console Magic: Master %c, %o, %O and ASCII Art in Browser DevTools

This tutorial explores advanced console.log techniques—including format specifiers, CSS styling, image rendering, and creating ASCII art—while detailing browser compatibility, practical code examples, and useful tools for front‑end developers seeking more expressive debugging output.

CSSascii-artconsole
0 likes · 8 min read
Unlock Console Magic: Master %c, %o, %O and ASCII Art in Browser DevTools
ITPUB
ITPUB
Jul 7, 2016 · Fundamentals

Mastering Linux printk: Levels, Macros, and Kernel Logging Mechanics

This article provides a comprehensive guide to Linux's printk system, covering its ring‑buffer design, log level definitions, early boot usage, helper macros, rate‑limiting techniques, kernel‑side implementation details, and ways to access logs from user space.

C++Operating Systemsdebugging
0 likes · 14 min read
Mastering Linux printk: Levels, Macros, and Kernel Logging Mechanics
Efficient Ops
Efficient Ops
Jun 21, 2016 · Operations

How to Effectively Learn Open Source Code: A DevOps Guide

This article outlines a step-by-step DevOps guide for mastering source code, covering preparation, code exploration, framework understanding, workflow tracing, data flow analysis, debugging techniques, and practical tips such as selecting resources, IDEs, and leveraging tests to accelerate learning.

DevOpsIDELearning Guide
0 likes · 15 min read
How to Effectively Learn Open Source Code: A DevOps Guide
ITPUB
ITPUB
Jun 21, 2016 · Backend Development

How to Debug Rare Core Dumps and Memory Leaks in High‑Concurrency Nginx/OpenSSL Deployments

This article walks through a real‑world investigation of intermittent core dumps and memory leaks in a heavily modified Nginx + OpenSSL stack under extreme QPS, detailing debugging strategies, custom load‑testing tools, and performance‑profiling techniques that helped pinpoint and fix the root causes.

High ConcurrencyMemory LeakNginx
0 likes · 23 min read
How to Debug Rare Core Dumps and Memory Leaks in High‑Concurrency Nginx/OpenSSL Deployments
21CTO
21CTO
Jun 18, 2016 · Backend Development

How to Debug Rare Core Dumps in High‑Concurrency Nginx: Tools & Strategies

This article shares a detailed post‑mortem of debugging extremely rare core dumps and memory leaks in a high‑concurrency Nginx HTTPS implementation, covering root‑cause analysis, custom stress‑test frameworks, and the use of tools such as gdb, valgrind, AddressSanitizer, perf and flame graphs to locate and fix the issues.

High Concurrencyasancore dump
0 likes · 21 min read
How to Debug Rare Core Dumps in High‑Concurrency Nginx: Tools & Strategies
Architecture Digest
Architecture Digest
Jun 18, 2016 · Backend Development

Debugging Rare Core Dumps and Memory Leaks in High‑Concurrency Nginx with OpenSSL

The article describes a real‑world investigation of extremely low‑probability core dumps and memory leaks in a heavily modified Nginx + OpenSSL stack, detailing the debugging workflow, custom high‑concurrency test harness, use of tools such as GDB, perf, Valgrind, AddressSanitizer, and the performance‑hotspot analysis that ultimately resolved the issues.

High ConcurrencyMemory LeakNginx
0 likes · 19 min read
Debugging Rare Core Dumps and Memory Leaks in High‑Concurrency Nginx with OpenSSL
Architecture Digest
Architecture Digest
Jun 11, 2016 · Information Security

In-Depth Debugging and Performance Analysis of Baidu Cloud Guard (Baidu Cloud Manager)

The article presents a detailed reverse‑engineering investigation of Baidu Cloud Guard, using Task Manager, Process Explorer, VTune, and WinDBG to expose its high page‑fault rate, anti‑debugging tricks, intensive heap allocations, and frequent process‑enumeration calls that cause excessive CPU usage.

Anti-debuggingHeap AllocationWinDbg
0 likes · 15 min read
In-Depth Debugging and Performance Analysis of Baidu Cloud Guard (Baidu Cloud Manager)
Efficient Ops
Efficient Ops
May 23, 2016 · Operations

Mastering strace: Diagnose Linux Process Issues with Real-World Examples

This article explains what strace is, how it works, and provides step‑by‑step examples—including fixing a failed service start, tracing nginx, diagnosing process crashes, shared‑memory errors, and performance analysis—to help operations engineers quickly locate and resolve Linux system problems.

Linuxdebuggingoperations
0 likes · 18 min read
Mastering strace: Diagnose Linux Process Issues with Real-World Examples
ITPUB
ITPUB
May 20, 2016 · Operations

Why MySQL Errcode 28 Happens Even With Free Disk Space—and How to Fix It

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.

CronErrcode28Linux
0 likes · 7 min read
Why MySQL Errcode 28 Happens Even With Free Disk Space—and How to Fix It
Baidu Intelligent Testing
Baidu Intelligent Testing
May 19, 2016 · Fundamentals

Common Causes of C/C++ Core Dumps and Case Analyses

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.

C++Linuxcore dump
0 likes · 6 min read
Common Causes of C/C++ Core Dumps and Case Analyses
21CTO
21CTO
May 11, 2016 · Fundamentals

5 Core Skills Every High‑Performance Software Engineer Must Master

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.

debuggingproductivitysoftware engineering
0 likes · 5 min read
5 Core Skills Every High‑Performance Software Engineer Must Master
Node Underground
Node Underground
May 9, 2016 · Backend Development

Master Node.js Memory Leak Detection: A Step-by-Step Guide

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.

Memory LeakNode.jsV8
0 likes · 12 min read
Master Node.js Memory Leak Detection: A Step-by-Step Guide
Qunar Tech Salon
Qunar Tech Salon
Apr 20, 2016 · Frontend Development

A Day in the Life of a Developer: Debugging IE7 JavaScript Issues

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.

IE7JavaScriptbug tracking
0 likes · 11 min read
A Day in the Life of a Developer: Debugging IE7 JavaScript Issues
Qunar Tech Salon
Qunar Tech Salon
Apr 14, 2016 · Backend Development

Effective Exception Handling in Java: Principles and Practices

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.

Javabest-practicesdebugging
0 likes · 10 min read
Effective Exception Handling in Java: Principles and Practices
21CTO
21CTO
Mar 26, 2016 · Backend Development

How to Pinpoint the PHP Code Behind CPU Spikes Using GDB

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.

BackendZenddebugging
0 likes · 6 min read
How to Pinpoint the PHP Code Behind CPU Spikes Using GDB
21CTO
21CTO
Feb 16, 2016 · Frontend Development

Why the JavaScript with Statement Is a Bad Idea: Performance Pitfalls and Hidden Bugs

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.

JavaScriptcode optimizationdebugging
0 likes · 9 min read
Why the JavaScript with Statement Is a Bad Idea: Performance Pitfalls and Hidden Bugs
Baidu Intelligent Testing
Baidu Intelligent Testing
Dec 4, 2015 · Fundamentals

Debugging Floating‑Point Precision Differences in Query‑Diff Tests: A CPU Instruction Set Case Study (AVX vs SSE)

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.

AVXCPUSSE
0 likes · 10 min read
Debugging Floating‑Point Precision Differences in Query‑Diff Tests: A CPU Instruction Set Case Study (AVX vs SSE)
Art of Distributed System Architecture Design
Art of Distributed System Architecture Design
Nov 25, 2015 · Backend Development

Mastering Node.js Memory: How V8 Manages Heap, Garbage Collection, and Leak Detection

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.

Node.jsdebugginggarbage collection
0 likes · 12 min read
Mastering Node.js Memory: How V8 Manages Heap, Garbage Collection, and Leak Detection
ITPUB
ITPUB
Nov 3, 2015 · Fundamentals

How to Stop Blaming Compilers and Write Better Code: 6 Proven Practices

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.

Continuous LearningSoftware Developmentbest practices
0 likes · 12 min read
How to Stop Blaming Compilers and Write Better Code: 6 Proven Practices
21CTO
21CTO
Oct 30, 2015 · Fundamentals

Boost Your Coding Efficiency: Master Planning, Pseudocode, and GTD Practices

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.

GTDdebuggingdeveloper efficiency
0 likes · 6 min read
Boost Your Coding Efficiency: Master Planning, Pseudocode, and GTD Practices
21CTO
21CTO
Oct 10, 2015 · Fundamentals

20 Essential Software Development Lessons Every Programmer Should Follow

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.

Continuous LearningSoftware Developmentbest practices
0 likes · 10 min read
20 Essential Software Development Lessons Every Programmer Should Follow
21CTO
21CTO
Sep 28, 2015 · Operations

Mastering Log Management: 16 Rules to Boost System Reliability

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.

Log Managementbest practicesdebugging
0 likes · 23 min read
Mastering Log Management: 16 Rules to Boost System Reliability
21CTO
21CTO
Sep 18, 2015 · Backend Development

Master PHP Debugging: 8 Skill Levels Every Developer Should Know

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.

Backenddebugginginterview
0 likes · 8 min read
Master PHP Debugging: 8 Skill Levels Every Developer Should Know
WeChat Client Technology Team
WeChat Client Technology Team
Aug 3, 2015 · Mobile Development

Deep Dive into Android M Doze Mode: Concepts, Debugging, and Code Analysis

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.

AndroidDeviceIdleControllerDoze
0 likes · 11 min read
Deep Dive into Android M Doze Mode: Concepts, Debugging, and Code Analysis
MaGe Linux Operations
MaGe Linux Operations
Jan 19, 2015 · Databases

Why Merging Redis Requests Can Still Slow Your System – A Real‑World Debugging Tale

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.

MGETRedisdebugging
0 likes · 9 min read
Why Merging Redis Requests Can Still Slow Your System – A Real‑World Debugging Tale
Nightwalker Tech
Nightwalker Tech
Jan 4, 2015 · Backend Development

Design and Pitfalls of Internet App Long‑Connection Push Systems and Related Backend Practices

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.

Message Queuebackend architecturedebugging
0 likes · 32 min read
Design and Pitfalls of Internet App Long‑Connection Push Systems and Related Backend Practices
Baidu Tech Salon
Baidu Tech Salon
Sep 11, 2014 · Backend Development

The Benefits of Software Maintenance and Debugging for Developers

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.

backend developmentdatabasedebugging
0 likes · 9 min read
The Benefits of Software Maintenance and Debugging for Developers
Baidu Tech Salon
Baidu Tech Salon
Jun 25, 2014 · Fundamentals

Uncovering Bohrbug, Heisenbug, Mandelbug & Schroedinbug: Software Bugs Explained

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.

Programming Fundamentalsbohrbugdebugging
0 likes · 6 min read
Uncovering Bohrbug, Heisenbug, Mandelbug & Schroedinbug: Software Bugs Explained
Baidu Tech Salon
Baidu Tech Salon
Apr 28, 2014 · Backend Development

The Elevator Bug: A Debugging Story

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.

Software Developmentbackend developmentdebugging
0 likes · 7 min read
The Elevator Bug: A Debugging Story