BestHub
Sign in
Tagged articles

Compilation

170 articles · Page 1 of 2
samdeepthink
samdeepthink
Jul 25, 2026 · Fundamentals

Why Veteran Developers Caution Beginners About IDEs—and the Three Steps to Master First

The article argues that beginners should first grasp the three fundamental stages of Java program execution—compilation, dependency resolution, and runtime—by manually using javac and java, because understanding these processes reveals what an IDE automates, prevents hidden pitfalls, and ultimately empowers confident IDE use.

CompilationDependency ManagementIDE
0 likes · 5 min read
Why Veteran Developers Caution Beginners About IDEs—and the Three Steps to Master First
Java Tech Workshop
Java Tech Workshop
May 23, 2026 · Fundamentals

Method Overloading vs Overriding in Java: Key Differences and Common Pitfalls

This article explains Java's two polymorphism mechanisms—static overload and dynamic override—detailing definitions, compiler rules, valid code examples, a side‑by‑side comparison table, and frequent pitfalls such as static method hiding, access‑modifier changes, and exception widening.

@OverrideCompilationMethod Overloading
0 likes · 10 min read
Method Overloading vs Overriding in Java: Key Differences and Common Pitfalls
Machine Learning Algorithms & Natural Language Processing
Machine Learning Algorithms & Natural Language Processing
Apr 27, 2026 · Artificial Intelligence

SkVM: A Language VM for Skill Enables One‑Write, Everywhere‑Efficient Execution on Any LLM

SkVM, an open‑source language virtual machine from Shanghai Jiao Tong University’s IPADS team, compiles Skill code once and runs it efficiently across diverse LLMs and Agent harnesses, delivering up to 50× speedups, 40% token savings, and performance comparable to Opus 4.6 on 30B models.

AgentCompilationLLM
0 likes · 10 min read
SkVM: A Language VM for Skill Enables One‑Write, Everywhere‑Efficient Execution on Any LLM
Deepin Linux
Deepin Linux
Mar 29, 2026 · Fundamentals

What Happens Inside an ELF File? From Source Code to a Running Process

This article explains how a C/C++ program is compiled into an ELF executable, details the ELF file structure, describes the kernel's validation and segment mapping, covers dynamic linking, and shows how the process starts execution from the _start entry point, providing practical commands and debugging tips.

CompilationDebuggingELF
0 likes · 34 min read
What Happens Inside an ELF File? From Source Code to a Running Process
Lisa Notes
Lisa Notes
Mar 14, 2026 · Fundamentals

How to Build Your First Java Application from Scratch

This tutorial walks you through installing the JDK, creating a HelloJava.java source file with Notepad, compiling it using javac, running it with the java interpreter, and explains the basic structure, comments, class definition, and main method of a Java program.

CommandLineCompilationHelloWorld
0 likes · 12 min read
How to Build Your First Java Application from Scratch
Java One
Java One
Dec 26, 2025 · Fundamentals

How C/C++, Java, and Python Run: A Deep Dive into Compilation and Execution

This article compares the execution models of C/C++, Java, and Python, explaining how compiled machine code, bytecode with JVM, and interpreted bytecode with the Python virtual machine operate, and illustrates each process with example file structures and compilation steps.

C++CompilationProgramming Languages
0 likes · 6 min read
How C/C++, Java, and Python Run: A Deep Dive into Compilation and Execution
Raymond Ops
Raymond Ops
Nov 16, 2025 · Operations

Master Linux Package Management: yum, apt, dpkg, and Source Compilation

This guide walks you through Linux package management fundamentals, covering yum and apt/apt‑get commands, dpkg/rpm operations, and a step‑by‑step example of compiling and installing software from source such as Nginx, while highlighting convenience, customizability, and permission considerations.

APTCompilationLinux
0 likes · 9 min read
Master Linux Package Management: yum, apt, dpkg, and Source Compilation
Liangxu Linux
Liangxu Linux
Nov 9, 2025 · Operations

Why Do You Still Need to Compile Linux Software? Uncovering the Underlying Logic

This article explains why many Linux applications require manual compilation, compares various installation methods—including package managers, source builds, binary packages, universal formats, and containers—and offers practical guidance on choosing the right approach for different scenarios.

CompilationLinuxPackage Management
0 likes · 12 min read
Why Do You Still Need to Compile Linux Software? Uncovering the Underlying Logic
DeWu Technology
DeWu Technology
Sep 1, 2025 · Mobile Development

Why R8’s ApiModel Adds an Extra new‑instance Instruction and Crashes Android Apps

This article explains how R8’s ApiModel optimization can generate a redundant new‑instance bytecode that triggers class initialization failures, why synchronized or try‑catch blocks also cause the issue, and presents four practical solutions including disabling ApiModel, official patches, custom fixes, and business‑level refactoring.

