This article explains the design and evolution of Redis's Simple Dynamic Strings (SDS), covering the original pre‑3.2 structure, the newer type‑specific headers, the core API functions for creating, clearing, and concatenating SDS objects, and the memory‑reallocation strategy that ensures binary safety and efficient storage.
This article introduces symmetric encryption algorithms such as DES, 3DES, and AES, explains their principles, advantages and drawbacks, and provides complete .NET Core sample code using the BouncyCastle library for encryption and decryption with various padding modes.
This article explains the principles of primary keys, compares auto‑increment IDs and GUIDs, introduces the Snowflake ID structure, discusses its benefits and drawbacks, and provides a complete .NET implementation using Redis for dynamic worker‑ID allocation, including handling clock rollback and code examples.
This article describes how the WeChat Pay team rebuilt the client‑side payment flow using a C++ cross‑platform framework, detailing the architectural redesign, performance improvements, routing mechanism, network request handling, and data‑flow safeguards that unified iOS and Android implementations while reducing code size and enhancing reliability.
This article explores various ways to implement interfaces in C++, comparing virtual functions, the Pimpl idiom, hidden subclasses, callback mechanisms, function pointers, std::function, member function pointers, and non‑intrusive traits, highlighting their trade‑offs in performance, binary compatibility, and design flexibility.
This article provides a comprehensive tutorial on using EF Core in .NET, covering DbContext setup for MySQL and SQL Server, thread‑safety considerations, connection‑pooling benefits, logging of generated SQL, various insertion techniques (single, cascade, bulk), querying methods, and efficient update patterns.
Lokie is a high‑performance iOS AOP framework written in C++14 that replaces the slow Aspect library by using libffi‑based trampolines, offering thread‑safe method interception, detailed API usage, runtime internals, and assembly‑level trampoline implementation with significant speed improvements.
This article walks through the design and implementation of a tiny Linux filesystem called TinyFS, explaining the VFS layers, required POSIX interfaces, data structures, core kernel code, usage steps, current limitations, and a roadmap for extending it with proper superblocks, concurrency, and page‑cache integration.
This article explains how to achieve high‑performance bulk inserts in .NET Core applications by converting entities to CSV or DataTable formats and using MySQL's LOAD DATA and SQL Server's SqlBulkCopy, providing reusable extension methods, interface abstractions, and performance benchmarks.
The article describes how the WeChat Pay client was rebuilt using a C++‑based cross‑platform framework to unify iOS and Android implementations, improve code reuse, reduce bugs, and achieve measurable performance and productivity improvements while introducing a UseCase‑driven architecture, routing mechanism, and disciplined network request handling.
With the rise of mobile, IoT, and edge computing, the long‑standing dominance of x86 is challenged, prompting developers to migrate applications to ARM‑based Kunpeng platforms; this article explains the architectural differences, a five‑step migration methodology, and detailed C/C++ compilation considerations including instruction, macro, and SIMD adaptations.
This article explains the true behavior of Thread.Sleep, clarifies common misconceptions about its timing, compares Thread.Sleep(0) with no sleep, and uses a cake‑sharing analogy to illustrate time‑slice versus preemptive scheduling in operating systems.
This article explains the LeetCode 88 problem of merging two sorted integer arrays, presents two solution approaches—simple concatenation with sorting and an optimal two‑pointer technique—and provides implementation examples in C++, Python, and Java to illustrate the concepts.
This article explains traditional image augmentation techniques focusing on geometric transformations such as translation and rotation, describes forward and backward mapping concepts, coordinate‑system conversion, matrix representations, and provides detailed C++ OpenCV examples for implementing these operations with warpAffine and getRotationMatrix2D.
This article reviews common unique identifier generation techniques—including database auto‑increment, UUID, Redis counters, Snowflake, Zookeeper, and MongoDB ObjectId—detailing their advantages, drawbacks, and practical implementation examples with C# code snippets.
This tutorial walks you through creating a simple C project in WebAssembly Studio, converting the code to WebAssembly, editing the accompanying HTML and JavaScript, and running the result in the browser, providing a hands‑on introduction to WebAssembly development.
The article discusses a real‑world scenario where a developer tried to reuse existing stored procedures to determine the presence of Job, Certification, and Disclosure records, explores various T‑SQL techniques such as temporary tables and output parameters, and concludes that stored procedures are often unsuitable for simple boolean logic due to maintenance and reuse challenges.
This article explains how WebRTC builds the video processing pipeline by detailing the capture module, internal data flow, VideoTrack construction, rendering, and encoder integration, and it outlines the key API calls such as AddTrack, CreateOffer, and SetLocalDescription that establish the end‑to‑end video stream.
This article explains the shift from X86 to ARM server architectures, the motivations for moving services to ARM cloud platforms, the challenges of instruction‑set differences, and provides concrete migration practices and tooling support from Huawei's Kunpeng ecosystem.
This guide walks you through creating a simple PHP extension, from generating the skeleton with ext_skel.php to understanding each generated file—config.m4, config.w32, php_test.h, test.c, and tests—so you can confidently build and install your own extension.
This article explains what Linux zombie processes are, why the kernel retains them after a program exits, the crucial information they store, and demonstrates how to create, observe, and properly clean up zombies using C code and standard system calls.
The article examines the historical shift from mainframes to x86, highlights the emerging need for ARM-based solutions like Huawei's Kunpeng processors, and provides detailed migration strategies, tools, and best‑practice steps for moving C/C++ and other workloads from x86 to ARM architectures.
This article explains how to combine Python with C/C++ using ctypes, Python.h wrappers, and SWIG, provides step‑by‑step code examples, and analyzes performance through bubble‑sort experiments, demonstrating the trade‑offs and best practices for high‑performance mixed‑language development.
This article explains how C++ compilers implement virtual functions using a hidden vptr and virtual table, showing how class size grows from 1 to 8 bytes, detailing memory layouts for single, multiple, and diamond inheritance, and providing commands to dump vtable and layout information.
This guide outlines a comprehensive learning path for C and C++ covering essential language concepts, core computer science fundamentals, practical Linux development tools, and recommended resources to help beginners transition into backend development roles.
This article explains the challenges of maintaining separate iOS and Android implementations for WeChat Pay, and details how a C++‑based cross‑platform framework—featuring abstracted business flows, a unified routing mechanism, managed network requests, and strict data‑transfer standards—dramatically improves code reuse, stability, and development productivity.
Microsoft announced that Visual Basic will no longer receive new features after .NET 5, focusing only on stability and compatibility, and urges developers to migrate their VB code to .NET Core while still supporting classic .NET for legacy scenarios.
This article explains why and how to adopt the open‑source Cppcheck tool for C/C++ static analysis, covering installation on Linux, building from source, command‑line usage, Jenkins plugin integration, pipeline scripting, and report visualization to prevent new warnings from entering the codebase.
This article provides a detailed summary of classic sorting algorithms—including insertion, shell, selection, bubble (standard and optimized), counting, merge (recursive and iterative), radix, and bucket sorts—explaining their stability, time complexities, and offering complete C implementations for each.
This article recounts how a developer transformed a massive three‑thousand‑line C# data‑center monitoring client into a concise fifteen‑line solution by applying reflection, generics, and systematic refactoring, while sharing practical advice on avoiding code generators, reinventing the wheel, and using unit tests to foster clean architecture.
This article introduces the concept of trees and binary search trees, defines a C struct for tree nodes, and provides complete implementations for creating nodes, inserting, deleting, searching, finding min/max, computing size and height, as well as recursive and non‑recursive traversals including pre‑order, in‑order, post‑order and level‑order.
Open Surge is a free, open‑source 2D retro platform game inspired by Sonic that also serves as a game‑creation system, written in C with Allegro, and can be easily installed on Ubuntu 18.04+ via the Snap store with simple keyboard controls.
An experienced developer recounts how he transformed a cumbersome three‑tier C# data‑center management system from thousands of lines to a concise, maintainable codebase using reflection, generics, and thoughtful refactoring, while sharing practical advice on avoiding code generators, reducing duplication, and embracing unit testing.
This article introduces dynamic programming as an optimization technique from operations research, explains its fundamental concepts, optimality principle, no‑after‑effect property, and overlapping subproblems, outlines the typical problem‑model steps, and demonstrates a practical C++ implementation for solving the fractional knapsack problem.
This guide shows backend developers how to install, proxy‑configure, and extend VS Code, then use its Remote Development extension to connect to servers and set up C++, Python, and Shell debugging, plus Git, Docker, MySQL, and productivity plugins for a lightweight, powerful IDE.
This article provides a thorough introduction to singly linked lists in C, covering their definition, basic operations, and a collection of classic interview problems such as reversal, copying, merging, loop detection, addition, sorted insertion, and finding the k‑th node from the end, each illustrated with complete source code.
This article uses a war metaphor to compare Java, Python, and C++—highlighting each language's strengths, weaknesses, typical use cases, and real‑world examples like the F‑35 fighter jet software—to help developers choose the right tool for their projects.
This article explains the core idea of greedy algorithms, outlines their basic workflow, identifies problem types where they apply, presents a generic greedy framework, demonstrates a fractional knapsack implementation in C++, and lists several classic greedy problems with brief solutions.
This article explains how to enumerate every permutation of an array using a depth‑first search backtracking algorithm, illustrates the process with a tree diagram, compares DFS with BFS, and provides a complete C implementation along with a generic Python template.
This article explains the binary‑tree maximum path sum problem, provides example inputs and outputs, analyzes three possible path configurations, and presents both a brute‑force and an optimized depth‑first search implementation in C.
This article explains why WebAssembly needs a standardized system interface, introduces the WebAssembly System Interface (WASI) for portable and secure execution, and provides a step‑by‑step tutorial for compiling a C "cat" program with wasi‑sdk and running it via Node.js.
This article details a comprehensive set of practical techniques—ranging from Xcode project configuration tweaks and CocoaPods packaging to CCache, distcc, hardware tricks, PCH usage, and deep Clang/LLVM analysis—that together reduced a massive iOS build from over 27 minutes to under 10 minutes.
This tutorial walks through setting up a Kunpeng development environment, building a simple Hello World program, creating a cross‑platform CMake project, and compiling, installing, and packaging MySQL 5.7 as RPM/DEB packages for CentOS 7 and Ubuntu 18.04.
This article explains how Redis implements its own string type using Simple Dynamic Strings (SDS), details the internal structure and dynamic expansion mechanism, and highlights the performance benefits such as O(1) length retrieval, buffer‑overflow protection, and reduced memory allocation overhead.
This article introduces common memory‑leak detection tools, explains how to analyze heap memory consumption of a C++ process using AddressSanitizer, Valgrind and the core_analyzer utility, and provides practical optimization suggestions for reducing memory bloat and fragmentation.
The article critiques the conventional step‑by‑step coding curriculum and introduces Jeff Olsen’s “prediction‑first” approach, which uses problem‑driven prediction to engage learners, improve conceptual understanding, and foster deeper programming skills across languages like Java, Python, and C.
This article demonstrates how to leverage WebAssembly and Emscripten to compile C code for high‑performance MD5 hashing and archive (zip/7z) parsing in the browser, covering library selection, memory management, file I/O via WorkerFS, async processing, and integration of C functions with JavaScript.
To overcome fragmented C++ builds across mobile, car‑machine and open‑platform teams, Gaode Map created the Python‑driven Abtor tool that generates CMake projects and manages cloud‑hosted dependencies, and paired it with the scalable Amap CI pipeline, enabling unified, cross‑platform compilation, automated testing, and permission‑controlled library publishing.
This article recounts a twelve‑year‑old French government software project that ballooned to over six million lines of C++ code, suffered from obsolete technology, chaotic version control, and absurd management practices, ultimately ending in failure and the arrest of its leaders.
This tutorial explains how to compile the ImageMagick C/C++ library to WebAssembly using Emscripten and Docker, configure its dependencies (zlib, libpng, libjpeg, libwebp), build the wasm module, and invoke ImageMagick commands from JavaScript with a virtual file system in the browser.
This article walks through the native entry point of the Java launcher, explaining how the main function delegates to JLI_Launch, initializes the JVM, loads the main class, constructs arguments, and finally invokes the Java main method with detailed code excerpts.
This article explores Nginx’s elegant architecture, detailing its master‑worker process model, modular design, event‑driven engine, and the step‑by‑step initialization sequence—including command‑line parsing, cycle creation, container setup, configuration parsing, socket inheritance, and listening socket creation—based on version 1.15.8.1.
WebAssembly enables high‑performance, ahead‑of‑time compiled code to run in browsers, and iQIYI leverages it by writing a C‑based FLV‑to‑MP4 transcoder compiled to Wasm, executed in a Web Worker, which boosts live‑stream conversion speed, reduces CPU usage, and opens doors for further web‑based media processing.
This article walks you through applying object‑oriented concepts in C by implementing the State design pattern, covering class simulation with structs, inheritance via macros, lifecycle management, polymorphism, and a complete client example that demonstrates state transitions for a water model.
A graduate student recounts the chaotic state of his research team's C# data‑mining project, highlighting poor naming conventions, oversized classes, overuse of singletons, redundant code, lack of proper inheritance, and other anti‑patterns, while offering concrete suggestions such as using meaningful identifiers, applying the single‑responsibility principle, leveraging LINQ, and adopting MVVM for cleaner, more maintainable code.
An intriguing experiment shows that replacing a harmless "y += 0" with "y += 0.1f" makes a tight C++ loop run seven times faster, revealing how denormalized floating‑point numbers trigger costly CPU paths and how understanding IEEE‑754 representation can restore performance.
This article provides a step‑by‑step tutorial on performing C++ code‑coverage testing using gcov, covering compilation flags, running the instrumented program, generating gcov reports, and creating detailed HTML reports with lcov, including command examples and configuration details.
This article explains why a C# char literal like '\x1d11e' is illegal, how Unicode code points map to glyphs, the role of code pages on Windows and Linux, and practical tips to avoid encoding mishaps across different programming languages.
This article explains gcov, the GCC‑bundled C/C++ code coverage tool, covering its basic concepts, the workflow for generating coverage data, and the instrumentation technique using basic blocks and arcs to record execution counts.
The article details Redis 6’s new multithreaded I/O feature—motivated by network‑I/O bottlenecks, implemented with lock‑free pending‑read queues that offload reads, writes, and protocol parsing to worker threads while keeping command execution single‑threaded—and demonstrates through a simple benchmark that using four I/O threads roughly doubles GET/SET throughput compared with Redis 5.
This article explains why the author created a custom C++ TCP server framework, outlines the required prerequisites and coding standards, and walks through a minimal echo server implementation together with the key cppbox library interfaces and usage examples.
This article explains how to locate and modify in‑memory game data, write simple Windows‑API cheat programs, automate gameplay actions, and intercept network traffic for popular PC games, providing step‑by‑step examples and full source code for each technique.
The article explains MySQL 8.0’s new iterator‑based executor, detailing the underlying iterator model, its advantages over the legacy executor, the specific RowIterator classes introduced, supported query features, and future enhancements for more advanced algebraic operations.
The article explores how bitwise operations can dramatically speed up counting the number of set bits in a 32‑bit integer, presenting a naive O(n) solution and four successive optimizations that reduce runtime from about two seconds to under a tenth of a second, while sharing practical low‑level coding tricks.
This article explains the principles of Linux shared memory interprocess communication, details the shmid_ds structure and system limits, walks through creation, control, attachment, detachment APIs, and provides a complete C example demonstrating parent‑child data sharing via shmget, shmat, shmdt, and shmctl.
The article details the background, design goals, layered architecture, message flow, UI customization mechanisms, and key class structures of the 58 Group's cross‑platform IM SDK, illustrating how it supports iOS, Android, Web, and H5 with extensible C++ and UIKit components.
This article introduces the Asynchronous Programming Model (APM) in C#, demonstrating how to use delegates and BeginInvoke/EndInvoke to run time‑consuming operations concurrently, includes sample code, explains delegate generation, and discusses practical considerations such as IAsyncResult handling and callback execution.
This article explains how C# thread pools reduce thread‑creation overhead, describes several ways to enqueue work (Task Parallel Library, ThreadPool.QueueUserWorkItem, asynchronous delegates, BackgroundWorker), provides practical code examples, and outlines important considerations such as thread naming, priority, and exception handling.
Developers can boost efficiency by using Excel to concatenate column values into SQL IN clauses or C# List syntax, locate duplicate entries, split cell contents by delimiters, and permanently disable automatic hyperlink creation, with step‑by‑step visual guides illustrating each technique.
This article explains how to create and start threads in C#, covering ThreadStart delegates, lambda expressions, passing parameters, naming threads, foreground/background distinctions, thread priority, and exception handling, with clear code examples and best‑practice recommendations.
This article introduces C# multithreading concepts, covering thread creation, memory isolation, data sharing, thread safety with locks, and the use of Join and Sleep methods, while providing clear code examples and explanations of how threads are scheduled and interact with the CPU.
This article introduces C# multithreading concepts, demonstrates thread creation, memory isolation, data sharing, thread safety with locks, and explains the use of Join and Sleep methods, providing practical code examples and best‑practice guidance for concurrent programming.
The article explains BufferQueue’s internal design and shows how Android developers typically use its wrapper classes—Surface as the producer and SurfaceTexture as the consumer—detailing their constructors, dequeue/queue workflows, lock/unlock mechanisms, and a complete SurfaceView example that illustrates buffer production and consumption by SurfaceFlinger.
This guide introduces five Android apps that let you write, compile, and run C/C++, Java, Python, front‑end web, and Linux code on a smartphone, with installation steps, key features, and screenshots to help beginners start mobile programming quickly.
This article introduces recursion by outlining its three essential elements—function purpose, base case, and recurrence relation—and demonstrates each step with clear Java/C examples such as factorial, Fibonacci, frog‑jump, and linked‑list reversal, while also covering common pitfalls and optimization techniques.
This article explores blockchain programming fundamentals, compares public and permissioned chains, reviews major development platforms, and evaluates the top five languages—C++, JavaScript, Python, Go, and Solidity—highlighting their strengths, weaknesses, and real‑world blockchain applications.
Microsoft has open‑sourced the Windows 10 Calculator app under the MIT license, providing C++ source code, build prerequisites, feature lists, and community‑reported bugs, while highlighting its role in Microsoft's broader open‑source strategy.
The article shares a developer’s experience interviewing at over 30 Chinese tech firms, breaking down three main interview focuses—data structures and algorithms, operating‑system and core‑technology knowledge, and project experience—while also offering practical advice on networking questions, open‑source tools, and how to evaluate a company's interview process.
The article shares the author’s interview experiences at over 30 companies and provides a comprehensive guide covering data‑structure and algorithm questions, core C++ concepts, operating‑system fundamentals, networking protocols, open‑source tools, project‑experience expectations, and practical advice for evaluating both technical and non‑technical aspects of potential employers.
Drawing from interviews at over thirty tech firms, this article breaks down the three main interview tracks—data structures and algorithms, operating‑system fundamentals, and project experience—while also sharing practical advice on evaluating companies, handling non‑technical questions, and navigating the hiring process.
Pika 3.0, the open‑source C++ Redis‑compatible storage built on RocksDB, introduces a new Blackwidow engine, enhanced binlog, and optimized server layer, delivering higher interface performance, reduced disk usage, extended key length, full ZSET compatibility, and improved overall efficiency.
The article details the design and overall architecture of ZhaiZhai's instant messaging (IM) system, covering product positioning, a four‑layer architecture (user, entry, logic, storage), and analyses of scalability, high availability, reliability, extensibility, and performance, highlighting the use of C++, RPC, MySQL, TiDB, and custom middleware.
This article demonstrates how to retrieve jokes from a free online API using Python, provides the same functionality in C#, shows the expected results, and includes links to the original API documentation for further exploration.
The article explains why a C++ program produces different outputs with and without the -O2 optimization flag, tracing the issue to strict aliasing violations caused by type‑punning pointer casts, and shows how disabling -fstrict-aliasing or using -fno‑strict‑aliasing resolves the problem.
Learn multiple techniques to calculate the square root of 2—including binary search, Newton’s iteration, and a clever C library implementation—through clear explanations, step‑by‑step illustrations, and full JavaScript and C code examples that reveal the underlying mathematics and performance considerations.
This article walks through the NewLife.Redis library’s two‑layer architecture, demonstrates basic and advanced usage with C# examples, shows pressure‑testing results, and shares practical tips such as GetAll/SetAll, pipelines, and serialization tricks for high‑throughput big‑data scenarios.
This article introduces blockchain as a secure data‑block structure and presents a concise overview of five popular programming languages—C++, Java, Python, Ruby, and Solidity—highlighting why each is suited for building blockchain applications.
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.
