BestHub
Sign in
Tagged articles
177 articles
Page 1 of 2
IT Services Circle
IT Services Circle
May 19, 2026 · Fundamentals

Can a Single String Constant Crash the Go Compiler with OOM?

A Go compiler issue shows that an exponentially growing string constant can exhaust memory during compilation, causing an out‑of‑memory crash, and the article explains how the constant is built, why it differs from variables, historical related bugs, the core team's mitigation plans, and practical safeguards for code generators and online compilers.

Code GenerationGoOOM
0 likes · 10 min read
Can a Single String Constant Crash the Go Compiler with OOM?
Open Source Tech Hub
Open Source Tech Hub
Apr 22, 2026 · Backend Development

Swoole‑Compiler v4 Introduces a Native PHP AOT Compiler Boosting Execution Speed Up to 150×

The Swoole‑Compiler v4 adds a native Ahead‑of‑Time (AOT) compiler that transforms PHP scripts into standalone binaries, eliminating the ZendVM interpreter, achieving up to 150× speed gains in intensive calculations such as Fibonacci and π, while detailing supported syntax, limitations, C/C++ interop, real‑world Workerman testing, and future roadmap.

AoTBenchmarkPHP
0 likes · 19 min read
Swoole‑Compiler v4 Introduces a Native PHP AOT Compiler Boosting Execution Speed Up to 150×
Kuaishou Tech
Kuaishou Tech
Mar 19, 2026 · Backend Development

How Kuaishou Boosted Build Performance with AutoFDO, ThinLTO, BOLT, and Propeller

This article details Kuaishou's systematic compiler and build‑system optimizations—including AutoFDO, ThinLTO, BOLT, and a newly improved Propeller—showing how they reduced compilation time from hours to seconds, cut CPU usage by 10%, and achieved up to 15% performance gains while solving profile‑staleness and integration challenges.

AutoFDOBoltBuild System
0 likes · 25 min read
How Kuaishou Boosted Build Performance with AutoFDO, ThinLTO, BOLT, and Propeller
Open Source Tech Hub
Open Source Tech Hub
Mar 6, 2026 · Fundamentals

Compile Rust to Linux ELF with a PHP‑Based Compiler – No LLVM Needed

An open‑source PHP‑written Rust compiler can generate native x86‑64 Linux ELF binaries without LLVM, assemblers, or linkers, offering ownership, borrowing, type checking, generics, traits, closures, and more; the guide covers installation via PHP and WSL, usage commands, supported features, and current limitations.

ELFPHPProgramming Language
0 likes · 8 min read
Compile Rust to Linux ELF with a PHP‑Based Compiler – No LLVM Needed
21CTO
21CTO
Feb 15, 2026 · Fundamentals

Why TypeScript 6.0 Beta Switches to Go: Faster Builds and Lower Memory

Microsoft announced the TypeScript 6.0 beta, the last version written in JavaScript, and revealed that the compiler will be re‑implemented in Go to improve editor startup, reduce build times, and cut memory usage, with new default compiler options and tsconfig behavior changes.

BetaJavaScriptTypeScript
0 likes · 3 min read
Why TypeScript 6.0 Beta Switches to Go: Faster Builds and Lower Memory
21CTO
21CTO
Jan 13, 2026 · Backend Development

Building a C Static Analyzer with MoonBit: From Lexer to Data‑Flow Analysis

This article walks through the design and implementation of a static analysis framework for C programs using MoonBit, covering lexical and syntactic parsing, AST generation, conversion to a control‑flow‑graph IR, and data‑flow analyses such as uninitialized‑variable detection and liveness.

CILData FlowMoonBit
0 likes · 19 min read
Building a C Static Analyzer with MoonBit: From Lexer to Data‑Flow Analysis
Full-Stack Cultivation Path
Full-Stack Cultivation Path
Dec 9, 2025 · Fundamentals

Go‑Rewritten TypeScript 7 Delivers Up to 10× Speed Boost

Microsoft’s Project Corsa rewrites the TypeScript compiler in Go, achieving a ten‑fold performance increase, halving memory usage, adding native multithreaded builds, and providing a stable Native Preview that developers can adopt today, while outlining the roadmap toward instant‑build compilation.

GoNative PreviewTypeScript
0 likes · 6 min read
Go‑Rewritten TypeScript 7 Delivers Up to 10× Speed Boost
21CTO
21CTO
Dec 8, 2025 · Frontend Development

Why TypeScript 7 Promises Up to 10× Faster Compilation and a Go‑Powered Future

Microsoft announced that the upcoming TypeScript 7 (codenamed Corsa) reaches its final stage, offering near‑full compatibility, up to ten‑fold faster compilation on large codebases, a shift to a Go‑based compiler, and a new VS Code language service with shared‑memory architecture.