AndroidApiModelCompilation
0 likes · 16 min read
Why R8’s ApiModel Adds an Extra new‑instance Instruction and Crashes Android Apps
Deepin Linux
Deepin Linux
Aug 29, 2025 · Fundamentals

Master VSCode for C/C++ on Linux: Step‑by‑Step Compilation & Debugging Guide

This article walks you through setting up a powerful C/C++ development environment on Linux using VSCode, covering toolchain installation, essential extensions, project initialization, key configuration files, large‑project tips, and a hands‑on Clangd example, all with clear code snippets and explanations.

C++CMakeClangd
0 likes · 44 min read
Master VSCode for C/C++ on Linux: Step‑by‑Step Compilation & Debugging Guide
Sohu Smart Platform Tech Team
Sohu Smart Platform Tech Team
Aug 8, 2025 · Mobile Development

Unlocking the Secrets of Objective‑C Blocks: From Syntax to Runtime Mechanics

This article demystifies Objective‑C blocks by explaining their definition, practical uses, syntax variations, common usage scenarios, underlying data structures and compilation process, copy semantics, variable capture rules, reference‑cycle pitfalls, and provides concise code examples and reference links for iOS developers.

BlocksCompilationMemory Management
0 likes · 15 min read
Unlocking the Secrets of Objective‑C Blocks: From Syntax to Runtime Mechanics
php Courses
php Courses
Jul 7, 2025 · Fundamentals

Master the Classic C++ Hello World: Step-by-Step Code Walkthrough

Learn how to write, compile, and run a basic C++ Hello World program, with a complete code listing, line-by-line explanations of each statement, common variations, compilation commands, and tips for understanding the program’s structure and output.

C++Code WalkthroughCompilation
0 likes · 6 min read
Master the Classic C++ Hello World: Step-by-Step Code Walkthrough
Liangxu Linux
Liangxu Linux
Jun 25, 2025 · Fundamentals

Why Hard-Coding Memory Addresses Is a Nightmare and How Symbols Solve It

The article explains how manually calculating absolute memory addresses for functions leads to error‑prone maintenance, introduces the concept of symbols to reference code by name, and details the role of object files, symbol tables, relocation tables, and the linking process that resolves addresses automatically.

CompilationLinkerlow-level programming
0 likes · 8 min read
Why Hard-Coding Memory Addresses Is a Nightmare and How Symbols Solve It
Java One
Java One
May 4, 2025 · Fundamentals

How Does Java Execution Differ from C? A 3‑Minute JVM Deep Dive

This article compares the compilation and runtime processes of C and Java programs, explains Java's class loading, linking, initialization, memory layout, execution engine components, and native interface, and highlights why Java startup is slower than native C execution.

ClassLoaderCompilationJVM
0 likes · 16 min read
How Does Java Execution Differ from C? A 3‑Minute JVM Deep Dive
Infra Learning Club
Infra Learning Club
Feb 22, 2025 · Fundamentals

Understanding NVCC Compilation: A Step‑by‑Step Technical Guide

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.

CUDACompilationGCC
0 likes · 12 min read
Understanding NVCC Compilation: A Step‑by‑Step Technical Guide
Liangxu Linux
Liangxu Linux
Jan 25, 2025 · Backend Development

Master GCC, G++ and GDB: From Installation to Advanced Debugging

This guide walks you through installing GCC/G++, compiling single‑ and multi‑file C/C++ programs, using essential compiler options, performing step‑by‑step builds, and leveraging GDB for effective debugging, while also covering common errors and their solutions.

C++CompilationLinux
0 likes · 17 min read
Master GCC, G++ and GDB: From Installation to Advanced Debugging
Infra Learning Club
Infra Learning Club
Jan 24, 2025 · Fundamentals

Inside NVCC: How CUDA Code Is Compiled and Linked

The article dissects NVCC’s compilation pipeline, showing how internal registration functions from host_runtime.h are injected into the host binary, how a simple CUDA demo is processed with --dryrun, and how the generated fatbin, PTX, and cubin files are linked and registered for GPU execution.

CUDACompilationFatBinary
0 likes · 10 min read
Inside NVCC: How CUDA Code Is Compiled and Linked
Python Programming Learning Circle
Python Programming Learning Circle
Jan 15, 2025 · Fundamentals

Python Performance Optimization Tools and Libraries

This article introduces a comprehensive set of Python performance‑enhancing tools and libraries—including NumPy, SciPy, PyPy, Cython, Numba, GPU‑based solutions, and various wrappers—explaining how they accelerate code execution, reduce memory usage, and enable efficient single‑ and multi‑processor programming.

