Tagged articles
GCC
62 articles · Page 1 of 1
This article outlines six fundamental differences between Unix and Linux, covering shell standards, command options, make implementations, C compilers, GNU vs Linux distinctions, and the UNIX trademark, with practical guidance for writing portable code.
BSDClangGCC
0 likes · 6 min read

The article explains that a false if constexpr condition does not magically erase the other branch; the compiler still performs semantic checks on non‑dependent code, and the real difference lies in how SFINAE discards whole overload candidates while if constexpr only discards statements after overload resolution.
C++GCCSFINAE
0 likes · 13 min read

This week’s tech roundup covers OpenAI’s free‑year program for 100 k researchers, dramatic price cuts in GPT‑5.6, TRAE Work’s enterprise AI workflow, Qualcomm’s personal‑AI strategy, GCC’s new AI‑code contribution rules, Claude Code’s prompt‑tuning lessons, Anthropic’s product‑management shift, and Li Fei‑Fei’s robot‑school venture, among other industry insights.
AnthropicClaude CodeGCC
0 likes · 30 min read

This article explains the fundamentals of Linux dynamic linking, compares .so shared objects with static libraries, walks through creating and compiling a simple math library, shows how to link and run an executable, and details runtime loading, library path configuration, and common troubleshooting techniques.
GCCLinuxShared Library
0 likes · 31 min read

This guide walks through installing all required packages, configuring ARM32 and ARM64 cross‑compilation toolchains on Ubuntu 18.04/20.04/22.04, verifying the setup with a sample program, and provides commands for fixing common issues and uninstalling the toolchains.
ARMCross-compilationGCC
0 likes · 6 min read

The article details a step‑by‑step local deployment of DeepSeek‑OCR‑2, covering GPU memory requirements, accuracy on complex tables, long inference times, dependency hurdles like GCC, GLIBC and flash‑attn, and provides concrete solutions using conda environments and symlinks.
DeepSeek-OCR 2GCCGPU
0 likes · 7 min read

On isolated internal networks where the system GCC is stuck at version 4.8.5, the article shows how to bypass system upgrades by using Conda to install GCC 9 in a virtual environment, create symlinks, and compile AI projects like vLLM without root access.
AI developmentGCCInternal Network
0 likes · 6 min read

From the painful days of hand‑written assembly to the birth of Fortran, the rise of GCC, and the modular revolution of LLVM, this article traces six decades of compiler history, highlighting key breakthroughs, influential figures, and the lasting impact on modern software development.
FortranGCCLLVM
0 likes · 6 min read

McKinsey’s latest report reveals that Gulf Cooperation Council (GCC) countries are heavily investing in AI infrastructure, achieving high adoption rates, but only a small fraction of firms have scaled AI projects to generate measurable value, highlighting gaps in strategy, talent, and change management.
AI AdoptionAI agentsAI strategy
0 likes · 7 min read


21CTONov 29, 2025 · Fundamentals
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.
C++C++20Compiler
0 likes · 5 min read

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.
C++EmbeddedGCC
0 likes · 9 min read

This article examines why compilers can be unreliable, explains how optimization errors, undefined‑behavior assumptions, and hardware‑specific code generation can introduce subtle bugs, presents real‑world examples from GCC, MSVC and Clang, and offers practical strategies to detect and avoid such compiler faults.
C++GCCMSVC
0 likes · 14 min read

This guide walks you through installing and configuring four major C++ development tools—Visual Studio, GCC, Clang, and CMake—covering platform-specific steps for Windows, Linux, and macOS, and highlights each tool’s advantages to help you choose the right environment for your projects.
C++CMakeClang
0 likes · 6 min read

This article explains how to measure, analyze, and improve CPU usage in software by examining key metrics, choosing efficient algorithms and data structures, leveraging compiler options, exploiting cache behavior and SIMD vectorization, and applying practical case studies with Linux profiling tools.
CPUCacheGCC
0 likes · 31 min read


21CTOMar 18, 2025 · Backend Development
GCC 15 is slated for release in late April or early May, bringing a native COBOL frontend, default C23 support, early C++23/26 features, expanded RISC‑V capabilities, and a roadmap that still leaves Algol‑68 for future versions.
Algol68C++23C23
0 likes · 6 min read

This step‑by‑step guide shows how to choose a Linux distribution, install GCC, configure Vim/VS Code/CLion, compile and run C/C++ programs, set up debugging with GDB and Valgrind, automate builds with Makefile or CMake, beautify the terminal, and manage code with Git, all with concrete commands and examples.
C++GCCGit
0 likes · 15 min read