GoLanguage ServiceTypeScript
0 likes · 4 min read
Why TypeScript 7 Promises Up to 10× Faster Compilation and a Go‑Powered Future
21CTO
21CTO
Nov 29, 2025 · Fundamentals

Why GCC’s Switch to C++20 Matters for Every C++ Developer

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.

CC++20compiler
0 likes · 5 min read
Why GCC’s Switch to C++20 Matters for Every C++ Developer
Liangxu Linux
Liangxu Linux
Nov 24, 2025 · Fundamentals

Understanding Struct Alignment and Over‑Aligned Types in C/C++

This article explains the natural alignment requirements of C/C++ data types, how structs are padded and aligned based on member alignments, the hardware, cache and compiler reasons for alignment, and the concept of over‑aligned types with practical examples and usage guidelines.

CC++compiler
0 likes · 11 min read
Understanding Struct Alignment and Over‑Aligned Types in C/C++
Tencent Technical Engineering
Tencent Technical Engineering
Nov 17, 2025 · Backend Development

How Profile‑Guided Optimization Supercharged WeChat’s Backend Services

This article details the year‑long exploration of Profile‑Guided Optimization (PGO) for WeChat’s backend, covering its theory, compiler implementations, practical experiments with Propeller and BOLT, transparent eBPF sampling, engineering challenges, and the measurable CPU and memory savings achieved across production services.

PGObackend servicescompiler
0 likes · 48 min read
How Profile‑Guided Optimization Supercharged WeChat’s Backend Services
Code Ape Tech Column
Code Ape Tech Column
Nov 5, 2025 · Backend Development

How Jeandle Leverages LLVM to Supercharge JVM Performance

Jeandle, an open‑source JIT compiler built on LLVM, brings advanced optimization and code generation to the OpenJDK HotSpot JVM, promising dramatic performance gains, modular extensibility, and a roadmap that includes full bytecode support, custom Java optimizations, and modern garbage‑collection integration.

JITJVMLLVM
0 likes · 6 min read
How Jeandle Leverages LLVM to Supercharge JVM Performance
Java Captain
Java Captain
Oct 31, 2025 · Backend Development

How Jeandle Uses LLVM to Supercharge JVM Performance

Jeandle, the new open‑source LLVM‑based JIT compiler for the OpenJDK HotSpot JVM, brings LLVM's powerful optimizations to Java, explaining JIT fundamentals, LLVM architecture, and the project's ambitious roadmap toward full bytecode support and advanced Java‑specific performance enhancements.

JITJVMJava
0 likes · 5 min read
How Jeandle Uses LLVM to Supercharge JVM Performance
Architect's Guide
Architect's Guide
Oct 30, 2025 · Backend Development

How Jeandle Uses LLVM to Supercharge JVM Performance

Jeandle, an open‑source JVM JIT compiler from Ant Group, leverages LLVM's modular optimization and code‑generation capabilities to bring unprecedented performance to Java applications, outlining its architecture, core concepts, and ambitious roadmap for future enhancements.

JITJVMJeandle
0 likes · 6 min read
How Jeandle Uses LLVM to Supercharge JVM Performance
Architect's Guide
Architect's Guide
Sep 30, 2025 · Information Security

Are Software Backdoors Legal? Real Cases, Legal Views, and Hidden Threats

This article examines real‑world anecdotes of hidden backdoors in software, explores how Chinese law treats such vulnerabilities, and outlines the hierarchy of backdoor techniques from simple code tricks to compiler‑level implants, highlighting the security risks they pose.

Software Securitybackdoorcompiler
0 likes · 6 min read
Are Software Backdoors Legal? Real Cases, Legal Views, and Hidden Threats
21CTO
21CTO
Sep 7, 2025 · Fundamentals

Why Top Rust Contributors Are Job Hunting and What It Means for the Language

The article examines how two leading Rust compiler engineers, Nicholas Nethercote and Michael Goulet, are seeking new positions, highlights their massive contributions, discusses the funding challenges of the Rust foundation, and explores how AI and corporate priorities are reshaping the future of the language.

Fundingcompilerdeveloper contributions
0 likes · 8 min read
Why Top Rust Contributors Are Job Hunting and What It Means for the Language
IT Services Circle
IT Services Circle
Sep 4, 2025 · Fundamentals

Why Two Top Rust Compiler Contributors Are Job Hunting – A Wake‑Up Call

Two leading Rust compiler engineers announced they are looking for new positions, exposing funding gaps in the Rust Foundation, highlighting their massive contributions to the language, and sparking a broader debate about how open‑source projects can sustainably support core developers amid AI‑driven budget shifts.

FundingRustcommunity
0 likes · 7 min read
Why Two Top Rust Compiler Contributors Are Job Hunting – A Wake‑Up Call
Liangxu Linux
Liangxu Linux
Sep 3, 2025 · Fundamentals

Can main() Recursively Call Itself? Limits, Risks, and Safer Alternatives

