Exécution De Programmes Mono-Fichier Sans Compilation en Java 11

Pourquoi a t-on besoin de ça ?

Si vous vous souvenez de l'ancien temps juste avant Java SE 11 (JDK 11), supposons que vous disposiez d'un fichier source HelloUniverse.java contenant la définition d'une classe et d'une méthode main statique qui affiche une ligne de texte unique sur le terminal, comme suit :

public class HelloUniverse{
      public static void main(String[] args) { 
            System.out.println("Hello InfoQ Universe");
      }
}

Normalement, pour exécuter cette classe, vous devez d'abord la compiler à l'aide d'un compilateur Java (javac), ce qui donne un fichier HelloUniverse.class : 

mohamed_taman$ javac HelloUniverse.java

Ensuite, vous utilisez une commande java pour exécuter le fichier de classe résultant dans une machine virtuelle Java (interpréteur) :

mohamed_taman$ java HelloUniverse
Hello InfoQ Universe

Cela démarre la machine virtuelle Java, charge la classe et exécute le code.

Mais que se passe-t-il si vous voulez tester rapidement un morceau de code ou si vous débutez dans l'apprentissage de Java (la clé ici) et souhaitez expérimenter le langage ? Ces deux étapes du processus peuvent sembler un peu lourdes.
Dans Java SE 11, vous avez la possibilité de lancer directement un fichier unique de code source, sans compilation intermédiaire.

Cette fonctionnalité est particulièrement utile pour les débutants dans le language qui souhaitent essayer des programmes simples. Lorsque vous combinez cette fonctionnalité avec jshell, vous obtenez un ensemble d'outils d'apprentissage pour les débutants.

Pour plus d'informations sur le nouveau Jshell 10+, consultez mon cours vidéo "Hands-on Java 10 Programming with JShell".

Les professionnels peuvent également utiliser ces outils pour explorer de nouveaux changements dans le language ou pour essayer une API inconnue. À mon avis, une plus grande puissance vient lorsque nous pouvons automatiser de nombreuses tâches, telles que l'écriture de programmes Java sous forme de scripts, puis leur exécution à partir du shell du système d'exploitation. Cette combinaison nous donne la flexibilité des scripts shell mais avec la puissance du langage Java. Nous explorerons cela plus en détail dans la seconde moitié de l'article.

Cette fonctionnalité intéressante de Java 11 vous permet d'exécuter un code source Java dans un fichier unique directement sans aucune compilation. Alors maintenant, plongeons-nous dans les détails et des sujets connexes intéressants.

Ce que vous devrez suivre

Pour exécuter toutes les exemples fournis dans cet article, vous devez utiliser une version récente de Java. Ce devrait être Java 11 ou plus. La version actuelle est le Java SE Development Kit 12.0.1. La version finale est disponible à partir de ce lien. Il vous suffit d'accepter la licence et de cliquer sur le lien correspondant à votre système d'exploitation. Si vous souhaitez explorer des fonctionnalités plus récentes, le dernier JDK 13 early access est le plus récent, et vous pouvez le télécharger à partir de ce lien.

Vous devez également noter que les versions d'OpenJDK sont désormais également disponibles auprès d'Oracle, ainsi que d'autres fournisseurs, y compris AdoptOpenJDK.

Dans cet article, nous utilisons un éditeur de texte brut plutôt qu'un IDE Java, car nous souhaitons éviter toute magie de l'IDE et utiliser la ligne de commande Java directement dans un terminal.

Exécuter un fichier .java avec java

JEP 330 , Launch Single-File Source-Code Programs, est l'une des nouvelles fonctionnalités introduites dans la version 11 du JDK. Cette fonctionnalité vous permet d'exécuter un fichier contenant du code source Java directement à l'aide de l'interpréteur java. Le code source est compilé en mémoire puis exécuté par l'interpréteur, sans produire de fichier .class sur le disque.

Cependant, cette fonctionnalité est limitée au code qui réside dans un seul fichier source. Vous ne pouvez pas ajouter de fichiers source supplémentaires à compiler lors de la même exécution.

Pour contourner cette limitation, toutes les classes doivent être définies dans le même fichier, mais il n'y a aucune restriction quant au nombre de classes dans le fichier, qu'elles soient toutes des classes publiques ou non, cela n'a pas d'importance tant qu'elles sont dans le même fichier source.