CompilationGPULibraries
0 likes · 8 min read
Python Performance Optimization Tools and Libraries
ByteDance SYS Tech
ByteDance SYS Tech
Dec 27, 2024 · Backend Development

How ByteDance Tackled C++ Compilation Bottlenecks and Massive Binary Bloat

ByteDance's STE team dissected the severe compile‑time delays and oversized binary artifacts in their data‑center C++ applications, presenting root‑cause analyses, LLVM bug fixes, and a suite of optimization techniques that together cut build times by up to 50% and reduced binary size by over 80%.

C++CompilationLLVM
0 likes · 26 min read
How ByteDance Tackled C++ Compilation Bottlenecks and Massive Binary Bloat
DeWu Technology
DeWu Technology
Nov 4, 2024 · Frontend Development

WebAssembly (Wasm): Concepts, Advantages, and Practical Rust Integration

WebAssembly (Wasm) is a portable binary format that runs near native speed in browsers, providing sandboxed security and modular deployment, though its ecosystem is still maturing; it shines in compute‑intensive tasks like scientific computing, gaming, and porting native code, and can be integrated with Rust via wasm‑bindgen and wasm‑pack to create npm‑compatible modules that outperform JavaScript on larger workloads, while requiring higher development effort.

CompilationFrontendJavaScript
0 likes · 15 min read
WebAssembly (Wasm): Concepts, Advantages, and Practical Rust Integration
MaGe Linux Operations
MaGe Linux Operations
Oct 15, 2024 · Operations

How to Compile and Deploy Nginx from Source on Linux

This guide walks through downloading the Nginx source package, extracting it, compiling and installing it to a custom directory, configuring a systemd service unit, and finally starting and verifying the server on a Linux system.

CompilationInstallationLinux
0 likes · 3 min read
How to Compile and Deploy Nginx from Source on Linux
Deepin Linux
Deepin Linux
Sep 10, 2024 · Fundamentals

Comprehensive Embedded Software Interview Guide: Memory Management, IPC, DMA, Kernel Allocation, and Core Concepts

This article provides an extensive overview of embedded software fundamentals, covering heap vs. stack differences, wild pointers, DMA roles, inter‑process communication methods, memory allocation strategies, malloc vs. new, volatile usage, pointer concepts, Linux kernel locks, FreeRTOS mechanisms, stack overflow prevention, compilation stages, quick‑sort algorithm, header inclusion, CAN identifiers, struct memory optimization, STM32 interrupt handling, user‑to‑kernel transitions, and condition‑variable thundering‑herd effects.

C++CompilationDMA
0 likes · 121 min read
Comprehensive Embedded Software Interview Guide: Memory Management, IPC, DMA, Kernel Allocation, and Core Concepts
Liangxu Linux
Liangxu Linux
Aug 28, 2024 · Fundamentals

Mastering GCC: From C Source to ELF Executable in Four Steps

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++Compilation
0 likes · 13 min read
Mastering GCC: From C Source to ELF Executable in Four Steps
Open Source Linux
Open Source Linux
Aug 23, 2024 · Backend Development

Mastering GCC: From Source Code to Executable ELF Binaries

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.

C programmingCompilationELF
0 likes · 13 min read
Mastering GCC: From Source Code to Executable ELF Binaries
Open Source Tech Hub
Open Source Tech Hub
Aug 12, 2024 · Backend Development

Compiling ThinkPHP8 with BPC: From Migration to Running OurBlog

This article explains how BPC, a PHP native compiler, can translate ThinkPHP8 code into C, outlines the required dependencies, details the migration of the OurBlog sample project, describes necessary code adjustments, and provides step‑by‑step instructions to compile and run the resulting binary.

BPCCompilationMigration
0 likes · 6 min read
Compiling ThinkPHP8 with BPC: From Migration to Running OurBlog
Liangxu Linux
Liangxu Linux
Aug 5, 2024 · Fundamentals

Static vs Dynamic Libraries: Save Disk Space and Simplify Updates

This article explains how programs are laid out in memory, walks through the compilation and linking stages, compares static and dynamic linking, and shows why dynamic libraries reduce disk and memory usage while making bug fixes easier.

CompilationDynamic LinkingStatic Linking
0 likes · 8 min read
Static vs Dynamic Libraries: Save Disk Space and Simplify Updates
Liangxu Linux
Liangxu Linux
Jul 28, 2024 · Fundamentals

Why Static Libraries Waste Space and How Dynamic Linking Saves It

This article explains the memory layout of a program, the compilation and linking processes, and compares static and dynamic libraries, highlighting how static linking duplicates code while dynamic linking shares libraries to reduce disk and memory usage.

CompilationDynamic LibraryLinker
0 likes · 7 min read
Why Static Libraries Waste Space and How Dynamic Linking Saves It
IT Services Circle
IT Services Circle
Jun 21, 2024 · Fundamentals