This article examines whether the C/C++ entry‑point function main can call itself recursively, outlines the relevant language standards, shows compiler support and example code, discusses practical limitations such as stack size and portability, and recommends safer programming patterns.

CC++Recursion
0 likes · 8 min read
Can main() Recursively Call Itself? Limits, Risks, and Safer Alternatives
macrozheng
macrozheng
Aug 22, 2025 · Fundamentals

How Jeandle’s LLVM‑Powered JIT Could Supercharge Java Performance

Jeandle, the new open‑source LLVM‑based JIT compiler released by Ant Group, aims to integrate LLVM’s high‑performance optimizations into the JVM, offering faster execution, future roadmap details, and insights into JIT and LLVM fundamentals for Java developers.

JITJVMJava
0 likes · 6 min read
How Jeandle’s LLVM‑Powered JIT Could Supercharge Java Performance
Java Backend Technology
Java Backend Technology
Aug 22, 2025 · Backend Development

How Jeandle’s LLVM‑Powered JIT Could Revolutionize Java Performance

Jeandle, the new open‑source LLVM‑based JIT compiler released by Ant Group, aims to boost Java performance by integrating LLVM’s optimization capabilities into the JVM, explaining JIT and LLVM fundamentals, its architecture, and an ambitious roadmap toward full bytecode support and advanced optimizations.

JITJVMJava
0 likes · 6 min read
How Jeandle’s LLVM‑Powered JIT Could Revolutionize Java Performance
ITPUB
ITPUB
Aug 12, 2025 · Backend Development

Why Microsoft Rewrote TypeScript in Go for a 10× Speed Boost

Microsoft’s TypeScript team migrated the compiler from JavaScript to Go, achieving up to ten‑fold performance gains, halving memory usage, and enabling shared‑memory concurrency, while preserving compatibility and exploring future AI‑driven code analysis and language‑service APIs.

GoTypeScriptcompiler
0 likes · 35 min read
Why Microsoft Rewrote TypeScript in Go for a 10× Speed Boost
21CTO
21CTO
Jun 21, 2025 · Fundamentals

How to Build a Toy BASIC‑to‑Go Compiler in a Weekend

An experienced programmer shares a weekend project that builds a simplified BASIC variant, toybasic, and a three‑stage compiler written in Go—using Nex for lexical analysis, goyacc for parsing, and custom code generation—to translate BASIC programs into Go code, complete with examples and source links.

BASICParsercompiler
0 likes · 9 min read
How to Build a Toy BASIC‑to‑Go Compiler in a Weekend
IT Services Circle
IT Services Circle
Jun 16, 2025 · Frontend Development

How React MCP Server Lets AI Optimize Your Components in Real Time

React MCP Server, an experimental addition to the React repository, bridges large language models with the React compilation toolchain via the MCP protocol, offering AI‑driven compile optimization and documentation lookup, enabling automated performance tuning of components through a closed‑loop of compilation, measurement, and improvement.

AIMCPPerformance Optimization
0 likes · 7 min read
How React MCP Server Lets AI Optimize Your Components in Real Time
Deepin Linux
Deepin Linux
May 8, 2025 · Fundamentals

Comprehensive Guide to CPU Performance Optimization and Tools

This article provides an in‑depth overview of CPU performance metrics, practical optimization techniques—including algorithm selection, compiler flags, cache‑aware programming, and vectorization—along with real‑world case studies and a detailed survey of Linux profiling and analysis tools for developers.

CPUPerformance Optimizationcompiler
0 likes · 31 min read
Comprehensive Guide to CPU Performance Optimization and Tools
Code Mala Tang
Code Mala Tang
Mar 20, 2025 · Backend Development

Microsoft Rewrites TypeScript Compiler in Go: Why and What It Means

Microsoft announced that it will rewrite the TypeScript compiler in Go, citing native code compilation, automatic memory management, simplicity, portability, and strong concurrency support, promising up to ten‑fold performance gains, faster editor feedback, new features, and a roadmap extending to a Go‑based TypeScript 7 release.

GoTypeScriptcompiler
0 likes · 9 min read
Microsoft Rewrites TypeScript Compiler in Go: Why and What It Means
Java Tech Enthusiast
Java Tech Enthusiast
Mar 19, 2025 · Industry Insights

Why Microsoft Switched to Go for the TypeScript Compiler – 10× Faster

Microsoft rewrote the TypeScript compiler in Go, achieving a nine‑to‑tenfold speed boost, and explains that Go’s low‑level design, built‑in garbage collection, cross‑platform compilation, and functional‑style compatibility made it a better fit than C#, reflecting both technical advantages and Microsoft’s internal “Eat Dog Food” culture.

CGoMicrosoft
0 likes · 5 min read
Why Microsoft Switched to Go for the TypeScript Compiler – 10× Faster
21CTO
21CTO
Mar 13, 2025 · Backend Development

