BestHub
Sign in
Tagged articles

Compiler

199 articles · Page 2 of 2
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.

CompilerOpen SourceOpenJDK
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.

CompilerLLVMMethod Dispatch
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.

AICompilerMojo
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.

AICompilerMojo
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.

AndroidCompilerLegal
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.

CompilerKCLRewrite
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.

BladeDISCCompilerGPU Optimization
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.

CompilerFrontendJavaScript
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 ToolBundlerCompiler
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.

BabelCompilerFrontend
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.

AndroidCheckerCompiler
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.

CompilerEcosystemProgramming 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.

BabelCompilerJavaScript
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.

ASTAnnotationProcessingCompiler
0 likes · 17 min read
Deep Dive into Java Compiler AST Instrumentation for Monitoring
ELab Team
ELab Team
Jun 17, 2022 · Fundamentals

How a Tiny Compiler Works: From Tokenizer to Code Generator

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.

ASTCompilerJavaScript
0 likes · 17 min read
How a Tiny Compiler Works: From Tokenizer to Code Generator
OPPO Kernel Craftsman
OPPO Kernel Craftsman
Jun 2, 2022 · Fundamentals

Design and Implementation of TinyLanguage Using Flex and Bison

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.

ASTBisonCompiler
0 likes · 30 min read
Design and Implementation of TinyLanguage Using Flex and Bison
Tencent Cloud Developer
Tencent Cloud Developer
May 24, 2022 · Backend Development

Three Advanced Go Techniques: Minimal Runtime, JIT Compilation, and Bootstrap

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.

AssemblyBootstrapCompiler
0 likes · 21 min read
Three Advanced Go Techniques: Minimal Runtime, JIT Compilation, and Bootstrap
DaTaobao Tech
DaTaobao Tech
Apr 7, 2022 · Frontend Development

Migrating a Large-Scale Taobao Store Frontend Project to TypeScript: Practices, Standards, and Compiler Insights

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.

CompilerMigrationTypeScript
0 likes · 35 min read
Migrating a Large-Scale Taobao Store Frontend Project to TypeScript: Practices, Standards, and Compiler Insights
Alibaba Terminal Technology
Alibaba Terminal Technology
Mar 28, 2022 · Backend Development

hyengine: Unifying Mobile Script Execution with JIT and Multi‑Language Support

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.

CompilerGarbage CollectionOptimization
0 likes · 36 min read
hyengine: Unifying Mobile Script Execution with JIT and Multi‑Language Support
NetEase Cloud Music Tech Team
NetEase Cloud Music Tech Team
Mar 24, 2022 · Fundamentals

Unlocking JavaScript Power: A Deep Dive into AST and Babel

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.

ASTBabelCompiler
0 likes · 13 min read
Unlocking JavaScript Power: A Deep Dive into AST and Babel
IT Services Circle
IT Services Circle
Mar 20, 2022 · Fundamentals

Understanding Enum Size and Compiler Options in C (gcc)

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

C++CompilerEnum
0 likes · 4 min read
Understanding Enum Size and Compiler Options in C (gcc)
Laravel Tech Community
Laravel Tech Community
Jan 4, 2022 · Fundamentals

Differences Between while(1) and for(;;) Loops in C

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.

AssemblyC++Compiler
0 likes · 4 min read
Differences Between while(1) and for(;;) Loops in C
Alibaba Cloud Infrastructure
Alibaba Cloud Infrastructure
Dec 27, 2021 · Fundamentals

Advances, Challenges, and Solutions for Programmable Switching ASICs – Alibaba Cloud’s Self‑Developed Compiler

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%.

Cloud InfrastructureCompilerData Plane
0 likes · 14 min read
Advances, Challenges, and Solutions for Programmable Switching ASICs – Alibaba Cloud’s Self‑Developed Compiler
ELab Team
ELab Team
Dec 22, 2021 · Frontend Development

Why Svelte Beats React & Vue: Compilation, Reactivity, and Ecosystem Explained

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.

CompilerReactivitySvelte
0 likes · 23 min read
Why Svelte Beats React & Vue: Compilation, Reactivity, and Ecosystem Explained
Yuewen Technology
Yuewen Technology
Sep 10, 2021 · Fundamentals

How to Build Your Own Expression Language with ANTLR and Java

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.

ANTLRCompilerExpression Language
0 likes · 16 min read
How to Build Your Own Expression Language with ANTLR and Java
ITPUB
ITPUB
Aug 13, 2021 · Fundamentals

How CPUs Process Gigantic Data Structures with Tiny Registers

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.