La première classe déclarée dans le fichier source sera récupérée pour être utilisée comme classe principale, et nous devrions placer notre méthode main dans cette classe. Donc, l'ordre compte.

Un premier exemple

Commençons maintenant comme nous le faisons chaque fois que nous commençons à apprendre quelque chose de nouveau - oui, exactement comme vous l'avez deviné - avec l'exemple le plus simple : Hello Universe!

Nous concentrerons nos efforts sur la démonstration de l'utilisation de cette fonctionnalité en essayant différents exemples afin que vous ayez une idée de la façon dont elle peut être utilisée dans le codage quotidien.

Si vous ne l'avez pas encore fait, créez le fichier HelloUniverse.java tel qu'il est fourni en haut de l'article, compilez-le et exécutez le fichier .class obtenu.

Maintenant, je veux que vous supprimiez le fichier .class; vous comprendrez pourquoi dans un instant :

mohamed_taman$ rm HelloUniverse.class

Maintenant, si vous exécutez la classe uniquement avec l'interpréteur Java, sans compilation, comme dans :

mohamed_taman$ java HelloUniverse.java
Hello InfoQ Universe

Vous devriez voir le même résultat qu'auparavant - il fonctionne.

Cela signifie que nous pouvons maintenant juste utiliser java HelloUniverse.java. Nous ne faisons que transmettre le code source plutôt que le fichier .class : il compile le code source en interne, puis exécute le code compilé obtenu et, finalement, le message est envoyé à la console.

Donc, il y a toujours un processus de compilation qui est réalisé et s'il y a une erreur de compilation, vous recevrez toujours une notification d'erreur. De plus, vous pouvez vérifier la structure des répertoires et voir qu'il n'y a pas de fichier .class généré ; c'est un processus de compilation en mémoire.

Voyons maintenant comment cette magie opère.

Comment l'interpréteur Java exécute le programme HelloUniverse

A partir de JDK 10, le lanceur Java fonctionne selon trois modes :

1. Exécuter un fichier class
2. Exécution de la classe principale d'un fichier JAR
3. Exécuter la classe principale d'un module

Maintenant en Java 11, un nouveau quatrième mode nommé source-file a été ajouté

4. Exécuter une classe déclarée dans un fichier source.

En mode source-file, le fichier source est compilé en mémoire et la première classe trouvée dans le fichier source est exécutée.

La décision de passer en mode source-file est déterminée par deux éléments de la ligne de commande :

1. Le premier élément de la ligne de commande qui n'est ni une option ni une partie d'une option.
2. L'option --source <version>, si présente.

Dans le premier cas, la commande Java examinera le premier élément de la ligne de commande qui n'est ni une option ni une partie d'une option. S'il s'agit d'un nom de fichier qui se termine par .java, il sera traité comme un fichier source Java à compiler et à exécuter. Vous pouvez toujours fournir des options à la commande Java avant le nom du fichier source. Par exemple, si vous souhaitez définir un chemin d'accès aux classes lorsque le fichier source utilise des dépendances externes.

Dans le second cas, le mode source-file est sélectionné et le premier élément de la ligne de commande qui n'est pas une option sera traité comme un fichier source à compiler et à exécuter. 

Si le fichier ne possède pas l'extension .java, l'option --source doit être utilisée pour forcer le mode source-file.
Cela est nécessaire dans les cas où le fichier source est un "script" à exécuter et si le nom du fichier source ne respecte pas les conventions de dénomination normales pour les fichiers source Java. 

Cette option --source peut être utilisée pour spécifier la version linguistique du code source. Je parlerai plus à ce sujet plus tard.

Pouvons-nous passer des arguments en ligne de commande ?

Améliorons le programme Hello Universe pour créer un message d'accueil personnalisé pour toute personne visitant l'univers InfoQ :

public class HelloUniverse2{
    public static void main(String[] args){
        if ( args == null || args.length< 1 ){
System.err.println("Name required");
System.exit(1);
        }
  var name = args[0];
  System.out.printf("Hello, %s to InfoQ Universe!! %n", name);
    }
}

Sauvegardons le code dans un fichier nommé Greater.java. Notez que le nom du fichier ne correspond pas au nom de la classe publique ce qui enfreint les règles de la spécification du langage Java.

Exécutez ce code et voyez ce qui va arriver :