Understanding the Difference Between Static and Dynamic Libraries

This article explains how programs are laid out in memory, the roles of code, data, heap, and stack sections, and compares static linking, which bundles all code into the executable, with dynamic linking, which loads shared libraries at runtime to save disk and memory space.

CompilationDynamic LinkingLibraries
0 likes · 9 min read
Understanding the Difference Between Static and Dynamic Libraries
Ops Development & AI Practice
Ops Development & AI Practice
Jun 2, 2024 · Fundamentals

Master MSVC: Install, Configure, and Compile C/C++ on Windows

This guide introduces Microsoft Visual C++ (MSVC), covering its key features, installation via Visual Studio or Build Tools, command‑line and VS Code integration, step‑by‑step compilation commands, and advanced options like parallel builds and PGO, helping developers efficiently build C/C++ projects on Windows.

Build ToolsC++Compilation
0 likes · 7 min read
Master MSVC: Install, Configure, and Compile C/C++ on Windows
Ops Development & AI Practice
Ops Development & AI Practice
May 9, 2024 · Fundamentals

Mastering Makefile: Core Concepts and Practical Examples for Efficient Builds

This article explains the essential Makefile concepts—including targets, dependencies, commands, variables, pattern and implicit rules, includes, conditionals, functions, special variables, and parallel execution—through clear explanations and real‑world code examples to help developers automate and streamline their build processes.

CompilationMakefileParallel Build
0 likes · 5 min read
Mastering Makefile: Core Concepts and Practical Examples for Efficient Builds
Java Tech Enthusiast
Java Tech Enthusiast
Mar 31, 2024 · Fundamentals

Command-Line Java Execution: From JDK 8 to JDK 22

The article guides beginners through command‑line Java execution, showing how JDK 8 requires explicit compilation and class‑path, JDK 11 introduces single‑source file launching without compilation, and JDK 22 extends this to multi‑file programs, allowing direct execution of several source files with a simple java command.

CompilationJDKjava
0 likes · 5 min read
Command-Line Java Execution: From JDK 8 to JDK 22
Ele.me Technology
Ele.me Technology
Feb 21, 2024 · Frontend Development

MorJS: Converting Mini‑Program Code to Web Applications – Architecture and Implementation

MorJS is a self‑developed tool that automatically converts Alipay mini‑program code into a full React web application by parsing AXML, ACSS and JavaScript into JSX, CSS and React logic, and supplying a runtime with lifecycle mapping, lit‑element UI components and API shims, cutting development effort by over 30% and unifying Ele.me’s web, app and mini‑program ecosystems.

CompilationMini ProgramMorJS
0 likes · 12 min read
MorJS: Converting Mini‑Program Code to Web Applications – Architecture and Implementation
Liangxu Linux
Liangxu Linux
Dec 25, 2023 · Fundamentals

Mastering Static and Dynamic Libraries on Linux: A Step‑by‑Step Guide

This article explains why reusable code should be packaged into libraries, compares static (.a) and dynamic (.so) libraries on Linux, and provides detailed commands, code examples, and troubleshooting steps for building and linking both types of libraries in C++ projects.

C++CompilationDynamic Library
0 likes · 10 min read
Mastering Static and Dynamic Libraries on Linux: A Step‑by‑Step Guide
Liangxu Linux
Liangxu Linux
Nov 9, 2023 · Fundamentals

Master BusyBox: A Lightweight Unix Toolkit for Embedded Systems

This guide introduces BusyBox, explains its core features and advantages, shows three ways to invoke its commands, details the compilation and installation steps, addresses common pitfalls, and provides practical examples for filesystem repair and network configuration on resource‑constrained devices.

BusyBoxCompilationcommand-line tools
0 likes · 8 min read
Master BusyBox: A Lightweight Unix Toolkit for Embedded Systems
21CTO
21CTO
Nov 4, 2023 · Fundamentals

Is Python a Compiled or Interpreted Language? Uncover the Truth

This article explores whether Python is a compiled or interpreted language by examining its compilation stages, error‑message generation, differences across Python versions, and the broader distinction between static and dynamic language features, ultimately showing that Python combines both compilation and interpretation.

CompilationInterpretationPython
0 likes · 17 min read
Is Python a Compiled or Interpreted Language? Uncover the Truth
MaGe Linux Operations
MaGe Linux Operations
Oct 25, 2023 · Backend Development

Step-by-Step Guide: Compile and Install PCL on Ubuntu

This tutorial walks you through installing the required dependencies, cloning the PCL source code, creating a build directory, configuring with CMake, and compiling and installing the Point Cloud Library on Ubuntu, while noting optional configuration steps and referencing official documentation for further details.

