Implementation -> Runtime

Author: olyagpl

docs/user/FAQ.md

@@ -3,19 +3,19 @@
 ### Does module/package XYZ work on GraalVM's Python runtime?
 
 It depends, but is currently unlikely.
-The first goal with GraalVM's Python implementation was to show that NumPy and related packages can run using the managed GraalVM LLVM runtime.
+The first goal with GraalVM's Python runtime was to show that NumPy and related packages can run using the managed GraalVM LLVM runtime.
 The GraalVM team continues to improve the number of passing CPython unittests, and to track the compatibility with popular PyPI packages.
 
-### Can the GraalVM Python implementation replace my Jython use case?
+### Can the GraalVM Python runtime replace my Jython use case?
 
 It can, but there are some caveats, like Python code subclassing Java classes or use through the `javax.script.ScriptEngine` not being supported.
 See the [Jython Compatibility](Jython.md) guide for details.
 
 ### Do I need to compile and run native modules as LLVM bitcode to use on GraalVM's Python runtime?
 
-If you want to run C extensions or use certain built-in features, yes, you need to build the module with GraalVM's Python implementation, and then it will run using the GraalVM LLVM runtime.
+If you want to run C extensions or use certain built-in features, yes, you need to build the module with GraalVM's Python runtime, and then it will run using the GraalVM LLVM runtime.
 However, many of the core features of Python (including, e.g., large parts of the `os` API) are implemented in pure Java and many standard library modules and packages work without running any LLVM bitcode.
-So even though the Python implementation depends on the GraalVM LLVM runtime, for many use cases
+So even though the Python runtime depends on the GraalVM LLVM runtime, for many use cases
 you can disallow native modules entirely.
 
 ### Can I use the GraalVM sandboxing features with Python?
@@ -29,7 +29,7 @@ Also, GraalVM's managed execution mode for LLVM fully works for running extensio
 
 The team is continuously working to ensure all polyglot features of GraalVM work as a Python user would expect.
 There are still many cases where expectations are unclear or where multiple behaviors are imaginable.
-The team is actively looking at use cases and continuously evolving the Python implementation to provide the most
+The team is actively looking at use cases and continuously evolving the GraalVM Python runtime to provide the most
 convenient and least surprising behaviour.
 
 ### What performance can I expect from GraalVM's Python runtime?
@@ -45,5 +45,5 @@ In any case, both with Native Image or when running on the JVM, you first need t
 
 ### Can I share warmed-up code between multiple Python contexts?
 
-Yes, this works, and you will find that starting up multiple contexts in the same engine, and running the same or similar code in them will get increasingly faster, because the compiled code is shared across contexts. 
+Yes, this works, and you will find that starting up multiple contexts in the same engine, and running the same or similar code in them will get increasingly faster, because the compiled code is shared across contexts.
 However, the peak performance in this setup is currently lower than in the single context case.

docs/user/Jython.md

@@ -59,7 +59,7 @@ methods:
 Method overloads are resolved by matching the Python arguments in a best-effort manner to the available parameter types.
 This also happens during when data conversion.
 The goal here is to make using Java from Python as smooth as possible.
-The matching allowed here is similar to Jython, but GraalVM's Python implementation uses a more dynamic approach to matching — Python types emulating `int` or `float` are also converted to the appropriate Java types.
+The matching allowed here is similar to Jython, but GraalVM's Python runtime uses a more dynamic approach to matching — Python types emulating `int` or `float` are also converted to the appropriate Java types.
 This allows, for example, to use Pandas frames as `double[][]` or NumPy array elements as `int[]` when the elements fit into those Java primitive types.
 
 | Java type              | Python type                                                                       |

docs/user/ParserDetails.md

@@ -28,7 +28,7 @@ the SST and scope tree are serialized such a file.
 
 ## Creating and Managing pyc Files
 
-#### `.pyc` files are created automatically by the GraalVM Python implementation when no or an invalid `.pyc` file is found matching the desired `.py` file.
+#### `.pyc` files are created automatically by the GraalVM Python runtime when no or an invalid `.pyc` file is found matching the desired `.py` file.
 
 When a Python source file (module) is imported during an execution for the first time, the appropriate `.pyc` file is created automatically.
 If the same module is imported again, then the already created `.pyc` file is used.