mohamed_taman$ java Greater.java "Mo. Taman"
Hello, Mo. Taman to InfoQ universe!!

Comme vous pouvez le constater, peu importe que le nom de la classe corresponde au nom du fichier; il est compilé en mémoire et aucun fichier .class n'est généré. Les lecteurs aux yeux de lynx ont peut-être aussi remarqué comment nous avons passé des arguments au code après le nom du fichier à exécuter. Cela signifie que tous les arguments apparaissant sur la ligne de commande après le nom du fichier sont transmis à la méthode main standard de cette manière.

Spécifiez le niveau de votre fichier de code avec l'option --source

Deux scénarios utilisent cette option --source :

1. Spécifiez le niveau des sources de votre fichier de code
2. Forcer le runtime Java en mode d'exécution de source

Dans le premier cas, lorsque vous omettez le niveau des sources, il est supposé être la version actuelle du JDK. Dans le second cas, vous pouvez transmettre des noms de fichiers avec des extensions autres que .java à compiler et à exécuter à la volée.

Examinons le second scénario, renommons Greater.java sans extension et essayons de le réexécuter en utilisant la même approche :

mohamed_taman$ java greater "Mo. Taman"
Error: Could not find or load main class greater
Caused by: java.lang.ClassNotFoundException: greater

Comme vous le voyez, en l'absence d'extension .java, l'interpréteur de commandes Java recherche une classe compilée à l'aide du nom fourni en tant qu'argument - mode 1 du programme de lancement de java. Pour éviter cela, nous devons utiliser l'option --source pour forcer le mode fichier source :

mohamed_taman$ java --source 11 greater "Mo. Taman"
Hello, Mo. Taman to InfoQ universe!!

Revenons maintenant au premier scénario. La classe Greater.java est compatible avec JDK 10 car elle contient le mot clé var, mais n'est pas compatible avec JDK 9. Changez le source en 10 et voyez ce qui se passe :

mohamed_taman$ java --source 10 Greater.java "Mo. Taman"
Hello Mo. Taman to InfoQ universe!!

Exécutez à nouveau la commande précédente, mais passez 9 à l'option --source au lieu de 10 :

mohamed_taman$ java --source 9 Greater.java "Mo. Taman"
Greater.java:8: warning: as of release 10, 'var' is a restricted local variable type and cannot be used for type declarations or as the element type of an array
var name = args[0];
            ^
Greater.java:8: error: cannot find symbol
var name = args[0];
        ^
  symbol:   class var
  location: class HelloWorld
1 error
1 warning
error: compilation failed

Notez la forme du message d'erreur - le compilateur vous avertit que la variable devient un nom de type restreint dans JDK 10, mais comme il s'agit du niveau 9 du language, la compilation continue. Toutefois, la tentative de compilation échoue, car un type appelé var est introuvable dans le fichier source.

Assez simple, non ? Voyons maintenant comment utiliser plusieurs classes.

Est-ce que ça fonctionne avec plusieurs classes ?

La réponse est oui.

Examinons un exemple de code contenant deux classes pour démontrer que la fonctionnalité fonctionne avec plusieurs classes. Le code vérifie si une chaîne donnée est un palindrome ou non. Un palindrome est un mot, une phrase, un nombre ou d'autres séquences de caractères qui se lisent de la même manière dans les deux sens, tels que " redivider" ou " reviver".

Voici le code enregistré dans un fichier nommé PalindromeChecker.java :

import static java.lang.System.*;
public class PalindromeChecker {
      public static void main(String[] args) {
            
            if ( args == null || args.length< 1 ){
                err.println("String is required!!");
                exit(1);
            }
            out.printf("The string {%s} is a Palindrome!! %b %n",
                  args[0],
                  StringUtils
                        .isPalindrome(args[0]));            
      }
}
public class StringUtils {
      public static Boolean isPalindrome(String word) {
      return (new StringBuilder(word))
            .reverse()
            .toString()
            .equalsIgnoreCase(word);
      }
}

Lançons maintenant le fichier :

mohamed_taman:code$ java PalindromeChecker.java RediVidEr
The string {RediVidEr} is a Palindrome!! True

Faisons-le encore, en remplaçant par "RaceCar":

mohamed_taman:code$ java PalindromeChecker.java RaceCar
The string {RaceCar} is a Palindrome!! True

Enfin, essayons "Mohamed" à la place de "RaceCar" :

