Linus Torvalds, the creator of Linux, publicly denounced C++ as a terrible language while supporting the inclusion of Rust in the kernel, sparking heated debate among developers about language choice, safety, and the future of low‑level system programming.
This article reviews the evolution of Node.js N-API, its ABI‑stable add‑on API, new multithreading and context support features, helper functions, build tooling options, and provides practical guidance for getting started and contributing to the ecosystem.
This article demonstrates how to convert traditional scikit‑learn and hmmlearn machine‑learning models into ONNX format and integrate them into a C++ gRPC service for fast online inference, covering environment setup, model conversion, custom operators, performance testing, and end‑to‑end pipeline construction.
The article examines the heated discussion about whether C++ is obsolete, presenting TIOBE ranking data, contrasting opinions on its relevance in various domains such as operating systems, game engines, and web development, and offering practical advice for newcomers deciding if C++ should be their first programming language.
This article explains how to build a high‑performance large‑file HTTP upload service with resumable support by using a C‑based server, client‑side hash generation, cookie‑based browser IDs, AJAX queries for upload progress, and JavaScript code that slices files and tracks upload speed and progress.
The article presents a high‑performance, thread‑safe object pool that combines thread‑local freelists, a global pool, and cache‑line‑aligned structures to reuse expensive objects, dynamically expand capacity, and achieve 50‑70% lower allocation latency than standard malloc/free and existing pool implementations.
The article demonstrates how Top‑down Micro‑architecture Analysis Methodology (TMAM) can quickly pinpoint CPU bottlenecks—such as front‑end, back‑end, and bad speculation stalls—in a simple C++ accumulation loop, and shows that applying targeted compiler, alignment, and branch‑prediction optimizations reduces runtime by roughly 34 % while increasing retiring slots.
This article explains how to integrate FluentValidation into ASP.NET Core for robust model validation, covering installation, defining validators, registering services, handling validation errors, conditional rules, cascade modes, asynchronous validation, and advanced features, with complete code examples.
A recent P2P box SDK upgrade introduced video screen‑tearing and gray‑screen issues for app users, which were traced to a faulty C++ vector initialization that caused multiple data buffers to share the same memory, and resolved by rolling back the SDK.
This article revisits traditional hash table design, then introduces a novel approach that deliberately leverages a controlled probability of hash collisions combined with SIMD parallelism, presenting the B16 and B16Compact hash tables, their structures, algorithms, and experimental results showing superior speed and space efficiency compared to unordered_map and F14.
This article explains the importance of comments in C/C++ code and provides detailed guidelines for file, function, variable, spelling, and TODO annotations, including examples and best‑practice recommendations to improve code readability and maintainability.
Tesla’s CTO Vijayan led a 25‑person team to create the company’s proprietary ERP, Warp, in just four months—starting with the low‑code platform Mendix, then rewriting it in C# on .NET for private‑cloud deployment—offering insights into rapid ERP development, low‑code choices, and architecture trade‑offs.
The article explains that aircraft software relies on standard computer components but requires highly reliable, robust, real‑time operating systems such as VxWorks for Boeing 787 and AH‑64, Integrity‑178B for many fighter jets and Airbus A380, and recent C++ implementations with CompCert for the F‑35, highlighting the unique demands of aerospace computing.
The article explores why building truly reusable components is challenging by comparing a concise functional F# implementation of FizzBuzz with a more verbose object‑oriented C# version, highlighting how language paradigms and design assumptions affect modularity, coupling, and extensibility.
This article presents ten practical low‑level optimization strategies—ranging from reducing computational workload and extracting common subexpressions to loop unrolling, accumulator parallelism, and conditional‑move coding—each illustrated with C examples, detailed analysis, and before‑after performance comparisons.
This article explains why comments are essential for code readability, outlines consistent comment styles, details file, function, variable, spelling, and TODO annotations, and provides practical examples to help developers write clear, maintainable C/C++ documentation.
The article compares the infinite loop constructs for(;;) and while(1) in C by compiling simple programs, examining the generated assembly with gcc, and shows that both produce identical machine code, while also noting compiler warnings and style preferences.
The article explains how the Linux kernel discovers and calls module initialization functions like inet_init by using the fs_initcall macro, which creates static initcall variables placed in specially‑named sections that the linker groups and the kernel iterates at boot time.
This article explains the shift from x86 to ARM architectures, outlines why services should be migrated to ARM‑based Kunpeng cloud servers, describes Huawei's migration tools and community support, and provides concrete C/C++ migration examples and common pitfalls for backend developers.
Gaode’s navigation service adopted test‑driven development using Google’s GTest to replace slow diff‑based checks with fast, lightweight unit tests, enabling incremental refactoring of legacy code, improving quality, handling data‑dependency challenges, and demonstrating that writing tests first clarifies requirements while adding minimal overhead.
This article explores how Test‑Driven Development and Google Test can improve quality and enable incremental refactoring of a complex, legacy online navigation system by addressing the shortcomings of traditional diff‑based testing, introducing unit‑testing fundamentals, and sharing practical implementation details and lessons learned.
This article presents a comprehensive guide on migrating business code from x86 to TaiShan aarch64 servers, covering language differences, compilation toolchains, architecture‑specific issues such as compiler options, assembly rewrites, memory ordering, floating‑point behavior, and recommended GCC optimizations.
This article benchmarks C and Rust by implementing five classic sorting algorithms—Bubble, Insertion, Selection, Shell, and Heap Sort—across three data sizes, analyzes the execution times on a macOS system, and discusses the nuanced performance differences and broader implications for language choice.
This article recounts how Tesla's CTO led a 25‑person team to develop the "Warp" ERP in just four months, initially using the Mendix low‑code platform before rewriting it in C# on .NET and deploying it to a private cloud, highlighting the technical decisions behind the project.
This article introduces static code analysis, outlines its advantages and disadvantages, presents eight typical scanning rule categories, and demonstrates common pitfalls such as null‑pointer dereferences, logic errors, uninitialized variables, and potential overflow issues with concrete code examples.
By systematically analyzing compilation stages and applying a mix of generic tactics—parallel and distributed builds, precompiled headers, ccache, C++20 modules, include pruning—and code‑level changes such as forward declarations, external templates, and replacing heavy Boost headers, the Meituan Search & NLP team cut a 20‑minute C++ build to about 100 seconds, a 70 % reduction, and instituted a compile‑fingerprint system to guard against regressions.
This article introduces Xrkmonitor, a Chinese open‑source monitoring platform that combines point monitoring, log collection, data visualization, and alerting, and provides detailed advantages, featured functions, online and offline deployment guides, and the underlying technology stack.
ImHex is a rapidly popular open‑source hex editor designed for eye‑friendly binary editing, offering features such as hex view, byte patching, custom language support, multi‑architecture disassembly, data import/export, and a sleek dark‑theme UI, with compilation instructions for Windows and Linux provided.
This guide walks through creating a Linux word‑and‑phrase translation tool that captures selected text via the X clipboard, translates it with translate‑shell, and displays the result in the terminal, using only a few command‑line utilities and a small C program.
The gRPC Core 1.34.0 release introduces numerous improvements and bug fixes across multiple language implementations, including new environment variable security support, Unix abstract socket URIs, enhanced xDS handling, updated platform compatibility, and added support for recent PHP, Python, and Ruby versions.
The article uses a casual conversation between two backend engineers to introduce multithreading concepts, explain shared vs. private resources, define thread‑safe and reentrant functions, illustrate common pitfalls with code examples, and provide practical guidelines for writing correct concurrent C++ services.
The latest Furion release introduces numerous new templates and utilities for MVC, WebAPI, Razor, and Blazor, updates core packages, refactors service resolution and authorization, fixes a wide range of bugs, and refreshes documentation for quick start, security, and database operations.
This article explains the purpose and benefits of layered software architecture, compares traditional three‑tier designs with hexagonal architecture, discusses system splitting and micro‑service considerations, and provides C# code examples illustrating domain, application, and adapter layers.
This article describes how a C++‑based cross‑platform framework was created to unify iOS and Android implementations of WeChat Pay, detailing the architectural challenges, the introduction of UseCase‑driven business flow, a routing mechanism, improved network request handling, and standardized data passing that together reduced code size, improved stability, and boosted development productivity.
TarsBenchmark is an open‑source, high‑performance microservice load‑testing tool from Tencent that uses a multi‑process, event‑driven architecture with connection reuse and lock‑free monitoring, supports extensible protocols via JSON test cases, and offers both single‑machine and cloud‑distributed testing, outperforming traditional tools like Apache Bench, Wrk, and JMeter.
This article explains the Android Property system, detailing its shared‑memory architecture, the trie‑based data structures (prop_bt, prop_area, prop_info), the initialization flow in the init process, the core C APIs for adding, reading, updating and iterating properties, and the Java SystemProperties wrapper used by applications.
This guide explains the GCC compiler's evolution, how to compile C and C++ programs using gcc and g++, highlights their differences, and provides practical command examples and linking options for successful builds.
This article provides a comprehensive overview of the most common Selenium WebDriver exceptions, categorizes them into checked and unchecked types, details language‑specific variants for Java, C# and Python, and offers practical guidance on diagnosing and handling each exception during automated browser testing.
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 explains why embedding compile‑time information in embedded binaries is essential for version verification, demonstrates how to use __DATE__ and __TIME__ macros, and provides three practical methods—including touch commands and pre‑build actions—to ensure the timestamp updates on every build.
This article presents a comprehensive overview of September 2020 Chinese programmer salaries by city, detailed statistics for Java developers, and the latest TIOBE programming language rankings, including historical trends, market share, and notable changes across major languages.
This step‑by‑step tutorial explains how to create both a notification‑type and an auto‑reply DingTalk robot, covering configuration in the DingTalk console, constructing webhook URLs, preparing JSON payloads, and implementing the required C# backend code to send and receive messages.
This tutorial explains how to create a unified DingTalk event distribution platform that registers a single callback URL, handles encrypted success responses, and forwards various DingTalk events—such as address changes and approval workflows—to internal business systems for bidirectional synchronization and automated processing.
This article describes how WeChat Pay built a C++‑based cross‑platform framework that unifies iOS and Android payment flows, introduces a UseCase‑driven architecture with routing, refactors network request handling, and standardizes data transmission to cut code by 45%, boost reliability, and accelerate feature delivery.
This article explains why DingTalk workflow is chosen, outlines its advantages and limitations, and provides a detailed, code‑driven tutorial on how to quickly integrate and launch a custom approval process using DingTalk's open platform APIs.
The report analyzes participant demographics in Alibaba Cloud's online programming competition, revealing a severe gender gap, nationwide representation, a predominance of young coders, a strong preference for C++, extensive problem‑solving habits, and quirky concerns like hair anxiety.
This article explains how to generate PKCS#12 (p12) certificates using BouncyCastle in .NET Core, extract keys with OpenSSL, install the certificates on Windows, and demonstrates encryption and decryption with the generated keys, providing complete code samples and step‑by‑step instructions.
This article examines two widespread misconceptions about object‑oriented programming—whether OOP inevitably slows down applications and whether an OOP language automatically means OOP programming—using performance data, real‑world examples, and a Java code sample to clarify the truth.
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.