CMakeCompilationPCL
0 likes · 3 min read
Step-by-Step Guide: Compile and Install PCL on Ubuntu
HelloTech
HelloTech
Oct 17, 2023 · Frontend Development

Running React Code in Mini Programs with Taro: Compilation vs Runtime Approaches

Unlike Taro 1/2, which compiles React code into native mini‑program files through a complex Babel‑based pipeline, Taro 3 runs the original React source at runtime by injecting a lightweight simulated DOM/BOM layer, simplifying development but adding a performance‑overhead that is mitigated with pre‑rendering and virtual lists.

CompilationDOM SimulationMini Program
0 likes · 21 min read
Running React Code in Mini Programs with Taro: Compilation vs Runtime Approaches
Tencent Cloud Developer
Tencent Cloud Developer
Oct 12, 2023 · Fundamentals

From 0 to 1: How to Design and Implement Your Own Scripting Language

The article walks readers through building a custom scripting language from scratch—explaining compilation basics, lexical scanning, parsing, bytecode generation, and virtual‑machine execution—using a sample language called eben to illustrate BNF syntax, variable scopes, control flow, functions, closures, object‑orientation, garbage collection, and the historical evolution of programming languages.

BNFBytecodeCompilation
0 likes · 46 min read
From 0 to 1: How to Design and Implement Your Own Scripting Language
JD Cloud Developers
JD Cloud Developers
Sep 5, 2023 · Backend Development

Inside Java Compilation: From Source Code to Optimized Bytecode

This article explains Java's compilation pipeline—from source parsing, symbol table construction, and annotation processing to semantic analysis and bytecode generation—and then details HotSpot's runtime JIT compilation, covering client vs server compilers, inlining, devirtualization, escape analysis, and on‑stack replacement.

BytecodeCompilationHotSpot
0 likes · 11 min read
Inside Java Compilation: From Source Code to Optimized Bytecode
21CTO
21CTO
Aug 3, 2023 · Fundamentals

What Is WebAssembly and Why It Matters for Modern Web Development

This article explains what WebAssembly is, why it is needed for high‑performance web applications, how it works internally, which languages can target it, typical use cases, and provides practical examples of loading and using WebAssembly modules in browsers and Node.js.

CompilationJavaScriptRust
0 likes · 11 min read
What Is WebAssembly and Why It Matters for Modern Web Development
Python Programming Learning Circle
Python Programming Learning Circle
Jul 29, 2023 · Fundamentals

Cython 3.0 Released: New Features and Improvements

Cython 3.0 has been officially released, offering a more Pythonic syntax, better C/C++ integration, expanded pure‑Python mode, automatic NumPy ufunc generation, Unicode identifiers, and preliminary support for Python's limited API, making it faster, safer, and easier to use.

CompilationCythonPure Python mode
0 likes · 4 min read
Cython 3.0 Released: New Features and Improvements
21CTO
21CTO
Jun 29, 2023 · Fundamentals

What Google’s Survey Reveals About Learning Rust and Its Real‑World Challenges

Google’s internal survey of over a thousand Rust developers shows that, despite concerns about ownership and borrowing, most find Rust no harder to learn than other languages, quickly become productive, appreciate its safety and performance, yet cite slow compilation as the top challenge.

CompilationDeveloper SurveyProgramming Languages
0 likes · 5 min read
What Google’s Survey Reveals About Learning Rust and Its Real‑World Challenges
MaGe Linux Operations
MaGe Linux Operations
May 31, 2023 · Fundamentals

Master Linux Kernel Essentials: Modules, Commands, and System Configuration

This article provides a comprehensive overview of the Linux kernel, explaining its core components, memory and process management, device drivers, system calls, and security, while detailing essential commands such as uname, lsmod, modinfo, modprobe, depmod, insmod, rmmod, sysctl, and guiding readers through kernel compilation and configuration using /proc and /sys.

CompilationLinuxModules
0 likes · 22 min read
Master Linux Kernel Essentials: Modules, Commands, and System Configuration
ByteDance Web Infra
ByteDance Web Infra
May 9, 2023 · Fundamentals

WebAssembly Runtime Architecture: Loading, Parsing, Execution, Memory Management and GC

This article provides a comprehensive overview of the WebAssembly runtime, detailing its binary format, module loading and validation, execution engine designs, linear memory layout, garbage‑collection proposals, and the WebAssembly System Interface (WASI), while illustrating each concept with diagrams and code examples.

CompilationGarbage CollectionMemory Management
0 likes · 34 min read
WebAssembly Runtime Architecture: Loading, Parsing, Execution, Memory Management and GC
Open Source Linux
Open Source Linux
Apr 26, 2023 · Backend Development