CPUCompilerLoad/Store
0 likes · 6 min read
How CPUs Process Gigantic Data Structures with Tiny Registers
Liangxu Linux
Liangxu Linux
Aug 6, 2021 · Fundamentals

Understanding GCC: Components, Cross‑Compilation, and ARM Toolchains

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

ARMC libraryCompiler
0 likes · 11 min read
Understanding GCC: Components, Cross‑Compilation, and ARM Toolchains
phodal
phodal
Jun 7, 2021 · Fundamentals

How to Design Effective Domain‑Specific Languages: Patterns, Syntax, and Tools

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.

CompilerParserSoftware Engineering
0 likes · 10 min read
How to Design Effective Domain‑Specific Languages: Patterns, Syntax, and Tools
ByteDance Dali Intelligent Technology Team
ByteDance Dali Intelligent Technology Team
Jun 7, 2021 · Frontend Development

Understanding Webpack 5 Compilation Process and Tapable Plugin System

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.

CompilerTapableTree-shaking
0 likes · 13 min read
Understanding Webpack 5 Compilation Process and Tapable Plugin System
21CTO
21CTO
May 29, 2021 · Frontend Development

How Google’s Sparkplug Compiler Boosts Chrome Performance by 23%

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.

ChromeCompilerJavaScript
0 likes · 4 min read
How Google’s Sparkplug Compiler Boosts Chrome Performance by 23%
Liangxu Linux
Liangxu Linux
Mar 29, 2021 · Fundamentals

Discover Classic Source Code Masterpieces Every Developer Should Explore

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.

CompilerGame DevelopmentOptimization
0 likes · 6 min read
Discover Classic Source Code Masterpieces Every Developer Should Explore
ITPUB
ITPUB
Mar 25, 2021 · Fundamentals

From Switches to Compilers: How Simple Logic Became Modern Programming

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.

AssemblyCompilerProgramming Languages
0 likes · 11 min read
From Switches to Compilers: How Simple Logic Became Modern Programming
Top Architect
Top Architect
Feb 20, 2021 · Fundamentals

Impressive Source Code Examples Every Developer Should Explore

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.

ChromiumCompilerGame Development
0 likes · 7 min read
Impressive Source Code Examples Every Developer Should Explore
Python Programming Learning Circle
Python Programming Learning Circle
Feb 4, 2021 · Fundamentals

11 Best Python Compilers and Interpreters for Developers

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.

Compilerdata sciencelanguage
0 likes · 8 min read
11 Best Python Compilers and Interpreters for Developers
MaGe Linux Operations
MaGe Linux Operations
Jan 11, 2021 · Fundamentals

Top 11 Python Compilers and Interpreters Every Developer Should Know

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.

CompilerPythondevelopment
0 likes · 8 min read
Top 11 Python Compilers and Interpreters Every Developer Should Know
Architects' Tech Alliance
Architects' Tech Alliance
Jan 3, 2021 · Backend Development

Code Migration Experience: Porting C/C++ Applications from x86 to TaiShan aarch64 Servers

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.

AssemblyC++Compiler
0 likes · 14 min read
Code Migration Experience: Porting C/C++ Applications from x86 to TaiShan aarch64 Servers
dbaplus Community
dbaplus Community
Jan 3, 2021 · Fundamentals

Why C Still Rules: A Deep Dive into Its History, Evolution, and Legacy

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.

BCPLC languageCompiler
0 likes · 23 min read
Why C Still Rules: A Deep Dive into Its History, Evolution, and Legacy
macrozheng
macrozheng
Dec 25, 2020 · Fundamentals

Unveiling Java’s Hidden Syntactic Sugar: From Generics to Try‑with‑Resources

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.

CompilerLanguage Featurescode examples
0 likes · 18 min read
Unveiling Java’s Hidden Syntactic Sugar: From Generics to Try‑with‑Resources
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Dec 4, 2020 · Fundamentals

Understanding Syntactic Sugar and Its Desugaring in Java

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.

Compilercode readabilitydesugaring
0 likes · 6 min read
Understanding Syntactic Sugar and Its Desugaring in Java
Tongcheng Travel Technology Center
Tongcheng Travel Technology Center
Nov 24, 2020 · Frontend Development

Thanos Multi‑Platform Development Framework: Architecture, Components, and Implementation

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.

CompilerMini ProgramRuntime
0 likes · 15 min read
Thanos Multi‑Platform Development Framework: Architecture, Components, and Implementation
JD Retail Technology
JD Retail Technology
Sep 28, 2020 · Mobile Development

Comprehensive Analysis of Swift vs Objective‑C: Adoption, Performance, Compiler Optimizations and Ecosystem Impact

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.

