# PyPy[glossary]

PyPy[glossary]
news getting-started documentation svn issues contact EU/project

PyPy, like any large project, has developed a jargon of its own. This document gives brief definition of some of these terms and provides links to more information.

abstract interpretation
  The technique of interpreting the bytecode of a user program with an interpreter that handles abstract objects instead of concrete ones. It can be used to check the bytecode or see what it does, without actually executing it with concrete values. See Theory.

annotator
  The component of the translator's toolchain that performs a form of type inference on the flow graph. See the annotator pass in the documentation.

application level
  applevel code is normal Python code running on top of the PyPy or CPython interpreter (see interpreter level)

backend
  Code generator that converts an RPython program to a target language using the PyPy toolchain. A backend uses either the lltypesystem or the ootypesystem.

compile-time
  In the context of the JIT, compile time is when the JIT is generating machine code "just in time".

CPython
  The "default" implementation of Python, written in C and distributed by the PSF on http://www.python.org.

external function
  Functions that we don't want to implement in Python for various reasons (e.g. they need to make calls into the OS) and whose implementation will be provided by the backend.

garbage collection framework
  Code that makes it possible to write PyPy's garbage collectors in Python itself.

interpreter level
  Code running at this level is part of the implementation of the PyPy interpreter and cannot interact normally with application level code; it typically provides implementation for an object space and its builtins.

jit
  just in time compiler.

llinterpreter
  Piece of code that is able to interpret flow graphs. This is very useful for testing purposes, especially if you work on the RPython Typer.

lltypesystem
  A C-like type model that contains structs and pointers. A backend that uses this type system is also called a low-level backend. The C and LLVM backends use this typesystem.

low-level helper
  A function that the RTyper can use a call to as part of implementing some operation in terms of the target type system.

mixed module
  a module that accesses PyPy's interpreter level. The name comes from the fact that the module's implementation can be a mixture of application level and interpreter level code.

multimethod
  A callable object that invokes a different Python function based on the type of all its arguments (instead of just the class of the first argument, as with normal methods). See Theory.
object space
  The object space (often abbreviated to "objspace") creates all objects and knows how to perform operations on the objects. You may think of an object space as being a library offering a fixed API, a set of operations, with implementations that a) correspond to the known semantics of Python objects, b) extend or twist these semantics, or c) serve whole-program analysis purposes.

ootypesystem
  An object oriented type model containing classes and instances. A backend that uses this type system is also called a high-level backend. The common lisp, javascript and cli backends all use this typesystem.

prebuilt constant
  In RPython module globals are considered constants. Moreover, global (i.e. prebuilt) lists and dictionaries are supposed to be immutable ("prebuilt constant" is sometimes abbreviated to "pbc").

promotion
  JIT terminology. promotion is a way of "using" a run-time value at compile-time, essentially by deferring compilation until the run-time value is known. See if the jit docs help.
rpython
  Restricted Python, a limited subset of the Python language. The limitations make type inference possible. It is also the language that the PyPy interpreter itself is written in.

rtyper
  Based on the type annotations, the RPython Typer turns the flow graph into one that fits the model of the target platform/backend using either the lltypesystem or the ootypesystem.

run-time
  In the context of the JIT, run time is when the code the JIT has generated is executing.

specialization
  A way of controlling how a specific function is handled by the annotator. One specialization is to treat calls to a function with different argument types as if they were calls to different functions with identical source.

stackless
  Technology that enables various forms of non conventional control flow, such as coroutines, greenlets and tasklets. Inspired by Christian Tismer's Stackless Python.

standard interpreter
  It is the subsystem implementing the Python language, composed of the bytecode interpreter and of the standard objectspace.

timeshifting
  JIT terminology. timeshifting is to do with moving from the world where there are only run-time operations to a world where there are both run-time and compile-time operations.
toolchain
  The annotator pass, The RPython Typer, and various backends.

transformation
  Code that modifies flowgraphs to weave in translation-aspects

translation-time
  In the context of the JIT, translation time is when the PyPy source is being analysed and the JIT itself is being created.

translator
  Tool based on the PyPy interpreter which can translate sufficiently static Python programs into low-level code.

type system
  The RTyper can target either the lltypesystem or the ootypesystem.

type inference
  Deduces either partially or fully the type of expressions as described in this type inference article on Wikipedia. PyPy's tool-chain own flavour of type inference is described in the annotator pass section.