This article walks through the NVCC compilation pipeline, explaining how CUDA source files are transformed into host and device binaries, detailing file extensions, compilation stages, command‑line options, intermediate artifacts, and the role of registration functions such as __nv_cudaEntityRegisterCallback and __sti____cudaRegisterAll.
CUDAGCCGPU
0 likes · 12 min read

This article explains why Linux programs may exit unexpectedly, introduces the backtrace utility and its underlying call‑stack mechanism, and provides step‑by‑step instructions—including compilation flags, signal handling, and address‑to‑source mapping—to accurately locate the root cause of crashes.
C++DebuggingGCC
0 likes · 25 min read

This article introduces five widely used, free C/C++ compilers—GCC, Clang/LLVM, Tiny C Compiler, Microsoft Visual C++, and Digital Mars—detailing their main features, platform support, typical usage commands, and ideal application scenarios for developers seeking lightweight or powerful compilation tools.
C++ClangCompiler
0 likes · 12 min read

This guide walks through the complete GCC compilation pipeline—preprocessing, compilation, assembly, and linking—demonstrates how to build a simple C program, inspect the resulting ELF file, and use Binutils tools to analyze sections and disassemble the binary.
BinutilsC++ELF
0 likes · 13 min read

This article explains how high‑level C/C++ programs are transformed into processor‑executable binary code on Linux, covering preprocessing, compilation, assembly, linking, the GCC toolchain, Binutils utilities, C runtime libraries, and ELF file analysis with practical command examples.
ELFGCCLinux
0 likes · 13 min read

This article explains how to use the shell's Here Document feature to embed C source code directly in a script, pipe it to gcc with appropriate flags, and instantly compile and run a hello‑world executable without separate source files.
C compilerGCChere-document
0 likes · 3 min read

A segmentation fault in a simple tile‑index copy loop was traced to GCC 9.2’s -O3 loop‑vectorization pass miscalculating structure offsets, and the issue was resolved by disabling -ftree-loop-vectorize or upgrading the compiler, as newer GCC versions and Clang handle the code correctly.
GCCNeonassembly
0 likes · 26 min read

This guide explains how GNU ld linker scripts work, covering their purpose, basic concepts like sections, symbols, VMA/LMA, the syntax of SECTIONS, INPUT, OUTPUT, and other commands, with practical examples and code snippets for embedded and desktop ELF binaries.
ELFEmbeddedGCC
0 likes · 30 min read

A client‑reported segmentation fault was traced to changing GCC’s optimization level from -O2 to -O3, revealing a bug in the -ftree-loop-vectorize option that miscalculates struct sizes, and the article explains the analysis, assembly inspection, NEON details, and a practical workaround.
DebuggingGCCNeon
0 likes · 28 min read

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.
BackendC++GCC
0 likes · 4 min read

This article guides readers through the complete GCC toolchain workflow—preprocessing, compilation, assembly, linking—and explains how to analyze the resulting ELF binary, covering essential commands, Binutils utilities, and runtime library details for C/C++ programs on Linux.
BinutilsELFGCC
0 likes · 13 min read

This guide explains how high‑level C/C++ source code is transformed into executable binary code on Linux using the GCC toolchain, covering preprocessing, compilation, assembly, linking, and ELF file inspection with practical command examples.
ELFGCCLinux
0 likes · 15 min read

This article explains the complete transformation of C/C++ source code into processor‑executable binary files using the GCC toolchain, covering preprocessing, compilation, assembly, linking, ELF structure, and practical command‑line examples on a Linux system.
ELFGCCLinux
0 likes · 16 min read

The Linux kernel removed Intel ICC compiler support in the 6.3 release, citing the compiler's deprecation, the shift to LLVM/Clang‑based DPC++, and the continued dominance of GCC and Clang, resulting in a cleaner codebase without any functional loss.
ClangCompilerGCC
0 likes · 3 min read

This article explains the fundamental concepts behind C language compilation, covering lexical, syntax, and semantic analysis, GCC options, file types, static and dynamic linking, ELF structure, and the loader process that turns source code into a runnable program.
C++ELFGCC
0 likes · 23 min read

This article outlines the fundamental differences between Unix and Linux, covering shell defaults, option styles, make utilities, compiler conventions, GNU versus Linux distinctions, and the trademarked UNIX term, helping developers write portable scripts and build systems across various Unix-like platforms.
GCCLinuxOperating Systems
0 likes · 5 min read