Why Microsoft Chose Go Over Rust for the TypeScript Compiler Rewrite

Microsoft announced a port of the TypeScript compiler to Go, promising over tenfold speed gains, and explained that portability and automatic garbage collection made Go a more practical choice than Rust despite community disappointment.

GoRustTypeScript
0 likes · 7 min read
Why Microsoft Chose Go Over Rust for the TypeScript Compiler Rewrite
21CTO
21CTO
Mar 12, 2025 · Fundamentals

Why Microsoft Is Rebuilding TypeScript in Go for 10× Faster Compilation

Microsoft announced a native Go implementation of the TypeScript compiler that dramatically cuts build times and memory usage, promising a ten‑fold speed boost for large projects and laying the groundwork for next‑generation AI‑assisted development tools.

GoMicrosoftTypeScript
0 likes · 6 min read
Why Microsoft Is Rebuilding TypeScript in Go for 10× Faster Compilation
Taobao Frontend Technology
Taobao Frontend Technology
Mar 12, 2025 · Frontend Development

How Native TypeScript Can Boost Your Build Speed by 10×

Anders Hejlsberg announces a native implementation of the TypeScript compiler that dramatically reduces build and editor startup times, offers up to ten‑fold speed gains across large codebases, and outlines the roadmap toward TypeScript 7 with enhanced AI‑driven tooling.

Editor Speedcompilernative compilation
0 likes · 9 min read
How Native TypeScript Can Boost Your Build Speed by 10×
Sohu Tech Products
Sohu Tech Products
Jan 22, 2025 · Mobile Development

A Comprehensive Guide to Swift Macros and SwiftSyntax Implementation

This guide explains Swift 5.9 macros—both attached and freestanding—detailing how the compiler expands them using SwiftSyntax’s AST manipulation, walks through creating and declaring macros, and demonstrates a PeerMacro that automatically generates async counterparts for completion‑handler functions, reducing boilerplate and improving code clarity.

Code GenerationMacro ExpansionSwift 5.9
0 likes · 29 min read
A Comprehensive Guide to Swift Macros and SwiftSyntax Implementation
php Courses
php Courses
Jan 15, 2025 · Backend Development

Understanding and Building a PHP Interpreter with C

This course introduces the background and features of PHP, explains the inner workings of the PHP interpreter—including lexical analysis, parsing, and the virtual machine—and guides students through implementing these components in C to create a simple interpreter while enhancing their programming and problem‑solving skills.

Backend DevelopmentC languagePHP
0 likes · 3 min read
Understanding and Building a PHP Interpreter with C
JD Tech Talk
JD Tech Talk
Jan 3, 2025 · Fundamentals

Understanding Compiler Front‑End: Lexical, Syntax, and Semantic Analysis with Antlr

This article introduces the fundamentals of compiler front‑end development, covering lexical analysis with finite automata, syntax analysis using context‑free grammars and parsing strategies, and semantic analysis concepts, while providing practical Antlr examples for Java code tokenization, parsing, and semantic checks.

ANTLRSyntax Analysiscompiler
0 likes · 11 min read
Understanding Compiler Front‑End: Lexical, Syntax, and Semantic Analysis with Antlr
21CTO
21CTO
Dec 12, 2024 · Information Security

How Google Added Low‑Cost Memory‑Safety Checks to C++ Production Code

Google's research shows that adding boundary checks to its C++ codebase can automatically fix thousands of CVE‑related memory bugs, cut production crash rates by 30%, and improve performance with only a 0.3% overhead, sparking a broad community discussion on safe legacy code.

C++LLVMMemory Safety
0 likes · 9 min read
How Google Added Low‑Cost Memory‑Safety Checks to C++ Production Code
Architecture Development Notes
Architecture Development Notes
Dec 4, 2024 · Fundamentals

Why Rust Beats TypeScript for Low‑Level Performance: A Developer’s Journey

The author, a seasoned TypeScript developer, explains why they chose Rust over C/C++, outlines effective learning resources, and compares Rust’s compiler, type system, and memory management to JavaScript/TypeScript, highlighting the language’s performance, safety, and practical benefits for low‑level development.

Memory SafetyRustSystems Programming
0 likes · 8 min read
Why Rust Beats TypeScript for Low‑Level Performance: A Developer’s Journey
php Courses
php Courses
Nov 27, 2024 · Backend Development

PHP Interpreter Internals: Theory and Hands‑On Implementation in C

This course introduces the background and characteristics of PHP, explains the role and operation of the PHP interpreter, and guides students through building a simple interpreter in C by covering lexical analysis, parsing, virtual machine design, and hands‑on debugging with GDB.

C programmingPHPProgramming Language
0 likes · 3 min read
PHP Interpreter Internals: Theory and Hands‑On Implementation in C
Java Tech Enthusiast
Java Tech Enthusiast
Sep 15, 2024 · Fundamentals

