Herb Sutter reveals that the ISO C++ committee has approved the C++26 schedule, promising major concurrency and parallelism enhancements, new language features like wildcard support and dangerous pointers, while discussing competition from Rust, Google’s Carbon, and his experimental cppfront project.
This article explains the fundamentals of Linux memory allocation, introduces Jemalloc’s core algorithms and data structures, and provides concrete optimization steps—including arena tuning, tcache configuration, and slab size adjustments—to achieve measurable CPU savings in high‑concurrency C++ services.
This article provides an introductory overview of several widely used programming languages—including Python, Go, C, C++, Java, PHP—and explains why Windows is primarily developed in C++, highlighting each language's origins, key advantages, and typical use cases.
The article introduces coroutine fundamentals and classifications, then explains how the Tars C++ framework (v3.0.0) implements stackful, symmetric coroutines using Boost.Context for user‑mode context switching and an epoll‑driven scheduler that manages coroutine lifecycles, states, and operations such as go, yield, sleep, and put.
This article explains the four common compilation and linking problems C/C++ developers encounter on 64‑bit Linux, covering preprocessing, ELF object formats, static library ordering, dynamic linking mechanics, symbol interposition, and runtime loading pitfalls, and provides concrete solutions for each.
By adopting a unified architecture and a pre‑compilation strategy that leverages CI, git‑diff module detection, version‑managed manifests, and platform‑specific build tools, Tencent Meeting cut its C++ cross‑platform compile times from minutes to seconds, achieving up to 99 % speedup across Windows, Android, iOS and macOS.
The gRPC 1.53.0 release introduces a series of core improvements, language‑specific enhancements for C++, C#, Python and Ruby, as well as bug fixes and new APIs, providing higher stability and performance for modern high‑performance RPC applications.
This article outlines the latest RocksDB release updates, including disabled checksum verification options, removed Lite and deprecated APIs, default shared library builds, new compression filter and MultiGetEntity APIs, and various bug fixes such as concurrency issues and async I/O error handling.
This article examines how strict adherence to clean‑code principles—such as using polymorphism, keeping functions tiny, and avoiding switch statements—can dramatically increase the number of CPU cycles required for simple area‑calculation loops, presenting benchmark results that show performance penalties of up to fifteen‑fold.
An extensive performance analysis shows that strictly following clean‑code rules—such as using polymorphism, avoiding switch statements, and keeping functions tiny—can dramatically increase execution time, with measured slowdowns up to fifteen times, while alternative table‑driven or flat‑structure approaches achieve orders‑of‑magnitude speed gains.
This guide walks you through installing VS Code on macOS, configuring essential C/C++ extensions, setting up the Clang/LLVM toolchain, creating a simple Hello World project, compiling, running, and debugging it using VS Code's tasks and launch configurations.
This technical digest surveys Tencent’s health‑code operations architecture, dissects ChatGPT’s training pipeline, contrasts Web 2.0 and Web 3.0 on Ethereum, explains AI‑generated art, details WeChat’s overload controls and QQ Music’s high‑availability design, examines the rapid scaling of the “Sheep Sheep” mini‑game, introduces Rust for front‑end developers, showcases big‑data football prediction models, and outlines common C++ pitfalls and best‑practice recommendations.
The article explains how to extend NSIS’s Inetc plug‑in by adding a /callback switch, storing the callback address, pushing total size, downloaded amount and percentage onto the NSIS stack after each buffer, and invoking the user‑defined function to update a progress bar during downloads.
This article explains the principles behind Google’s sanitizer tools, especially AddressSanitizer, covering symbol interposition, the interceptor mechanism, and how these techniques replace libc functions to reliably locate memory and thread errors in C++ applications on Linux.
The article explains how a WeChat e‑commerce team adopted Domain‑Driven Design, reorganizing a fast‑paced, multi‑team project into a four‑layer onion architecture with strategic sub‑domains, bounded contexts, anti‑corruption layers, domain events, aggregates, repositories and services, to achieve maintainability, extensibility, cohesion and loose coupling.
The TIOBE Index for December 2022 shows C++ surpassing Java to enter the top three, while Python and C remain leaders, and highlights shifting positions for languages like SQL, Assembly, Kotlin, Julia, and emerging trends across the top 20 programming languages.
Sonic‑CPP, an open‑source C++ JSON library co‑developed by ByteDance’s STE and Service Framework teams, leverages SIMD vectorization, optimized memory layout, on‑demand parsing, and a compact DOM design to achieve up to 2.5× faster parsing than RapidJSON and competitive serialization performance, with extensive benchmark results and production‑grade usage.
This article compiles an extensive list of operating systems, graphical interfaces, desktop search tools, office suites, databases, browsers, email clients, IDEs, virtual machines, server software, and many other applications, highlighting the programming languages—primarily C, C++, and occasionally assembly or Java—used to develop each of them.
This article compares the legacy C++17 stackless coroutine implementation using macro‑generated state machines with the native C++20 coroutine model, explains their core concepts, and demonstrates how to design a flexible scheduler that manages various await modes and integrates custom awaitable tasks.
The guide thoroughly explains C++’s intricate syntax and language features—from historic C inheritance, array handling, and implicit conversions to enums, macros, and const correctness—while detailing modern C++11 concepts like rvalue references, move semantics, reference collapsing, perfect forwarding, and auto deduction to help developers avoid pitfalls and write cleaner, efficient code.
Modern C++ performance suffers when seemingly harmless abstractions—such as virtual functions, hidden copies, non‑trivial destructors, overused std::shared_ptr, type‑erasing wrappers, std::variant/optional, and std::async—prevent inlining and efficient memory use, while patterns like std::move on returns, hidden destructors in tail recursion, and branchy loops thwart NRVO, tail‑call, and auto‑vectorization optimizations.
This article introduces the ten most important programming languages for cybersecurity, explains why each language matters, and shows how mastering them can boost your ability to protect systems, detect threats, and build secure applications in an increasingly digital world.
Microsoft Azure CTO Mark Russinovich argues that C and C++ should be retired for new projects in favor of Rust, highlighting memory‑safety benefits, industry adoption challenges, and responses from language creators, while examining the broader impact on system software development.
The article explains how Asio implements C++20 coroutine support by converting callback‑based async operations into awaitables with use_awaitable, launching them via co_spawn and co_spawn_entry_point, handling result propagation and thread dispatch, and providing parallel composition operators (&&, ||) for concurrent awaiting.
The article thoroughly examines Asio’s core mechanisms—its scheduler’s post handling, the strand’s lock‑based ordering, and the timer subsystem’s heap‑driven queues—detailing executor operations, multi‑threaded execution paths, platform‑specific timer schedulers, and the efficient C++ techniques that enable high‑performance asynchronous programming.
The article explains C++11 move semantics, showing how std::move forces rvalue treatment and how std::forward preserves value categories for perfect forwarding, illustrating copy vs. move constructors, custom move implementations, and the performance benefits of eliminating unnecessary copies.
This article introduces GDI and DXGI screen capture techniques, provides Qt implementations with detailed code examples, compares their performance and visual results, and presents a CPU/GPU usage benchmark, concluding that DXGI offers higher GPU efficiency while both methods have specific trade‑offs.
Meta has officially added Rust, Hack, Python, and C++ as its preferred backend languages, outlining strict criteria such as core library support, security, operational risk, expertise, and developer experience, while also noting community‑supported languages and its long‑term commitment to Rust amid broader VR ambitions.
Google’s Carbon project, led by Chandler Carruth and backed by experts like Kate Gregory, aims to explore capabilities beyond C++ with a focus on memory safety and interoperability, while Bjarne Stroustrup weighs in on its early-stage design, goals, and challenges.
Google engineer Chandler Caruth unveiled Carbon, an experimental C++ successor designed to match C++ performance while offering seamless interoperability and a smoother migration path, highlighting its roadmap, key features, and the challenges it aims to solve in modern systems programming.
This note shows how C++ templates and a one‑line macro can generate a universal wrapper that hooks any system API, logs and filters its parameters—including variadic and pointer arguments—while handling special cases such as const and void* buffers, eliminating repetitive custom wrappers.
The article explains how compile‑time polymorphism in modern C++—using libraries like folly::poly and dyno—can replace traditional virtual‑table based runtime polymorphism by employing small‑object optimization, compile‑time generated VTables, and type‑erased wrappers, delivering near‑virtual performance without inheritance or heap allocation.
The article explains libunifex’s CPU‑thread scheduler architecture, detailing how a lightweight scheduler wraps a manual_event_loop execution context with a mutex‑protected FIFO task queue, how operations bridge receivers to the context, and outlines various thread‑bound and platform‑specific scheduler variants.
The article thoroughly examines libunifex’s structured concurrency implementation, detailing its DSL‑based execution framework and the three core components—Sender Factory, Sender Adapter, and Receiver—through examples like just(), then(), and sync_wait(), and explains how these pieces combine to build asynchronous pipelines.
This article introduces Google’s Sanitizers suite for detecting C/C++ memory errors, reviews essential memory concepts and C++ standards, compares compiler support, and explains why these tools are crucial for improving security and productivity in large‑scale C++ projects such as NetEase Cloud IM.
This article thoroughly explains libunifex’s sender/receiver model for C++ asynchronous programming, covering its design goals, module structure, pipeline composition, key functions like schedule, then, sync_wait, and the connect/start mechanisms, while demonstrating practical examples and integration with C++20 coroutines and cancellation support.
This article explains how modern C++ libraries achieve extensible interfaces using Customization Point Objects and the tag_invoke mechanism, compares classic techniques, details the implementation of ranges::begin, and shows how tag_invoke provides a scalable, concept‑friendly alternative for generic library design.
This article presents a series of images that quickly review essential C++ backend development topics, highlighting low‑level concepts such as memory management, inter‑process communication, network programming, and the importance of databases and Linux, while comparing C++ to Java backend routes.
The article proposes a GCC‑plugin‑based tool called TU that automatically extracts AST information from C/C++ source files to generate boundary unit tests, custom cases, and mocks without modifying business code, dramatically reducing the manual effort required for comprehensive test development.
The May 2023 TIOBE ranking shows the Top 10 languages unchanged, with C# posting the highest growth of 1.98% and a near‑two‑percent market‑share rise, while C++ driven by C++20 is poised to challenge the Top 3, accompanied by notable shifts for R, Swift, and Ruby in the Top 20.
The article explains when lock‑free queues are needed, why they outperform locked alternatives, presents single‑producer and multi‑producer implementations with detailed code, benchmarks their throughput versus mutex‑based queues, and concludes they excel for low‑contention or dominant‑producer scenarios but may lag under high contention.
This article explains why static analysis is essential for C/C++ development, compares compiler warnings with dedicated tools, introduces cppcheck, shows how to install and use it on sample programs, and demonstrates its ability to uncover bugs that compilers often miss.
This article explains a Tencent interview question requiring identification of a QQ number appearing more than half the time among 2N entries, discusses naive sorting and hashmap approaches, and presents the optimal O(N) time, O(1) space Moore voting algorithm with a complete C++ implementation and sample output.
This article explains the real‑time operating systems used in modern aircraft, detailing how VxWorks powers Boeing 787 and AH‑64, Integrity‑178B runs on platforms like the F‑35 and Airbus A380, and why the industry is shifting from ADA to C++ for safety‑critical software development.
This article explains how memory allocation on the stack is faster than on the heap, demonstrates the process with assembly instructions, provides benchmark code comparing allocation speeds, discusses compiler optimizations, and outlines the differences, advantages, and pitfalls of stack and heap memory usage.
This article presents a comprehensive, language‑only C++ learning roadmap, detailing essential concepts, recommended books for each stage, practical coding exercises, advanced topics such as STL source, object model, language design, and curated video tutorials to help learners master C++ efficiently.
This article compiles a comprehensive collection of free C++ learning resources, including tutorial sites, source code repositories, FAQs, reference manuals, and open‑source libraries, to help developers progress beyond basic concepts and deepen their programming expertise.
This article explains the concepts, components, and lifecycle of Remote Procedure Call (RPC), compares it with HTTP, and demonstrates how to use the open‑source C++ SRPC framework to build client and server applications, including code generation, serialization, compression, and protocol handling.
gRPC Core version 1.45.0 introduces numerous updates including XDS error handling, core version upgrade, memory leak fixes, transparent retries, channel credential improvements, Windows memory leak resolution, xDS RBAC filter updates, as well as language‑specific enhancements for C++, C#, Objective‑C, and Python.
The article shows how the Lura library uses C++ reflection to build a concise Lua bridge that automatically registers functions, properties, and object lifecycles via userdata and meta‑tables, simplifying bridge code compared to traditional libraries while supporting coroutines and profiling.
This article explains the proper C++ singleton implementation known as Meyers' Singleton, showing how a static local variable inside a getInstance() function ensures thread‑safe lazy initialization, avoids static‑initialization‑order problems, and handles inheritance correctly.
The article explores the origin and purpose of the infamous deadbeef constant and other so‑called magic numbers in C/C++ code, explains why they appear, shows real examples, and advises developers to replace them with named constants for clearer, safer code.
This article explains the classic maximum subarray problem, presents a brute‑force O(n³) method, an improved O(n²) version, a divide‑and‑conquer O(N log N) algorithm, and a linear‑time O(N) dynamic‑programming solution, each with full C++ code and complexity analysis.
This article explains an Alibaba interview problem about counting friend circles using the union‑find (disjoint set) data structure, provides a detailed conceptual analysis, visual illustrations, and a complete C++ implementation that determines whether two people belong to the same circle and computes the total number of distinct circles.
The article explains how Ponder’s C++ reflection library uses template‑based type erasure to register and invoke functions at runtime, detailing the Function class, registration syntax, argument conversion, Lua integration, performance considerations, and a complete Vector3 DotProduct example.
The article dissects the Ponder C++ reflection library’s Property subsystem, explaining how registration via ClassBuilder creates property entries, how traits and ValueBinders map members to abstract Property objects, and how runtime Get/Set calls traverse templated binders to provide type‑safe, high‑performance access.
The article explains how to implement a runtime reflection system for C++ using the Ponder library, detailing type registration, property and function metadata, builder-generated meta‑objects, type‑erasure wrappers like UserObject and Value, and runtime APIs for dynamic object creation and invocation.
This article explores the evolution of C++ templates, explains the purpose and syntax of concepts, demonstrates how they replace SFINAE and enable_if with clearer compile‑time checks, and shows practical ways to define and use concepts for safer generic programming.
This article introduces the classic Two Sum problem, explains its brute‑force O(n²) approach, then presents an optimal O(n) hash‑table solution and a more advanced sort‑plus‑binary‑search method, providing complete C++ implementations and performance comparisons for each technique.
The article shows how profiling‑driven compiler and OS techniques—such as sampling and instrumentation PGO, BOLT code layout, AutoFDO pipelines, basic‑block reordering, partial inlining, branch and function reordering—can alleviate instruction‑cache and front‑end stalls in large C/C++ cloud workloads, delivering up to 18 % performance gains.
This article details how a C++‑based cross‑platform framework was designed for WeChat Pay to unify iOS and Android implementations, improve scalability, quality assurance, and developer productivity through use‑case abstraction, a routing mechanism, and refined network and data handling.
This article explains how to answer range maximum queries on a static array efficiently by preprocessing with a sparse table, achieving O(n log n) build time and O(1) query time, and provides a complete C++ implementation with state compression and interval decomposition.
The article, the second in the “From C++ to Rust” series, explains how Rust replaces C++’s return‑value and exception error handling with the Result type, the ? operator, and the thiserror/anyhow crates, and introduces Rust’s lifetime system, borrow checker, elision rules, variance, and common misconceptions for developers transitioning from C++.
The article discusses how to give each class object a unique identifier, compares inheritance and composition for associating objects, and examines the trade‑offs of each approach using C++ examples, ultimately suggesting that the choice should depend on hierarchy depth and maintenance cost.
The article explains the different meanings of the && operator in C++—as a true rvalue reference in non‑template functions, as a forwarding (universal) reference in templates, and its behavior when binding to function return values—illustrated with code examples and practical guidelines.
Move semantics in C++11 let objects transfer ownership of resources via rvalue references and std::move, eliminating costly copies, improving performance, requiring explicit move constructors and assignment operators—preferably marked noexcept—to keep source objects valid, enable container optimizations, and work with NRVO when copying would otherwise occur.
This article traces the historical origins of coroutines from early COBOL compiler challenges, explains their cooperative execution model, compares them with thread scheduling, and reviews how modern languages like Python, C++ and Go implement coroutine support to improve IO‑bound performance.
C++11 smart pointers—unique_ptr, shared_ptr, and weak_ptr—replace manual new/delete by providing exclusive, shared, and non‑owning ownership semantics, automatically preventing leaks and dangling references, simplifying multithreaded code, and, when used with best‑practice guidelines, avoid common pitfalls such as double deletions and cyclic dependencies.
The article explains the theoretical minimum and maximum of Tencent QQ numbers, why the lower bound starts at 10001, what would happen if all IDs were exhausted, and how a bitmap can efficiently represent and deduplicate billions of QQ IDs using simple C++ code.
This article walks through C++20 coroutines with clear explanations, three runnable examples, deep dives into promise_type, coroutine_handle, co_await, co_yield and co_return, and shows how to build both void‑returning and int‑returning coroutines while illustrating the compiler‑generated control flow.
This article reviews the most suitable programming languages for artificial intelligence, explaining why Python, R, Java, LISP, Prolog, C++, Haskell, JavaScript, and Julia excel in AI development and outlining their key advantages and typical applications.
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 details NetEase Cloud Music's cross‑platform network library practice, describing the challenges of duplicated implementations, the design of a unified Cronet‑based solution, upgrade strategies, pitfalls, and real‑world performance gains of up to 40% when enabling QUIC.
This article explains how to determine whether a singly linked list contains a cycle using three approaches—brute‑force, hash‑marking, and the optimal fast‑and‑slow pointer technique—providing Go and C++ implementations that achieve minimal time and O(1) space complexity suitable for a Tencent interview.
The article compares C++ and Rust for developers switching languages, explaining how Rust enforces move semantics instead of copy defaults, uses the safe Option enum with exhaustive pattern matching instead of nullable pointers, and favors lazy, chainable iterators over index‑based loops for performance and safety.
This article explores why standard string‑to‑integer conversions become performance bottlenecks in high‑concurrency scenarios and presents a series of increasingly optimized C++ solutions—from native library calls to loop‑unrolled, byteswap, divide‑and‑conquer, and SIMD tricks—demonstrating dramatic speed gains backed by Google Benchmark results.
The article explains gRPC fundamentals, illustrating service definition in .proto files, synchronous and asynchronous client and server implementations with CompletionQueue and CallData state machines, streaming RPC patterns, HTTP/2 protocol details, metadata handling, and the structure of generated stub and service code.
This article walks you through creating a nostalgic NES (FC) emulator using C++ and SFML, covering required tools, CMake build steps, command‑line usage, and default keybindings, while sharing personal reflections on summer gaming memories.
Zheng Lin‑kai’s record‑breaking Tetris AI for the Tencent Geek Challenge combines a two‑layer breadth‑first search—stage‑level pruning in Python and fast round‑level BFS in C++—with a heuristic that rewards high score, low occupied cells, and smooth board transitions, enabling a 1,413,876‑point performance.
This document outlines the latest release of the C++ coroutine library “co”, providing GitHub links, reference documentation, new features such as xrepo, vcpkg integration, defer, channel, waitgroup, scheduler APIs, API changes, and several bug fixes.
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.
Benchmarking C++ exceptions against error‑code handling reveals that frequent throws incur more than tenfold slowdown due to libc++ runtime functions like __cxa_allocate_exception and stack unwinding, while rare exceptions and empty try blocks add negligible overhead, highlighting the trade‑off between safety and performance.
This article explains how JavaScript and C++ exceptions work in Node.js native addons, compares traditional v8::TryCatch handling with the newer Maybe-based approach in node-addon-api v4.1.0, and shows practical code examples for reliable error management.
This article presents a comprehensive overview of the open‑source Workflow framework by Sogou, highlighting its high‑performance asynchronous architecture, rich feature set, practical C++ code examples for building servers and clients, and detailed explanations of its task‑flow and timer implementations for backend developers.
This article describes how the PC teacher desktop client adopts a layered MVL architecture, introduces unit testing with GoogleTest and GoogleMock, explains the underlying TEST and RUN_ALL_TESTS macro mechanisms, demonstrates mock view implementation, and shows how code coverage is measured to achieve targeted test coverage levels.
The Vivo Internet Server Team extended TARS with a dynamic load‑balancing algorithm that recalculates each node’s weight every minute using metrics such as 5‑minute average response time, timeout and exception rates, CPU, memory and network load, automatically adapting traffic distribution beyond the built‑in round‑robin, weighted round‑robin and consistent‑hash methods.
This tutorial walks you through creating a Qt‑based application launcher using QML and C++, covering project setup, parsing Linux .desktop files, designing a swipeable UI, displaying icons, handling selection, and launching applications via QProcess.
The article compares Flutter’s native interaction methods, explaining how Platform Channels use message codecs and thread switching for method calls, while FFI lets Dart directly invoke C functions, offering superior performance but more boilerplate, and discusses trade‑offs, implementation details, and a benchmark showing the speed gap.
This article explores Baidu C++ engineers' deep‑dive into performance optimization, covering memory‑access patterns, string‑buffer handling, protobuf merging, malloc strategies, job‑arena allocation, cache‑line effects, and modern memory‑order semantics to achieve multi‑fold speedups in large‑scale backend services.
This article explains the concepts of single and multiple inheritance, the diamond problem in C++, why Java forbids multiple class inheritance, and how Java 8 uses default methods in interfaces to achieve similar functionality, illustrated with clear code examples and diagrams.
The article presents Sogou's open‑source C++ Workflow framework, highlighting its industrial‑grade performance, simple asynchronous API for servers and clients, benchmark results, and key features such as integrated task scheduling, extensive documentation, and real‑world adoption across many companies.
Although malloc is a universal allocator, its lack of scenario-specific optimization makes it unsuitable for high‑performance server applications; this article explains malloc’s internal workflow, compares it with custom memory‑pool techniques, and details various pool designs, thread‑safety strategies, and an interesting cross‑thread free problem.
This guide explains why comments are essential for code readability, outlines various comment styles for C/C++—including file, function, variable, spelling, and TODO comments—and provides concrete examples and best‑practice recommendations to help developers write clear, maintainable code.
This article recounts a twelve‑year‑long French government software project that amassed over six million lines of C++ code, suffered from outdated technology, chaotic version control, absurd management policies, and ultimately collapsed, offering stark lessons for developers and project leaders.
The Apache Ignite 2.9.1 release introduces new features such as graceful shutdown for ZookeeperDiscoverySpi, system views for binary metadata and metadata storage, and numerous bug fixes across core, Java thin client, JDBC, .NET, and C++ components, improving stability, performance, and compatibility.
In a recent global C++ conference, Bjarne Stroustrup outlined the major features of C++20, explained his design philosophy of simplicity, balance, freedom and friendliness, and highlighted how C++ continues to serve a wide range of domains while offering guidance for learning and future evolution.
This comprehensive guide covers the fundamentals of processes and threads, their definitions, relationships, creation, lifecycle, scheduling strategies, context switching, inter‑process communication methods, and practical C/C++ examples, providing a deep dive into operating‑system concepts for developers and interview preparation.
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.
This article explains how N‑API provides an ABI‑stable, cross‑version add‑on API for Node.js, outlines recent multithreading, worker‑thread, and helper function enhancements, discusses build tooling options, and offers resources for getting started and contributing to the ecosystem.