Tagged articles
interpreter
68 articles · Page 1 of 1
This article explains two critical PHP interpreter vulnerabilities (CVE-2026-109618 and CVE-2026-109619) that allow unauthenticated remote code execution and sensitive data leakage via memory exhaustion and use-after-free flaws, affecting mod_php and PHP-FPM deployments powering WordPress, Drupal, and Joomla.
CVE-2026-109618CVE-2026-109619PHP
0 likes · 11 min read

This article examines the three least‑used behavioral design patterns—Mediator, Visitor, and Interpreter—by explaining the problems each solves, showing core implementations with order‑page examples, highlighting their narrow applicability, common pitfalls, and why developers should often steer clear of them.
behavioraldesign patternsinterpreter
0 likes · 12 min read

This article introduces the five classic software architecture styles—data‑flow, call/return, data‑centric, virtual‑machine, and independent component—explaining their core mechanisms, advantages, drawbacks, real‑world examples, and a five‑step method for selecting the appropriate style in system design and exams.
Layered Architecturearchitecture stylesblackboard
0 likes · 28 min read

The upcoming Python 3.13 release, slated for October 2024, aims to boost interpreter performance by at least 50% through a Tier‑2 optimizer, subinterpreter support, and revamped memory management, building on groundwork completed in Python 3.12 such as low‑impact monitoring and improved bytecode compilation.
Tier-2 Optimizerinterpretermemory management
0 likes · 5 min read

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.
C languageCompilerPHP
0 likes · 3 min read

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.
CompilerPHPProgramming Language
0 likes · 3 min read

This article explains the low‑level mechanics of Python function calls, distinguishing Python‑implemented and C‑implemented functions, dissecting the bytecode generated for a simple call, and walking through the CPython CALL instruction, stack layout, method handling, and the relationship between PyFunctionObject, PyFrameObject, and PyCodeObject.
Function CallPyCFunctionObjectbytecode
0 likes · 10 min read

The article explains how PyPy’s just‑in‑time compilation dramatically speeds up Python code—often surpassing CPython and even native C implementations—by describing the performance problem, presenting benchmark results, and detailing the differences between interpreted, ahead‑of‑time, and JIT‑compiled execution.
PyPyPythoninterpreter
0 likes · 5 min read

This article dissects CPython's _PyEval_EvalFrameDefault function, explaining how the interpreter treats itself as a CPU, uses a stack frame, switches between Python and C call stacks, and employs computed‑goto optimizations to efficiently dispatch bytecode instructions.
CPythonbytecodecomputed goto
0 likes · 26 min read

This article explains how the Python interpreter initializes its runtime environment, compiles source code into PyCodeObject bytecode, creates stack frames, and executes the bytecode using functions like PyEval_EvalFrame and _PyEval_EvalFrameDefault while detailing the role of the runtime stack and its associated C macros.
C++PythonRuntime Stack
0 likes · 21 min read

This article explains how the Python interpreter, after runtime initialization, creates a stack frame, invokes a series of C functions such as PyEval_EvalCode, _PyEval_Vector, and _PyEval_EvalFrameDefault to traverse and execute bytecode, and details the underlying runtime stack structures and macro APIs that support instruction evaluation.
C APIPyEvalPython
0 likes · 25 min read


21CTOSep 28, 2024 · Fundamentals
This article introduces beginners to Python’s dynamic typing, strong typing, and the inner workings of its interpreter, contrasting them with static languages, and demonstrates how variable assignment and memory management differ through clear examples and explanations of CPython’s runtime behavior.
PythonStrong Typingdynamic typing
0 likes · 5 min read

Mark Shannon’s “Shannon Plan” for Faster CPython outlines three parallel initiatives—Tier 2 optimizer, enabling sub‑interpreters via PEP 554, and memory‑management improvements—aimed at making Python up to five times faster by Python 3.13, with Microsoft joining the effort.
CPythonPEP 554Python
0 likes · 4 min read

The article explains CPython's object memory caching, details the structure of the tuple free‑list, reproduces a bug where length‑20 tuples aren't reused, shows the debugging steps, and presents a one‑line source change that corrects the issue in Python 3.12/3.13.
CPythonPythonbug fix
0 likes · 7 min read

The article explains how PyPy leverages just‑in‑time (JIT) compilation to dramatically speed up Python code execution, outperforming both the standard CPython interpreter and even native C implementations, and includes a practical benchmark and code example.
Pythoninterpreterprogramming
0 likes · 5 min read

The article analyzes why Android 14's debuggable runtime became significantly slower due to a change from the nterp interpreter to the switch interpreter, explains the underlying ART modifications, and presents the Google‑provided fixes that restore performance to Android 13 levels.
ARTdebuggableinterpreter
0 likes · 8 min read