How Source Code Is Transformed into Machine Instructions

A compiler transforms source code into executable machine instructions by first tokenizing the text into keywords, identifiers and literals, then parsing these tokens into an abstract syntax tree, generating and optimizing intermediate code, and finally assembling and linking the output for the target architecture or LLVM IR.

ASTLLVMMachine Code
0 likes · 4 min read
How Source Code Is Transformed into Machine Instructions
Liangxu Linux
Liangxu Linux
Sep 15, 2024 · Backend Development

Top Free C/C++ Compilers: GCC, Clang/LLVM, TCC, MSVC, and Digital Mars

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++ClangMSVC
0 likes · 12 min read
Top Free C/C++ Compilers: GCC, Clang/LLVM, TCC, MSVC, and Digital Mars
Tencent Cloud Developer
Tencent Cloud Developer
Aug 28, 2024 · Fundamentals

Uncovering the 50,000‑Line TypeScript checker.ts: Design Choices and Performance Impacts

This article dissects the massive 5‑万‑line checker.ts file in the TypeScript compiler, explaining why the team packed the entire type‑system logic into a single file, how low‑level decisions like named‑parameter comments, heavy use of const enum, ESM/CJS export patterns, var usage, and lack of try‑catch affect V8 performance, and what these choices reveal about TypeScript’s evolution.

ESMTypeScriptchecker.ts
0 likes · 13 min read
Uncovering the 50,000‑Line TypeScript checker.ts: Design Choices and Performance Impacts
Alibaba Cloud Big Data AI Platform
Alibaba Cloud Big Data AI Platform
Aug 22, 2024 · Artificial Intelligence

How RECom Accelerates Recommendation Model Inference on GPUs

The RECom compiler introduces a subgraph‑parallel fusion technique and symbolic shape handling to dramatically speed up GPU inference of deep recommendation models with massive embedding columns, achieving up to 6.61× lower latency and 1.91× higher throughput than TensorFlow baselines, while eliminating redundant computations.

GPU OptimizationRecommendation Systemscompiler
0 likes · 10 min read
How RECom Accelerates Recommendation Model Inference on GPUs
Code Mala Tang
Code Mala Tang
Jul 30, 2024 · Frontend Development

What’s New in TypeScript 5.6 Beta? Explore the Latest Compiler Features

Microsoft released TypeScript 5.6 Beta on July 26 2024, introducing stricter null‑and‑truthiness checks, iterator helper methods, built‑in iterator types, arbitrary module identifiers, new compiler flags like --noUncheckedSideEffectImports and --noCheck, region‑priority diagnostics, improved project ownership detection, and several notable behavior changes across the language and tooling.

BetaIteratorsTypeScript
0 likes · 23 min read
What’s New in TypeScript 5.6 Beta? Explore the Latest Compiler Features
Java Tech Enthusiast
Java Tech Enthusiast
Jul 26, 2024 · Fundamentals

From Binary to High-Level Languages: The Origin of Compilers and Recursion

From raw binary on punched tape to mnemonic assembly and then to high‑level constructs like if, while, and functions, programmers created recursive grammars that compile source code into abstract syntax trees, which a compiler translates back into machine instructions, illustrating how recursion underpins both programming language design and computation.

CPUProgramming LanguageRecursion
0 likes · 11 min read
From Binary to High-Level Languages: The Origin of Compilers and Recursion
21CTO
21CTO
Apr 17, 2024 · Fundamentals

Build Your Own DSL in Six Steps with Langium

This guide walks you through creating a domain‑specific language using Langium, covering lexical analysis, parsing, linking, semantic validation, developer experience enhancements, and deployment options, all illustrated with concrete ZModel examples and code snippets.

DSLLangiumTypeScript
0 likes · 11 min read
Build Your Own DSL in Six Steps with Langium
ByteFE
ByteFE
Apr 16, 2024 · Frontend Development

Deep Dive into Webpack: Core Compilation Process, Plugins, Loaders, and Asset Emission

This article provides a comprehensive walkthrough of Webpack’s internal architecture, detailing the core JavaScript bundling workflow, the roles of Compiler and Compilation objects, the lifecycle of plugins and loaders, the parsing of modules into an AST, chunk creation, and the final emission of assets to the output directory.

Asset emissionChunk graphJavaScript bundling
0 likes · 27 min read
Deep Dive into Webpack: Core Compilation Process, Plugins, Loaders, and Asset Emission
21CTO
21CTO
Apr 15, 2024 · Artificial Intelligence

Why Mojo’s Open‑Source Release Could Redefine AI Programming

Modular Inc. announced the open‑source release of Mojo’s core standard library, highlighting its Python‑like syntax, MLIR‑based compiler, SIMD‑first design, eager destruction, and performance claims of being tens of thousands of times faster than Python, positioning it as a potential future‑dominant AI language.