21CTODec 9, 2022 · Fundamentals
Linux will start supporting the Rust programming language from kernel version 6.1, adding about 12,500 lines of code, with ongoing work from the Rust‑for‑Linux community, GCC’s Rust front‑end integration, and early driver examples demonstrating Rust’s potential in kernel development.
GCCLinuxRust
0 likes · 5 min read


21CTOSep 17, 2022 · Fundamentals
The upcoming Linux 6.0 kernel hints at future Rust driver support, but significant hurdles remain such as compiler compatibility, LLVM vs GCC toolchains, and limited architecture support, making widespread Rust integration unlikely until later releases.
GCCLLVMLinux
0 likes · 4 min read

This article walks through the complete GCC toolchain workflow—preprocessing, compilation, assembly, and linking—using a simple C "Hello World" program, explains the roles of GCC, Binutils and the C runtime, and shows how to inspect the resulting ELF binary with common Linux utilities.
ELFGCCLinux
0 likes · 13 min read

This guide explains why you should avoid compiling GCC yourself and shows step‑by‑step how to use Red Hat's Developer Toolset or gcc‑toolset to install, switch, and activate newer GCC versions on both CentOS 7 and CentOS 8, including temporary and permanent activation methods.
CentOSDevtoolsetGCC
0 likes · 7 min read

This guide explains how C/C++ source code is transformed into a runnable binary on Linux by walking through the four stages of preprocessing, compilation, assembly, and linking, detailing GCC and Binutils utilities, command‑line examples, and ELF file inspection techniques.
ELFGCCLinux
0 likes · 14 min read

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.
ASTC++GCC
0 likes · 11 min read

This article explains how high‑level C/C++ programs are transformed into processor‑executable binaries on Linux, covering preprocessing, compilation, assembly, linking, the GCC and Binutils utilities, and how to inspect the resulting ELF file.
ELFGCCToolchain
0 likes · 14 min read

This article provides a step-by-step guide for Java programmers on using gcc, covering the preprocessing, compilation, assembly, and linking stages, and demonstrates how to create and use static and dynamic libraries in C with practical code examples.
Dynamic LibraryGCCc-programming
0 likes · 5 min read

This article examines how the memory size of C enum types varies with declared value ranges and compiler options such as -fshort-enums, showing default and shortened sizes across different compilers and illustrating the impact of adding larger constant values.
C++CompilerEmbedded
0 likes · 4 min read

This Bash script automates the installation of GCC 11.2.0 and Redis 6.2.6 on a Linux system, configures Redis settings, creates a systemd service unit, and starts the Redis service, providing a reproducible setup procedure for developers and system administrators.
GCCsystemd
0 likes · 4 min read

This article explains the syntax and semantics of C's while(1) and for(;;) constructs, compares their execution flow, shows how to compile each to assembly with gcc, and demonstrates that, aside from file names, the generated code is identical under typical settings.
C++GCCassembly
0 likes · 6 min read

This article explains how to measure code coverage for C/C++ projects using GCC's built‑in Gcov tool and the LCOV utility, covering prerequisite setup, compilation with profiling flags, running tests, generating .gcno/.gcda files, producing .gcov reports, creating HTML visualizations, and cautions against over‑relying on coverage percentages.
GCCcode coveragelcov
0 likes · 11 min read

This article explains the GCC compiler suite, its internal packages (Binutils, gcc‑core, Glibc), demonstrates a simple C build, and details cross‑compilation techniques for ARM, including differences between arm‑linux‑gcc, arm‑elf‑gcc, and various C libraries such as uClibc and newlib.
ARMC libraryCross-compilation
0 likes · 10 min read

This article explains the GNU Compiler Collection (GCC) architecture, its core packages (Binutils, gcc‑core, Glibc), demonstrates a simple C compilation workflow, and details cross‑compilation techniques for ARM including arm‑linux‑gcc, arm‑elf‑gcc, and various C libraries such as uClibc and newlib.
ARMC libraryCompiler
0 likes · 11 min read

The article compares the infinite loop constructs for(;;) and while(1) in C by compiling simple programs, examining the generated assembly with gcc, and shows that both produce identical machine code, while also noting compiler warnings and style preferences.
C++GCCassembly
0 likes · 5 min read