Mastering GCC: From Preprocessing to ELF Analysis in Linux

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.

BinutilsC programmingCompilation
0 likes · 13 min read
Mastering GCC: From Preprocessing to ELF Analysis in Linux
Liangxu Linux
Liangxu Linux
Apr 15, 2023 · Fundamentals

Why Your C++ Build Fails: Hidden Pitfalls in 64‑Bit Linux Compilation & Linking

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.

C++CompilationDynamic Loading
0 likes · 15 min read
Why Your C++ Build Fails: Hidden Pitfalls in 64‑Bit Linux Compilation & Linking
Liangxu Linux
Liangxu Linux
Apr 12, 2023 · Fundamentals

Mastering the GCC Toolchain: From Preprocessing to ELF Analysis

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.

CompilationELFGCC
0 likes · 15 min read
Mastering the GCC Toolchain: From Preprocessing to ELF Analysis
ByteDance Web Infra
ByteDance Web Infra
Apr 11, 2023 · Fundamentals

Overview of the WebAssembly Language Ecosystem and Toolchains

This article provides a comprehensive overview of WebAssembly 2.0, its cross‑platform advantages, and the most popular programming languages and toolchains—including C/C++, Rust, Go, AssemblyScript, Emscripten, Binaryen, wasi‑sdk, TinyGo, wabt, wasm‑pack and wasm‑bindgen—while discussing their strengths, limitations, and typical use cases.

CompilationProgramming LanguagesToolchains
0 likes · 24 min read
Overview of the WebAssembly Language Ecosystem and Toolchains
Programmer DD
Programmer DD
Mar 24, 2023 · Backend Development

Why Lombok @Data + @Builder Removes No‑Args Constructor and How to Fix It

This article explains why combining Lombok's @Data and @Builder annotations eliminates the default no‑argument constructor, demonstrates the compilation issues it causes, and provides two practical solutions—including using @Tolerate or separating constructors with @RequiredArgsConstructor and @NoArgsConstructor—while also detailing Lombok's compilation mechanism and a custom annotation example.

Builder PatternCompilationLombok
0 likes · 6 min read
Why Lombok @Data + @Builder Removes No‑Args Constructor and How to Fix It
AI Cyberspace
AI Cyberspace
Mar 7, 2023 · Fundamentals

Unlocking the Secrets of C Compilation: From Source to Executable

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++CompilationDynamic Linking
0 likes · 23 min read
Unlocking the Secrets of C Compilation: From Source to Executable
Java Architecture Diary
Java Architecture Diary
Jan 16, 2023 · Backend Development

How to Compile and Run Nacos Console in Standalone Mode

This guide walks you through cloning the Nacos repository, compiling it with Maven (including special handling for Mac M‑series chips), explains the role of Protocol Buffers, and shows how to configure and run the Nacos console in standalone mode.

CompilationNacosProtocol Buffers
0 likes · 2 min read
How to Compile and Run Nacos Console in Standalone Mode
Open Source Linux
Open Source Linux
Dec 19, 2022 · Operations

Step-by-Step Guide: Install Linux Kernel 6.0 on Ubuntu 22.04

Learn how to install and configure the latest Linux Kernel 6.0 on Ubuntu 22.04, covering prerequisites, system updates, downloading source, configuring modules, compiling, installing, updating GRUB, and verifying the new kernel with detailed commands and screenshots.

CompilationInstallationLinux
0 likes · 6 min read
Step-by-Step Guide: Install Linux Kernel 6.0 on Ubuntu 22.04
MoonWebTeam
MoonWebTeam
Dec 4, 2022 · Frontend Development

Why Svelte Beats Vue3 and React: Real-World Performance Gains and Core Mechanics

This article presents a comprehensive investigation of Svelte, detailing its dramatic bundle size reduction, performance improvements, compilation-based architecture, core implementation, advantages, drawbacks, and practical usage guidelines, supported by real project data, npm and GitHub statistics, and code examples to help developers confidently adopt Svelte.

CompilationFramework ComparisonFrontend
0 likes · 30 min read
Why Svelte Beats Vue3 and React: Real-World Performance Gains and Core Mechanics
Architects' Tech Alliance
Architects' Tech Alliance
Nov 21, 2022 · Fundamentals

The Eternal Quest: Abstract Models, Computing Foundations, and the Philosophy of Learning

This essay explores how abstract models serve as timeless keys to knowledge, examines the physical and logical foundations of computers—from binary states to the Von Neumann architecture, compilation, and distributed systems—and advocates universal doubt and independent thinking as essential learning strategies.

Compilationabstract modelscomputing fundamentals
0 likes · 10 min read
The Eternal Quest: Abstract Models, Computing Foundations, and the Philosophy of Learning
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Nov 9, 2022 · Fundamentals