mohamed_taman:code$ java PalindromeChecker.java Taman
The string {Taman} is a Palindrome!! false

Comme vous pouvez le constater, vous pouvez ajouter autant de classes publiques que nécessaire dans un seul fichier source. La seule chose qui compte est que la méthode principale soit définie dans la première classe du fichier source. L'interpréteur (commande Java) utilisera la première classe comme point d'entrée pour lancer le programme après la compilation du code en mémoire.

Les modules sont-ils autorisés ?

Oui, l'utilisation de modules est complètement autorisée. Le code compilé en mémoire s'exécute dans le cadre d'un module sans nom avec l'option --add-modules=ALL-DEFAULT qui donne accès à l'intégralité des modules fournis avec le JDK.

Cela permet au code d'utiliser différents modules sans avoir à déclarer explicitement la dépendance dans un module-info.java.

Examinons un code exécutant une requête HTTP à l'aide de la nouvelle API HTTP Client fournie avec JDK 11. Notez que ces API ont été introduites dans Java SE 9 en tant que fonctionnalité incubateur, mais qu'elles sont désormais intégrées comme fonctionnalité standard du module java.net.http.

Dans cet exemple, nous allons appeler une simple API REST via une méthode GET pour obtenir certains utilisateurs. Nous appellerons un endpoint public https://reqres.in/api/users?page=2. L'exemple de code est dans un fichier dont le nom est UsersHttpClient.java :

import static java.lang.System.*;
import java.net.http.*;
import java.net.http.HttpResponse.BodyHandlers;
import java.net.*;
import java.io.IOException;

public class UsersHttpClient{
    public static void main(String[] args) throws Exception{
var client = HttpClient.newBuilder().build(); 
var request = HttpRequest.newBuilder()
.GET()
.uri(URI.create("https://reqres.in/api/users?page=2"))
.build();

var response = client.send(request, BodyHandlers.ofString());
out.printf("Response code is: %d %n",response.statusCode());
out.printf("The response body is:%n %s %n", response.body());     
    }
}

L'exécution du programme aboutit au résultat suivant :

mohamed_taman:code$ java UsersHttpClient.java
Response code is: 200
The response body is:
{"page":2,"per_page":3,"total":12,"total_pages":4,"data":[{"id":4,"first_name":"Eve","last_name":"Holt","avatar":"https://s3.amazonaws.com/uifaces/faces/twitter/marcoramires/128.jpg"},{"id":5,"first_name":"Charles","last_name":"Morris","avatar":"https://s3.amazonaws.com/uifaces/faces/twitter/stephenmoon/128.jpg"},{"id":6,"first_name":"Tracey","last_name":"Ramos","avatar":"https://s3.amazonaws.com/uifaces/faces/twitter/bigmancho/128.jpg"}]}

Cela vous permet de tester rapidement les nouvelles fonctionnalités fournies par différents modules sans avoir à créer votre propre module.

Pour plus d'informations sur le nouveau système de modules de la plate-forme Java (JPMS), vous pouvez consulter mon cours vidéo " Getting Started with Clean Code Java SE 9 ".

Pourquoi les scripts sont-ils importants pour Java ?

Tout d'abord, rappelons-nous ce qu'est un script afin de comprendre pourquoi il est important qu'il soit disponible dans le langage de programmation Java.

Nous pouvons définir le script comme suit :
"Un script est un programme écrit pour un environnement d'exécution spécifique qui automatise l'exécution de tâches ou de commandes pouvant également être exécutées une par une par un humain."

De cette définition générique, nous pouvons dériver une définition simple pour un langage de script; Un langage de script est un langage de programmation qui utilise une construction de haut niveau pour interpréter et exécuter une ou plusieurs commandes à la fois.

Un langage de script est un langage de programmation qui utilise une série de commandes dans un fichier. Généralement, les langages de script sont souvent interprétés (plutôt que compilés) avec le style de programmation procédural (bien que certains langages de script aient aussi des fonctionnalités orientées objet).

En général, les langages de script sont plus faciles à apprendre et plus rapides à coder que les langages compilés et structurés tels que Java, C et C ++. Exemples de langages de script côté serveur, notamment Perl, PHP et Python, ainsi que JavaScript côté client.

