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.
Rising to the top of the 2023 TIOBE rankings, C#—born in the early 2000s to simplify complex software—combines type safety, cross‑platform .NET support, and modern tooling, enabling developers to build AI, cloud‑native, game, full‑stack web, desktop, mobile, and IoT applications with increasing popularity worldwide.
Discover how Manticore Search, an open‑source C++‑based high‑performance search engine, claims to outperform Elasticsearch by up to 15‑times, offering cost‑effective, multi‑threaded full‑text search, SQL compatibility, Docker deployment, and extensive language client support for diverse data workloads.
This guide consolidates essential C standard library functions for converting between strings and numeric types—including atof, atoi, atol, gcvt, strtod, strtol, strtoul, toascii, tolower, and toupper—detailing their headers, prototypes, behavior, and practical code examples with expected outputs.
Anders Hejlsberg, a Copenhagen‑born programming prodigy, created the Turbo Pascal compiler, led Borland’s Delphi that sold millions, then at Microsoft designed Visual J++, the .NET framework, the C# language, and co‑authored TypeScript, shaping software development across three decades.
A seemingly harmless C ternary expression fails on Windows because a backslash in a comment turns the rest of the line into a comment, leading to a cross‑platform tmpfile bug and a similar spacing mistake that broke the code.
To cope with soaring traffic on Bilibili’s effect‑advertising engine, the team systematically measured latency, eliminated redundant Redis calls, switched JSON to Protobuf, applied branch‑prediction hints, loop‑unrolling and AVX256 SIMD, introduced object‑pooling and an inverted‑index request format, cutting CPU usage by 21 % and boosting peak throughput 13 %.
This note introduces several open‑source C unit‑testing frameworks, compares their features, and provides a step‑by‑step guide for porting and using the Unity framework on an STM32 platform, including configuration, test case writing, and result interpretation.
This article explains the Linux Netlink mechanism, its protocol families, advantages over ioctl and /proc, detailed user‑space socket usage, and the kernel‑side APIs required to create, send, receive, and manage Netlink messages, including code examples.
This comprehensive guide explains the fundamentals of pointers in C, covering memory layout, variable storage, address arithmetic, const and void pointers, pointer arrays, function pointers, and common pitfalls, with clear diagrams and runnable code examples to deepen your understanding of low‑level programming.
Manticore Search is a modern, open‑source C++‑based full‑text search engine that claims up to 15‑times faster performance than Elasticsearch in certain scenarios, offering SQL compatibility, multi‑threaded architecture, columnar storage, Docker deployment, and extensive client language support.
This tutorial provides a comprehensive, step‑by‑step guide to using the DHT11 temperature and humidity sensor with an STM32F103C8T6 MCU, covering hardware wiring, sensor specifications, timing diagrams, HAL‑based driver implementation, and complete source code for reliable data acquisition.
This guide explains how Linux programs receive command‑line arguments using argc and argv, demonstrates parsing techniques with manual loops, getopt, getopt_long, and getopt_long_only, and provides complete C code examples with expected outputs and common pitfalls.
A humorous tale reveals how an uninitialized stack variable caused a segmentation fault in C, how inserting a printf unintentionally altered memory to hide the bug, and why proper debugging with GDB is essential to understand such hidden issues.
This article surveys various error and exception handling mechanisms in C, C++, Java, Go, Rust and other languages, comparing global error codes, return values, error stacks, and OS-level support, and evaluates their advantages and drawbacks for modern software development.
This article explains the principles and usage of dynamic memory allocation in C/C++ (malloc, calloc, realloc, free, new, delete), compares their behaviors, demonstrates common pitfalls, and extends the discussion to Linux kernel memory statistics, cache handling, swappiness tuning, and garbage‑collection concepts.
This guide explains how to create a lightweight daemon called ethcheck that continuously monitors the presence of a USB Ethernet adapter on Linux, checks its IP configuration, and automatically adjusts the interface using low‑level system calls and scripts.
Redis founder antirez has open‑sourced BOTLIB, a lightweight C library for building Telegram bots, featuring clear code structure, global chat state management, client handling, and a step‑by‑step event loop, making it an ideal learning project for C network programming enthusiasts.
This article shares a comprehensive embedded software interview guide, covering written‑test topics such as structs vs. unions, linked lists, pointer safety, endianness detection, and a strcpy implementation, followed by technical interview tips, HR interview advice, and concluding remarks.
This article explains why a solid program architecture is essential for embedded projects, introduces a lightweight time‑slice scheduling framework that separates OS logic from user code, and provides complete C source files—including an intrusive doubly‑linked list implementation—to help developers quickly create and manage tasks on a microcontroller.
This article explains the core Linux kernel data structures—including doubly linked lists, kfifo queues, IDR mappings, and red‑black trees—detailing their design, key macros like container_of and offsetof, and providing complete C code samples for initialization, insertion, traversal, and deletion.
This article explains how to use mapping tables to efficiently decode serial port commands and drive UI menu navigation in embedded C, providing concrete data structures, instruction lists, and example functions for both communication handling and scene management.
This article details the complete redesign of QQ Browser's content ingestion system, explaining why the original micro‑service architecture caused low efficiency and performance, and how a zero‑base redesign using a monolithic service, plugin framework, fault‑tolerant pipelines, and thread separation dramatically improved throughput, latency, and developer productivity.
The Bilibili Vision Toolkit (BVT) is a C++ SDK that unifies multimedia AI algorithms through a low‑coupling core, modular dynamic libraries, and a multi‑engine backend, enabling configurable DAG pipelines, asynchronous parallel execution, and seamless FFmpeg filter integration for high‑performance, cross‑platform video processing.
After inheriting a decade‑old query optimizer with massive code duplication and performance issues, our team reduced the codebase by 80%, improved stability, cut startup time from 18 minutes to seconds, and enabled cloud deployment, sharing the code smells we encountered, their motivations, and concrete fixes.
This guide shows how to clone the SmallChat repository, compile the C source with gcc, launch the server binary, and connect via telnet to test the default 7771 port, including code snippets and command‑line examples.
This article explores the motivation, design, implementation, and performance testing of a high‑performance object pool that reduces allocation overhead in multithreaded environments by using thread‑local storage, freelists, and lock‑optimized global resources.
This article explains the principles of Profile‑Guided Optimization, outlines the three‑step workflow, demonstrates practical PGO implementations for Go and C++ with code examples and devirtualization techniques, and presents benchmark results showing significant latency reduction and throughput improvement.
This tutorial explains C pointers in depth, covering memory addresses, declaration, initialization, dereferencing, pointer arithmetic, function pointers, passing by reference, and dynamic memory allocation, with clear code examples and practical usage tips.
The classic real‑time strategy game Red Alert, originally released by Westwood Studios and later acquired by EA, has had parts of its 1996 source code for both Tiberian Dawn and Red Alert released on GitHub, offering C++ developers insight into the well‑structured game logic while excluding assets and the engine.
This article explains C pointers in depth, covering memory layout, declaration, initialization, dereferencing, pointer arithmetic, function pointers, passing by reference, dynamic memory allocation, and common use cases, with clear code examples for each concept.
This article explains how to integrate the C++ Core Guidelines checker via Clang‑Tidy into Android C++ projects, covering setup in ndk‑build and Android Studio, using quick‑fixes to automatically refactor code, generating a JSON compilation database, and highlighting the guidelines' impact on modern C++ talent development.
An iOS engineer shares the challenges, tools, and insights gained while transitioning to Windows desktop development, covering language hurdles, IDE quirks, UI frameworks, encoding issues, debugging techniques, and broader thoughts on cross‑platform development and the mindset of a true technologist.
This guide explains C structs—from basic definitions and declaration styles to memory alignment, byte sizing, bit‑field handling, nested structures, and using structs as function parameters—providing clear code examples and practical tips for efficient embedded and systems programming.
This article explains the fundamentals of sockets as a network communication abstraction, covering process communication, TCP/UDP protocols, socket descriptors, key system calls, the TCP three‑way handshake and four‑way termination, Linux kernel basics, and provides complete C examples for a server and client.
The October TIOBE Index shows Java slipping out of the top three while C# gains ground, sparking speculation that C# could surpass Java soon and highlighting how licensing changes and Kotlin’s rise are reshaping programming language popularity.
The October 2023 TIOBE programming language ranking reveals that C# is poised to surpass Java, which may fall to the fifth position, while also highlighting market‑share shifts, the historical rivalry between the two languages, and a broader overview of the top 50 languages.
This article reviews a series of typical programming blunders—from incorrect local file includes and obscure character usage to excessive if‑else chains, meaningless variable names, hard‑coded outputs, missing returns, and thread‑sleep misuse—offering concrete examples and community comments to help developers learn from these errors.
This article outlines five frequent mistakes in C socket programming—ignoring return values, mishandling peer closures, address‑in‑use errors, endianness issues when sending structured data, and false assumptions about TCP framing—while providing concrete code examples and Linux debugging tools to help developers write more reliable network code.
The crash in asl::LooperObserverMan::notifyIdle was traced to a compiler‑level store‑store reordering that exposed an uninitialized observer pointer, causing an illegal memory access, and was fixed by inserting a memory barrier or using proper atomic ordering to enforce correct initialization order.
This article explains the three common techniques for wrapping C function‑like macros—plain braces, do{…}while(0), and the GNU ({}) extension—detailing their syntax, usage pitfalls, advantages, disadvantages, and recommendations for safe macro design.
This article explains how WeChat Pay solved the fragmented iOS/Android implementations by building a C++‑based cross‑platform framework, introducing UseCase‑driven flow abstraction, a unified routing mechanism, disciplined network request handling, and standardized data passing, resulting in up to 45% code reduction and faster feature delivery.
Former Meta engineer Aydyn Tairov quickly ported the Python implementation of Llama2 to the newly released Mojo language, demonstrating that Mojo’s SIMD primitives can accelerate Python code by up to 250 times and even make the Python version run 20% faster than the original C implementation.
This guide explains typical C memory‑allocation errors, practical ways to avoid them, and introduces a lightweight logging system that automatically records allocations and frees to help developers detect memory leaks during debugging.
This guide explores the most commonly used C standard library headers—stdio.h, stdlib.h, and string.h—detailing each function’s purpose, usage, and providing clear code examples such as printf, malloc, strcpy, and qsort to help programmers write cleaner, more efficient C code.
This article details the complete redesign of a large‑scale content ingestion platform, explaining why the original microservice‑heavy architecture suffered from low development efficiency and poor performance, how a monolithic‑plus‑plugin approach solved these issues, and the resulting 13‑fold speedup, 10‑fold batch improvement, and 70% latency reduction.
Manticore Search is a C++‑based open‑source search engine that builds on Sphinx, offering high‑performance full‑text search, SQL compatibility, and significant speed advantages over Elasticsearch, with detailed usage instructions and Docker deployment examples for developers.
This article explains the fundamentals of C pointer variables, covering their memory layout, declaration, initialization, pointer arithmetic with arrays, passing pointers between functions, and using arrays as function parameters, illustrated with clear code examples and diagrams.
The article details how QQ Browser's content architecture was transformed from a fragmented micro‑service system into a single monolithic service with a plugin framework, dramatically improving processing speed, fault tolerance, and development efficiency while handling thousands of content types.
The article describes how a C++‑based cross‑platform framework was built to unify iOS and Android implementations of WeChat Pay, addressing bugs, scalability, quality assurance, routing, network request management, and data‑flow discipline, ultimately improving development efficiency and user experience.
This guide explains what a process is, how it differs from a thread, various ways to create and terminate processes in Linux, and provides detailed examples of inter‑process communication mechanisms—including message queues, shared memory, UNIX domain sockets, pipes, and semaphores—complete with C code samples.
DGraph, a C++ recommendation engine launched in 2022 for 得物, combines an index layer with a service layer, uses lock‑free RCU structures, a custom mmap‑based D‑Allocator, RoaringBitmap invert indexes, and a multi‑operator fusion scheduler to achieve high‑performance, eventually consistent, scalable recommendations.
This tutorial walks you through creating a simple Unix shell in C, covering its lifecycle, input handling, command parsing, process launching, built‑in commands, and full source compilation, while providing complete code examples and explanations.
This article explains the fundamentals of C function pointers, how to declare and use them, employ typedef for readability, pass them as arguments, return them from functions, store them in arrays, and apply them to implement flexible callback mechanisms with complete code examples.
