KafkaBridge is a lightweight, multi-language SDK that simplifies Kafka read/write operations, offering unified interfaces, long‑connection reuse for PHP‑FPM, and reliable message delivery, with detailed compilation steps, usage examples, and performance benchmarks across C++, Python, PHP, and Go.
The article details how Redis’s incremental rehashing can double memory usage and trigger massive key eviction and scan inconsistencies in large‑scale clusters, explains the underlying dictionary structures, demonstrates the cursor bug when tables shrink, and presents a memory‑guard and scan‑cursor patch that resolves both problems.
This article presents a curated list of noteworthy open‑source C projects—including event libraries, caching systems, databases, web servers, testing frameworks, and classic Unix kernels—each with a brief description, key features, and download links for developers seeking practical learning resources.
This tutorial presents a complete enterprise‑level Makefile example, detailing version numbering, dynamic library integration, macro definitions, include paths, compilation flags, output directory handling, and clean targets, while also showing the associated source code layout and how to retrieve the full project from the public account.
This article explains a practical approach for managing common C source files shared by several applications by placing the shared code in a dedicated folder and using a Makefile that automatically discovers, compiles, and links both the common and application‑specific files, reducing redundancy and simplifying maintenance.
This article walks through the design and implementation of a C program that reads a text file, replaces all occurrences of a target substring with a new string using low‑level pointer operations, and writes the modified content back to the file, complete with memory‑allocation calculations and code examples.
Unity3D runs C# scripts by compiling them to Common Intermediate Language, which the embedded Mono virtual machine executes—mirroring the .NET CLR—allowing cross‑platform execution, while also supporting other languages compiled to IL, and illustrating the compilation pipeline from source to native code.
This article explains how a unified, cross‑platform long‑connection component built on libuv, mbedTLS and WebSocket was refactored into a plug‑in architecture that decouples layers, uses double‑linked structures and function pointers, and dramatically improves flexibility and maintainability.
This article explains C/C++ constants—including integer, floating‑point, character, string, and symbolic forms—their syntax, examples, and common errors, and then covers variables, their definition, assignment, initialization, and related best‑practice notes.
This article details how to migrate a video‑fingerprinting pipeline—covering video frame extraction, Hessian‑Affine + SIFT feature computation, JPEG and BLAS dependencies, multi‑threading, NEON acceleration, package‑size reductions, and a Bloom‑filter based retrieval system—onto iOS and Android devices while addressing practical pitfalls and performance trade‑offs.
This article provides a comprehensive overview of the .NET platform’s evolution, covering the original .NET Framework, its comparison with Java, the rise of Mono for cross‑platform support, the introduction of .NET Standard, the modern .NET Core and ASP.NET Core, and guidance on tooling and learning resources.
This article explains Redis's dictionary structure, the conditions that trigger rehashing, the step‑by‑step incremental rehash process, and provides the core C implementation code, illustrating how Redis maintains high performance while resizing its hash tables.
This article presents the design, DPDK‑based implementation, performance optimizations, and test results of KDNS—a C‑language DNS server that replaces ContainerDNS's Go server, achieving near line‑rate processing, high availability, and significant latency improvements over traditional bind9 solutions.
This article explains how to access native C/C++ functions and complex structures from Java using JNI, JNA, and SWIG, compares their trade‑offs, provides type‑mapping tables, detailed code examples for struct definitions, passing, and callbacks, and offers practical tips for reliable cross‑language integration.
This article explains the circuit breaker pattern for distributed systems, detailing its problem context, state machine solution, implementation in C#, key considerations, usage scenarios, and comprehensive unit tests, illustrating how to improve system resilience and prevent cascading failures.
This article explains how to set up gcov and lcov on Ubuntu, write a simple C++ program, compile it with coverage flags, generate .gcno and .gcda files, use lcov to create an HTML coverage report, and interpret the resulting line and function coverage percentages.
This article recounts a 2017 internal high‑performance competition where a C server handling a 40 million‑row user‑info dataset was progressively optimized through data compression, custom hash tables, memory layout redesign, and a thread‑pool model, ultimately achieving a four‑fold throughput increase.
The article outlines a systematic method for structuring native‑layer code and using dlopen, dlsym, and dlclose to dynamically load and unload .so libraries on Android, enabling selective loading, reduced memory usage, hot‑fix updates, and solutions to STL version, permission, and C++ name‑mangling challenges.
This article describes how the author built a Python library called CAAFinder to simplify Dassault CATIA CAA development by managing API references, and walks through setting up a PyCharm project with a VirtualEnv to use the tool.
The November TIOBE index shows Python climbing to fourth place, surpassing C#, while other script languages slip down the top‑20, prompting analysis of Python's rapid growth, Java's decline, and the performance challenges facing scripting languages in large‑scale software.
This article explains C macro fundamentals, covering object-like and function-like macros, advanced techniques such as variadic macros, token pasting, and practical examples like NSLog, singleton, and weak/strong patterns in ReactiveCocoa in iOS development.
This article explains why Xiaomi built Pegasus to replace HBase, describes its architecture—including MetaServer, ReplicaServer, partitioning, multi‑replica design and the PacificA consensus algorithm—covers implementation challenges such as load balancing, consistency, latency, testing, and outlines current status and future plans.
According to the October 2017 TIOBE Index, Java, C, and C++ remain the top three languages, while C# and Python hold fourth and fifth places; Swift has slipped to 16th, and the rise of hybrid mobile frameworks is boosting C# and JavaScript at the expense of Java and Swift.
This article interviews Baidu’s chief architect Ge Jun about the origins, design principles, performance advantages, and open‑source release of the high‑performance C++/Java RPC framework brpc, highlighting its extensive internal use, architectural features, and future roadmap.
This article explains the fundamental ideas of Domain‑Driven Design, showing how to build expressive domain models, use a ubiquitous language, map bounded contexts, apply strategic and tactical patterns, and implement the concepts with C# code, UML sketches, and architectural guidelines.
This tutorial explains how to build and integrate OpenSSL 1.1.0e for modern Android, iOS, and Linux environments, providing shell scripts for each platform, detailed configuration steps, and examples of using the resulting static libraries in C, JNI, and Java code.
This article presents a detailed, game‑like learning roadmap for programmers, recommending foundational scripting languages, Unix/Linux mastery, web development, databases, C/C++ and Java, system programming, design patterns, and advanced topics such as distributed systems and big‑data technologies to guide career growth.
A backend process that reports CPU and memory every 10 seconds missed occasional reports on Windows because the Sleep function oversleeps by up to one scheduler time slice, a problem solved by adjusting timing or using higher‑precision wait mechanisms such as Event.wait on Linux.
This article explains what a finite state machine (FSM) is, where it is commonly used, and walks through three C implementations—plain if/else, switch‑case, and a function‑pointer table—highlighting their advantages, drawbacks, and providing complete code examples.
This article recounts a baffling C bug where Microsoft's tmpfile() on Windows creates files in C:\, causing a stray backslash to comment out code, and explains how replacing a ternary operator with an if‑else fixed the issue while illustrating common cross‑platform pitfalls.
The article explains why adding 0.1 and 0.2 in JavaScript, Python or C produces 0.30000000000000004 instead of 0.3, by detailing binary floating‑point representation, IEEE‑754 encoding, exponent alignment, rounding rules, and shows C code that reveals the exact stored bits.
This guide walks through creating a basic HTTP/1.0 web server in C that handles GET/POST requests, serves static HTML, performs error handling, runs simple CGI scripts, and interacts with a MySQL database, complete with project structure and common troubleshooting tips.
This article explains the concepts of anonymous and named pipes in Linux, compares their characteristics, shows how to create them with mknod and mkfifo, and provides a complete C example that implements a two‑process chat program using threads and pipe I/O.
This article walks through the Linux kernel's clock management code, explaining how the clk_get_sys function matches devices, handles mutexes, and enables clocks on Samsung platforms, while illustrating each step with annotated code screenshots.
The article discusses practical solutions for long C++ build times, introduces a company‑wide compile cluster with a localbuild.sh script, outlines how developers can run automated tests, defines testing strategies, sets criteria for feature readiness, and presents approaches to performance testing and estimation adjustments within a CI‑driven development workflow.
This step‑by‑step guide shows how to set up Unity with Google’s Cardboard SDK, import the required assets, add gaze‑based interaction components, write a C# script to change object colors on focus, link events, and finally package the project for Android devices.
This article explains how a simple Hello World program is transformed from source code into machine code, detailing the roles of object files, sections, linking (static and dynamic), and loading, while showing practical examples with GCC, objdump, and readelf on Linux.
This article explains how to create a PHP extension function named array_concat that merges two arrays by concatenating string values for matching keys, detailing the required C code, Zend hash operations, parameter parsing, and example usage, providing a practical guide for PHP developers.
This guide walks through extending MySQL 5.6.32 by adding a new SQLCOM_STOP_SLAVES command that stops all replication slaves, detailing modifications to lex.h, sql_cmd.h, sql_yacc.yy, sql_parse.cc, and mysqld.cc, along with compilation tips and troubleshooting steps.
This article uses a mailbox analogy to explain Linux socket I/O models—synchronous blocking, synchronous non‑blocking, I/O multiplexing with select, and signal‑driven I/O—providing detailed C and Perl code examples and discussing each model's advantages and drawbacks.
This article explains how Tencent's Mars framework provides a cross‑platform, high‑performance logging module (xlog) for mobile apps, covering its architecture, the evolution from V1.0 to V2.0, mmap usage, compression, encryption, and practical implementation details.
This article provides an in‑depth technical walkthrough of MySQL’s MEM_ROOT memory allocator, covering the key macros, the MEM_ROOT and USED_MEM structures, initialization and allocation routines, pointer‑manipulation logic, and the heuristic algorithm that grows block sizes as usage increases.
This article explains the concept of Linux kernel memory pools, details the mempool_t structure, shows how to create and destroy a mempool, and walks through the allocation and free functions with code examples, highlighting their role in preventing allocation failures under memory pressure.
This article explains what zombie processes are in Linux, how they are created when a child exits without its parent calling wait, demonstrates their detection with ps, provides sample C code to reproduce and handle them, and shows techniques to avoid their accumulation.
The article explains MySQL’s DYNAMIC_STRING structure, detailing its fields, how to initialize it with init_dynamic_string, and how functions like dynstr_append_mem, dynstr_trunc, dynstr_realloc, and dynstr_append_os_quoted manage dynamic resizing, truncation, and OS‑quote handling for safe string operations.
This article examines the design of WeChat's cross‑platform XLog module, detailing how it balances performance, reliability, and security through memory buffering, mmap usage, and efficient compression to provide smooth, loss‑less logging for mobile applications.
This article explains how to design and implement a simple game server framework, covering the definition of server development, the two main game‑server architectures, core scene‑service requirements, a lightweight network library built on sockets, and sample C# code for connectors, server and client networking components.
The article introduces Ctrip DAL, an open‑source Java/C# database access framework that supports sharding across MySQL and SQL Server, provides a code generator and client library, and helps large enterprises manage multi‑team, multi‑database environments while ensuring scalability, consistency, and security.
Ctrip DAL is an open‑source, multi‑language database access framework that supports sharding, code generation, and cross‑team management, enabling large‑scale enterprises to protect existing investments while rapidly scaling their data layer across MySQL and SQL Server.
This article introduces the open‑source Exceptionless framework, explains how to set up an account, integrate it into an ASP.NET Core project, configure logging and custom events with code examples, and shows how to view and manage collected error data.
This article describes a C# program that continuously captures microphone audio, uses volume thresholds derived from Fourier analysis to automatically start and stop recording, and provides the full configuration and source code needed to build a smart recorder for capturing dream speech.
This guide introduces WebAssembly and its ecosystem—explaining how Emscripten compiles C/C++ to asm.js or .wasm, how Binaryen converts asm.js to the final binary, and provides step‑by‑step Ubuntu installation, simple hello‑world compilation, build‑process wrappers, and real‑world examples such as FFmpeg, SQLite, and game engines.
This article walks through a basic C "Hello World" program, shows its compiled assembly in Visual Studio, and explains each instruction and register to reveal the low‑level operations hidden behind a seemingly trivial example.
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.
This article explains the fundamentals of unit testing, compares it with integration testing and test‑driven development, describes what makes a good unit test, shows how to improve code testability, and provides concrete C# examples using XUnit, FluentAssertions, and Moq.
This article examines typical C/C++ memory problems, classifying them into memory leaks and performance issues caused by fragmentation, explains root causes such as lost pointers, improper releases, unbounded allocations, and provides diagnostic examples and mitigation strategies using memory pools like tcmalloc.
The article recounts how the author transformed a massive, repetitive three‑tier factory class in a C# data‑center management system into a clean, reflection‑based solution of just a few lines, while sharing practical refactoring lessons, pitfalls of code generators, and advice on unit‑testing and architecture design.
This article examines fourteen typical CPU‑related performance problems in C/C++ applications—such as excessive memset, inefficient string handling, improper container usage, lock contention, and heavy I/O—explains their causes, presents real‑world examples, and compares popular CPU profiling tools to guide developers toward effective optimization.
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 explains how to use Linux pthread condition variables, covering initialization, the pthread_cond_wait function, signal handling, and a complete C example that demonstrates thread coordination and mutex interaction for reliable multithreaded programming.
This guide walks you through locating PHP internal function definitions in the source tree, using strpos as an example, and explains the surrounding C code structure, parameter parsing, error handling, and macro usage for deeper insight into PHP's backend implementation.
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 compiles a comprehensive set of embedded‑C interview questions covering preprocessors, macros, infinite loops, data declarations, static, const, volatile, bit manipulation, fixed‑address memory access, interrupts, code snippets, dynamic allocation, typedefs and obscure syntax, each with detailed explanations and example code.
This article explains MySQL's widely used MEM_ROOT memory allocator, detailing its macros, the MEM_ROOT and USED_MEM structures, initialization routine, allocation algorithm, and pointer handling, while illustrating how free and used blocks are managed via linked lists.
This tutorial walks you through installing Lua on Ubuntu, creating a convenient symlink, then demonstrates both calling Lua functions from C and invoking C functions from Lua, complete with compilation commands and expected output screenshots.
Clang Static Analyzer, integrated in Xcode, provides static code analysis for C, C++ and Objective‑C, and this guide explains its core checkers, common warning types such as null‑pointer dereference and division‑by‑zero, and demonstrates how to run it via scan‑build on an iOS project to generate HTML reports.
This article compiles a comprehensive, English‑language overview of numerous open‑source .NET libraries and frameworks—including caching, logging, NoSQL, scheduling, IoC containers, ORMs, serialization, cross‑platform runtimes, web, mobile, networking, graphics, desktop, testing, transaction, search, validation, charting, and messaging solutions—providing brief descriptions for each.
This article explores four high‑performance TCP server models in .NET/C#—Asynchronous Programming Model (APM), Task‑based Asynchronous Pattern (TAP), SocketAsyncEventArgs (SAEA), and Registered I/O (RIO)—detailing their accept and read loops, implementation nuances, pooling strategies, and sample code, while highlighting performance considerations and real‑world usage.
David Fullerton explains how Stack Exchange uses a C#‑centric monolith‑plus design, Redis caching, ElasticSearch, and continuous rolling deployments across two data centers to reliably handle billions of monthly requests while maintaining performance and scalability.
This article explains why Chinese characters often appear as garbled text on Windows and Linux, introduces the history and hierarchy of Chinese encoding standards such as GB2312, GBK, GB18030 and Unicode, compares ASCII, UTF‑8/16/32, shows practical command‑line experiments, and offers guidance for handling Chinese text in C and Python programs.
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 presents a step‑by‑step case study of locating and fixing a memory‑leak problem in Baidu's Bigpipe Broker backend by analyzing a running leaking process with GDB, pmap, and custom scripts, highlighting the pitfalls of Valgrind and the importance of clear function naming.
This article details a real‑world investigation of a memory‑growth issue in a core backend service caused by improper use of Protocol Buffers, describing the symptoms, reproduction attempts, step‑by‑step root‑cause analysis, the implemented fix, and performance verification results.
The article details the author's multi‑month effort to replace SQL Server persistence in the open‑source EQueue message queue with a high‑performance local file storage solution, covering the motivations, design considerations, chunked binary file format, write‑and‑read mechanisms, and flushing strategies.
A graduate student recounts the shocking code quality issues he found in his team's data‑mining project, highlighting bad naming, massive classes, duplicated logic, overuse of singletons, excessive comments, and other anti‑patterns that jeopardize maintainability and graduation.
This article details the design, implementation, and performance of Lushan, a high‑throughput offline static data storage server built with libevent that supports dynamic library mounting, key‑value indexing, and efficient query handling for large‑scale recommendation workloads.
This article compiles 33 notable open‑source web crawler projects across multiple programming languages, detailing their core features, licensing, supported platforms, and typical use cases, helping developers choose the right tool for large‑scale data harvesting and analysis.
This article provides a concise overview of numerous deep learning libraries and frameworks available for Python, Matlab, C++, Java, JavaScript, Lua, Julia, Haskell, .NET, and R, highlighting their main features, language bindings, and typical use cases in artificial intelligence research and development.
This article introduces the YouCompleteMe Vim plugin, explains its semantic completion advantages over traditional text‑based methods, lists supported languages, shows installation and compilation steps for macOS and Linux, and provides configuration tips to achieve IDE‑like code assistance within Vim.
This article explains C#'s managed and unmanaged resource handling, memory regions, garbage‑collection algorithms, generational GC, finalizers, the IDisposable pattern, value vs. reference types, and practical methods for discovering and pinpointing memory leaks in Windows Phone applications.
LevelDB, created by Google Fellows Jeff Dean and Sanjay Ghemawat, is a high‑performance C++ key‑value library that provides persistent, ordered storage with snapshots, compression, and atomic batch operations, achieving up to 400,000 random writes and 60,000 random reads per second.
The article argues that while programmers obsess over performance gains, maintainability is often more critical, illustrating this with C# LINQ vs Single/First debates, database design pitfalls, and the hidden costs of premature optimization, ultimately urging developers to prioritize readable, maintainable code and measure performance before refactoring.
The author recounts transitioning from PHP and .NET web development to building Android and iOS apps with Xamarin, describing the motivations, new programming paradigms like MVVM and async, the steep learning curve, and the ongoing commitment to mastering mobile development.
This article explains how to embed the Lua scripting engine into native C programs, Java applications via LuaJava, Android apps using JNI, and iOS projects, covering environment setup, bridge functions, compilation commands, and runtime examples for each platform.
This article explains Linux kernel interrupt handling, top‑half and bottom‑half mechanisms, IRQ request/release, shared IRQs, disabling/enabling IRQs, tasklets, workqueues, softirqs, the timer API, and provides a complete character‑device driver example with a user‑space test program.
On Linux, C source is turned into an ELF executable through compilation with gcc, linking of object files and libraries, and loading by the kernel, a process that depends on CPU architecture, binary formats, symbol tables, dynamic relocation, and startup code before main runs.
This guide walks you through creating a lightweight WPF desktop application that leverages Baidu Translate’s public API to translate words, covering API key acquisition, HTTP GET requests, JSON parsing with Newtonsoft.Json, UI design in XAML, and handling special characters, enabling instant word translation without ads.
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.
The article surveys ten frequently cited quirky language features—from JavaScript’s “+” string coercion and automatic semicolon insertion, to Perl’s mandatory true module return and cryptic special variables, C’s interchangeable array indexing, PHP’s mixed case sensitivity, Ruby’s truthy zero, Python’s indentation blocks, C’s pointer arithmetic, and Java’s autoboxing with Integer caching—highlighting their surprising behaviors and community frustrations.
