apply textual suggestions to standalone module documentation

Author: timfel

docs/user/PythonStandaloneBinaries.md

@@ -6,51 +6,54 @@ permalink: /reference-manual/python/standalone-binaries/
 ---
 # Standalone Applications with Python
 
-It can be desirable to distribute Python applications or libraries as standalone binaries or JAR files without any external dependencies.
-The Truffle framework that GraalPy is built on and the Sulong LLVM runtime that GraalPy can leverage for managed execution of Python's native extensions allow us to completely virtualize all filesystem accesses of Python programs, including those to the standard library and installed packages.
+With GraalVM Python implementation (GraalPy), you can distribute Python applications or libraries as standalone binaries or JAR files without any external dependencies.
+The [Truffle framework](https://github.com/oracle/graal/tree/master/truffle) that GraalPy is built on, and the [Sulong LLVM runtime](https://github.com/oracle/graal/tree/master/sulong) that GraalPy leverages for managed execution of Python's native extensions enables users to completely virtualize all filesystem accesses of Python programs, including those to the standard library and installed packages.
 
 GraalPy comes with a module that can create standalone binaries or Java project skeletons.
-The binaries simply bundle everything into one native image.
+The binaries bundle everything into one native executable.
 The Java skeletons are set up with Maven to build and run self-contained JAR files.
-They can also be used to generate a standalone binaries from those JARs later, so the Java skeletons offer more flexibility and control over the steps.
+They can also be used to generate a standalone binary from those JARs later, so Java skeletons offer more flexibility and control over the steps.
+
+### Prerequisite
+
+Set `JAVA_HOME` to use a GraalVM distribution.
 
 ## Creating GraalPy Binaries
 
-Suppose we have a simple Python script `my_script.py` that does some useful work when run directly.
-If we wanted to distribute it as a standalone native image, we run the following command:
+Suppose there is a simple Python script, `my_script.py`, that does some useful work when run directly.
+To distribute it as a standalone native binary, run the following command:
 
 ```
-$ graalpy -m standalone binary --module my_script.py --output my_binary
+graalpy -m standalone binary --module my_script.py --output my_binary
 ```
 
-This will generate a standalone `my_binary` file which includes the Python code, the GraalPy runtime, and the Python standard library in a single, self-contained executable.
+It generates a standalone `my_binary` file which includes the Python code, the GraalPy runtime, and the Python standard library in a single, self-contained executable.
 Use `graalpy -m standalone binary --help` for further options.
 
-## Embedding GraalPy in Java Applications
+## Embedding GraalPy in a Java Application
 
-Suppose now we wanted to distribute our `my_script.py` script as a JAR that can run on any GraalVM that includes GraalPy.
-To prepare such a Java project, the `standalone` GraalPy tool has another command:
+You can distribute the Python script as a JAR file that runs on GraalVM and includes GraalPy.
+To achieve this, run the `java` subcommand of GraalPy's `standalone` module:
 
 ```
-$ graalpy -m standalone java --output-directory MyJavaApplication --module my_script
+graalpy -m standalone java --output-directory MyJavaApplication --module my_script.py
 ```
 
-The target folder `MyJavaApplication` includes a `pom.xml` that makes it easy to generate a JAR or a GraalVM native image with Maven.
+It creates a Java project _MyJavaApplication_. It includes a `pom.xml` that makes it easy to generate a JAR or a GraalVM native executable with Maven.
 You can open this Maven project with any Java IDE and edit the main class that was created to modify the Python embedding.
-To build, you can use either `mvn -Pjar package` to create a JAR, or `mvn -Pnative package` to create a GraalVM native image.
-For both, make sure to set your `JAVA_HOME` to use a GraalVM distribution.
+To build the application, either `mvn -Pjar package` to create a JAR file, or `mvn -Pnative package` to create a GraalVM native executable.
 
 Take a look at the generated `pom.xml`.
 There are some options to tweak the performance and footprint trade-off.
-Review also our general documentation on Python native images to find out how to remove other unwanted components and further reduce the binary size.
+Review the [Python Native Images documentation](PythonNativeImages.md) to find out how to remove other unwanted components and further reduce the binary size.
 
 The generated project should be viewed as a starting point.
 It includes the entire Python standard library, so the Python code can invoke all of the standard library code.
 The resources can be manually pruned to reduce the included Python libraries to the necessary amount, reducing both the size of the package and the time to start up.
-The Java code demonstrates some useful default options for the Python context, but other settings may be desirable to further control what the Python code is allowed to do.
+This Java example demonstrates some useful default options for the Python context, but other settings may be desirable to further control what the Python code is allowed to do.
 
-## Security considerations
+## Security Considerations
 
-Creating a native image or a JAR that includes the Python code could be seen as a mild form of obfuscation, but it does not protect your source code.
+Creating a native executable or a JAR that includes the Python code could be seen as a mild form of obfuscation, but it does not protect your source code.
 While the Python sources are not stored verbatim into the image (only the GraalPy bytecode is), that bytecode is easy to convert back into Python sources.
-If stronger protection for the included Python source code is required, this needs to be handled by a means of e.g. encryption of the resources before building the native image, and adding approproate decryption into the generated virtual file system.
+If stronger protection for the included Python source code is required, consider, for example, encryption of the resources before building the native executable, and adding appropriate decryption into the generated virtual file system.

graalpython/lib-graalpython/modules/standalone/pom.xml

@@ -128,14 +128,14 @@
                 <buildArg>-H:-CopyLanguageResources</buildArg>
                 <buildArg>--initialize-at-build-time=Py2BinLauncher$JarFileSystem</buildArg>
               </buildArgs>
-              <!-- Remove the properties below to include the Python JIT compier -->
+              <!-- Remove the properties below to include the Python JIT compiler -->
               <jvmArgs>
                 <arg>-Dtruffle.TruffleRuntime=com.oracle.truffle.api.impl.DefaultTruffleRuntime</arg>
                 <arg>-Dpolyglot.engine.WarnInterpreterOnly=false</arg>
               </jvmArgs>
               <!-- Flip the property below for verbose or quiet image build -->
               <verbose>true</verbose>
-              <!-- Flip the property below to include debug symbols for the image -->
+              <!-- Flip the property below to include debug symbols in the native executable -->
               <debug>false</debug>
             </configuration>
           </plugin>