[GR-57679] Use Espresso project name instead of Java on Truffle.

PullRequest: graal/18692

Author: olyagpl

docs/reference-manual/java-on-truffle/Demos.md

@@ -2,14 +2,15 @@
 layout: docs
 toc_group: espresso
 link_title: Demo Applications
-permalink: /reference-manual/java-on-truffle/demos/
+permalink: /reference-manual/espresso/demos/
+redirect_from: /reference-manual/java-on-truffle/demos/
 ---
 
 # Running Demo Applications
 
-Java on Truffle is an implementation of the Java Virtual Machine Specification, which offers some interesting capabilities in addition to being able to run applications in Java or other JVM languages.
+Espresso is an implementation of the Java Virtual Machine Specification, which offers some interesting capabilities in addition to being able to run applications in Java or other JVM languages.
 For example, the enhanced [HotSwap capabilities](HotSwap.md) boosts developer productivity by enabling unlimited hot code reloading.
-Moreover, to illustrate what Java on Truffle can do, consider the following short examples.
+Moreover, to illustrate what Espresso can do, consider the following short examples.
 
 ## Mixing AOT and JIT for Java
 
@@ -21,46 +22,45 @@ GraalVM Native Image technology allows compiling applications ahead-of-time (AOT
 The main trade off for using Native Image is that the analysis and compilation of your program happens under the closed world assumption, meaning the static analysis needs to process all bytecode which will ever be executed in the application.
 This makes using some language features such as dynamic class loading or reflection tricky.
 
-Java on Truffle is a JVM implementation of a JVM bytecode interpreter, built on the [Truffle framework](../../../truffle/docs/README.md).
+Espresso is a JVM implementation of a JVM bytecode interpreter, built on the [Truffle framework](../../../truffle/docs/README.md).
 It is essentially a Java application, as are the Truffle framework itself and the GraalVM JIT compiler.
 All three of them can be compiled ahead-of-time with `native-image`.
-Using Java on Truffle for some parts of your application makes it possible to isolate the required dynamic behavior and still use the native executable on the rest of your code.
+Using Espresso for some parts of your application makes it possible to isolate the required dynamic behavior and still use the native executable on the rest of your code.
 
 Consider a canonical Java Shell tool (JShell) as an example command line application.
 It is a REPL capable of evaluating Java code and consists of two parts:
 * the UI - CLI app handling input-output
 * the backend processor for running code you enter into Shell.
 
-This design naturally fits the point we are trying to illustrate. We can build a native executable of the JShell's UI part, and make it include Java on Truffle to run the code dynamically specified at run time.
+This design naturally fits the point we are trying to illustrate. We can build a native executable of the JShell's UI part, and make it include Espresso to run the code dynamically specified at run time.
 
-Prerequisites:
-* [Latest GraalVM](https://www.graalvm.org/downloads/)
-* [Java on Truffle](README.md#getting-started)
+#### Prerequisites:
+* [GraalVM JDK](https://www.graalvm.org/downloads/)
+* [Espresso](README.md#getting-started)
 
-1. Clone the [project](https://github.com/graalvm/graalvm-demos) with the demo applications and navigate to the `espresso-jshell` directory:
-
-```
+Clone the [project](https://github.com/graalvm/graalvm-demos) with the demo applications and navigate to the `espresso-jshell` directory:
+```shell
 git clone https://github.com/graalvm/graalvm-demos.git
 cd graalvm-demos/espresso-jshell
 ```
 
-The JShell implementation is actually the normal JShell launcher code, which only accepts Java on Truffle implementation (the project code-name is "Espresso") of the execution engine.
+The JShell implementation is actually the normal JShell launcher code, which only accepts Espresso implementation of the execution engine.
 
 The "glue" code that binds the part which is AOT compiled with the component that dynamically evaluates the code is located in the `EspressoExecutionControl` class.
-It loads the JShell classes within the Java on Truffle context and delegate the input to them:
+It loads the JShell classes within the Espresso context and delegate the input to them:
 
-```
-    protected final Lazy<Value> ClassBytecodes = Lazy.of(() -> loadClass("jdk.jshell.spi.ExecutionControl$ClassBytecodes"));
-    protected final Lazy<Value> byte_array = Lazy.of(() -> loadClass("[B"));
-    protected final Lazy<Value> ExecutionControlException = Lazy.of(() -> loadClass("jdk.jshell.spi.ExecutionControl$ExecutionControlException"));
-    protected final Lazy<Value> RunException = Lazy.of(() -> loadClass("jdk.jshell.spi.ExecutionControl$RunException"));
-    protected final Lazy<Value> ClassInstallException = Lazy.of(() -> loadClass("jdk.jshell.spi.ExecutionControl$ClassInstallException"));
-    protected final Lazy<Value> NotImplementedException = Lazy.of(() -> loadClass("jdk.jshell.spi.ExecutionControl$NotImplementedException"));
-    protected final Lazy<Value> EngineTerminationException = Lazy.of(() -> loadClass("jdk.jshell.spi.ExecutionControl$EngineTerminationException"));
-    protected final Lazy<Value> InternalException = Lazy.of(() -> loadClass("jdk.jshell.spi.ExecutionControl$InternalException"));
-    protected final Lazy<Value> ResolutionException = Lazy.of(() -> loadClass("jdk.jshell.spi.ExecutionControl$ResolutionException"));
-    protected final Lazy<Value> StoppedException = Lazy.of(() -> loadClass("jdk.jshell.spi.ExecutionControl$StoppedException"));
-    protected final Lazy<Value> UserException = Lazy.of(() -> loadClass("jdk.jshell.spi.ExecutionControl$UserException"));
+```shell
+protected final Lazy<Value> ClassBytecodes = Lazy.of(() -> loadClass("jdk.jshell.spi.ExecutionControl$ClassBytecodes"));
+protected final Lazy<Value> byte_array = Lazy.of(() -> loadClass("[B"));
+protected final Lazy<Value> ExecutionControlException = Lazy.of(() -> loadClass("jdk.jshell.spi.ExecutionControl$ExecutionControlException"));
+protected final Lazy<Value> RunException = Lazy.of(() -> loadClass("jdk.jshell.spi.ExecutionControl$RunException"));
+protected final Lazy<Value> ClassInstallException = Lazy.of(() -> loadClass("jdk.jshell.spi.ExecutionControl$ClassInstallException"));
+protected final Lazy<Value> NotImplementedException = Lazy.of(() -> loadClass("jdk.jshell.spi.ExecutionControl$NotImplementedException"));
+protected final Lazy<Value> EngineTerminationException = Lazy.of(() -> loadClass("jdk.jshell.spi.ExecutionControl$EngineTerminationException"));
+protected final Lazy<Value> InternalException = Lazy.of(() -> loadClass("jdk.jshell.spi.ExecutionControl$InternalException"));
+protected final Lazy<Value> ResolutionException = Lazy.of(() -> loadClass("jdk.jshell.spi.ExecutionControl$ResolutionException"));
+protected final Lazy<Value> StoppedException = Lazy.of(() -> loadClass("jdk.jshell.spi.ExecutionControl$StoppedException"));
+protected final Lazy<Value> UserException = Lazy.of(() -> loadClass("jdk.jshell.spi.ExecutionControl$UserException"));
 ```
 
 There is more code to pass the values correctly and transform the exceptions.
@@ -69,7 +69,7 @@ To try it out, build the `espresso-jshell` binary using the provided script, whi
 2. Build the JAR file
 3. Build a native executable
 
-After the build you can observe the resulting binary file (`file` and `ldd` are Linux commands)
+After the build you can observe the resulting binary file (`file` and `ldd` are Linux commands):
 ```shell
 file ./espresso-jshell
 ldd ./espresso-jshell
@@ -85,9 +85,9 @@ jshell> 1 + 1
 1 ==> 2
 ```
 
-Experiment with loading new code into JShell and see how Java on Truffle executes it.
+Experiment with loading new code into JShell and see how Espresso executes it.
 
-Watch a video version of the mixing AOT and JIT compiled code with Java on Truffle demo.
+Watch a video version of the mixing AOT and JIT compiled code with the Espresso demo.
 
 <div class="row">
   <div class="col-sm-12">
@@ -109,14 +109,14 @@ Watch a video version of the mixing AOT and JIT compiled code with Java on Truff
 <br>
 
 
-## GraalVM Tools with Java on Truffle
+## GraalVM Tools with Espresso
 
-Java on Truffle is a proper part of the GraalVM ecosystem, and like other GraalVM-supported languages gets the support of developer tooling by default. The [Truffle framework](/graalvm-as-a-platform/language-implementation-framework/) integrates with the tools such as the debugger, profiler, memory analyzer, the [Instrumentation API](https://www.graalvm.org/truffle/javadoc/com/oracle/truffle/api/instrumentation/TruffleInstrument.html).
+Espresso is a proper part of the GraalVM ecosystem, and like other GraalVM-supported languages gets the support of developer tooling by default. The [Truffle framework](/graalvm-as-a-platform/language-implementation-framework/) integrates with the tools such as the debugger, profiler, memory analyzer, the [Instrumentation API](https://www.graalvm.org/truffle/javadoc/com/oracle/truffle/api/instrumentation/TruffleInstrument.html).
 The interpreter for a language needs to mark the AST nodes with some annotations to support those tools.
 
 For example, to be able to use a profiler, a language interpreter needs to mark the root nodes.
 For the debugger purposes, the language expressions should be marked as instrumental, the scopes for the variables specified, and so on. The language interpreter does not need to integrate with the tools itself.
-As a result, you can profile a Java on Truffle program out of the box using either the CPU Sampler or Memory Tracer tools.
+As a result, you can profile a Java application on Espresso out of the box using either the CPU Sampler or Memory Tracer tools.
 
 For example, if we have a class like the following one computing the prime numbers:
 ```java
@@ -168,9 +168,9 @@ java -truffle --experimental-options --memtracer Main > output.txt
 
 Other tools that GraalVM offers are [Chrome Debugger](../../tools/chrome-debugger.md), [Code Coverage](../../tools/code-coverage.md), and [GraalVM Insight](../../tools/insight/README.md).
 
-Having the "out-of-the-box" support for the developer tooling makes Java on Truffle an interesting choice of the JVM.
+Having the "out-of-the-box" support for the developer tooling makes Espresso an interesting choice of the JVM.
 
-Watch a short demonstration of GraalVM built-in tools for Java on Truffle.
+Watch a short demonstration of GraalVM built-in tools for Espresso.
 
 <div class="row">
   <div class="col-sm-12">

docs/reference-manual/java-on-truffle/FAQ.md

@@ -2,46 +2,54 @@
 layout: docs
 toc_group: espresso
 link_title: FAQ
-permalink: /reference-manual/java-on-truffle/faq/
+permalink: /reference-manual/espresso/faq/
+redirect_from: /reference-manual/java-on-truffle/faq/
 ---
 
 # Frequently Asked Questions
 
 ### Does Java running on Truffle implement the Java language running as a Truffle interpreter?
 
 Not quite: it implements the Java Virtual Machine running as a Truffle interpreter.
-That means it can only run a Java program once it has been compiled to Java bytecode (classes, JAR files, etc.) with your favorite Java compiler (for example, `javac`) or a build tool (Maven, Gradle, etc.).
+That means it can only run a Java program once it has been compiled to Java bytecode (classes, JAR files, and so on) with your favorite Java compiler (for example, `javac`) or a build tool (Maven, Gradle, and so on).
 In the GraalVM family, this is similar to WebAssembly or the LLVM interpreter: while both can run C programs, they have to be compiled by a C compiler first.
 
 ### Does Java running on Truffle run on the HotSpot JVM too?
-Like other languages implemented with the [Truffle framework](../../../truffle/docs/README.md), it can run both as a native executable or on top of the HotSpot JVM.
-Running on top of the HotSpot JVM is currently only possible on Linux x64 and macOS x64.
+
+Like other languages implemented with the [Truffle framework](../../../truffle/docs/README.md), it can run both as a native executable or on the HotSpot JVM.
+Running on the HotSpot JVM is currently only possible on Linux x64 and macOS x64.
 We plan to extend this capability to other platforms.
 
-### Does running Java on Truffle require the HotSpot JVM?
+### Does running Espresso require the HotSpot JVM?
 
 No, it doesn't, it works fine as a native executable.
-Java on Truffle does require a standard core Java library (the _rt.jar_ library for Java 8 or the `lib/modules` file for Java 11+ as well as the associated native libraries: `libjava`, `libnio`, etc.).
+Espresso does require a standard core Java library (the _rt.jar_ library for Java 8 or the `lib/modules` file for Java 11+, as well as the associated native libraries: `libjava`, `libnio`, and so on).
+
+### Running Java on GraalVM already brings the highest level of optimization, what benefits will Espresso give me?
 
-### Running Java on GraalVM already brings the highest level of optimization, what benefits will Java on Truffle give me?
-- Java on Truffle will inherit the extensive tooling provided by the Truffle framework. This means that for the things like code coverage and profiling you would no longer need to rely on external tools.
-- Another important aspect is that Java on Truffle comes with improved isolation of the host Java VM and the Java program running on Truffle.
-- Moreover, Java on Truffle can run in the context of a native executable while still allowing dynamically-loaded bytecode!
+- Espresso inherits the extensive tooling provided by the Truffle framework. This means that for code coverage and profiling you would no longer need to rely on external tools.
+- Another important aspect is that Espresso comes with improved isolation of the host Java VM and the Java program running on Truffle.
+- Moreover, Espresso can run in the context of a native executable while still allowing dynamically-loaded bytecode!
 - Finally, you can enjoy the benefits of enhanced HotSwap capabilities which will help boost your productivity.
 
-### What is the license for Java on Truffle?
-Java on Truffle is an implementation of the Java Virtual Machine. It is open source and is offered as free software under the [GNU General Public License version two (GPLv2)](https://github.com/oracle/graal/blob/master/tools/LICENSE).
+### What is the license for Espresso?
+
+Espresso is an implementation of the Java Virtual Machine. It is open source and is offered as free software under the [GNU General Public License version two (GPLv2)](https://github.com/oracle/graal/blob/master/tools/LICENSE).
+
+### Can I run Espresso in production?
 
-### Can I run Java on Truffle in production?
 Yes, you can on Linux x64. Support for other platforms is still experimental.
 
-### What performance can I expect from executing Java on Truffle?
+### What performance can I expect from executing Espresso?
+
 Performance is currently 2-3x slower than the HotSpot JVM.
-It does not match the speed offered by GraalVM yet for sure, but having created a fully-working Java on Truffle runtime, the development team is now focusing on making it as performant as the GraalVM JIT.
+It does not match the speed offered by GraalVM yet for sure, but having created a fully-working Espresso runtime, the development team is now focusing on making it as performant as the GraalVM JIT.
 
 ### Can I embed Java running on Truffle in my application?
+
 Yes, you can use [GraalVM's Polyglot API](https://www.graalvm.org/sdk/javadoc/org/graalvm/polyglot/package-summary.html) to run Java bytecode in a separate context from the host Java VM.
-You can even embed a Java 8 context in a Java 11, 17 or 21 application (using the option `--java.JavaHome=/path/to/jdk8`).
+You can even embed a Java 8 context in a Java 11, 17, or 21 application (using the option `--java.JavaHome=/path/to/jdk8`).
 
 ### Why do I see "Unrecognized option: -javaagent:.../idea_rt.jar..." when I try to run my app from the IDE?
-It is not possible to attach an agent to Java on Truffle. For the time being, add: `-XX:+IgnoreUnrecognizedVMOptions` to the VM options too.
+
+It is not possible to attach an agent to Espresso. For the time being, add `-XX:+IgnoreUnrecognizedVMOptions` to the VM options.