AI programmingMLIRMojo
0 likes · 14 min read
Why Mojo’s Open‑Source Release Could Redefine AI Programming
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Mar 16, 2024 · Frontend Development

Rax2Taro: Building a Compiler to Convert Rax Components into Taro

This article walks through the design and implementation of a compiler that automatically transforms Rax components into Taro components, covering the background, Babel‑based AST processing, import rewriting, component attribute mapping, project structure, automated end‑to‑end testing, and future enhancements.

ASTComponent ConversionRax
0 likes · 15 min read
Rax2Taro: Building a Compiler to Convert Rax Components into Taro
php Courses
php Courses
Mar 7, 2024 · Backend Development

Understanding and Implementing a PHP Interpreter in C

This course introduces the background and features of PHP, explains the role and operation of the PHP interpreter, and guides learners through building core components such as lexical analysis, parsing, and a virtual machine in C, enabling hands‑on creation of a simple interpreter.

Backend DevelopmentC languagePHP
0 likes · 3 min read
Understanding and Implementing a PHP Interpreter in C
php Courses
php Courses
Feb 19, 2024 · Backend Development

Course Overview: Understanding and Implementing a PHP Interpreter in C

This course introduces the background and features of PHP, explains the role and inner workings of the PHP interpreter—including lexical analysis, parsing, and the virtual machine—and guides students to implement a simple interpreter using C, enhancing their programming and problem‑solving skills.

Backend DevelopmentC programmingPHP
0 likes · 4 min read
Course Overview: Understanding and Implementing a PHP Interpreter in C
Tencent Cloud Developer
Tencent Cloud Developer
Dec 12, 2023 · Fundamentals

Understanding Go Function Pointers and Their Performance Impact

The article explains how Go’s function values introduce an extra indirection and trigger escape analysis, making indirect calls slower than C pointers, and offers optimization tactics such as avoiding function‑pointer calls, using switch‑based dispatch, or applying the unsafe noescape trick when safe.

Escape AnalysisGocompiler
0 likes · 15 min read
Understanding Go Function Pointers and Their Performance Impact
21CTO
21CTO
Dec 3, 2023 · Fundamentals

Why MoonBit’s Small WASM Binaries and Fast Performance Matter

MoonBit is a new open‑source programming language from China that delivers tiny WebAssembly binaries, high runtime speed, advanced compile‑time performance, and a modern toolchain, while sparking community debate over adding Chinese keywords to its syntax.

Chinese keywordsMoonBitProgramming Language
0 likes · 8 min read
Why MoonBit’s Small WASM Binaries and Fast Performance Matter
21CTO
21CTO
Oct 5, 2023 · Artificial Intelligence

Why AI Needs a New Unified Engine: Inside Modular’s Vision and the Mojo Language

In a candid interview, Chris Lattner and Tim Davis explain how Modular aims to solve AI infrastructure fragmentation by building a unified, hardware‑agnostic engine, the challenges of compiler design, and the creation of Mojo—a Python superset designed for high‑performance, scalable AI development.

AIMojoProgramming Language
0 likes · 31 min read
Why AI Needs a New Unified Engine: Inside Modular’s Vision and the Mojo Language
Baidu Geek Talk
Baidu Geek Talk
Sep 25, 2023 · Frontend Development

How Baidu’s New Mini‑Program Compiler Boosted Build Speed by Up to 7×

Baidu’s mini‑program compiler was completely rebuilt with a self‑designed architecture, multi‑threading, full‑process caching and sourcemap optimizations, delivering 2‑7× faster builds, lower memory usage and smaller output while keeping compatibility with the old system.

Mini ProgramPerformance Optimizationbuild tools
0 likes · 19 min read
How Baidu’s New Mini‑Program Compiler Boosted Build Speed by Up to 7×
IT Services Circle
IT Services Circle
Aug 30, 2023 · Cloud Computing

MoonBit: A Cloud‑Native WebAssembly Programming Language for Cloud and Edge Computing

MoonBit, a new WebAssembly‑based programming language created by a Chinese development team, targets cloud and edge computing with an integrated toolchain that includes a compiler, build system, IDE and deployment tools, offering smaller binaries, higher runtime performance, and advanced compile‑time optimizations, as demonstrated by benchmarked Fibonacci implementations in MoonBit, Go, and Rust.

BenchmarkMoonBitProgramming Language
0 likes · 4 min read
MoonBit: A Cloud‑Native WebAssembly Programming Language for Cloud and Edge Computing
21CTO
21CTO
Aug 23, 2023 · Backend Development

Why LLVM Is the Secret Engine Powering Modern Languages

This article explains what LLVM is, how it differs from GCC, its design for portability, its role in language development, JIT compilation, automatic optimizations, domain‑specific language support, and what it does not handle, providing a comprehensive overview for developers.