21CTOApr 6, 2024 · Fundamentals
This article chronicles the author's six‑month journey creating the Pinecone programming language, covering its core features, design decisions about compilation versus interpretation, custom lexing and parsing, implementation choices, and practical advice for anyone wanting to build their own language.
C++Compiler designProgramming Language
0 likes · 18 min read

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.
C languageCompilerPHP
0 likes · 3 min read

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.
CompilerPHPbackend development
0 likes · 4 min read

This article provides a comprehensive overview of the Java Virtual Machine, detailing its architecture, class loading process, runtime data areas, and execution engine, including interpreter and JIT compilation, to help readers grasp JVM fundamentals for Java development and interview preparation.
Class LoadingJITJVM
0 likes · 8 min read

This article explains the concept of Just‑In‑Time compilation for Python, introduces the copy‑and‑patch JIT proposed for CPython 3.13, shows how it works with bytecode templates, compares it to traditional JIT approaches, and presents simple benchmark results and implementation details.
CPythonCopy-and-PatchJIT
0 likes · 13 min read


21CTOJan 12, 2024 · Fundamentals
The upcoming CPython 3.13 release will optionally include a JIT compiler built on LLVM, offering modest speed gains of 2%‑9% today and promising larger improvements in future versions through advanced optimization techniques.
CPythonJITLLVM
0 likes · 6 min read

The article explains how Python’s speed limitations can be overcome with PyPy’s just‑in‑time compilation, presenting a performance test that shows PyPy outpacing both the standard interpreter and even compiled C code, and details the underlying differences between JIT, AOT, and interpreted execution.
JITPyPyPython
0 likes · 5 min read

This article guides readers through designing and implementing a basic Python interpreter that can evaluate arithmetic expressions by defining tokens, writing a lexer and parser with PLY, specifying BNF grammar, handling precedence, and assembling a runnable program that processes user input.
BNFPLYParser
0 likes · 9 min read


21CTOOct 5, 2023 · Fundamentals
The article outlines the major performance and architectural goals for Python 3.12, describing the Faster CPython project’s specialized opcodes, multithreading proposals, object size reductions, memory‑management improvements, and API stability efforts that aim to boost speed and maintainability.
CPythonPEPPython
0 likes · 8 min read

The article explains Python’s Global Interpreter Lock—its historical origins, how CPython’s tick‑based and later time‑slice schedulers manage thread execution, why it limits multi‑core performance, common multiprocessing workarounds, and the difficulties of removing it despite recent proposals for a GIL‑free build.
ConcurrencyGILMultithreading
0 likes · 15 min read

Python’s Global Interpreter Lock is slated for optional removal, with a multi‑stage roadmap that begins experimental support in Python 3.13, promises broader adoption in the mid‑term, and aims for default status within five years, reshaping concurrency for AI and other workloads.
AIGILPython
0 likes · 6 min read


ByteFEJul 12, 2023 · Fundamentals
This article walks through the complete implementation of a basic WebAssembly interpreter called WAInterp using TypeScript, covering module decoding, instantiation, execution of various sections, handling of instructions, and a practical example, thereby deepening understanding of WebAssembly fundamentals and virtual machine design.
ProgrammingLanguagesTypeScriptVirtualMachine
0 likes · 58 min read

This article explains how to create a Lispy Value storage system in C, defining numeric and error types, enumerations, constructors, printing functions, and semantic error detection to support a simple Lisp REPL that evaluates Polish notation expressions.
C++Lisperror handling
0 likes · 9 min read

This article explains Python's design choices such as mandatory indentation, floating‑point arithmetic quirks, immutable strings, the absence of switch statements, memory management, and many other language features, providing clear reasoning, code examples, and best‑practice recommendations for Python developers.
best-practicesinterpreterlanguage-design
0 likes · 26 min read

The article explores cross‑platform mobile development techniques, from simple WebView‑based app‑to‑web solutions to advanced virtual‑machine designs and interpreter optimizations, detailing WebView implementations, mini‑programs, React Native, Flutter, and various VM encoding strategies for efficient JavaScript execution.
JavaScriptWebViewcross-platform
0 likes · 28 min read

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

The article explains how CPython 3.11 achieves a 1.25‑times speed boost over 3.10 through a new adaptive bytecode interpreter, outlines the goals of the Faster‑CPython project and PEP 659, and discusses the planned JIT compiler for future Python releases.
JITPEP659faster-cpython
0 likes · 6 min read