@@ -42,14 +42,14 @@ The hashcode is generated only based on the Python source by calling `source.has
 The `.pyc` files are also regenerated if a magic number in the Python parser is changed.
 The magic number is hard-coded in the Python source and can not be changed by the user (unless of course that user has access to the bytecode of Python).
 
-The developers of GraalVM's Python implementation change the magic number when the format of SST or scope tree binary data is altered.
-This is an implementation detail, so the magic number does not have to correspond to the version of GraalVM's Python implementation (just like in CPython).
-The magic number of pyc is a function of the concrete Python implementation Java code that is running.
+The developers of GraalVM's Python runtime change the magic number when the format of SST or scope tree binary data is altered.
+This is an implementation detail, so the magic number does not have to correspond to the version of GraalVM's Python runtime (just like in CPython).
+The magic number of pyc is a function of the concrete Python runtime Java code that is running.
 
 Note that if you use `.pyc` files, you will need to allow write-access to GraalVM's Python runtime at least when switching versions or changing the original source code.
 Otherwise, the regeneration of source files will fail and every import will have the overhead of accessing the old `.pyc` file, parsing the code, serializing it, and trying (and failing) to write out a new `.pyc` file.
 
-A `*.pyc` file is never deleted by GraalVM's Python implementation, only regenerated.
+A `*.pyc` file is never deleted by GraalVM's Python runtime, only regenerated.
 It is regenerated when the appropriate source file is changed (timestamp of last modification or hashcode of the content) or the magic number of the Python imnplementation parser changes.
 Magic number changes will be communicated in the release notes so that embedders or system administrators can delete old `.pyc` files when upgrading.
 
@@ -123,7 +123,7 @@ these language options:
 Note that a Python context will not enable writing `.pyc` files by default.
 The `graalpython` launcher enables it by default, but if this is desired in the embedding use case, care should be taken to ensure that the `__pycache__` location is properly managed and the files in that location are secured against manipulation just like the source `.py` files they were derived from.
 
-Note also that to upgrade the application sources to GraalVM Enteprise's Python implementation, old `.pyc`
+Note also that to upgrade the application sources to GraalVM Enteprise's Python runtime, old `.pyc`
 files must be removed by the embedder as required.
 
 ## Security Considerations

docs/user/README.md

@@ -1,8 +1,8 @@
-# GraalVM Python Implementation
+# GraalVM Python Runtime
 
 GraalVM provides a Python 3.8 compliant runtime.
-A primary goal of the Python implementation is to support SciPy and its constituent libraries, as well as to work with other data science and machine learning libraries from the rich Python ecosystem.
-At this point, the Python implementation is made available for experimentation and curious end-users.
+A primary goal of the GraalVM Python runtime is to support SciPy and its constituent libraries, as well as to work with other data science and machine learning libraries from the rich Python ecosystem.
+At this point, the Python runtime is made available for experimentation and curious end-users.
 See [FAQ](FAQ.md) for commonly asked questions about this implementation.
 
 ## Installing Python
@@ -25,15 +25,15 @@ graalpython [options] [-c cmd | filename]
 
 If no program file or command is given, you are dropped into a simple REPL.
 
-GraalVM supports some of the same options as Python 3.8 as well as some additional options to control the underlying Python implementation, GraalVM's tools, and the execution engine.
+GraalVM supports some of the same options as Python 3.8 as well as some additional options to control the underlying Python runtime, GraalVM's tools, and the execution engine.
 These can be viewed using the following command:
 ```shell
 graalpython --help --help:tools --help:languages
 ```
 
 ## Installing Supported Packages
 
-GraalVM Python implementation comes with a tool called `ginstall` which may be used to install a small list of packages known to work to some extent with GraalVM's Python runtime.
+GraalVM Python runtime comes with a tool called `ginstall` which may be used to install a small list of packages known to work to some extent with GraalVM's Python runtime.
 It is recommended to always create a virtual environment first, using the standard Python module `venv`.
 Creating such an environment avoids any incompatible interaction with the local user's packages that may have been
 installed using a system installation of CPython:

docs/user/Tooling.md

@@ -1,6 +1,6 @@
 # Tooling Support for Python
 
-GraalVM's Python implementation is incomplete and cannot launch the standard Python debugger `pdb`.
+GraalVM's Python runtime is incomplete and cannot launch the standard Python debugger `pdb`.
 However, it can run the tools that GraalVM provides.
 The `graalpython --help:tools` command will give you more information about tools currently supported on Python.