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.
The article summarizes a PrestoCon talk that reviews Meta's year‑long production experience with Prestissimo—a C++ Presto worker built on the Velox execution engine—highlighting its architecture, integration design, performance gains, and lessons for anyone considering Velox‑based vectorization.
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.
This guide walks C beginners through the TinyHttp project—providing Chinese annotations, environment setup, common pitfalls, detailed code flow, key function explanations, and step‑by‑step instructions to compile, run, and test a minimal web server.
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.
Redis creator antirez released Smallchat, a compact open‑source C chat server of about 200‑300 lines, illustrating multiplexed I/O with select, global state handling, and client management, making it an ideal hands‑on example for C network‑programming beginners.
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.
The article explains how the C# volatile keyword ensures that fields accessed by multiple threads always hold the latest value by preventing compiler optimizations, lists the types it can be applied to, and warns of pitfalls when used with complex data structures.
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.
Thread.Sleep pauses a thread for a specified time, but its behavior depends on OS scheduling; Sleep(0) yields the CPU to let other threads run, while Sleep(1000) doesn’t guarantee immediate wake‑up, illustrating how time‑slice and priority‑based scheduling affect thread execution.
This article explores five obscure yet useful C language features—enum bit‑fields, label‑and‑goto error handling, varargs functions, unconventional union usage, and conditional compilation—providing clear explanations and code examples to help programmers write more flexible and efficient code.
Based on analysis of over 14 million developer job postings from January 2022 to May 2023, DevJobsScanner identified JavaScript/TypeScript, Python, Java, C#, PHP, C/C++, Ruby, and Go as the eight programming languages with the highest demand, accounting for roughly 29% of all language‑specific positions.
The July 2023 TIOBE Index reveals that C++ has almost caught up with C, while JavaScript climbs to a historic high of #6, several languages return to record positions, and the full Top 100 ranking—including a detailed list of languages ranked 51‑100—is presented with trend charts and methodological notes.
This guide explains how rtty combines a lightweight C client, a Go server, and a Vue front‑end to provide web‑accessible terminals for remote Linux device maintenance, covering its key features, installation steps, token generation, and browser‑based access.
This article walks through creating Rust projects that call C functions directly, generate bindings with bindgen, and wrap a complex C library (secp256k1), providing complete commands, Cargo configurations, and build scripts for seamless Rust‑C integration.
An anonymous developer built WinGPT, a C‑based ChatGPT client that runs on Windows 3.1 and later 16‑or 32‑bit Windows versions, using native TLS 1.3 to connect to OpenAI’s API, highlighting the challenges of retro UI controls, Winsock dependency, and icon creation on legacy systems.
This guide explains Linux serial port device files, shows how to list them, and provides four C programming methods—polling, select‑based interrupt, SIGIO signal handling, and threaded reading—complete with code examples and detailed configuration steps.
This article explains what Linux system calls are, how they are implemented—including parameter preparation, mode switching, execution, and return—and lists common file, process, network, and device calls, highlighting their role in enabling applications to access kernel services.
This article explains how Linux kernel drivers use wait queues for process sleep and wake‑up, covering static and dynamic initialization, the various wait_event macros, wake‑up functions, complete driver source code, Makefile setup, and step‑by‑step build and testing instructions.
The TIOBE June 2023 ranking reveals Python still leading but slipping to 13% share, while AI-driven popularity, emerging languages X++ and Raku, and the steady rise of C, C++, and Java reshape the top‑10 programming language landscape.
This article explains the inner workings of Redis Hashes, covering the dict and listpack storage mechanisms, memory‑optimizing conditions, rehashing strategies, and the underlying C structures that enable fast O(1) field lookups and efficient memory usage.
This article walks through the Linux kernel's slab cache memory‑freeing path, explaining the kmem_cache_free API, validation steps, fast‑path and slow‑path reclamation, CPU‑local and NUMA‑node handling, and the final destruction of slab caches with detailed code examples.
The article shows how to shrink Android NDK .so binaries by over 30% through code de‑duplication, disabling exceptions/RTTI/iostream, using fine‑grained sections with LTO and dead‑code elimination, limiting exported symbols via version scripts, employing JNI dynamic registration, and consolidating C++ runtime dependencies into a shared library.
This article investigates the performance degradation caused by DPDK memory fragmentation, explains the underlying heap and element management, presents detailed profiling and test results, and proposes two practical solutions that dramatically reduce allocation latency and improve overall system throughput.
The article compares C++ and Java in terms of job opportunities, industry demand, skill requirements, and career advice, helping graduates decide which language aligns best with their background and the current market trends in 2023.
The article explains that many core components of modern computing—operating systems, network stacks, compilers, drivers, and runtimes—are written in C/C++, making the language essential for infrastructure, but because reinventing these complex systems is impractical, beginners often shift to higher‑level languages for application development, illustrated with a Lego analogy.
This article provides a comprehensive guide to error handling in C, covering error classification, step‑by‑step handling procedures, return‑value and out‑parameter techniques, global errno usage, goto and setjmp/longjmp jumps, signal handling, program termination functions, assertions, and practical encapsulation patterns with full code examples.
This article explains how to improve Android local‑search latency by embedding JavaScriptCore via JNI, detailing the performance bottlenecks, the integration workflow, essential JSC APIs, JNI usage patterns, and concrete C++/Java code examples that cut processing time by roughly half.
The May 2024 TIOBE programming language index shows minimal changes in the top 20, with Go falling to #12, C++ climbing to #4 with over 3% growth, and newer languages like Swift and Rust still finding it hard to break into the top 100, while the CEO emphasizes the stability of language popularity.
This article explains the differences between std::function and std::invoke in C++, shows how std::function can wrap callable objects such as function pointers, and demonstrates using std::invoke to call various callable types—including free functions and member functions—through clear code examples.
This article explains what unit testing is, provides C# code examples for a simple calculator, and discusses four reasons why automated unit tests should run in CI/CD pipelines to improve development speed, prevent regressions, and protect code written by other developers.
A seemingly harmless C bug caused a Windows build to ignore a ternary file‑creation expression because a stray backslash in a comment turned the following code into a comment, illustrating how tiny syntax errors can cripple cross‑platform programs.
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.
This article walks you through the complete process of compiling pure‑C eBPF programs using the Linux 4.18 kernel source, covering environment setup, kernel source acquisition, essential build steps, detailed make command analysis, and verification of both user‑space and kernel‑space components.
WebAssembly has evolved to version 2.0, offering extensive instruction support, large memory handling, and vector operations, and is now widely used across web and non‑web scenarios; this article surveys popular languages (C/C++, Rust, Go, AssemblyScript, JavaScript, etc.) and key toolchains such as Emscripten, Binaryen, wasi‑sdk, TinyGo, wabt, wasm‑pack, and wasm‑bindgen.
The April 2024 TIOBE index shows a stable top‑20 with Python, C, Java, C++ and C# unchanged, a 4.68% surge for C++, Rust holding its lower‑top‑20 spots, and the newcomer Zig entering the top 50 at rank 46, accompanied by a brief overview of its key features and industry reactions.
This article explains how improper pointer usage and memory‑alignment violations in C can cause crashes on microcontrollers, demonstrates the issue with a concrete code example, and provides portable solutions such as byte‑wise access or memcpy to avoid unaligned accesses.
This article explains the two‑stage socket I/O process in Linux, compares blocking, non‑blocking, and I/O multiplexing techniques, details the select, poll, and epoll APIs with their advantages and drawbacks, and provides complete C code examples for a high‑performance TCP server and client.
This article explains Linux's socket networking framework, details BSD Socket APIs, the abstraction and VFS layers, protocol families, and provides comprehensive guides with code samples for creating, configuring, and using TCP and UDP sockets in C.
This article shares a newcomer’s six‑month experience in game test development, covering automation testing fundamentals, script writing, maintenance practices, tool creation workflows, and cross‑language integration between C#, Lua, PHP, and SQL, offering practical guidance for aspiring test engineers.
This article explains the principles of memory leaks, details the zero‑overhead libmemunreachable detector, walks through its core algorithms and code, and describes the modifications Taobao made to enable reliable leak detection in Android release builds.
This tutorial walks you through creating a basic Unix shell in C, covering prompt output, command input, parsing with strtok, handling built‑in commands like cd and echo, forking child processes, executing commands via execvp, and assembling the complete source code.
This article explains how C programs allocate, resize, initialize, and transfer memory using functions like malloc, free, realloc, memset, memcpy, memmove, and alloca, and provides coding standards to avoid out‑of‑bounds errors, leaks, and use‑after‑free bugs.
This article compiles a detailed interview guide covering TCP/UDP differences, three‑way handshake and four‑way termination, flow and congestion control, select/poll/epoll mechanisms, zero‑copy techniques, Redis advantages and persistence, MySQL MVCC and repeatable‑read semantics, as well as core C++ topics and common algorithm questions.
This tutorial walks through extending a C‑based Lisp interpreter with string support, comment parsing, built‑in print and error commands, file loading capabilities, providing complete code examples and explanations for each feature in the interpreter.
This tutorial walks through extending a C‑based Lisp interpreter by adding conditional branching, comparison built‑ins, an if keyword, and registering all built‑in functions, while providing the complete source code and explanations for each component.
This article presents the EJC (Electron‑Java‑C/C++) architecture adopted by ZhiZhuan’s quality‑inspection platform, detailing its layered design, communication modules, JNI/JNA integration, performance comparisons, and real‑world implementation for cross‑platform desktop tools, illustrating how the approach enhances extensibility, maintainability, and scalability.
This tutorial walks through adding Q‑Expression support to a Lisp‑style interpreter written in C, covering syntax definition, parser updates, implementation of head, tail, join, list, and eval functions, macro‑based assertions, and a complete source listing with compilation instructions.
This article explains the concept of S‑Expressions, defines their simple syntax, and provides a complete C implementation that parses, stores, evaluates, and prints S‑Expression based Lisp code, including detailed explanations of data structures, constructors, destructors, and evaluation logic.
This article explains how to create a Lispy Value storage system in C, defining numeric and error types, enumerations, constructors, printing functions, and semantic error detection to support a simple Lisp REPL that evaluates Polish notation expressions.
This article explains Polish (prefix) notation, defines its syntax and lexical rules, and walks through implementing a full parser and evaluator in C using the MPC library, complete with code examples, compilation instructions, and sample interactive sessions.
This guide walks through building a cross‑platform interactive C REPL, covering basic input/output loops, integrating GNU Readline for line editing and history, handling portability with preprocessor directives, and using the MPC library to create a simple Doge language parser.
