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.
This article provides a detailed overview of Babel, covering its definition, history, installation, configuration, core compilation phases, plugin and preset mechanisms, polyfill handling, and a step‑by‑step example of creating a custom try‑catch plugin for JavaScript code transformation.
This article dissects Go’s select statement, explaining its I/O multiplexing purpose, compile‑time transformation via walkSelect and walkSelectCases, and the multi‑stage runtime algorithm in runtime.selectgo that handles various case patterns, lock ordering, polling randomness, and channel blocking behavior.
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.
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.
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.
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.
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.
This article explains the architecture and evolution of the Kotlin compiler, detailing the roles of the frontend and backend, the transition from K1’s PSI and BindingContext to K2’s FIR and IR, and how Kotlin Compiler Plugins like Compose and No‑arg are implemented.
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.
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.
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.
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.
This article shares three intriguing Zhihu answers that illustrate how developers embed hidden backdoors in software—from contract‑related ROM hacks to compiler‑level exploits—while discussing Chinese legal interpretations and the varying technical sophistication of such vulnerabilities.
This article walks through the core concepts and implementation steps of a minimal JavaScript compiler, covering tokenization, parsing into an AST, traversing with a visitor, transforming the tree, and generating target code, while also explaining the visitor pattern and polyfills.
The article walks readers through designing and implementing TinyLanguage—a minimal interpreted language with 4‑byte integers, constants, if/else, for loops, and print—by using Flex for lexical analysis, Bison for parsing into an AST, and an execution engine, even showing a Fibonacci example and future LLVM compilation possibilities.
This article explores how to reduce Go's heavy runtime by replacing its entry point, demonstrates building a minimal Go runtime, implements a simple Python JIT compiler in Go, and shows how to create a self‑hosted Go compiler using LLVM IR, complete with code examples and optimizations.
The article demonstrates three advanced Go techniques—eliminating the standard runtime by custom entry points, building a simple Python JIT compiler that translates bytecode to optimized machine code, and bootstrapping the Go compiler itself via AST‑to‑LLVM translation—offering practical code examples that reveal compiler internals.
This article walks through creating a minimal JavaScript compiler—starting from tokenizing Lisp‑style input, building an abstract syntax tree, traversing and transforming it, and finally generating equivalent C‑style code, illustrating the core parse‑transform‑generate workflow used by tools like Babel.
Hare is a newly announced system programming language by Drew DeVault that combines a static type system, manual memory management, and a minimal runtime to target operating systems, system tools, compilers, and other high‑performance low‑level tasks, with C‑like syntax but greater simplicity.
The article recounts how the author migrated Taobao’s 20k‑line store‑decoration frontend from JavaScript to TypeScript, detailing development‑side best‑practices, engineering standards such as ESLint/TSConfig rules and project references, compiler performance tricks, source‑level AST checks, and supporting tools, while comparing alternatives and advising incremental, well‑scoped refactoring.
This article introduces hyengine, a lightweight, high‑performance engine designed to run multiple scripting languages such as JavaScript, WebAssembly, and Python on mobile devices, detailing its architecture, JIT compilation, optimizer passes, memory allocator, garbage collector, and performance benchmarks compared to LLVM and other runtimes.
Go 1.18 introduces generics, built‑in fuzzing, compiler enhancements, new ports, and up to 20% performance gains across several architectures, while also outlining experimental packages and known generic limitations for developers to consider.
This article explains what an Abstract Syntax Tree (AST) is, how the ESTree specification standardizes JavaScript syntax, and how Babel parses, traverses, and transforms code using AST nodes, providing practical examples, core packages, plugin creation, and real‑world application scenarios for developers.
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.
This article explains the inner workings of the TypeScript compiler, detailing each stage—from scanning source code into tokens, parsing tokens into an AST, binding symbols, performing type checking, to emitting JavaScript and declaration files—while providing code examples and diagrams of the process.
The article explains the syntax and semantics of while(1) and for(;;) infinite loops in C, compares their generated assembly code, and demonstrates through compiled examples that both constructs produce essentially identical machine code despite minor semantic differences.
This article explains the syntax, execution flow, and practical differences between the C constructs while(1) and for(;;), demonstrating through compiled assembly that both produce identical code for an empty infinite loop under typical compiler settings.
This article reviews the evolution of programmable switching ASICs, outlines three major challenges—chip‑specific language diversity, distributed data‑plane programming, and resource optimization—and presents Alibaba Cloud’s self‑developed compiler as a high‑level solution that boosts development efficiency by up to 78% while cutting chip resource usage by up to 84%.
This guide introduces Zephir, outlines its key features and required dependencies, and provides step‑by‑step commands to install the Zephir parser, the php‑zephir‑parser extension, and Zephir itself on a Linux/Ubuntu system, finishing with PATH configuration.
This article introduces Svelte, explains its compile‑time approach versus runtime frameworks, compares code size and performance with React and Vue, details its reactivity model, compiler and runtime internals, explores the surrounding ecosystem, and shows how to build web components and assess its suitability for projects.
This article explains why Chinese characters become garbled on Windows when using Qt or Cocos2d‑x, explores ASCII, GBK, Unicode, UTF‑8 and ANSI encodings, shows how Visual Studio misdetects UTF‑8 files, and provides step‑by‑step solutions to eliminate the issue permanently.
This article explains what Objective‑C blocks are, why they are useful, how to declare and use them in various contexts, and dives into the compiler‑generated data structures, copy/dispose mechanisms, __block semantics, memory‑management pitfalls, and reference‑cycle avoidance.
Version 2.098.0 of the D programming language has been released, featuring DMD 2.098.0 and LDC 1.28.0 compilers, OpenBSD support, 17 major compiler changes, runtime improvements, library updates, and Dub enhancements, along with 160 issue fixes.
This article walks through the complete process of designing a simple domain‑specific expression language, defining its grammar, generating a lexer and parser with ANTLR, implementing an AST visitor in Java, and integrating the engine into a Java project.
This article explains Babel's role as a JavaScript compiler, details its three‑step architecture (parse, transform, generate), introduces plugin creation using the visitor pattern with practical code examples, and demonstrates how to debug and configure Babel plugins in a front‑end development workflow.
A recent Go repository commit sets the compiler's -G flag default to 3, activating the new types2 type‑checker and built‑in generics support while still allowing the old checker via -G=0, marking a significant shift in Go's language capabilities.
This article explains why a CPU with only a few small registers can still operate on massive in‑memory data structures by loading one element at a time using load/store instructions and how compilers strategically allocate registers to minimize memory traffic.
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.
QuanTaichi introduces a new language abstraction and compiler system that quantizes simulation data, dramatically reducing memory and bandwidth usage so that high‑precision physical effects—once requiring multiple GPUs—can now run on a single GPU, even on mobile devices.
This article presents a comprehensive guide to designing external domain‑specific languages, covering presentation modes, terminology extraction, relationship and syntax design, data‑structure definition, parser implementation with generator tools, testing strategies, and evolution techniques, illustrated with real‑world examples and code snippets.
This article explains the internal compilation mechanism of webpack 5.11.0, covering Tapable’s event system, the Compiler and Compilation lifecycle, module creation, parsing, resolving, rule compilation, generators, and tree‑shaking, with practical code examples illustrating how plugins and hooks operate.
Google’s new Sparkplug compiler for the V8 engine, introduced in Chrome 91, claims to cut CPU usage by the equivalent of 17 years per day and deliver a 23% speed boost, promising faster web experiences for all Chromium‑based browsers.
This article explains why concatenating a null String with another string in Java produces the unexpected "nullhello world" output, debunks common misconceptions, and details the compiler's StringBuilder optimization, bytecode behavior, and related null‑handling mechanisms.
This article showcases remarkable historical source code—from the Apollo 11 guidance computer and Quake III Arena's graphics tricks to the massive GNU compiler, Chromium's modular architecture, and the compact Gitk GUI—highlighting how developers achieved extraordinary efficiency and innovation with limited resources.
The article traces the evolution from primitive CPU operations expressed as binary switches, through the birth of assembly language and low‑level patterns, to the abstraction of recursion, syntax trees, and compilers that translate human‑readable code into machine instructions.
Version 2.096.0 of the DMD compiler has been officially released, introducing 17 major changes across the compiler, runtime, standard library, and Dub integration, fixing 81 bugs, adding new types and compiler switches, updating JSON output, and deprecating several features.
The article showcases a curated collection of remarkable source code—from the Apollo 11 guidance computer and Quake III Arena's fast inverse‑square‑root routine to the massive GNU compiler, Chromium browser engine, and the single‑file Gitk GUI—illustrating how developers historically pushed hardware limits and organized complex projects.
This article introduces Python as a beginner‑friendly, multi‑purpose language and presents eleven notable Python compilers and interpreters—including Brython, Pyjs, WinPython, Skulpt, Shed Skin, ActivePython, Transcrypt, Nutika, Jython, CPython, and IronPython—highlighting their main features, platforms, and typical use cases.
This article introduces Python as a beginner‑friendly, multi‑purpose language, explains its compilation process, and presents eleven powerful Python compilers and interpreters—including Brython, Pyjs, WinPython, Skulpt, Shed Skin, ActivePython, Transcrypt, Nutika, Jython, CPython, and IronPython—highlighting their key features and where to download them.
This article presents a comprehensive guide on migrating business code from x86 to TaiShan aarch64 servers, covering language differences, compilation toolchains, architecture‑specific issues such as compiler options, assembly rewrites, memory ordering, floating‑point behavior, and recommended GCC optimizations.
This article chronicles the origins and development of the C programming language, profiles its creators, examines its ancestors BCPL and B, explores early compiler construction, compares language features, showcases classic code examples, and highlights the enduring relevance of C in modern systems and libraries.
This article explains the concept of syntactic sugar in Java, detailing how features such as generics, auto‑boxing/unboxing, enums, inner classes, var‑args, enhanced for loops, switch with strings, conditional compilation, assertions, try‑with‑resources, and string concatenation are implemented by the compiler and why they improve code readability and safety.
The article explains the concept of syntactic sugar in programming, its benefits for readability and efficiency, describes how Java implements and desugars such features—including the switch‑on‑String transformation—and illustrates the process with code examples and decompiled output.
The article introduces the Thanos framework, a Vue‑based compile‑time solution that enables cross‑platform development for nine mini‑program and web targets by unifying components, APIs, and runtime behaviors, and details its architecture, scaffold tools, compiler mechanics, and runtime optimizations.
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.
This article presents a detailed comparison between Swift and Objective‑C, covering language popularity, community activity, real‑world app adoption, performance benchmarks, Swift's advantages and disadvantages, ABI and module stability, Apple’s strategic support, binary size effects, and deep compiler optimizations such as SIL, inlining, generic specialization, and dispatch mechanisms.
This article introduces Python as a beginner‑friendly, portable language and presents eleven of the best Python compilers and interpreters—detailing their features, platforms, and typical use cases—to help developers choose the right tool for web, data science, or cross‑language projects.
The article explains how to instrument code for coverage using LLVM’s modular compiler infrastructure—adding compile‑time probes that generate .gcno files, runtime counters that produce .gcda files, and then parsing these with GCOV, while detailing LLVM IR, basic blocks, flow graphs, and extensions for custom plugins.
The article explains the fundamental role of operating systems in managing hardware resources, scheduling tasks, and isolating applications, then provides a detailed analysis of Huawei's HarmonyOS—including its distributed architecture, microkernel design, deterministic latency engine, high‑performance IPC, unified IDE, and the Ark Compiler—highlighting how these features aim to create a seamless, multi‑device software ecosystem.
The article argues that Go+, by preserving Go's concise syntax while adding Python‑like type inference and tensor support, can address Python's flexibility‑induced code‑quality and performance issues, making it a viable front‑end language for data‑science, deep‑learning libraries, and compiler ecosystems.
After years of using Python for AI and data science, the author examines its flexibility drawbacks and argues that Go+, with its static typing and concise syntax, can address Python’s limitations, offering comparable ease for tensor operations, potential for a new deep‑learning front‑end language.
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.
This article examines how the Go compiler translates range loops into low‑level assembly instructions, walks through a concrete example with code and assembly output, explains each instruction’s role, and highlights recent compiler improvements that enhance safety and scheduler interaction.
The Chinese Academy of Sciences has launched Mulan, a domestically designed programming language aimed at smart IoT applications, featuring an elastic actor execution model, a self‑built compiler and IDE, and an education‑driven ecosystem to foster its adoption across schools and industry.
This article explains how Swift leverages LLVM's three‑stage compiler architecture and the Swift Intermediate Language (SIL) to implement protocol extensions, detailing the generation and analysis of SIL code, VTables, Witness Tables, and function calls to reveal the language's underlying compilation process.
The article introduces Wenyan, an esoteric programming language that lets developers write code in Classical Chinese characters, demonstrates "Hello World" and a prime‑number sieve example compiled to JavaScript, and provides installation, usage, and feature details for this open‑source, Turing‑complete language.
The article introduces V8’s architecture, tracing its shift from the memory‑heavy Full‑Codegen and Crankshaft compilers to the modern Ignition bytecode interpreter and TurboFan optimizing compiler, and explains how lexical analysis, AST parsing, bytecode generation, and runtime feedback together boost startup speed and reduce memory usage.
This tutorial walks through constructing a JavaScript arithmetic parser using a finite‑state lexer, a stack‑based parser that builds an abstract syntax tree (AST), and an evaluator that supports numbers, operators, parentheses, vectors, and custom symbols like @rot and @dot, complete with visual demos.
This article explains the inner workings of Babel, the JavaScript compiler, outlines what syntax it transpiles versus what requires polyfills, describes its three compilation stages, demonstrates AST generation and tokenization, and provides step‑by‑step examples of creating simple Babel plugins for code transformation.
This article shares a detailed experience of migrating business code—including C/C++ and Java applications—from x86 servers to TaiShan aarch64 servers, covering language differences, compilation issues, assembly rewrites, compiler options, and performance optimizations to achieve smoother execution on the new architecture.
Metaprogramming in Dart leverages the Dill intermediate representation and its abstract syntax tree to programmatically generate, transform, or inject code at compile time, enabling features such as custom serialization, AOP hooks, and reflection‑like capabilities without runtime overhead.
The article examines Huawei's HarmonyOS, detailing its rumored launch, the role of the Ark compiler, its C/C++ foundation, microkernel design, cross‑platform ambitions, and the challenges it faces in gaining developer and manufacturer adoption.
This article explains how the V8 JavaScript engine generates machine code for floating‑point addition on Intel x64, covering V8’s architecture, the IEEE‑754 representation that causes precision loss, and a step‑by‑step analysis of the relevant C++ source and the resulting addsd instruction.
This article provides a detailed technical analysis of Phoenix's native index creation and maintenance mechanisms, the underlying source code for index building, the role of coprocessors, and the complete SQL compilation pipeline from parsing to execution, highlighting how hints and optimizers influence index usage.
This tutorial explains how to implement a simple LL(1) parser in Go for SQL queries, covering lexical analysis, syntax analysis, finite‑state‑machine strategy, and testing, providing complete code snippets and practical guidance for developers interested in parser construction.
This article explores Java's syntactic sugar from a compilation perspective, dissecting bytecode and class files to reveal the underlying mechanisms of features such as switch on strings, generics, autoboxing, varargs, enums, lambdas, and more, helping developers understand both usage and implementation.
This article demystifies how programming languages are transformed by compilers, covering the roles of lexical analysis, parsing, abstract syntax trees, code generation, and linking, with practical Rust examples, diagrams, and references to deepen your understanding of language implementation.
The article explains how to extend MySQL’s built‑in lexer and Bison‑based parser to expose table names, query features, and optimization advice via a simple language‑agnostic service, illustrating core data structures, useless‑condition elimination, feature generation for slow‑query analysis, and practical learning tips.
This guide walks you through the core components of Webpack—including Tapable, Compiler, Compilation, Resolver, Module Factory, Parser, and Template—explaining their roles, source locations, and how they interact to transform entry files into bundled assets.
This article explains Java's traditional JIT compilers, introduces Graal as a modular Java‑level JIT and AOT compiler, compares its optimizations with HotSpot's C2, and provides practical steps to enable Graal in Java 10, offering deeper insight into JVM performance tuning.
This article presents a comprehensive overview of a universal FPGA‑based CNN accelerator, detailing its motivation, flexible architecture, compiler workflow, memory and compute unit designs, and performance comparisons that demonstrate significant latency and cost advantages over CPU and GPU solutions for real‑time AI inference.
This article provides a comprehensive technical overview of Vue.js, explaining why MVVM frameworks are needed, the advantages of Vue, and detailing the internal mechanisms of its observer, compiler, watcher, caching system, and dependency collection, while offering practical tips for reading open‑source code.
A programmer hired to fix a quirky questionnaire program on an old 3B2 machine discovers that the source code repeatedly reverts, the curses library is tampered, and ultimately a malicious compiler injects backdoor code, leading to a multi‑day forensic investigation and replacement of the toolchain.
This article explains practical Swift optimization techniques—including enabling compiler optimizations, whole‑module compilation, reducing dynamic dispatch with final and private, using value types and ContiguousArray, unchecked arithmetic, generic specialization, unmanaged references, and class‑only protocols—to improve runtime speed and binary size for iOS apps.
Google's Go 1.5 release replaces the traditional C compiler with a native Go compiler, introduces major performance and garbage‑collection improvements, and crucially adds support for the ARM architecture that dominates smartphones, enabling developers to write high‑performance mobile applications in Go.
This article compiles detailed interview experiences for backend engineering roles at major Chinese tech firms, covering algorithm challenges, system design, networking, compiler concepts, and personal reflections that help candidates prepare effectively.
This article explains the role of Java compilers, compares static, client, server and tiered compilation, and describes common JVM optimizations such as dead‑code elimination, inlining, and loop transformations to improve Java application performance.
This article explains Facebook's Hiphop tool, its evolution from static PHP-to-C++ compilation to HHVM with JIT, and provides a detailed walkthrough of compiler fundamentals including lexical, syntax, and semantic analysis, intermediate code generation, optimization, and code generation.
Chris Lattner, the original creator of LLVM and Clang, now leads Apple’s Developer Tools division and has driven the development of Swift since 2010, integrating his compiler expertise, fostering interactive tools like Xcode Playgrounds, and shaping modern programming education.