Pendant longtemps, Java a été classé comme langage compilé, bien structuré, fortement typé, interprété par la machine virtuelle Java pour s'exécuter sur n'importe quelle architecture informatique. Cependant, une plainte à propos de Java est qu'il n'est pas aussi rapide d'apprendre ou de prototyper par rapport aux langages de script courants.

Cependant, Java est maintenant un langage vieux de 24 ans et est utilisé par environ 9,4 millions de développeurs à travers le monde. Pour faciliter l'apprentissage de Java et l'essai de ses fonctionnalités et de ses API aux jeunes générations de programmeurs sans pour autant nécessiter une compilation et des IDE, plusieurs fonctionnalités ont été ajoutées dans les dernières versions. À partir de Java SE 9, l'outil JShell (REPL) prenant en charge la programmation interactive a été ajouté, dans le but de faciliter la programmation et l'apprentissage de Java.

Maintenant, avec JDK 11, Java est en train de devenir un langage de programmation capable de prendre en charge les scripts, car vous pouvez exécuter votre code simplement en appelant la commande java !

Il existe deux méthodes de base pour créer des scripts dans Java 11 :

1. Utiliser l'outil java directement.
2. Utilisation de scripts en ligne de commande *nix - similaires à un script bash.

Nous avons déjà exploré la première option, il est donc temps d'examiner la seconde option, une fonctionnalité qui ouvre la porte à de nombreuses possibilités.

Fichiers Shebang : exécutez du code Java en tant que script shell.

Comme indiqué précédemment, Java SE 11 prend en charge les scripts, notamment les fichiers shebang *nix traditionnels. Aucune modification de la JLS (Java Language Specification) n'est requise pour prendre en charge cette fonctionnalité.

Dans un fichier shebang classique, les deux premiers octets doivent être 0x23 et 0x21, ce qui correspond au codage ASCII des deux caractères "#!". Tous les octets suivants du fichier sont alors lus avec l'encodage de caractères par défaut de la plate-forme en vigueur.

Par conséquent, un début de première ligne #! est nécessaire uniquement si vous souhaitez exécuter le fichier avec le mécanisme shebang du système d'exploitation. Cela signifie qu'il n'est pas nécessaire d'utiliser une première ligne spéciale lorsque le programme de lancement Java est explicitement utilisé pour exécuter le code à partir d'un fichier source, comme dans l'exemple HelloUniverse.java ci-dessus.

Exécutons l'exemple suivant dans un Terminal fonctionnant sous macOS Mojave 10.14.5. Mais d'abord, nous devrions définir quelques règles importantes à suivre lors de la création d'un fichier shebang :