Understanding JavaScript Variable Lookup and Scope from the ECMAScript Specification and V8 Engine Perspective

The article explains how JavaScript variable lookup and lexical scope are determined during compilation by the V8 engine, covering the language's compiled‑and‑interpreted nature, JIT optimizations, AST generation, lazy parsing, dynamic lookups, and bytecode creation to demystify runtime performance.

CompilationECMAScriptJavaScript
0 likes · 14 min read
Understanding JavaScript Variable Lookup and Scope from the ECMAScript Specification and V8 Engine Perspective
Programmer DD
Programmer DD
Oct 12, 2022 · Backend Development

Why Lombok @Data + @Builder Breaks No‑Args Constructors and How to Fix It

This article explains why combining Lombok's @Data and @Builder annotations removes the automatically generated no‑argument constructor, demonstrates the compilation process behind Lombok, and provides two practical solutions using @Tolerate or @RequiredArgsConstructor/@NoArgsConstructor to restore the missing constructor.

BuilderCompilationLombok
0 likes · 6 min read
Why Lombok @Data + @Builder Breaks No‑Args Constructors and How to Fix It
Architecture Digest
Architecture Digest
Aug 19, 2022 · Fundamentals

Learning the Eternal: Abstract Models, Computer Foundations, and Critical Thinking

The article argues that true learning should focus on enduring abstract models rather than transient knowledge, exploring computer fundamentals such as binary states, Von Neumann architecture, compilation theory, distributed systems, and advocating methodological approaches like universal doubt and independent thinking.

Compilationabstract modelscomputer fundamentals
0 likes · 12 min read
Learning the Eternal: Abstract Models, Computer Foundations, and Critical Thinking
IEG Growth Platform Technology Team
IEG Growth Platform Technology Team
Jul 25, 2022 · Frontend Development

Building FFmpeg to WebAssembly: A Practical Guide for Frontend Developers

This article explains how to compile FFmpeg and its dependencies to WebAssembly using Emscripten and Docker, covering the basics of WASM, compiler toolchains, build scripts, configuration flags, and the resulting output files, providing a practical guide for front‑end developers seeking high‑performance media processing in the browser.

CompilationDockerEmscripten
0 likes · 15 min read
Building FFmpeg to WebAssembly: A Practical Guide for Frontend Developers
Open Source Linux
Open Source Linux
Jul 13, 2022 · Fundamentals

Mastering GCC: From Source Code to ELF Executable Explained

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.

C programmingCompilationELF
0 likes · 13 min read
Mastering GCC: From Source Code to ELF Executable Explained
Liangxu Linux
Liangxu Linux
Jun 22, 2022 · Fundamentals

From Source to Executable: Mastering the GCC Toolchain and ELF Analysis

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.

CompilationELFGCC
0 likes · 14 min read
From Source to Executable: Mastering the GCC Toolchain and ELF Analysis
Cognitive Technology Team
Cognitive Technology Team
Apr 21, 2022 · Backend Development

Resolving Maven Compilation Hang After Upgrading Spring Cloud from Java 8 to Java 11 and Dealing with Lombok @Builder.Default Issues

The article explains why a Spring Cloud project upgraded from Java 8 to Java 11 gets stuck during Maven compilation, shows how to enable detailed compiler logs with Maven‑compiler‑plugin settings, presents the lengthy compilation output, and advises cautious use of Lombok’s @Builder.Default to avoid similar hangs.

CompilationJava 11Lombok
0 likes · 12 min read
Resolving Maven Compilation Hang After Upgrading Spring Cloud from Java 8 to Java 11 and Dealing with Lombok @Builder.Default Issues
ELab Team
ELab Team
Mar 31, 2022 · Frontend Development

How Babel Transforms Modern JavaScript: A Deep Dive into Frontend Compilation

This article explains the fundamentals of compilation, compares compiled and interpreted languages, outlines the full compiler pipeline, and uses Babel as a concrete example to show how JavaScript code is parsed, transformed, and generated for broader browser compatibility.

ASTBabelCompilation
0 likes · 27 min read
How Babel Transforms Modern JavaScript: A Deep Dive into Frontend Compilation
Top Architect
Top Architect
Mar 28, 2022 · Databases

Key Aspects of Distributed Storage Systems: Replication, Engines, Transactions, Analytics, Multi‑Core, Computation, and Compilation

This article provides a comprehensive overview of distributed storage, covering seven core aspects such as replication, storage engines, transaction processing, analytical query execution, multi‑core scalability, computation models, and compilation techniques, while also highlighting practical challenges and design considerations for modern database systems.