At the 2022 Python Language Summit, developer Sam Gross presented a proposal to eliminate CPython's Global Interpreter Lock by adding a new, more efficient lock mechanism that could debut in Python 3.12, sparking extensive discussion about multithreading performance and implementation challenges.
CPythonGILLock
0 likes · 4 min read


21CTOMay 16, 2022 · Fundamentals
The upcoming CPython release in October promises major performance improvements, new browser support, and a potential removal of the Global Interpreter Lock, reflecting industry‑backed efforts from Meta, Microsoft, and the Python core team to modernize the language.
GILhotpyinterpreter
0 likes · 4 min read

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

This article explains how Python’s elegant a,b = b,a variable swap works under the hood by examining bytecode, stack manipulation with ROT_TWO, evaluation order nuances, and the differences when swapping more than two variables, providing clear code examples and interpreter insights.
Pythoninterpretertuple unpacking
0 likes · 9 min read

The article presents PUA Language, a tongue‑in‑cheek programming language that replaces traditional syntax with corporate buzzwords, explains its keyword mappings, shows example code, discusses its open‑source origins from a Rust‑based Monkey interpreter, and reflects on its cultural impact within tech companies.
PUA LanguageProgramming Languagecorporate jargon
0 likes · 5 min read

The article introduces PUA Language, a tongue‑in‑cheek programming language that maps corporate buzzwords like “赋能” and “抓手” to code constructs, showcases its syntax table, explains its Monkey‑based interpreter origins, provides GitHub links, and invites readers to explore its source and online demo.
MonkeyProgramming LanguageRust
0 likes · 6 min read

This article examines PEP 659, the Specializing Adaptive Interpreter proposed for CPython, explains its non‑JIT approach, details the warm‑up, adaptive, specializing and de‑optimisation phases, and walks through the actual source‑code implementation using the LOAD_GLOBAL instruction as a concrete example.
CPythonPEP 659Python
0 likes · 17 min read

The article introduces PUA Language, a tongue‑in‑cheek programming language that replaces traditional keywords with corporate buzzwords, explains its syntax mapping, shows example code and diagrams, and provides links to its Rust‑based Monkey interpreter source and online playground.
Domain-Specific LanguageProgramming LanguageRust
0 likes · 6 min read

This article walks through creating a Python arithmetic interpreter with the PLY library, covering token definitions, lexer rules, BNF grammar, parser implementation, operator precedence, and a runnable REPL, providing complete code and explanations for each step.
BNFPLYPython
0 likes · 9 min read

This article summarizes Sam Gross’s nogil project—a Python 3.9 fork that removes the GIL—detailing its design changes, early benchmarks, integration challenges, and the community’s discussion on feasibility, performance, and the roadmap toward a GIL‑free CPython.
CPythonConcurrencyGIL
0 likes · 18 min read

This article explains how to create a simple arithmetic expression interpreter in Python by leveraging the PLY (Python Lex‑Yacc) library, covering token definition, lexer implementation, BNF grammar, parser rules, operator precedence, error handling, and a complete runnable example.
BNFPLYParser
0 likes · 9 min read

The article explains how Go, traditionally a compiled language, can serve as a scripting language using the Yaegi interpreter—detailing its syntax‑compatible design, easy struct integration, quick‑start example, performance comparison with gopher‑lua and Tengo, and practical engineering guidelines for safe embedding.
EmbeddingGoYaegi
0 likes · 16 min read

This article walks through the design and implementation of a WebAssembly interpreter, covering Wasm fundamentals, binary module structure, decoding into an in‑memory representation, stack‑based virtual machine execution, call‑stack management, and concrete code examples from the open‑source project.
Binary DecodingLow-Level ProgrammingStackVM
0 likes · 24 min read

This article dissects Python’s standard pdb module, explaining its pure‑Python implementation on top of bdb and cmd, the event‑driven tracing mechanism, core debugging commands such as step, next, continue, and how MNN Workbench embeds these capabilities for mobile AI development.
PDBPythoncode analysis
0 likes · 19 min read

This week’s WecTeam Front‑end Weekly highlights a concise explanation of how compilers and interpreters transform source code into intermediate representations before execution, and shares a personal story on how open‑source contributions foster efficient work habits, product thinking, and lifelong passion.
compilationintermediate representationinterpreter
0 likes · 2 min read

The article presents PUA Language, a tongue‑in‑cheek programming language that maps typical programming constructs to corporate buzzwords, explains its syntax through a keyword table, shows example code snippets, and provides links to its open‑source repository and online interpreter for readers to explore.
PUA LanguageProgramming LanguageRust
0 likes · 6 min read