• Ne mélangez pas le code Java avec le langage de script shell de votre système d'exploitation.
• Si vous devez inclure des options à la VM (Virtual Machine), vous devez spécifier --source comme la première option après le nom de l'exécutable dans le fichier shebang. Ces options incluent : --class-path, --module-path, --add-exports, --add-modules, --limit-modules, --patch-module, --upgrade-module-path et toutes les variantes de ces options. Il pourrait également inclure la nouvelle option --enable-preview, décrite dans la JEP 12
• Vous devez spécifier la version du langage Java utilisé pour le code source dans le fichier.
• Les caractères shebang (#!) doivent être la première ligne du fichier et ressembler à ceci : 

  #!/path/to/java --source <version>

• L'utilisation du mécanisme shebang pour exécuter des fichiers conformes à la convention de dénomination standard (fichiers se terminant par .java) pour les fichiers source Java n'est pas autorisée.
• Enfin, vous devez marquer le fichier comme exécutable en utilisant : 

  chmod +x <Filename>.<Extension>.

Pour notre exemple, créons un fichier shebang (script utility program) qui listera le contenu d'un répertoire dont le nom est passé en paramètre. Si aucun paramètre n'est passé, le répertoire actuel sera utilisé par défaut.

#!/usr/bin/java --source 11
import java.nio.file.*;
import static java.lang.System.*;

public class DirectoryLister {
      public static void main(String[] args) throws Exception {
            vardirName = ".";

            if ( args == null || args.length< 1 ){
err.println("Will list the current directory");
            } else {
                  dirName = args[0];
            }

            Files
            .walk(Paths.get(dirName))
            .forEach(out::println);       
      }
}

Enregistrez ce code dans un fichier nommé dirlist sans extension, puis rendez le exécutable :

mohamed_taman:code$ chmod +x dirlist

Exécutez-le comme suit :

mohamed_taman:code$ ./dirlist
Will list the current directory
.
./PalindromeChecker.java
./greater
./UsersHttpClient.java
./HelloWorld.java
./Greater.java
./dirlist

Exécutez-le à nouveau avec la commande suivante en passant le répertoire parent et vérifiez vous-même le résultat.

mohamed_taman:code$ ./dirlist ../

Remarque : la ligne shebang (la première ligne) est ignorée par l'interpréteur lors de l'évaluation du code source. Par conséquent, un fichier shebang peut également être appelé explicitement par le programme de lancement, éventuellement avec les options supplémentaires suivantes :

$ java -Dtrace=true --source 11 dirlist

En outre, il convient de noter que, si le fichier de script se trouve dans le répertoire en cours, on peut l'exécuter comme suit :

$ ./dirlist

Ou, si le script est dans un répertoire du chemin PATH de l'utilisateur, vous pouvez l'exécuter comme suit:

$ dirlist

Enfin, terminons en montrant quelques conseils et astuces à prendre en compte lors de l'utilisation de cette fonctionnalité.

Trucs et astuces

1. Certaines options que vous pouvez transmettre à javac ne peuvent pas être transmises (ni reconnues d'ailleurs) par l'outil java, telles que les options -processor ou -Werror.
2. Si les fichiers .class et .java existent dans le classpath, le programme de lancement vous oblige à utiliser le fichier class.

mohamed_taman:code$ javac HelloUniverse.java
mohamed_taman:code$ java HelloUniverse.java
error: class found on application class path: HelloUniverse

3. Gardez à l'esprit la possibilité de conflits de noms de classes et de packages. Regardez la structure de répertoire suivante :

   mohamed_taman:code$ tree
   .
   ├── Greater.java
   ├── HelloUniverse
   │   ├── java.class
   │   └── java.java
   ├── HelloUniverse.java
   ├── PalindromeChecker.java
   ├── UsersHttpClient.java
   ├── dirlist
   └── greater

   Notez le fichier java.java du package HelloUniverse et le fichier du répertoire HelloUniverse.java en cours. Que se passe-t-il lorsque vous essayez de l'exécuter :

   mohamed_taman:code$ java HelloUniverse.java

   Quel fichier sera exécuté, le premier ou le second ? Le programme de lancement java ne fait plus référence au fichier class HelloUniverse. Au lieu de cela, il chargera et exécutera le fichier source HelloUniverse.java afin que le fichier du répertoire actuel soit exécuté.

J'aime utiliser cette fonctionnalité shebang car elle ouvre un monde de possibilités pour créer des scripts permettant d'automatiser beaucoup de travail en utilisant la puissance du langage Java.

Résumé

À partir de Java SE 11 et pour la première fois dans l'historique du langage de programmation, vous pouvez exécuter un script contenant du code Java directement sans compilation. La fonctionnalité d'exécution de code source de Java 11 permet d'écrire des scripts en Java et de les exécuter directement à partir de la ligne de commande *inx .

Commencez dès aujourd'hui à expérimenter cette nouvelle fonctionnalité et à coder avec plaisir. Dites moi merci en passant le mot, juste en le partageant avec vos collègues.

Ressources

• JEP 330: Launch Single-File Source-Code Programs
• JEP 12: Preview Language and VM Features
• JDK 11 Documentation
• Java SE Development Kit 12.0.1
• Test your front-end against a real API

A propos de l'auteur

Mohamed Taman est architecte d'entreprise sénior @DevTech d.o.o, un des Java Champions, un des ambassadeurs Oracle Groundbreaker, Adopts Java SE.next (), JakartaEE.next (), un membre du JCP, était membre du comité exécutif du JCP, membre du groupe d'experts des JSR 354, 363, 373 , JUG Leader de l'EGJUG et membre du conseil du club Oracle Egypt Architects, parle à propos de Java, adore le mobile, Big Data, Cloud, Blockchain, DevOps. Conférencier international, auteur de livres et des vidéos "JavaFX essentials", "Getting Started with Clean Code, Java SE 9" et "Hands-On Java 10 Programming with JShell", et d'un nouveau livre "Secrets of a Java Champions", a remporté les récompenses Duke’s choice en 2015, en 2014 et JCP pour les participants au programme d'adoption adopt-a-jar en 2013.