CompilationStorage EngineTransaction
0 likes · 13 min read
Key Aspects of Distributed Storage Systems: Replication, Engines, Transactions, Analytics, Multi‑Core, Computation, and Compilation
Tencent Cloud Developer
Tencent Cloud Developer
Mar 16, 2022 · Fundamentals

How V8 Executes JavaScript: From Parsing to JIT Optimization

This article explains the core concepts of compilation and interpretation, compares static and dynamic languages, and walks through the V8 engine’s workflow—including parsing, bytecode generation, JIT compilation, and TurboFan optimizations—providing concrete code examples and command‑line tips.

BytecodeCompilationJavaScript
0 likes · 8 min read
How V8 Executes JavaScript: From Parsing to JIT Optimization
Sohu Tech Products
Sohu Tech Products
Jan 26, 2022 · Frontend Development

Flutter for Web: Two Compilation Approaches and Their Internals

This article explains Flutter's layered architecture, compares two web‑support strategies (HTML + CSS + Canvas vs. CSS Paint API), and details the dart2js and dartdevc compilers, their workflows, code examples, and when to use each for development or production.

CompilationFrontenddart2js
0 likes · 10 min read
Flutter for Web: Two Compilation Approaches and Their Internals
Alipay Experience Technology
Alipay Experience Technology
Jan 12, 2022 · Frontend Development

How Umi’s Design Boosts Frontend Speed and Reliability: Insights from SEE Conf 2022

At SEE Conf 2022, Ant Group’s frontend lead Yun Qian detailed Umi’s evolution, covering its compilation-time architecture, dependency pre‑bundling, multi‑build engine, performance optimizations like MFSU, and the balance between community openness and internal constraints, offering practical lessons for modern frontend development.

Build OptimizationCompilationFrontend
0 likes · 13 min read
How Umi’s Design Boosts Frontend Speed and Reliability: Insights from SEE Conf 2022
Kuaishou Tech
Kuaishou Tech
Dec 22, 2021 · Mobile Development

Swift Performance Optimization: Compilation Speed, Memory Usage, and Runtime Improvements

This article examines various Swift performance optimization techniques—including compilation speed improvements, memory allocation strategies, struct versus class trade‑offs, enum usage, collection handling, lazy sequences, bridge reduction, and function dispatch—providing practical code examples and analysis to help developers write faster, more efficient Swift code.

CollectionsCompilationEnums
0 likes · 16 min read
Swift Performance Optimization: Compilation Speed, Memory Usage, and Runtime Improvements
Kuaishou Frontend Engineering
Kuaishou Frontend Engineering
Dec 20, 2021 · Mobile Development

Boost Swift Performance: Compilation, Memory, and Runtime Optimizations

This article explores practical Swift performance enhancements, covering compilation‑time reductions through smarter type inference, memory‑usage improvements via structs, enums, and collection strategies, and runtime speed gains by understanding function dispatch and applying final, private, and lazy sequence techniques.

CompilationMemory ManagementSwift
0 likes · 17 min read
Boost Swift Performance: Compilation, Memory, and Runtime Optimizations
Douyu Streaming
Douyu Streaming
Dec 1, 2021 · Mobile Development

How to Get, Build, and Extend WebRTC m79 Source for Windows, Android, and iOS

This guide explains how to obtain the WebRTC m79 source, compile it for Windows, Android, and iOS, walk through the basic signaling and peer‑connection workflow, and implement advanced video‑capture and audio‑volume features with custom C++ extensions, while unifying the codebase across platforms.

C++CompilationWebRTC
0 likes · 19 min read
How to Get, Build, and Extend WebRTC m79 Source for Windows, Android, and iOS
ByteDance Dali Intelligent Technology Team
ByteDance Dali Intelligent Technology Team
Oct 20, 2021 · Mobile Development

Bypassing Android dex2oat Restrictions for targetSdkVersion ≥ 29: Analysis and Implementation

This article investigates the Android dex2oat compilation restrictions introduced for targetSdkVersion ≥ 29, analyzes their impact on app performance, explores SELinux enforcement, and presents a practical solution using system commands and binder calls to trigger dex2oat compilation for both primary and secondary APKs, improving load and runtime speed.

APKAndroidCompilation
0 likes · 19 min read
Bypassing Android dex2oat Restrictions for targetSdkVersion ≥ 29: Analysis and Implementation
ELab Team
ELab Team
Oct 13, 2021 · Frontend Development

How V8 Supercharges JavaScript: Inside the Engine’s Magic

This article explores the V8 JavaScript engine’s architecture, from its historical origins and source‑code acquisition to its loading strategies, lexical analysis, parsing, compilation, and execution optimizations, illustrating how V8 achieves high performance in browsers and Node.js.

CompilationEngineJavaScript
0 likes · 23 min read
How V8 Supercharges JavaScript: Inside the Engine’s Magic