This guide explains the GCC compiler's evolution, how to compile C and C++ programs using gcc and g++, highlights their differences, and provides practical command examples and linking options for successful builds.
C++C++Compiler
0 likes · 7 min read

This tutorial explains how GCC version 10.2 compiles C and C++ programs, clarifies the differences between the gcc and g++ commands, shows how file extensions and the -x option affect language selection, and provides concrete command examples for successful compilation and linking.
C++GCCc-programming
0 likes · 7 min read

This article provides a comprehensive overview of the GNU Compiler Collection (GCC), covering its origins, evolution, core compilation stages, essential command‑line options, and advanced capabilities such as building shared and static libraries and mixed‑language projects.
C languageCompilerDynamic Library
0 likes · 7 min read

This guide explains how to use GCC's built‑in AddressSanitizer to detect memory leaks, heap/stack/global buffer overflows, use‑after‑free, and initialization‑order bugs, providing sample code, compilation flags, and example outputs for each error type.
C++ debuggingGCCMemory Leak
0 likes · 18 min read

libgccjit, an embedded GCC JIT library, has been experimentally ported to Windows, with developers overcoming libtool and Automake differences, handling DLL creation, and noting GPLv3 licensing implications, demonstrating the feasibility of GCC JIT on Windows despite limited adoption prospects.
GCCGPLv3JIT
0 likes · 2 min read

This guide details the migration of X86‑compiled C/C++ applications to Huawei TaiShan Aarch64 servers, covering language differences, required compiler versions, common build‑time errors, assembly rewrites, memory‑ordering quirks, floating‑point precision issues, and specific GCC flags to achieve correct and performant binaries.
Compiler FlagsGCCaarch64
0 likes · 14 min read

This guide explains how to build an ARM GCC cross‑compilation toolchain on non‑ARM (x86) servers, covering environment preparation, toolchain download, installation steps, environment variable configuration, and testing the compiled binaries on a Kunpeng cloud server.
ARMCross-compilationGCC
0 likes · 5 min read


ITPUBSep 27, 2019 · Operations
CentOS 8 has been officially released, mirroring RHEL 8 with a 4.18 kernel, DNF package manager, updated programming languages, GCC 8.2, newer database servers, and a shift to nftables, while offering upgrade instructions, source‑code access, and links to official download resources.
CentOS 8GCCLinux
0 likes · 6 min read

The article explains why a C++ program produces different outputs with and without the -O2 optimization flag, tracing the issue to strict aliasing violations caused by type‑punning pointer casts, and shows how disabling -fstrict-aliasing or using -fno‑strict‑aliasing resolves the problem.
C++GCCOptimization Flags
0 likes · 8 min read

This tutorial shows how to write a concise Makefile that automatically discovers all .c files in a directory, builds each into an executable with matching names, and supports easy addition of new programs with a single make command.
GCCMakefileautomation
0 likes · 4 min read

This step‑by‑step tutorial shows how to write a Makefile for a tiny C program, then progressively improves it with separate object files, variables, pattern rules, and built‑in functions like wildcard and patsubst, while explaining each concept and its benefits.
GCCMakefileMakefile Tutorial
0 likes · 9 min read

This step‑by‑step guide shows how to access the terminal in Ubuntu, install VMware Tools, switch to faster domestic apt mirrors, and add essential development packages such as vim, git, and gcc/g++ to turn a newly installed VM into a ready‑to‑code environment.
GCCGitVMware Tools
0 likes · 7 min read


ITPUBMar 17, 2017 · Fundamentals
This guide explains Linux library types, naming conventions, and step‑by‑step commands for creating static (.a) and shared (.so) libraries, managing symbolic links, checking dependencies, runtime search paths, dynamic loading, and using GNU Libtool.
GCCGNU LibtoolShared Library
0 likes · 7 min read


ITPUBSep 8, 2016 · Fundamentals
This guide walks through the ELF format, the compilation‑assembly‑linking pipeline, and step‑by‑step creation and usage of static (.a) and dynamic (.so) libraries on Linux, including gcc, ar, ldconfig, ldd and runtime loading with dlopen.
Dynamic LibraryELFGCC
0 likes · 16 min read


ITPUBMar 11, 2016 · Fundamentals
This guide explains the naming conventions, source code, compilation commands, and linking techniques for creating a Linux shared library (.so) using GCC, including options like -fpic, -shared, absolute‑path linking, and the -l flag after copying the library to /usr/lib.
GCCLinuxShared Library
0 likes · 6 min read