IRJITLLVM
0 likes · 13 min read
Why LLVM Is the Secret Engine Powering Modern Languages
ByteFE
ByteFE
Jul 19, 2023 · Frontend Development

Optimizing Web Front‑End Performance with WebAssembly: Design and Implementation of ByteReact

This article explores how WebAssembly can break the speed limits of JavaScript by compiling both framework and business logic into WebAssembly, describes the design of the ByteReact front‑end framework, its custom Bytets compiler that turns TypeScript into WebAssembly, and presents performance measurements showing up to three‑fold speed gains for compute‑heavy UI tasks.

ReactTypeScriptWebAssembly
0 likes · 20 min read
Optimizing Web Front‑End Performance with WebAssembly: Design and Implementation of ByteReact
Programmer DD
Programmer DD
Jun 13, 2023 · Backend Development

Why Tencent’s OpenKona JDK Could Transform Java Development in China

Tencent has donated its high‑performance OpenKona JDK to the Open Source China foundation, offering the full source code, build infrastructure and national‑cryptography support, and already powers over a million servers across more than 120 companies, promising a domestic alternative for Java development in big‑data, AI and cloud scenarios.

Backend DevelopmentJavaOpenJDK
0 likes · 4 min read
Why Tencent’s OpenKona JDK Could Transform Java Development in China
NetEase Cloud Music Tech Team
NetEase Cloud Music Tech Team
Jun 5, 2023 · Fundamentals

Understanding Swift SIL and Method Dispatch Mechanisms

Swift inserts the high‑level SIL intermediate representation between source code and LLVM, exposing type declarations, method blocks, and virtual tables, while supporting three dispatch strategies—direct for value types and final methods, VTable for regular class methods, and Objective‑C message dispatch for @objc dynamic methods—crucial for debugging mixed Swift/Objective‑C and protocol‑extension behavior.

LLVMMethod DispatchSIL
0 likes · 20 min read
Understanding Swift SIL and Method Dispatch Mechanisms
IT Services Circle
IT Services Circle
May 8, 2023 · Artificial Intelligence

Mojo: A New High‑Performance Programming Language Bridging Python Ease and C‑Level Speed for AI

Mojo, the new programming language announced by Chris Lattner’s Modular AI, combines Python’s usability with C‑level performance, offering seamless interoperability, extensive compiler optimizations, and scalability for AI workloads, positioning itself as a potential breakthrough in machine‑learning infrastructure and development.

AIMojoProgramming Language
0 likes · 8 min read
Mojo: A New High‑Performance Programming Language Bridging Python Ease and C‑Level Speed for AI
21CTO
21CTO
May 7, 2023 · Artificial Intelligence

Can Mojo Make Python 35,000× Faster? Inside the New AI‑Focused Language

Modular's new Mojo language blends Python's ease of use with C‑level performance, leveraging MLIR and hardware acceleration to claim up to 35,000‑fold speed gains, while offering system‑programming features, zero‑cost abstractions, and a path toward a Python superset for AI development.

AIMojoPython
0 likes · 6 min read
Can Mojo Make Python 35,000× Faster? Inside the New AI‑Focused Language
Python Programming Learning Circle
Python Programming Learning Circle
Mar 31, 2023 · Information Security

Backdoors in Software: Real-World Cases, Legal Perspectives, and Security Implications

The article recounts real-world examples of hidden backdoors in software—from an Android ROM project and Ken Thompson’s compiler-level exploit—to discuss their legal ambiguity in China, highlight the challenges of detection, and conclude with a call for developers to share their own experiences, alongside a promotional Python course.

AndroidSoftware Securitybackdoor
0 likes · 6 min read
Backdoors in Software: Real-World Cases, Legal Perspectives, and Security Implications
21CTO
21CTO
Mar 5, 2023 · Backend Development

Why We Rewrote KCL in Rust: 66% Faster Execution and 20× Faster Parsing

This article details the motivations, challenges, and outcomes of rewriting the KCL compiler from Python to Rust, highlighting significant performance gains, reduced bugs, memory savings, and the learning curve associated with adopting Rust for a large‑scale systems project.

KCLRustSystems Programming
0 likes · 10 min read
Why We Rewrote KCL in Rust: 66% Faster Execution and 20× Faster Parsing
Alibaba Cloud Big Data AI Platform
Alibaba Cloud Big Data AI Platform
Dec 9, 2022 · Artificial Intelligence

What’s New in BladeDISC 0.3.0? Boosting PyTorch 2.0, GPU/CPU Optimizations, and Quantization

BladeDISC 0.3.0 introduces full PyTorch 2.0 compilation support, new TorchDynamo optimizations, extensive GPU memory‑intensive compute enhancements, Shape Constraint IR, experimental quantization across multiple hardware platforms, and a suite of compiler‑level improvements for training and inference acceleration.