CompilerObjective‑CSwift
0 likes · 25 min read
Comprehensive Analysis of Swift vs Objective‑C: Adoption, Performance, Compiler Optimizations and Ecosystem Impact
MaGe Linux Operations
MaGe Linux Operations
Sep 4, 2020 · Fundamentals

Top 11 Python Compilers & Interpreters Every Developer Should Know

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.

CompilerPythondevelopment
0 likes · 8 min read
Top 11 Python Compilers & Interpreters Every Developer Should Know
Amap Tech
Amap Tech
Aug 28, 2020 · Fundamentals

Code Coverage Instrumentation Using LLVM and GCOV

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.

CompilerIRInstrumentation
0 likes · 17 min read
Code Coverage Instrumentation Using LLVM and GCOV
Architects' Tech Alliance
Architects' Tech Alliance
Jul 19, 2020 · Fundamentals

Why Operating Systems Are Essential and an In‑Depth Look at Huawei's HarmonyOS Architecture

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.

CompilerDistributed ArchitectureHarmonyOS
0 likes · 25 min read
Why Operating Systems Are Essential and an In‑Depth Look at Huawei's HarmonyOS Architecture
AntTech
AntTech
Jul 16, 2020 · Artificial Intelligence

Why Go+ Can Complement Python for Data‑Science and Deep‑Learning Workflows

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.

CompilerGo+Programming Language
0 likes · 15 min read
Why Go+ Can Complement Python for Data‑Science and Deep‑Learning Workflows
Alibaba Cloud Developer
Alibaba Cloud Developer
Jul 16, 2020 · Artificial Intelligence

Can Go+ Fill Python’s Gaps in Data Science and Deep Learning?

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.

CompilerGoProgramming Languages
0 likes · 16 min read
Can Go+ Fill Python’s Gaps in Data Science and Deep Learning?
Liangxu Linux
Liangxu Linux
Jun 16, 2020 · Backend Development

Unlocking GCC: History, Features, and Mastering Its Compilation Options

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

C languageCompilerDynamic Library
0 likes · 7 min read
Unlocking GCC: History, Features, and Mastering Its Compilation Options
360 Zhihui Cloud Developer
360 Zhihui Cloud Developer
Feb 13, 2020 · Backend Development

How Go Compiles Range Loops into Assembly: A Deep Dive

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.

AssemblyCompilerbackend development
0 likes · 8 min read
How Go Compiles Range Loops into Assembly: A Deep Dive
ITPUB
ITPUB
Jan 17, 2020 · Fundamentals

Introducing Mulan: China’s New ‘C for the IoT Era’ Programming Language

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.

CompilerIoTMulan
0 likes · 6 min read
Introducing Mulan: China’s New ‘C for the IoT Era’ Programming Language
Sohu Tech Products
Sohu Tech Products
Jan 8, 2020 · Backend Development

Understanding Swift SIL: Exploring LLVM Backend and Protocol Extension Implementation

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.

CompilerLLVMProtocol Extension
0 likes · 12 min read
Understanding Swift SIL: Exploring LLVM Backend and Protocol Extension Implementation
vivo Internet Technology
vivo Internet Technology
Dec 11, 2019 · Fundamentals

An Introduction to V8 JavaScript Engine Architecture and Bytecode Execution

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.

BytecodeCompilerIgnition
0 likes · 11 min read
An Introduction to V8 JavaScript Engine Architecture and Bytecode Execution
WecTeam
WecTeam
Oct 29, 2019 · Fundamentals

How to Build a Custom Arithmetic Parser with AST and Vector Extensions in JavaScript

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.

ASTCompilerJavaScript
0 likes · 23 min read
How to Build a Custom Arithmetic Parser with AST and Vector Extensions in JavaScript
政采云技术
政采云技术
Sep 15, 2019 · Frontend Development

Understanding Babel: How It Works and How to Write a Babel Plugin

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.

ASTBabelCompiler
0 likes · 13 min read
Understanding Babel: How It Works and How to Write a Babel Plugin
Architects' Tech Alliance
Architects' Tech Alliance
Sep 4, 2019 · Operations

Code Migration Experience: Porting Business Applications from x86 to TaiShan aarch64 Servers

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.

AssemblyCompileraarch64
0 likes · 13 min read
Code Migration Experience: Porting Business Applications from x86 to TaiShan aarch64 Servers
Xianyu Technology
Xianyu Technology
Aug 22, 2019 · Fundamentals

Metaprogramming in Dart: AST Manipulation with Dill

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.

ASTCompilerDART
0 likes · 8 min read
Metaprogramming in Dart: AST Manipulation with Dill
Weidian Tech Team
Weidian Tech Team
Jul 12, 2019 · Fundamentals

