Genshin Impact combines Unity's C# scripting, C++ engine cores, Go or Java for servers, Python for tooling, and even hand‑written assembly for critical paths, illustrating how a modern AAA game relies on a multi‑language stack to balance performance and development speed.
This article explains how C++ implements polymorphism through virtual tables and virtual pointers, walks through their generation, memory layout, single‑ and multiple‑inheritance scenarios, distinguishes compile‑time and runtime polymorphism, and shows practical guidelines for when to use or avoid polymorphic designs.
This article explains how an operating system divides a C/C++ program's virtual address space into four distinct regions—code, global, stack, and heap—detailing their lifetimes, permissions, management rules, and common pitfalls such as memory leaks, dangling pointers, and stack overflow.
The article explains compile‑time polymorphism in C++, shows why traditional SFINAE is hard to read and debug, and demonstrates how C++20 Concepts provide clearer syntax, precise errors, and better multi‑condition support, backed by side‑by‑side code examples and a detailed feature comparison.
The author recounts how a naïve generic C++ object pool caused data residue, construction failures, and incompatibility with primitive types, then demonstrates a refactored, thread‑safe pool that leverages compile‑time Type Traits, std::enable_if, and constexpr if to apply distinct creation, reset, and destruction logic for trivial, Clear‑able, and non‑trivial types, eliminating the earlier bugs.
This benchmark measures the peak memory consumption of one, ten‑thousand, one‑hundred‑thousand and one‑million concurrent tasks in Rust, Go, Java, C#, Node.js, Python and Elixir, revealing surprising differences such as Go using far more memory than Rust and .NET showing unusually low usage.
The article explains why high‑concurrency programs suffer from memory fragmentation and system‑call overhead, compares memory pools and object pools, outlines their distinct use‑cases, provides step‑by‑step C and C++ implementations, and highlights optimization tips and common pitfalls.
The article explains how off‑heap memory and mmap enable zero‑copy I/O for high‑performance Linux services, but because the JVM does not manage it, careless allocation or missing releases can cause off‑heap memory leaks that lead to OOM, and it provides concrete detection and mitigation techniques.
The article explains how clang can dump the exact vtable layout for a class with multiple inheritance, revealing that a single vtable is actually a virtual table group composed of a primary and secondary table, each containing its own offset_to_top, RTTI entries, function slots and thunks, and shows why new virtual functions appear only in the primary part while the secondary part holds adjusted thunks for overridden base functions.
This article walks readers through the fundamentals of Linux PCI/PCIe buses, explains the kernel PCI subsystem, details core data structures such as struct pci_dev, struct pci_driver, and struct pci_device_id, and provides step‑by‑step code examples for device enumeration, driver matching, resource allocation, and practical driver implementation.
The article examines how SpaceX’s software teams—covering flight control, enterprise information systems, ground launch‑pad software, and avionics testing—use a diverse tech stack to ensure real‑time reliability, illustrating that rockets rely on both fuel and code to reach orbit.
The article explains the four most frequently tested static keyword pitfalls in C/C++ interviews—local variable initialization, thread‑unsafe functions, file‑level global scope, and class member sharing—detailing their underlying lifetime and scope rules, common misconceptions, and a concise answer template to prevent losing an offer.
Genshin Impact combines Unity's C# scripting, C++ engine cores, Go/Java server back‑ends, Python tooling, and even hand‑written assembly to balance performance and development speed across its massive AAA open‑world game.
The author, an experienced embedded engineer, recommends C, Python, Shell, and Go as the top four languages for most scenarios, explaining each language's strengths, typical use cases, and trade‑offs while noting when other languages like Java or Rust might be appropriate.
The article explains how the default 4 KiB pages cause frequent TLB misses, how using 2 MiB huge pages expands a single TLB entry’s coverage by 512×, reduces page‑walk depth and page‑table overhead, and provides C++ examples for both hugetlbfs and Transparent Huge Pages.
A ten‑week side‑by‑side study by ST, Inria and university researchers shows that Rust firmware for an STM32U585 microcontroller uses 45 % less RAM than an equivalent C implementation while matching performance, highlighting Rust's zero‑heap model, portability advantages and the remaining limitations for low‑end MCUs.
The article explains that in multithreaded programs, even when threads operate on independent data, the CPU may still suffer severe performance loss due to false sharing of cache lines, and shows how cache‑line alignment and C++17 hardware‑aware constants can eliminate the problem.
Vicinae is an open‑source, C++‑native desktop command panel for macOS and Windows that launches in under a millisecond, offers built‑in functions like app search, clipboard history, file indexing, and supports React/TypeScript Raycast plugins, script commands, and dmenu mode, positioning itself as a fast, extensible alternative to Alfred, Raycast and uTools.
SQLite, the server‑less, single‑file database engine, is the most widely deployed database on the planet, powering Android, iOS, browsers and countless desktop apps; this article walks through its core features, Linux installation, command‑line CRUD, language bindings for Python, C, Java and Go, plus practical backup and performance tricks.
The ds4.c project, authored by Redis founder Salvatore Sanfilippo, is a Metal‑only C inference engine that uses asymmetric 2‑bit quantization, disk‑based KV caching, and OpenAI/Anthropic‑compatible APIs to achieve usable performance for DeepSeek V4 Flash on high‑end Apple Silicon Macs.
The article recommends a progression of open‑source projects—starting with libevent, then muduo, Redis, and finally nginx—to help developers master C/C++ network programming through hands‑on exploration, performance tuning, and debugging techniques.
This article benchmarks the peak memory usage of one, ten thousand, one hundred thousand, and one million concurrent tasks across Rust, Go, Java, C#, Node.js, Python, and Elixir, revealing surprising differences in runtime memory footprints and scalability.
TrueAsync Server is a high‑performance HTTP/1.1, HTTP/2 and HTTP/3 server written in C that embeds directly into the PHP process, runs entirely on a single thread, eliminates inter‑thread communication, supports multi‑protocol on one port, and offers a suite of low‑level optimizations and a clear API for developers.
The article explains that NULL is a macro equal to integer 0, which can cause type‑mixing errors in overload resolution and template deduction, while the C++11 keyword nullptr has its own std::nullptr_t type, providing strict pointer semantics, eliminating overload ambiguities, improving safety, readability, and integration with modern C++ features.
The article explains that although C++ extends the lifetime of temporaries bound to a const reference, this rule has three critical edge cases—returning const references from functions, binding references in member initializer lists, and using the ternary operator—each of which can produce a dangling reference and cause obscure runtime crashes.
A comprehensive analysis of the ProgramBench study reveals that top‑tier AI models like Claude excel at recreating Go and Rust projects, while GPT‑based models struggle, highlighting language‑specific engineering advantages and exposing AI coding habits that shape future software development.
The author argues that successful programming relies 70% on understanding, 20% on practice, and only 10% on memorization, emphasizing that developers should focus on grasping core concepts, building muscle memory through repeated coding, and using documentation as needed rather than trying to memorize every API.
Reqable is a free, cross‑platform API testing tool built with Flutter and C++ that offers instant startup, low memory usage, offline storage, HTTP/2‑3 support, data migration from other tools, packet‑capture debugging, and an active open‑source community, positioning it as a high‑performance replacement for Postman.
The article explains that undefined behavior in C++ often stems from standard‑library misuse, describes the new C++26 P3471R4 hardened library that turns such UB into runtime contract violations, cites Google’s production data showing over a thousand bugs found with only 0.30% overhead and a 30% drop in segfaults, and details how to enable and use the feature.
The article dissects libstdc++'s std::sort implementation, explaining how introsort combines quicksort, heap sort, and insertion sort, why the recursion threshold of 16 and the depth limit of 2·log₂(n) are chosen, and how a sentinel trick eliminates boundary checks for extra performance.
Redis founder antirez unveiled ds4.c, a pure‑C inference engine that leverages Objective‑C and Metal to run DeepSeek V4 locally on Mac devices, delivering about 27 token/s on an M3 Ultra—far slower than GPU servers but offering a dependency‑free, on‑device solution that keeps data private.
Mojo 1.0 beta combines familiar Python syntax with C/Rust‑level speed, introduces API‑stabilizing language changes, expands cross‑vendor GPU support, and delivers measurable AI/ML performance gains, while offering a decision framework that weighs its early‑stage ecosystem against production needs.
The article explains how frequent dynamic allocations cause external and internal memory fragmentation, illustrates the problem with C++ examples, and shows that pre‑allocating a large contiguous block as a memory pool—managed via block division, free‑list tracking, and thread‑safe operations—significantly reduces fragmentation, improves allocation speed, and boosts concurrency performance.
JetBrains has announced that its flagship C/C++ IDE CLion is now free for any non‑commercial use, joining WebStorm and Rider in a broader strategy that lowers barriers for students, open‑source contributors, hobbyists, and content creators while preserving full functionality.
The article explains CRTP’s core mechanism—each template instantiation creates an independent type—and demonstrates three real‑world patterns (object counting, interface injection, and a type‑safe clone) with complete C++ code, pitfalls, and performance comparisons to virtual‑function alternatives.
This article demystifies lock‑free queues by explaining their low‑level implementation, atomic operations, memory barriers, and the four SPSC/MPMC models, while also covering ABA problems, false sharing avoidance, and practical C++ code examples to help developers truly understand high‑concurrency fundamentals.
This article explains the low‑level logic of Linux workqueues, detailing how asynchronous tasks are represented, how work items interact with kernel threads, the key data structures involved, scheduling strategies, and practical code examples for creating, queuing, and managing workqueue tasks.
Chris Wellons, a veteran open‑source engineer with 24 years of experience, announced his departure from Emacs after two decades, detailing his shift to Vim, the creation of stackcalc and Elfeed2 in C++ with wxWidgets, and the efficiency gains that drove the change.
The CodeTrend daily briefing spotlights the most starred GitHub projects of April 29 2026, covering today’s top picks, the week’s hottest repositories and the month’s biggest surges across AI agents, developer tools, finance applications, hacking utilities and more.
Windows 11’s built‑in Notepad has become bloated and still lacks essential editing features such as syntax highlighting, line numbers, and code folding, while Notepad4, a modern C++ rewrite, restores those basics, adds CPU‑specific optimizations, multilingual support, and fast handling of large files.
The CodeTrend daily report spotlights the most‑starred GitHub projects added today, this week and this month across languages, highlighting hot repos such as Claude‑Code tools, VibeVoice, FinceptTerminal, and a range of AI, finance, and developer utilities.
A stress test of 50 million syscalls revealed that a C++ implementation silently accumulated over 4 GB of memory and crashed without any alerts, while an equivalent Rust version remained stable, highlighting how gradual memory bloat can evade monitoring and cause hidden failures in high‑concurrency services.
The article surveys the most popular IDEs for C development on Linux, compares personal preferences such as VSCode, CLion, Vim/Neovim, and Emacs, and examines how large internet firms, embedded‑software companies, fintech, and startups choose their tools based on learning curve, performance, project size, and team policies.
A recent r/cpp discussion reveals three distinct C++ developer mindsets—legacy‑code loyalists, modern‑feature enthusiasts, and mixed‑approach pragmatists—debating whether C++20/23 innovations boost productivity or merely pile on complexity, and proposes incremental modernization as a balanced path forward.
This guide walks beginners through progressive Linux network programming projects—starting with an Echo server, advancing to a concurrent chatroom, and culminating in a simple HTTP server—to solidify core concepts like TCP handshakes, socket I/O, and protocol handling.
This article provides a comprehensive, step‑by‑step analysis of Linux's io_uring, covering its architecture, design principles, workflow, performance advantages over traditional models like epoll, practical C code examples, optimization techniques, real‑world use cases, and the challenges developers may face when adopting it.
The article walks through EasySearch's Rules plugin, showing how its high‑performance C++ rule engine can automatically match and tag documents during the ingest pipeline, enabling zero‑latency content classification for scenarios like regional, sentiment, and entity tagging.
This comprehensive guide walks readers through the Linux PCI driver architecture, explains the PCI and PCIe bus evolution, details the kernel's layered driver framework, enumerates devices, manages resources, registers drivers, and presents a full SSD driver case study with code examples and performance tuning techniques.
This article explains how C++17 fold expressions replace verbose recursive variadic template tricks with concise one‑line constructs, covering their four syntactic forms, practical examples such as summing, printing, compile‑time checks, and common pitfalls to avoid.
The article details the design and evolution of the Multiplicative Tree framework—from version 1.0 to 3.0—showing how a DSL‑based, compile‑time‑checked configuration system delivers instant formula deployment, robust stability safeguards, and significant performance gains for multi‑objective ranking models.
This article walks through the five practical levels of using C++ friend— from a quick syntax recap to operator overloads, factory functions, iterator access, swap idiom, and the Passkey pattern—explaining when and why each scenario warrants a friend declaration and how it impacts encapsulation and interview performance.
This comprehensive tutorial walks you through installing VSCode and GDB on Linux, macOS, and Windows, configuring launch.json and tasks.json, mastering basic and advanced debugging techniques such as breakpoints, watchpoints, multithreaded and remote debugging, and troubleshooting common issues for C/C++ development.
This article explores common pitfalls when using std::shared_ptr in C++, including unnecessary copying, extra heap allocations, cyclic references, and subtle memory retention with make_shared, provides benchmark comparisons, and offers practical guidelines such as preferring const‑reference passing, using std::make_shared, and employing weak_ptr to break cycles.
This article explains how to adopt Linux kernel's struct‑array initialization and device‑tree matching techniques to implement a flexible C‑based UART driver that supports multiple compression configurations, complete with code examples and compilation guidance.
This comprehensive guide explains why race conditions occur in Linux processes, explores the underlying concepts of critical sections and synchronization, and provides practical examples of atomic operations, mutexes, semaphores, condition variables, read‑write locks, and spinlocks to ensure safe concurrent programming.
This article provides a comprehensive guide to Linux TCP development, explaining the role of system calls, the three‑way handshake and four‑way termination, detailing core socket functions such as socket, bind, listen, accept, connect, read/write, recv/send, and includes complete example code for building a simple TCP server and client with troubleshooting tips.
This article explains how to keep essential information from lengthy AI chat histories by using an intelligent summarization prompt, injecting the summary as a system message, and applying a sliding‑window strategy that retains the last three exchanges, thereby reducing token cost and preserving context continuity.
This tutorial walks through STM32's eight GPIO operating modes—four inputs and four outputs—detailing their electrical behavior, typical use cases, configuration steps, and providing complete HAL code examples to help embedded developers choose the right mode for reliable designs.
The article walks through a seemingly simple C file‑creation snippet that fails on Windows because Microsoft's tmpfile() uses C:\, then reveals a hidden bug where a stray backslash in a comment and a missing space in an expression silently turn code into comments, illustrating how tiny syntax errors can break cross‑platform programs.
The article details the design of a cross‑platform C++ rendering engine built for a mobile reading app, explaining its three‑layer architecture, file‑format support, layout and caching mechanisms, security features, and how these technical choices delivered measurable improvements in page views, reading time, and conversion rates.
This article explains what function pointers are in C, shows their declaration syntax, provides simple and advanced usage examples—including callbacks, state machines, and command dispatch—offers best‑practice tips, and demonstrates how they empower flexible embedded development.
This article explains the role of the Linux user stack in multithreaded programs, covering its memory layout, how each thread gets a private stack, stack frame mechanics, growth and overflow handling, and practical examples of creating and debugging stacks with pthreads and gdb.
This article compares the execution models of C/C++, Java, and Python, explaining how compiled machine code, bytecode with JVM, and interpreted bytecode with the Python virtual machine operate, and illustrates each process with example file structures and compilation steps.
This article explains the fundamentals of Linux thread stack memory, identifies why default stack sizes can cause waste or overflow in high‑concurrency scenarios, and provides practical techniques—including stack‑size tuning, code refactoring, and memory‑mapping—to reduce memory usage and improve service stability.
This tutorial explains what function pointers are, how to declare and use them in C, and demonstrates practical embedded‑system patterns such as callbacks, state machines, command dispatch, and advanced techniques like pointer arrays and struct members, while highlighting common pitfalls.
This article explains the fundamental differences between C arrays and pointers by examining memory layout, mutability, sizeof behavior, function parameter handling, multidimensional arrays, and practical best‑practice guidelines, providing clear code examples that reveal why declarations like char s1[] = "liangxu" and char *s2 = "liangxu" behave differently.
This article introduces MuditaOS, an open‑source embedded operating system for the minimalist Mudita Pure phone, detailing its FreeRTOS‑based service architecture, type‑safe message passing, lifecycle management, and the technical stack that enables a low‑power, E‑Ink‑optimized mobile experience.
This article explains the role of copy constructors in C++, when the compiler automatically provides a default one, the situations that trigger copy construction, why bitwise copying can be unsafe, and how to implement proper deep‑copy semantics with clear code examples.
GCC has officially made C++20 the default language standard, a shift that reshapes codebases, tooling, and developer habits, requiring both newcomers and seasoned programmers to adapt to new features like modules, concepts, and coroutines while managing potential build issues.
This article explains the natural alignment requirements of C/C++ data types, how structs are padded and aligned based on member alignments, the hardware, cache and compiler reasons for alignment, and the concept of over‑aligned types with practical examples and usage guidelines.
This article explains the concept of flexible arrays in C, compares them with pointer‑based arrays, shows allocation and deallocation code, and discusses memory continuity, performance, fragmentation risk, and suitable usage scenarios for embedded systems.
This article benchmarks memory consumption of concurrent programs across Rust, Go, Java, C#, Node.js, Python, Elixir and others, revealing surprising differences in how threads, async runtimes, and virtual threads scale from a single task up to one million concurrent tasks.
This guide explains how to use a custom dynamic loader library on STM32 (Cortex‑M7) microcontrollers, covering project structure, installation steps, and runtime usage to load relocatable AXF files into RAM similarly to DLLs or shared objects.
This tutorial shows how C arrays are stored in the stack, global segment, and heap on a 64‑bit Linux system, using gcc compilation, gdb inspection, and concrete memory addresses to illustrate the exact layout of each region.
The November 2025 TIOBE ranking shows Python still on top, but C# is rapidly gaining ground and may surpass Java for the first time in history, driven by cross‑platform .NET, open‑source momentum, modern language features, and strong backing from Microsoft and the cloud ecosystem.
This article explains how to reconstruct a 32‑bit floating‑point value from four serial bytes in embedded C by using a union or struct overlay, demonstrates the code, shows the resulting little‑endian byte order, and provides a simple function to detect system endianness.
This article explains how to create a user‑defined read() function in C that coexists with the standard library read() by using the static keyword and separate translation units, providing code examples, compilation steps, and execution results.
The article reviews the official .NET 10 release, highlighting AI Agent Framework simplifications, extensive cryptography API updates, JIT and runtime performance gains, new C# 14 language features, F# 10 improvements, stack‑allocated arrays, SDK refinements, and the latest MAUI and ASP.NET Core capabilities.
This article introduces the lightweight lwbtn library for embedded C, explains its core features, shows how to integrate it on STM32 with a complete demo, and provides an in‑depth analysis of its architecture, state‑machine processing, click detection algorithm, configuration options, and practical usage tips.
This article explains how static_cast provides compile‑time type safety, clearer intent, and zero runtime overhead compared to C‑style casts, covering basic arithmetic, pointer, and enum conversions, the compiler’s processing steps, practical examples, and best‑practice recommendations for safe C++ coding.
This comprehensive guide explains how TCP/IP functions as the Internet's traffic rules, details each protocol in the suite, explores the four‑layer model, showcases practical C++ socket examples, and provides troubleshooting tips for real‑world networking scenarios.
This article curates a collection of popular open‑source microcontroller projects, covering practical software modules such as MultiButton, QueueForMcu, and StateMachine, complete hardware projects like TinyGameEngine and HomeAutomation, IoT platforms, creative gadgets, and debugging tools, each with repository links, feature highlights, usage examples, and code snippets.
This article introduces lwevt, a lightweight C event‑management library for embedded systems, covering its design goals, key features, X‑Macro‑based type definitions, thread‑safety considerations, and step‑by‑step usage examples with full source code snippets.
This article presents eight high‑frequency embedded‑system interview questions, explains the underlying concepts such as boot process, interrupt handling, stack overflow detection, struct alignment, bit‑banding, dynamic memory risks, volatile usage, and provides concise C code examples and best‑practice answers to help candidates succeed in technical interviews.
This guide introduces the lightweight C logging library log.c, explains its core structures, configuration functions, and thread‑safe usage, then walks through downloading the source, compiling, running a sample program, and inspecting the generated log files.
This guide walks you through installing prerequisites, cloning the ZLMediaKit source, compiling it on Linux, configuring it to work with WVP, and launching the server, plus troubleshooting tips and a Docker deployment alternative for GB28181 video integration.
Even when a C++ program appears to run correctly, writing beyond allocated memory can corrupt heap metadata, causing a delayed crash at free(); this article explains the underlying malloc/free mechanisms, demonstrates the issue with code examples, and offers debugging tools and defensive programming practices to prevent such errors.
This guide outlines comprehensive C coding style rules, covering indentation, naming conventions, whitespace, comments, function prototypes, variable declarations, structures, enums, control flow, macros, and documentation, with clear examples to help developers write clean, maintainable, and consistent code across projects.
TBOX is an open‑source C library offering a unified, cross‑platform API that simplifies common development tasks across Windows, macOS, Linux, Android, iOS and BSD, featuring modules for streams, coroutines, memory, containers, algorithms, networking, databases, and more, with build instructions via xmake.
The October 2025 TIOBE index shows Python retaining the top spot while C reclaims second place, with C++, Java, and C# fiercely contesting the rankings, highlighting each language’s unique strengths and the shifting popularity driven by new standards, ecosystem growth, and emerging technology demands.
This article explains LeetCode problem 1749, which asks for the subarray with the maximum absolute sum, and shows how prefix sums reduce the task to tracking minimum and maximum prefix values, providing full reference implementations in Java, C++, Python, and TypeScript.
This article explains the concept of strong and weak functions in C, shows how to declare them with GCC and other compilers, outlines the linker selection rules, and demonstrates practical uses such as library overrides, interrupt handlers, callbacks, test stubs, plugin systems, and related pitfalls.
This tutorial walks through STM32F103ZET6 ADC fundamentals, explains key parameters, demonstrates how to use the VOFA+ PC tool for data visualization, and provides step‑by‑step implementations of several filtering algorithms—including first‑order complementary, median, arithmetic average, moving average, limit‑average, and Kalman filters—complete with code examples and performance analysis.
This article explains the concept, syntax, and practical use cases of C++ placement new, compares it with ordinary new, discusses memory‑pool and stack allocations, highlights alignment and lifetime management issues, and provides interview‑style Q&A with code examples.
This article explains the fundamental differences between stack and heap memory allocation, covering their mechanisms, performance characteristics, common pitfalls such as overflow and leaks, and practical coding examples in C and C++, helping developers choose the right memory strategy for efficient software design.
Choosing the right lock—mutex or spinlock—can dramatically affect program performance; this article explains their underlying waiting mechanisms, compares CPU usage, context‑switch costs, and suitability across multi‑core versus single‑core, high‑contention versus low‑contention scenarios, and provides practical C++ code examples.
This article examines the diminishing premium of overseas degrees, suggests one‑year master programs for career advancement, and then provides a comprehensive Baidu interview guide covering C++/PHP fundamentals, memory allocation, networking protocols, process vs thread, Redis performance, and a complete quicksort implementation in C++.
This article explains how C++ template metaprogramming (TMP) and SFINAE let developers move calculations and type checks to compile time, providing zero runtime cost, and demonstrates practical techniques with clear code examples and modern language features up to C++20.
This article explains how the C++ deque combines the random‑access speed of a vector with the constant‑time double‑ended insertions of a list by using a segmented storage architecture, detailing its internal map, iterator mechanics, core operations, performance comparisons, practical use cases, and common pitfalls.
The cpp‑linter project launched a dedicated website using MkDocs‑Material to showcase its tools, highlight major adopters, provide quick start guides, and invite community discussion, while sharing design tips and emphasizing the importance of good documentation for open‑source success.
