This guide explains the differences between carriage return and newline, explores C output buffering strategies, and provides step‑by‑step C code to create a countdown and a dynamic progress bar that updates smoothly in the terminal.
This article provides a detailed source‑code walkthrough of Envoy's outbound request processing, explaining how the proxy receives client data, parses HTTP requests, selects routes and clusters, forwards traffic upstream, handles retries and shadowing, and finally returns responses to downstream clients.
This tutorial explains how to create a console progress bar in C by covering newline versus carriage return handling, output buffering strategies, using fflush to force screen updates, and adapting the code for multi‑digit countdowns.
Linux kernels 3.9+ introduce the SO_REUSEPORT option, allowing multiple processes to bind and listen on the same port, with the kernel handling load‑balancing and security checks; this article explains the problem it solves, the underlying implementation, and provides practical C examples and verification steps.
This article provides an in‑depth analysis of Envoy's outbound request processing, covering listener initialization, the use of SO_REUSEPORT for load distribution, original destination handling, and the detailed steps of connection creation and filter chaining within the Envoy proxy architecture.
This article explains the purpose and behavior of the Thread.Sleep function in .NET, clarifies common misconceptions about its timing and effects, and relates it to operating‑system scheduling concepts such as time‑slice and preemptive multitasking.
This article walks through Redis’s annotated source code to explain how its single‑threaded architecture initializes the server, loads configuration and data, and continuously processes file and time events within a while‑loop, revealing why Redis achieves high performance without spawning additional worker threads.
This article surveys the programming languages and technologies underlying a wide range of operating systems, user interfaces, desktop tools, databases, browsers, servers, and other software, illustrating how C, C++, Java, and other languages dominate different components across the software ecosystem.
This guide outlines practical best‑practice recommendations—such as using C++17, proper header guards, forward‑slash paths, UTF‑8 encoding, restrained inline functions, standard fixed‑width types, careful char handling, readable nested templates, conditional compilation, Clang compiler, thin conversion layers, custom asserts, composition over inheritance, safe static initialization, and limited template use—to help developers write portable, maintainable, efficient C++ code across Windows, macOS, Linux, desktop and mobile platforms.
This article demonstrates how to create a basic FTP‑like file transfer application in C using Windows Winsock, covering both server and client implementations, handling file size negotiation, data transmission loops, and compilation steps, with complete source code examples.
The long‑standing Windows PDF Patcher tool, known for its rich PDF editing capabilities, has finally been open‑sourced on GitHub, revealing its C# and C codebase, .NET Framework foundation, development environment, project structure, and a unique “Conscience License” that encourages charitable giving.
This article explains how WeChat Pay tackled inconsistent iOS and Android implementations by building a unified C++ cross‑platform framework, introducing UseCase‑based business flow, a routing mechanism, and improved network request handling, resulting in fewer bugs, faster development, and higher productivity.
The article explains how to design a C++‑based multithreaded service that uses Pthreads, channels, and TensorRT to parallelize deep‑learning inference tasks, thereby reducing latency and dramatically increasing throughput for AI applications such as facial‑recognition access control systems.
This article explains why a high‑traffic platform migrated from SQL Server to Elasticsearch, covering the technical motivations, performance characteristics, indexing strategies, data synchronization methods, API design, and operational monitoring to achieve a scalable, low‑latency search solution.
This guide explains Linux kernel workqueues, their core structures and default system queues, shows how to use the schedule_work API, and walks through a complete driver example that captures the ESC key, queues a work item, and verifies execution via dmesg.
The IEEE Spectrum 2021 programming language ranking shows Python retaining the overall lead while C# jumps dramatically to sixth place, highlighting shifts in developer demand across web, enterprise, mobile, and embedded domains based on data from eight major sources.
The IEEE Spectrum 2021 programming language ranking shows Python retaining the top spot across overall and multiple sub‑rankings while Microsoft’s C# jumps from 23rd in 2020 to 6th in 2021, reflecting shifting industry demand and emerging trends.
The article explains the syntax and semantics of while(1) and for(;;) infinite loops in C, compares their generated assembly code, and demonstrates through compiled examples that both constructs produce essentially identical machine code despite minor semantic differences.
This article explains the syntax and semantics of C's while(1) and for(;;) constructs, compares their execution flow, shows how to compile each to assembly with gcc, and demonstrates that, aside from file names, the generated code is identical under typical settings.
This article explains how to improve Python performance by embedding C or C++ code: write the source, compile it into a shared library, and invoke its functions from Python with the ctypes module, providing step‑by‑step commands and example code for both C functions and C++ classes.
This article explains how Redis implements its Sorted‑Set data type by starting from a basic ordered singly linked list, analyzing its insertion and query complexities, introducing the skiplist structure, deriving its O(log N) performance, and detailing the underlying C source code for creation, insertion, lookup, and deletion.
This article explains the theoretical and practical range of Tencent QQ numbers, why the lower limit is set to 10001, how unused accounts are reclaimed, and demonstrates how bitmap techniques can efficiently deduplicate billions of QQ IDs using simple C++ code.
This article explains how Redis implements its Sorted‑Set using a skiplist, starting with the basics of a singly linked list, analyzing insertion and query complexities, deriving the skiplist structure and its O(log N) performance, and comparing it with hash tables, balanced trees, and B‑trees.
This article explains the low‑level principles of C++ coroutine context switching, walks through the owl.context API design, demonstrates assembly implementations for co_getcontext, co_setcontext, co_swapcontext and co_makecontext, and provides practical examples and code to build stackful coroutines on 32‑bit ARM.
The article describes how a C++‑based cross‑platform framework, combined with UseCase abstraction, routing mechanisms, unified network request handling, and strict data‑transfer rules, solved iOS/Android inconsistencies in WeChat Pay, cut code size by 45%, kept crash rates stable, and dramatically improved development efficiency.
This guide explains how to obtain the WebRTC m79 source, compile it for Windows, Android, and iOS, walk through the basic signaling and peer‑connection workflow, and implement advanced video‑capture and audio‑volume features with custom C++ extensions, while unifying the codebase across platforms.
The article explores how Tarn Adams has single‑handedly maintained and expanded the indie game Dwarf Fortress for two decades, growing its C/C++ codebase to over 700,000 lines, funding development through donations, and continuously adding new gameplay modes and AI features without major refactoring.
This tutorial walks through building a simple Whack‑a‑Mole Unity game, adding scene objects and state‑machine scripts, then integrating Agora's voice SDK to create a worldwide voice chat channel, complete with code examples and step‑by‑step instructions.
This article presents the complete Unity source code of the "Protect the Kitten" 2D mini‑game, explains its project structure and core scripts, and demonstrates how to integrate Agora's audio SDK to add simple voice‑chat functionality, with download links for the full project.
This article recounts a disastrous 12‑year software project with over 6 million lines of C++ code, outdated CORBA middleware, chaotic version control, and absurd management practices, illustrating how technical debt and bureaucratic mismanagement can doom even the most ambitious engineering efforts.
Visual Studio 2022 has been officially released with a go‑live license, bringing 64‑bit support, .NET 6, C++ 20, Azure Cloud Services, hot‑reload, enhanced debugging, Git integration, UI personalization, and many other productivity improvements for developers across languages and platforms.
This article explains how a Windows PE executable is launched, detailing the creation of the process and main thread, the role of the OEP, and how the runtime startup functions like _tmainCRTStartup ultimately invoke the user-defined main/wmain function.
This article explains the motivation behind creating the C++ coroutine framework "owl" for the cross‑platform WeChat client, compares callback, promise, and coroutine approaches with code examples, and details its design choices such as stackful coroutines, single‑thread scheduling, structured concurrency, and performance characteristics.
This article investigates the high CPU usage and latency observed after expanding a large Redis cluster, analyzes the root cause in the CLUSTER SLOTS implementation and client MOVED handling, proposes an optimized slot‑traversal algorithm, and demonstrates significant performance improvements through benchmarking and profiling.
In large Redis clusters the original CLUSTER SLOTS implementation traversed every master and all 16,384 slots, causing ~52 % CPU usage and high MGET latency during migrations, but redesigning it to iterate the pre‑built slot array reduced complexity to O(total slots), cutting execution time from 2 ms to 0.17 ms and eliminating the CPU hotspot, a fix now merged into Redis 6.2.2.
This article explains how Android captures ANR events by intercepting the SIGQUIT signal, covering the relevant signal‑handling functions (kill, signal, sigaction, sigwait, pthread_sigmask), their differences, the SignalCatcher thread implementation, and how developers can create custom SIGQUIT monitors for ANR analysis.
This article introduces an open‑source SMS verification module, outlines essential security features such as code expiry, length limits, request throttling, and one‑time use, and provides complete C# implementations for generating, sending, and validating both image and SMS captchas.
This article explains what program core dumps are, how to interpret core‑dump files, and provides detailed GDB debugging techniques—including register inspection, stack frame analysis, variable printing, memory dumping, and handling optimized code—to locate and resolve the root causes of crashes.
This article explains why unit testing is essential for reducing code complexity, outlines common testing models, provides language‑specific best practices for Java, C++, and Python, and describes how to measure test coverage and effectiveness across large‑scale projects.
This article explains the thread‑merging problem that arises when using PlatformView in multi‑engine Flutter scenarios, analyzes its root causes in both independent and lightweight engines, and presents a comprehensive solution—including code changes, task‑queue merging logic, and practical implementation details — that has been merged into the official Flutter engine repository.
This article shares a 985 graduate's personal background, systematic interview preparation for C++ and Go backend positions, detailed interview question collections from major tech companies, and practical advice on study resources, project presentation, and coding practice to help candidates succeed in technical interviews.
This article explains the merge sort algorithm’s divide‑and‑conquer principle, analyzes its O(n log n) time complexity, and provides two complete C# code examples—one for a generic merge sort and another for merging two already sorted arrays—along with visual illustrations of the merging process.
IEEE Spectrum’s 2021 programming language ranking, based on eight online data sources and eleven metrics, lists the top 55 languages, highlights a stable top five with Python leading, and reveals notable shifts such as C#’s rise to #6 and HTML entering the top ten.
This article details a graduate student's AI‑driven solution to the Tencent Geek Competition's "E‑Tetris" challenge, describing the EI‑Tetris heuristic, feature‑based evaluation, state‑pruned dynamic programming, C++ implementation, performance results, and potential improvements.
This article walks through embedding the V8 JavaScript engine into a C++ game server, demonstrates a HelloWorld example, shows how to bind C++ classes using Puerts, and explains how to compile and embed a full Node.js runtime, with complete code snippets and a GitHub repository link.
This article analyzes popular programming languages—including PHP, Java, C, C++, Python, Go, and JavaScript—to help beginners decide which language to start with in 2021, highlighting each language's strengths, job prospects, and suitability for newcomers.
This article explains the hierarchical design of network libraries, detailing the roles of Session, Connection, Channel, and Socket layers, their interactions, code examples, and how they can be combined or extended for various backend services.
This article explains the basic network programming pattern, introduces epoll as an I/O multiplexing solution for high‑concurrency servers, and demonstrates how Redis 5.0 integrates epoll through its event‑loop abstraction with detailed code examples and debugging tips.
The article describes how a C++‑based cross‑platform framework and a unified routing mechanism were introduced to solve iOS and Android inconsistencies in WeChat Pay, resulting in fewer bugs, 45% less code, faster feature delivery, and a more reliable data‑flow architecture.
This article explains how PyTorch's BP Engine dynamically builds the computation graph for back‑propagation, detailing its C++ class structure, thread management, task queues, and key functions such as start_threads, compute_dependencies, execute, and evaluate_function, with illustrative code examples.
This article explains how PyTorch implements its dynamic autograd graph using the core C++ classes Variable, Function, and Engine, detailing their initialization, inheritance hierarchy, code structures, and the execution flow of backward propagation.
This article explains Redis's Simple Dynamic String (SDS) data structure, its internal layout, how it differs from traditional C strings, and the performance, memory‑reallocation, and data‑format benefits it brings to Redis's key‑value storage.
This article traces the ten‑year evolution from Emscripten’s early C++‑to‑JavaScript compiler through asm.js to modern WebAssembly, highlighting key milestones, technical challenges, performance optimizations, and real‑world applications such as games, AutoCAD, and Google Meet, while providing code examples and installation steps.
July’s TIOBE Index, marking its 20‑year anniversary, shows C, Java and Python retaining the top three spots with narrowing gaps, highlights rising gains for C++, Go, Rust, TypeScript and others, and provides a detailed look at the top‑50 language rankings and historical trends.
This article provides an in‑depth English overview of PHP’s SAPI architecture, detailing the CGI SAPI module structure, the core _sapi_module_struct and sapi_globals definitions, and walking through the startup sequence including sapi_startup, sapi_globals_ctor, and FastCGI initialization with code examples.
This article explores how the C++‑based Klee framework brings component‑based, data‑driven, and reactive UI development to native mobile and desktop apps, comparing its efficiency and architecture with modern web frameworks and RxSwift, and showcasing practical code examples.
The article recounts a recent project where reusing existing stored procedures to check a user's Job, Certification, and Disclosure data led to maintenance headaches, prompting a discussion of alternative approaches, their drawbacks, and why duplicating the query sometimes becomes the only viable solution.
This article chronicles the ten‑year evolution from Emscripten’s C++‑to‑JavaScript compiler through asm.js to the modern WebAssembly standard, highlighting key milestones, performance challenges, and real‑world applications that have reshaped what browsers can achieve.
libtask, a lightweight coroutine library written by Russ Cox, demonstrates how to build a cooperative multitasking scheduler in C, detailing task creation, context switching, epoll‑based I/O handling, and a non‑preemptive FIFO scheduling model that enables asynchronous I/O to appear synchronous for server development.
The article presents recent market‑share data for programming languages, showing a decline in C/C++ and a rise in Java, and pairs this with salary charts that illustrate current compensation trends across these languages.
Gaode’s new serverless/FaaS platform, built on Alibaba Cloud Function Compute with custom C++, Go, and Node.js runtimes, now processes over 100 000 QPS, enabling a unified client‑cloud codebase, rapid feature iteration, automatic scaling and cost savings, while supporting extensive monitoring, Dapr integration, and future edge‑computing enhancements.
This article explains what WebAssembly is, why it was created, how to compile C or Rust code to .wasm, integrate it into JavaScript projects, and showcases real‑world performance gains and use cases such as image processing and barcode scanning.
A sysadmin narrates how he monitors four Redis nodes, detects master failure with PING, promotes a slave using SLAVEOF, reconfigures the remaining replicas, and ultimately automates the entire process with a custom Sentinel program and a multi‑node Sentinel cluster for high availability.
This article presents a white‑box, unit‑test‑driven approach for automatically generating C/C++ test cases that detect and recall runtime stability issues, detailing problem analysis, solution design, code‑analysis, test‑data generation, code generation, failure analysis, and deployment results across large‑scale backend modules.
This guide explains why adhering to the Linux kernel coding style matters, introduces automatic tools such as checkpatch.pl, Lindent, and astyle for fixing style violations, and details the core conventions for indentation, line length, brace placement, naming, comments, macros, and other critical aspects of kernel C code.
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.
