This article explains the end‑to‑end architecture, principles, and code implementation of the dynamic cross‑platform framework (Roma/Dynamic) on HarmonyOS, covering template loading, JS‑C++‑ArkTS instance creation, V‑Dom and Component tree construction, rendering pipeline, view updates, and performance optimizations.
This article explains how the Huolala mobile team built a stable symbol demangling system using the open‑source symbolic‑demangle tool, covering the concepts of name mangling, why symbolic was chosen, step‑by‑step adaptation for newer Swift versions, Linux Python‑wheel building, and practical troubleshooting tips.
This article details Ctrip's end‑to‑end weak‑network identification model, covering background, metric selection, data collection on iOS and Android, processing pipelines with dynamic weighting, weighted median calculations, success‑rate trends, threshold tuning, and deployment results across multiple platforms.
QuickJS manages memory using reference counting for each object combined with a cycle‑collector that periodically scans roots, decrements child references, and frees objects whose counts drop to zero, while also supporting traditional reachability‑based garbage‑collection techniques such as mark‑sweep, copying, and generational collection.
This article explains the technical mechanisms behind game memory modifiers—including memory scanning, DLL injection, debugging tools, file editing, anti‑cheat evasion, and pointer scanning—using the "Black Myth: Wukong" trainer as a concrete example, and provides complete C++ code samples.
This article explains how the Python interpreter initializes its runtime environment, compiles source code into PyCodeObject bytecode, creates stack frames, and executes the bytecode using functions like PyEval_EvalFrame and _PyEval_EvalFrameDefault while detailing the role of the runtime stack and its associated C macros.
The article explains how Linux manages memory page watermarks, when the allocator falls back to kswapd, and the exact conditions that trigger direct compaction via __alloc_pages_direct_compact, then walks through the core compaction functions—try_to_compact_pages, compact_zone_order, compact_zone, and the page‑migration helpers—illustrated with flow diagrams and real kernel code.
This article explains how Redis implements dynamic string expansion using the Simple Dynamic String (SDS) structure, detailing the sdsMakeRoomFor function, its allocation strategy, type handling, and the architectural changes introduced in Redis 7.0.
This article examines the concept of weak pointers and weak references in Go, Rust, Java, and C#, comparing their implementations, explaining their memory‑management semantics, presenting concrete code examples, and discussing the upcoming Go weak‑pointer proposal and practical scenarios such as caching and event handling.
The article explains how to ensure data correctness in Linux inter‑process shared memory communication by using synchronization mechanisms—semaphores, mutexes, and condition variables—providing step‑by‑step code examples for each method and discussing their proper initialization, usage, and potential pitfalls.
This article presents a curated collection of high‑impact C utility code examples—including a circular buffer, assertion macro, bit‑reversal function, fixed‑point arithmetic, endianness conversion, bit masks, timer handling, binary search, and a simple bitset—explaining their purpose and showing ready‑to‑use implementations for embedded systems.
The article analyses the design of Rust’s Mutex API, compares it with the classic C/POSIX mutex API, explores alternative Rust designs that mimic C, and demonstrates through concrete code examples why Rust’s guard‑based approach preserves safety while a C‑style API would re‑introduce data‑race hazards.
This guide explains how to replicate Linux kernel's initcall mechanism in STM32 projects by using function‑pointer sections, modifying the linker script, and defining ordered initialization macros to replace sequential main‑function calls, enabling modular and loosely‑coupled code execution.
This article explains how to use eBPF fentry and fexit probes to monitor the Linux unlink system call, compares them with kprobes, provides complete C and Go examples, shows compilation with eunomia‑bpf, and discusses the low‑overhead advantages of fentry for kernel tracing.
This article explains how to create and bind native UI components in HarmonyOS by leveraging ArkUI's C/C++ API, covering project setup, library linking, module interface acquisition, node creation, attribute setting, and integration with ArkTS through NodeContent and ContentSlot.
This article walks through creating a first eBPF program using C and Go on Ubuntu 22.04, covering required dependencies, kernel‑space vs user‑space concepts, event selection, BPF map definition, and a tracepoint function that measures per‑process CPU time.
This article explains C function pointers—from basic declaration and typedef usage to calling functions, passing pointers as parameters for callbacks, returning pointers from functions, and creating pointer arrays—illustrated with complete code samples and practical use cases.
The article examines the launch of the Chinese 3A title "Black Myth: Wukong", analyzes programmers' challenges in high‑cost game development, presents survey data on AI coding tools, introduces Tencent Cloud AI Code Assistant, and provides a step‑by‑step tutorial for integrating the assistant into Unreal Engine projects using Rider.
This guide walks through the complete GCC compilation pipeline—preprocessing, compilation, assembly, and linking—demonstrates how to build a simple C program, inspect the resulting ELF file, and use Binutils tools to analyze sections and disassemble the binary.
The article examines the technology behind the Chinese AAA title “Black Myth: Wukong”, revealing its use of Unreal Engine 5 with C++ as the core language, additional JavaScript integration via Unreal.js, and discusses community speculation about tools like PuerTS while also containing promotional material for development tools.
The article examines how the Chinese AAA title “Black Myth: Wukong” leverages Unreal Engine 5, C++, Blueprint visual scripting, and even a custom C#‑based USharp plugin to deliver cutting‑edge graphics, physics, AI, and culturally rich gameplay, illustrating the convergence of advanced technology and Chinese heritage in modern game development.
The article explains that Black Myth: Wukong is built mainly with C++ on Unreal Engine, outlines the engine's royalty model, and uses this case to highlight why Chinese developers favor Java and Python over C++, the challenges of low‑level software development in China, and the need for more domestic C/C++ talent.
This article reviews the evolution of hot‑update methods in games, critiques Lua, PuerTS, and HybridCLR, and proposes a minimalist Unity solution that combines AssetBundle resource updates with runtime DLL loading via reflection, demonstrating a simple, low‑dependency architecture validated on Android VR projects.
This article explores the classic “Hello World” program across five popular programming languages—Python, C#, C++, JavaScript, and PHP—detailing each language’s syntax, key functions, and code snippets, while reflecting on the significance of this introductory example for beginners.
This article explains why memory leaks occur only with heap allocations in C, describes how malloc and related functions allocate memory, outlines two common ways to obtain heap memory, identifies the three essential elements of a leak, debunks common freeing misconceptions, and provides practical inspection steps to prevent leaks.
This article explains how to implement finite state machines in C using three classic approaches—switch‑case, table‑driven, and function‑pointer—detailing their structures, code examples, trade‑offs, and safety considerations for embedded and general‑purpose software development.
The article examines DARPA's TRACTOR project, which aims to use large‑language‑model AI to automatically translate legacy C and C++ code into safe Rust, discusses the memory‑safety motivations, technical challenges, community reactions, and the broader push by US agencies to abandon unsafe languages.
This article explains how C's /* */ and // comment delimiters work, shows edge cases where they appear inside strings, macros, or line continuations, and provides concrete code examples illustrating correct and incorrect usages along with the compiler errors they may trigger.
This article explains three core ways to implement finite state machines in C—switch‑case, table‑driven, and function‑pointer approaches—detailing their structures, code examples, advantages, pitfalls, and how they relate to extended and hierarchical state machines.
This article explains the differences between array‑based sequential storage and pointer‑based linked storage, introduces singly, doubly and circular linked lists, and provides complete C implementations for creation, insertion, deletion, and traversal with clear diagrams and step‑by‑step code examples.
This guide explains core C programming concepts—including bitwise operators, macro definitions, conditional compilation directives, extern declarations, typedef aliases, struct usage, and the static keyword—providing clear examples and code snippets to help developers write more efficient and maintainable code.
Domain-Driven Design (DDD) is a software development methodology that bridges business and technology by defining clear domain models, improving communication, code quality, and handling complexity through layered architecture, with concrete C# examples of entities, value objects, aggregates, and domain services.
The article explains that __disable_irq() and __enable_irq() are compiler‑provided intrinsics that expand to CPSID i and CPSIE i instructions, return the prior PRIMASK state, globally mask CPU interrupt handling without stopping hardware events, and contrasts them with CMSIS __NVIC_DisableIRQ/EnableIRQ which control individual interrupt lines.
This article reviews JetBrains AI, an LLM‑powered assistant for JetBrains IDEs, exploring its code‑completion, code‑explanation, unit‑test generation, and refactoring capabilities through real C# examples and discussing its impact on developer workflows.
This guide explains how LCDs work as LED matrices, how to create and use dot‑matrix font libraries, the various modulo methods for mapping bits to bytes, differences between vector and bitmap fonts, and the Chinese character encodings (GB2312, GBK, GB18030) needed for multilingual embedded displays.
Multithreaded programming splits tasks across logical and hardware threads to exploit multicore CPUs, requiring careful use of synchronization primitives such as mutexes, read‑write locks, condition variables, and lock‑free atomics, while avoiding pitfalls like race conditions, deadlocks, and false sharing for correct, high‑performance software.
The article presents a detailed engineering analysis of RaftKeeper v2.1.0, describing benchmark methodology, performance gains across create, mixed, and list workloads, and four major optimizations—including response serialization parallelism, list‑request handling, system‑call reduction, thread‑pool redesign, and asynchronous snapshot processing—demonstrating substantial throughput and latency improvements in large‑scale ClickHouse deployments.
The article explains how encapsulating peripheral registers in a struct rather than using separate global variables reduces literal‑pool usage, cuts instruction count, and improves execution speed on Cortex‑A9, providing step‑by‑step assembly analysis, compilation commands, and further optimization techniques.
This article shows how C can achieve object‑oriented‑style design by using structs to model classes and function pointers as methods, providing concrete code examples such as a linked‑list implementation, interface definition, and test harness to illustrate the technique.
This article provides a detailed technical overview of Presto 2.0, the native C++ query engine built on the Velox library, covering its motivation, vectorized architecture, memory management, performance benchmarks from Meta and IBM, and deployment practices for large‑scale data warehouses.
This article reports that C++ has overtaken C to rank second in the latest TIOBE index, outlines the historical evolution of C++ across three phases, highlights the recent record climbs of Go and Rust, and notes the broader usage of these languages despite the presence of promotional material.
Meituan enhances Apache Spark by integrating the Gluten‑Velox vectorized execution engine, converting row‑wise operations to columnar SIMD processing, which yields over 40 % memory savings and up to 13 % faster runtimes across thousands of ETL jobs, while addressing stability, ORC support, shuffle redesign, and off‑heap memory optimization.
TBOX is a C‑based cross‑platform development library that unifies interfaces for multiple operating systems, offers a rich set of modules such as streams, coroutines, databases, networking, and utilities, and provides detailed build instructions and example code for rapid integration.
This article explains how to use the C standard library functions setjmp and longjmp to create a lightweight cooperative multitasking scheduler without timers, covering their mechanics, stack handling, task creation, time‑slice yielding, and provides complete example code and a Git repository link.
This article explains how to implement finite state machines in C using three approaches—switch‑case, table‑driven, and function‑pointer—detailing their structures, code examples, trade‑offs, and extensions such as compressed tables and hierarchical state machines for robust embedded systems.
This article introduces Reader, an open‑source Jina AI tool that converts any web URL into a format optimized for large language models, and llm.c, a minimalist C and CUDA project that demonstrates how to train a GPT‑2‑style LLM from scratch.
This article provides a comprehensive, hands‑on tutorial for Windows developers on how to set up the Visual Studio environment and use the cl.exe command‑line compiler to build, link, and optimize C++ programs, covering basic commands, common options, and practical examples.
This guide introduces Microsoft Visual C++ (MSVC), covering its key features, installation via Visual Studio or Build Tools, command‑line and VS Code integration, step‑by‑step compilation commands, and advanced options like parallel builds and PGO, helping developers efficiently build C/C++ projects on Windows.
This article explains the evolution of iLogtail from a single‑file collector to a multi‑language, plugin‑based observability pipeline, outlines the motivations for refactoring, describes the new unified data model, plugin abstractions, pipeline design, configuration management, hot‑reload mechanisms, and the separation of enterprise and open‑source code, providing a comprehensive view of the architectural upgrade.
The May 2024 TIOBE index shows an unchanged Top 5 with Python as the sole language gaining market share, while C and C++ fall due to memory‑safety concerns and PHP drops to a historic low amid competition from modern web frameworks.
This article describes how a C++‑based cross‑platform framework and a unified routing mechanism were built for WeChat Pay to eliminate platform‑specific bugs, streamline data flow, improve crash stability, cut code size by nearly 45%, and boost development productivity across iOS and Android.
This article explains how to invoke Go functions from C within the same process, covering the three‑step implementation, the required cgo compilation commands, the generated intermediate files, and the runtime mechanisms such as crosscall2 and stack switching that make cross‑language calls possible.
The article presents MaxSDK, a unified C# SDK for Unity that abstracts platform‑specific native SDKs across Android, iOS, Windows, macOS and future platforms, offering a singleton interface, abstract base classes, data models, and callback listeners to dramatically cut integration effort, maintenance cost, and enable easy extension to other engines.
This article explains the classic producer‑consumer synchronization challenge, describes its importance in concurrent programming, and provides two complete C implementations—one using mutexes and condition variables and another using semaphores—along with detailed code and sample output.
This article demonstrates how to use the Lex lexical analyzer generator to build a minimal cat‑like utility by creating an empty rule file, then extends the technique to develop a simple SQL syntax highlighter with colorized output, explaining the role of %% separators, default rules, and compilation steps.
This article presents two widely used software timeout mechanisms for embedded systems, explaining their concepts, implementation steps, code examples, and a comparative analysis to help engineers replace CPU‑blocking delays with hardware‑timer‑based solutions.
This article walks through C++ object memory layout using concrete examples, covering basic data members, methods, private and static members, inheritance (with and without virtual functions), compiler optimizations, and address‑space layout randomization, all demonstrated with GDB inspections and code snippets.
Through detailed code examples and step‑by‑step analysis, this article explains how the Linux 3.12 kernel implements file system readahead, showing how synchronous and asynchronous prefetch windows are initialized, adjusted, and used to improve sequential read performance.
Andrej Karpathy’s LLM.c project demonstrates how a compact, pure‑C (and CUDA) codebase of roughly 1000 lines can train a GPT‑2 model, covering data preparation, memory management, layer implementations, compilation, and practical tips for running and testing the model on CPUs and GPUs.
This article explains how Profile‑Guided Optimization (PGO) can increase MySQL throughput by 30‑50% without changing application code, detailing the required compilation steps, necessary CMake flags, and real‑world benchmark results that demonstrate the performance gains and their limitations.
The Zigzag Conversion algorithm rearranges an input string into a Z‑shaped pattern across a specified number of rows, tracks the current row while toggling direction at the top and bottom, stores characters per row, and finally concatenates the rows to produce the transformed string, with reference implementations in C++, Java, and Python.
This article explains C language memory partitioning—including stack, heap, global/static, constant, and code sections—illustrates their characteristics and growth directions, then applies the concepts to STM32F103 by showing memory map details and providing a complete Keil‑based C program that prints the addresses of variables in each region.
The article showcases Justine Tunney’s remarkable engineering feats—from the RedBean web server that runs the same binary on six operating systems, to the cosmopolitan libc, a 512‑byte sectorLisp, the Blinkenlights visual debugger, the RoseHub security effort, and the llamafile tool that packages large language models into a single portable executable.
This guide explains how to allocate, initialize, resize, and release heap memory in C using malloc, calloc, realloc, free, and memset, with detailed code examples and tips for avoiding memory leaks.
This article explains the POSIX standards, their role in providing portable Unix-like system interfaces, demonstrates network client‑server programming with POSIX sockets, analyzes key socket functions and the TCP three‑way handshake, and introduces POSIX named and unnamed semaphores with example code for synchronization and producer‑consumer patterns.
The April TIOBE Index shows Python gaining market share while C and C++ lose ground due to memory‑safety concerns, PHP slipping to historic lows, and a broader shift in developer preferences driven by AI, web frameworks, and security considerations.
The article presents practical backend performance optimization methods—including substituting Protobuf with native C++ classes, employing cache‑friendly data structures, integrating jemalloc/tcmalloc, using lock‑free double‑buffer designs, and tailoring data formats—to achieve up to three‑fold speed improvements and significant latency reductions.
This article explains the differences between threads and processes in Linux, introduces the concept of POSIX signals, describes how signals are delivered and handled in multithreaded programs, and provides a complete C example demonstrating proper signal handling across threads.
Jared Parsons reflects on two decades at Microsoft, detailing C#'s shift to open source, the compiler’s transformation into an API, rigorous testing practices, and how these changes have shaped the language’s design, ecosystem, and performance for modern developers.
This article explains the C language memory segmentation—including stack, heap, global/static, constant, and code areas—illustrates their behavior on STM32F103 with Keil V5, and provides detailed example code that prints the addresses of variables in each region to demonstrate allocation and lifetime.
This article explains what zero‑length arrays are, how they are defined in C, why they appear frequently in the Linux kernel as flexible array members, and provides a complete kernel‑style implementation showing creation, expansion, and cleanup of a dynamically sized integer array.
The article offers a concise, modern C++ (C++11+) tutorial covering fundamental built‑in types, variable declaration with auto and uniform initialization, pointer and array handling, function definitions, overloading, templates, class design—including constructors, move semantics, inheritance, virtual functions—and essential standard‑library utilities such as smart pointers and std::function.
This article details how ByteDance's cloud‑native observability team tackled performance bottlenecks in their metricserver2 Agent—reducing memory copies, merging tiny packets, applying SIMD for tag parsing, and switching compression libraries—to cut CPU usage by over 10% and memory usage by nearly 20% while handling petabyte‑scale metric data.
This comprehensive guide introduces modern C++ fundamentals, covering core language features such as basic types, memory management, pointers, arrays, functions, object‑oriented concepts, templates, and best‑practice idioms to help developers refresh or build a solid C++ foundation.
This guide explains how to allocate, initialize, resize, and release heap memory in C using malloc, calloc, realloc, memset, and free, with clear examples, common pitfalls like memory leaks, and best‑practice recommendations for safe memory management.
Microsoft’s open‑source Garnet, built in C# for high throughput and low latency, serves as a Redis‑compatible cache; this article explains its architecture, installation via Docker, basic command usage, Java integration, supported commands, and performance benefits over traditional Redis deployments.
This article explores the fundamentals of multithreaded programming, comparing traditional lock-based synchronization with advanced lock-free techniques, and demonstrates how iLogtail implements thread models, memory barriers, atomic operations, spin locks, double-buffering, and deferred reclamation to achieve scalable, high-performance concurrency.
This tutorial walks you through installing libcurl on Ubuntu, writing a simple C program that uses libcurl to perform a GET request, compiling the code with the proper linker flags, and running the executable to display the fetched web page.
This article walks through a series‑by‑step performance‑tuning process for high‑throughput C++ services, replacing Protobuf with plain classes, adopting cache‑friendly hash tables, switching to jemalloc, implementing a double‑buffer lock‑free data structure, and tailoring data formats, each backed by concrete code examples, benchmark results, and analysis of trade‑offs.
This article explains the motivations behind iLogtail's architectural redesign, details the evolution from a single‑file C++ collector to a modular pipeline with Golang plugins, outlines the refactor goals and implementation practices, and reflects on the challenges and outcomes of the six‑month effort.
This article provides concise explanations and code examples for common interview questions covering C global variable defaults, binary representations, finding top‑k elements, double‑pointer and binary search techniques, OOP concepts in C, differences between C++ class and struct, UDP packet limits, TCP read() return values, memory leaks in infinite loops, and resource cleanup on process exit.
This article presents practical performance‑optimization strategies for high‑throughput C++ services, including replacing Protobuf with hand‑written classes, adopting cache‑friendly data structures, using jemalloc/tcmalloc instead of the default allocator, employing lock‑free double‑buffer designs, tailoring data formats for specific workloads, and leveraging profiling tools to measure gains.
Microsoft confirms its continued commitment to C# while actively recruiting Rust architects to rewrite core cloud services, highlighting Rust's performance and memory‑safety benefits, industry demand, budget considerations, and the broader trend of major tech firms investing in Rust.
This article explores the design and implementation of a portable, high‑performance JavaScript engine, covering ECMAScript basics, V8 TurboFan optimization, the QuickJS engine architecture, memory management, building and extending QuickJS, and integrating it with libuv for asynchronous I/O.
This guide explains how to manipulate hardware registers, use function pointers, and perform bit‑level operations in C to control NAND Flash on S3C2410/S3C2440 platforms, providing concrete macro definitions, struct layouts, and initialization code for portable embedded development.
This article explains why C++ template instantiation can cause code bloat and provides concrete, actionable strategies—such as extracting non‑template parts to base classes, using helper abstractions, avoiding unnecessary template parameters, and measuring binary size—to significantly reduce compiled binary size while keeping code maintainable.
This article presents nine powerful C utility code examples—including a circular buffer, custom assertions, bit reversal, fixed‑point arithmetic, endianness conversion, bit masks, timer handling, binary search, and a simple bitset—explaining their purpose and demonstrating how they can improve performance and maintainability in embedded system development.
The cpp-linter-action tool, a GitHub Action for C/C++ linting, has been updated to version 2.9.0 adding a Pull Request Review feature that posts suggestions directly in PRs, along with other functionalities such as Annotations, Thread Comments, and Step Summaries.
This article showcases the correct "Hello World" syntax for twelve widely used programming languages, providing clear code snippets and brief explanations to help beginners understand the fundamental first program across Java, C, Python, C++, C#, Visual Basic .NET, JavaScript, PHP, Objective‑C, SQL, Ruby, and MATLAB.
This article explains Netty’s reactor‑based asynchronous architecture, compares classic multithread, select, poll and epoll I/O multiplexing models, demonstrates Java‑C interaction via JNI, and provides a complete hand‑written epoll server implementation with detailed code and performance insights.
This article explains how Dart implements multithreading through Isolates built on a C++ ThreadPool, detailing the roles of Task and Worker objects, the lock mechanisms with Monitor and MonitorLocker, and the lifecycle and scheduling logic that powers Dart's runtime concurrency.
Facing low development efficiency, poor CPU utilization, and fragile fault tolerance, the QQ Browser content ingestion team rebuilt a 93‑service microservice system into a single‑process, plugin‑driven architecture, achieving up to 13‑fold throughput gains, 10‑fold batch‑processing speedups, and dramatically reduced lead times and code complexity.
This article reviews binary tree traversal methods, clarifies the correct postorder sequence, and provides Morris traversal implementations in C++, C, and Python, while also discussing common interview misconceptions and offering illustrative examples.
This article explains the motivation, dictionary design, bigram table, encoding rules, and real‑world compression results of the Smaz2 library, a space‑optimized C/Python compressor for short LoRa messages on microcontrollers with less than 2 KB RAM.
This article introduces the Zorb Framework, a lightweight object‑oriented embedded framework for STM32F429, detailing its core modules, hardware setup, debugging output, assertion handling, and a basic time system with complete C code examples.
The article examines C++'s identity crisis, arguing that a weak ecosystem, limited standard‑library support, and a focus on language features by the standards committee and Microsoft have left the language awkwardly positioned compared to languages like Java, Python, and Go.
This article revisits a 2017 decision to ban exceptions in a large codebase, examines the technical and organizational reasons behind that rule, analyzes exception mechanics, coroutine interactions, and performance impacts with concrete C++ examples, and finally proposes a pragmatic action plan for safely adopting exception‑driven design.
This article explores advanced applications of the C volatile keyword, demonstrating its role in multithreaded synchronization, embedded hardware register access, disabling compiler optimizations for debugging, and safe pointer type casting, each illustrated with complete, runnable code examples.
This article details how to train a YOLOv8‑pose model for license‑plate detection, convert it to TensorRT engine, implement C++ inference and preprocessing, expose the functionality via CGO to Go, and assemble a lightweight web service for real‑time plate recognition.
The article explores how a developer generated billions of if‑statements in C to decide odd or even for 32‑bit numbers, scaling the approach with Python‑generated code, custom assembly, memory‑mapped binaries, and discusses the practical limits and performance of such an extreme solution.