BladeDISCGPU OptimizationMLIR
0 likes · 11 min read
What’s New in BladeDISC 0.3.0? Boosting PyTorch 2.0, GPU/CPU Optimizations, and Quantization
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Nov 25, 2022 · Frontend Development

Vue Compiler Overview and Sandbox Compilation Techniques

This article explores the fundamentals of Vue's compilation process, compares Vue 2 and Vue 3 compilers, demonstrates sandbox compilation with code examples, and discusses practical considerations such as handling templates, scripts, styles, and hot‑module reloading, providing developers with insights to effectively integrate Vue compilation in browser environments.

JavaScriptVuecompiler
0 likes · 17 min read
Vue Compiler Overview and Sandbox Compilation Techniques
ELab Team
ELab Team
Nov 12, 2022 · Frontend Development

Build Your Own Mini Webpack: A Step‑by‑Step Guide to Single‑Entry Bundling

This article walks through creating a minimal webpack implementation that bundles a single entry file, covering prerequisite knowledge, initialization parameters, compilation steps, loader handling, dependency resolution, chunk creation, and file generation, complete with code examples and explanations.

Build ToolBundlerJavaScript
0 likes · 12 min read
Build Your Own Mini Webpack: A Step‑by‑Step Guide to Single‑Entry Bundling
vivo Internet Technology
vivo Internet Technology
Oct 26, 2022 · Frontend Development

Migrating WePY Mini‑Program to UniApp: Compiler Design and Implementation

The Vivo front‑end team built a custom compiler that automatically transforms WePY mini‑program files—including templates, scripts, components, and pages—into UniApp Vue code, cutting the estimated 25‑person‑day migration to seconds, delivering a bug‑free launch and paving the way for open‑sourcing the tool.

JavaScriptUniappbabel
0 likes · 32 min read
Migrating WePY Mini‑Program to UniApp: Compiler Design and Implementation
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Oct 24, 2022 · Mobile Development

Understanding Compose Compiler Checkers: ComposableCallChecker, ComposableDeclarationChecker, and ComposeDiagnosticSuppressor

This article explains how the Compose compiler’s front‑end checkers—ComposableCallChecker, ComposableDeclarationChecker, and ComposeDiagnosticSuppressor—validate @Composable usage, handle inline lambdas, annotation retention, and named‑argument restrictions, providing code examples and visual diagrams to illustrate each rule.

AndroidCheckerComposable
0 likes · 13 min read
Understanding Compose Compiler Checkers: ComposableCallChecker, ComposableDeclarationChecker, and ComposeDiagnosticSuppressor
政采云技术
政采云技术
Sep 21, 2022 · Backend Development

Understanding Java Annotation Processing (APT) and Implementing a Custom Lombok‑like Processor

This article explains the principles behind Java annotation processing tools such as APT, compares APT with AOP and Java agents, and provides a step‑by‑step guide to creating a custom Lombok‑style annotation processor that generates getters, setters, and toString methods at compile time.

APTAnnotationProcessingBytecodeGeneration
0 likes · 17 min read
Understanding Java Annotation Processing (APT) and Implementing a Custom Lombok‑like Processor
21CTO
21CTO
Sep 20, 2022 · Fundamentals

What Are the Top 10 Challenges Facing Rust Today and Tomorrow?

Microsoft engineer Nick Cameron outlines the ten biggest governance, ecosystem, and technical challenges Rust must overcome in the coming years, offering insight into community dynamics, crate management, async support, language usability, memory safety, compiler complexity, and macro design.

EcosystemMemory SafetyProgramming Language
0 likes · 11 min read
What Are the Top 10 Challenges Facing Rust Today and Tomorrow?
ByteFE
ByteFE
Sep 19, 2022 · Frontend Development

Comprehensive Guide to Babel: History, Configuration, Plugins, Presets, Runtime and Webpack Integration

This article provides an in‑depth overview of Babel, covering its origins, core purpose as a JavaScript compiler, configuration file options, plugin and preset usage, runtime optimization, integration with webpack, and the underlying parsing‑transform‑generation pipeline illustrated with a simple compiler example.

JavaScriptPluginsbabel
0 likes · 30 min read
Comprehensive Guide to Babel: History, Configuration, Plugins, Presets, Runtime and Webpack Integration
JD Tech
JD Tech
Aug 30, 2022 · Fundamentals

Deep Dive into Java Compiler AST Instrumentation for Monitoring

This article explores how to eliminate repetitive monitoring code in Java services by building a compile‑time instrumentation component that leverages JSR‑269 annotation processing and AST manipulation, detailing the component design, technical selection, compiler internals, implementation steps, and lessons learned.

ASTAnnotationProcessingInstrumentation
0 likes · 17 min read
Deep Dive into Java Compiler AST Instrumentation for Monitoring