Guido van Rossum’s recent “Making CPython Faster” talk reveals the Shannon Plan—a four‑year effort, backed by Microsoft, to boost Python’s performance up to five times, with the first milestone targeting a 2× speedup in the upcoming Python 3.11 release through adaptive bytecode interpreters and other optimizations.
CPythonGuido van RossumPEP 659
0 likes · 4 min read

Released in October 2020, Pyston v2 is a JIT‑based Python implementation that delivers roughly 20% speed improvements over CPython 3.8 in macro‑benchmarks, offers easy deployment, maintains high compatibility with CPython, and incorporates techniques such as DynASM JIT, quickening, and process‑building optimizations.
JITPystonRuntime
0 likes · 5 min read

This article explains how the PyPy interpreter dramatically speeds up Python code through just‑in‑time (JIT) compilation, compares its performance to CPython and C, and provides a practical example demonstrating the runtime gains.
JITPyPyPython
0 likes · 5 min read

The article explains how PyPy’s just‑in‑time compilation can make Python code run faster than even native C implementations, demonstrates benchmark results comparing default Python, PyPy, and C, and outlines the differences between ahead‑of‑time compilation, interpretation, and JIT.
JITPyPyPython
0 likes · 5 min read

This article explains in detail how ClickHouse processes a user‑submitted SQL query, covering the server’s request handling, parsing, query rewrite, optimization, interpreter execution, and result transmission, while illustrating key source code snippets and architectural components.
BackendClickHouseDatabase Internals
0 likes · 18 min read

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.
CompilerPythonTools
0 likes · 8 min read

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.
CompilerPythonTools
0 likes · 8 min read

This article explains why Python is popular yet slower than compiled languages, introduces PyPy as a drop‑in replacement for CPython that uses JIT compilation to accelerate code by an average of 7.6×, and outlines its workings, benefits, and limitations.
CPythonJITPyPy
0 likes · 8 min read

Learn how to create a simple stack‑based virtual machine in Python, covering its core components—code, stack, and address—along with essential methods like push, pop, dispatch, and run, plus an interactive REPL, complete with example code and execution output.
PythonREPLTutorial
0 likes · 5 min read

This article introduces ten widely used software architectural patterns, explains their structure and key characteristics, and lists typical application scenarios for each, helping developers choose appropriate architectures for large‑scale enterprise systems.
Event BusLayered ArchitectureMVC
0 likes · 9 min read

This article explores the origins, design trade‑offs, and performance impact of Python’s Global Interpreter Lock (GIL), explains why it persists in CPython, reviews past attempts to remove it, and offers practical guidance for developers seeking effective concurrency solutions.
CPythonConcurrencyGIL
0 likes · 12 min read

This article explores the origins, challenges, and ongoing research surrounding Python's Global Interpreter Lock (GIL), explaining why it limits multithreaded performance, how it has evolved, and what alternatives developers can consider for true parallel execution.
CPythonConcurrencyGIL
0 likes · 13 min read


21CTOOct 28, 2018 · Fundamentals
This guide explains how to launch Python’s REPL, avoid common indentation errors, and transition from interactive commands to creating and executing a simple Python script from the command line.
PythonREPLScript
0 likes · 4 min read

This tutorial walks Python beginners through the complete process of setting up a Python interpreter in PyCharm, covering initial prompts, navigating the Project Interpreter settings, selecting an interpreter, applying changes, and troubleshooting common configuration issues.
IDEPyCharmPython
0 likes · 6 min read

The article explores the history, design challenges, and performance impact of Python's Global Interpreter Lock (GIL), explaining why it persists, how it limits multithreaded execution, and what recent changes and research reveal about possible alternatives.
CPythonConcurrencyGIL
0 likes · 12 min read

This article explains why the same integer values can produce different results with the ‘is’ operator in Python, covering small‑integer caching, the general integer object pool, constant pools, and the distinction between whole‑module and line‑by‑line execution modes.
Constant PoolInteger cachinginterpreter
0 likes · 9 min read

The article explores Python’s Global Interpreter Lock (GIL), explaining its origins, how it limits true multithreading, the challenges of removing it, historical attempts, recent improvements, and why developers often prefer multiprocessing over threading for parallel execution.
CPythonConcurrencyGIL
0 likes · 13 min read

This article explains how Spring Framework applies four classic design patterns—Interpreter, Builder, Factory Method, and Abstract Factory—to simplify object creation and configuration, providing clear Java code examples, Spring bean definitions, and a discussion of their roles within the framework.
Abstract FactoryBuilderJava
0 likes · 13 min read

A shebang (#!) line placed at the start of a script tells the operating system which interpreter to use, can include optional arguments, and may employ the env command to locate the executable, with variations such as hashbang, pound‑bang, and hash‑pling.
.envNodeScript
0 likes · 1 min read