Why JavaScript Float Addition Is Inaccurate: Inside V8’s Machine Code

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.

CompilerJavaScriptMachine Code
0 likes · 12 min read
Why JavaScript Float Addition Is Inaccurate: Inside V8’s Machine Code
DataFunTalk
DataFunTalk
Jun 28, 2019 · Databases

Deep Dive into Phoenix Index Creation, Maintenance, and SQL Compilation

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.

CompilerCoprocessorDatabase
0 likes · 26 min read
Deep Dive into Phoenix Index Creation, Maintenance, and SQL Compilation
360 Tech Engineering
360 Tech Engineering
Jun 25, 2019 · Fundamentals

Building an LL(1) SQL Parser in Go

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.

CompilerGoLL(1) parser
0 likes · 9 min read
Building an LL(1) SQL Parser in Go
Java Backend Technology
Java Backend Technology
May 16, 2019 · Backend Development

Unveiling Java’s Syntactic Sugar: How the Compiler Simplifies Your Code

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.

CompilerLambdagenerics
0 likes · 18 min read
Unveiling Java’s Syntactic Sugar: How the Compiler Simplifies Your Code
MaGe Linux Operations
MaGe Linux Operations
Dec 24, 2018 · Fundamentals

How Programming Languages Really Work: Inside the Compiler Journey

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.

CompilerProgramming LanguageRust
0 likes · 14 min read
How Programming Languages Really Work: Inside the Compiler Journey
Meituan Technology Team
Meituan Technology Team
May 17, 2018 · Databases

Understanding MySQL SQL Parsing and Optimization Techniques

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.

CompilerDBADatabase
0 likes · 15 min read
Understanding MySQL SQL Parsing and Optimization Techniques
Node Underground
Node Underground
Apr 8, 2018 · Frontend Development

Master Webpack Internals: From Tapable to Template Explained

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.

Build ToolsCompilerModule Bundling
0 likes · 5 min read
Master Webpack Internals: From Tapable to Template Explained
21CTO
21CTO
Mar 21, 2018 · Backend Development

Unlocking Java Performance: How Graal Replaces C2 in HotSpot JIT

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.

CompilerGraalVMHotSpot
0 likes · 11 min read
Unlocking Java Performance: How Graal Replaces C2 in HotSpot JIT
Tencent Architect
Tencent Architect
Oct 20, 2017 · Artificial Intelligence

Design and Performance of a General‑Purpose FPGA CNN Accelerator for Real‑Time AI Services

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.

AI InferenceCNN accelerationCompiler
0 likes · 13 min read
Design and Performance of a General‑Purpose FPGA CNN Accelerator for Real‑Time AI Services
ITPUB
ITPUB
May 11, 2016 · Information Security

Uncovering a Hidden Compiler Backdoor on a 3B2 System – A Day‑by‑Day Debugging Saga

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.

CompilerLegacy SystemsReverse Engineering
0 likes · 9 min read
Uncovering a Hidden Compiler Backdoor on a 3B2 System – A Day‑by‑Day Debugging Saga
21CTO
21CTO
Dec 21, 2015 · Mobile Development

Boost Swift Performance: Essential Optimization Tips for Mobile Developers

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.

CompilerOptimizationSwift
0 likes · 17 min read
Boost Swift Performance: Essential Optimization Tips for Mobile Developers
21CTO
21CTO
Aug 25, 2015 · Backend Development

Google Go 1.5 Adds Native ARM Support – What It Means for Mobile Development

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.

ARMCompilerProgramming Language
0 likes · 5 min read
Google Go 1.5 Adds Native ARM Support – What It Means for Mobile Development
21CTO
21CTO
Aug 11, 2015 · Backend Development

Inside Top Chinese Tech Interviews: Backend Engineer Questions & Answers

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.

AlgorithmsCompilerInterview
0 likes · 9 min read
Inside Top Chinese Tech Interviews: Backend Engineer Questions & Answers
Qunar Tech Salon
Qunar Tech Salon
Jan 5, 2015 · Fundamentals

Understanding Java Compilers and JVM Optimization Techniques

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.

BytecodeCompilerJVM
0 likes · 19 min read
Understanding Java Compilers and JVM Optimization Techniques
Baidu Tech Salon
Baidu Tech Salon
Jun 5, 2014 · Fundamentals

Chris Lattner: LLVM, Clang, and the Creation of Swift

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.

CompilerLLVMProgramming Languages
0 likes · 6 min read
Chris Lattner: LLVM, Clang, and the Creation of Swift