Carnet Jupyter pour Java

Le puissant de Jupyter Notebook

Les Jupyter Notebooks sont un excellent outil, développé à l'origine pour aider les scientifiques et les ingénieurs des données à simplifier leur travail avec les données à l'aide du langage de programmation Python. En fait, la nature interactive des notebooks les rend idéaux pour visualiser rapidement les résultats du code sans configurer d'environnement de développement, de compilation, de packaging, etc. Cette fonctionnalité a été cruciale pour son adoption dans les domaines de la science des données, de l’apprentissage automatique et de la modélisation statistique, où les compétences en développement étaient moins essentielles que l’expertise en manipulation de données.

Avantages

Vous trouverez ci-dessous quelques-uns des avantages du notebook Jupyter

1. Développement interactif : les blocs-notes permettent aux développeurs d'écrire du code en petits morceaux, de les tester immédiatement et de visualiser les résultats. Ce flux de travail interactif favorise une itération et un débogage plus rapides, idéal pour l'exploration de données, le développement d'algorithmes et le prototypage rapide.
2. Visualisations riches : Généralement, Notebook est intégré à de puissantes bibliothèques de visualisation qui peuvent afficher des tracés, des graphiques et d'autres sorties visuelles en ligne.
3. Documentation et code ensemble : les blocs-notes combinent du code exécutable avec des cellules de démarque, permettant aux développeurs de documenter leur code, d'expliquer la logique, etc., créant ainsi des bases de code plus lisibles et maintenables.
4. Collaboration : en partageant des blocs-notes, les membres de l'équipe peuvent réviser et exécuter du code sans configurer d'environnement de développement, ce qui facilite la collaboration, en particulier dans les équipes interfonctionnelles impliquant des parties prenantes non techniques.
5. Reproductibilité : les cahiers peuvent être réexécutés de haut en bas, garantissant que toute analyse ou test peut être reproduit de manière cohérente. Ceci est crucial pour le débogage, les tests ou la présentation des résultats.

En résumant on peut dire que

Les notebooks Jupyter rationalisent le processus de développement, de l'exploration initiale au code prêt pour la production, offrant flexibilité et retour en temps réel.

Brisez la barrière Python

Compte tenu des avantages qu'offrent les notebooks Jupyter, il serait formidable que les développeurs de logiciels utilisent une telle approche de notebook pour développer, par exemple, des TESTS DE CAS D'UTILISATION pour des projets ou fournir des COMMENTAIRE INTERACTIF.

La question ici est :

EST-IL POSSIBLE D'UTILISER UN NOTEBOOK JUPYTER POUR UN LANGAGE DE PROGRAMMATION AUTRE QUE PYTHON❓ ?

La réponse est OUI?.

L'architecture de Jupiter

Les outils Jupyter ont été conçus pour prendre en charge plusieurs langages de programmation via le concept Kernel, voir le schéma ci-dessous :

Le noyau est la manière dont le serveur de notebook Jupyter évalue les blocs de code écrits par l'utilisateur dans le document du notebook (.ipynb), il suffit donc d'avoir un noyau capable d'évaluer le code du langage de programmation de votre choix pour avoir il est pris en charge par le notebook Jupyter.
Bien sûr, il est facile de déduire que chaque langage de programmation potentiel qu'un noyau Jupyter peut prendre en charge devrait prendre en charge la fonctionnalité de boucle de lecture-évaluation-impression (REPL).

La question devient :

EXISTE-T-IL UN NOYAU JUPYTER AUTRE QUE PYTHON ONE❓ ?

La réponse est Oui ?.

Dernièrement, j'ai travaillé sur Langgraph4J qui est une implémentation Java du plus célèbre Langgraph.js qui est une bibliothèque Javascript utilisée pour créer des workflows d'agents et multi-agents par Langchain. Il est intéressant de noter que [Langchain.js] utilise des notebooks Javascript Jupyter alimentés par un noyau DENO Jupiter pour implémenter et documenter les procédures.
J'ai donc été confronté à un dilemme sur la façon d'utiliser (ou éventuellement de simuler) la même approche en Java et, sans grand espoir, j'ai commencé à chercher un noyau Jupyter prenant en charge Java étant donné qu'à partir de la version JDK 9, il y avait l'introduction de JShell qui a activé le REPL pour Java.

Le noyau Java Jupyter

Après quelques recherches (et l'idée étrange d'essayer de me lancer dans une implémentation DIY), j'ai atterri sur rapaio-jupyter-kernel qui est un noyau Jupyter qui prend en charge Java ?. Le projet indique :

Noyau Jupyter pour langage Java basé sur JShell. Il implémente la spécification de message Jupyter version 5.4 et nécessite Java = 22.

C'est incroyable ; Je commence à l'utiliser et WOW !?. Jetez un œil à certaines de ses fonctionnalités, ci-dessous j'ai résumé les plus représentatives :

Fonctionnalités du bloc-notes Java Jupyter

---

Vous pouvez écrire du Java normal.

var result = 2 + 2;
result

4

// including classes
record Complex(double a, double b) {
    public Complex add(Complex c) {
        return new Complex(a+c.a, b+c.b);
    }
}
Complex x = new Complex(10,20);
x.add(new Complex(1,1))

Complexe[a=11.0, b=21.0]

// methods can also be implemented
int add(int a, int b) { return a+b; }
add(2,3)

5

Magic commands

Besides Java code, a cell can contain special commands implemented by the kernel. These are called magic code and there are two types: magic lines and magic cells.
Magic lines are lines which are prefixed with %. After the prefix it is followed by the magic command and the optional parameters. Below is an example of magic line:

// magic line which asks JShell to list the types defined in this notebook in this moment
%jshell /types

| record Complex

Magic commands interpolation

Sometimes there is a need to run a magic command in a more dynamic way. This can be done using magic interpolation.
Magic interpolation is the interpolation of marked content which starts with \{ and ends with }. Any content decorated with those markers is evaluated in jshell and the result is transformed in a String which replaces the decorated content in the magic command.

String version = "1.0.2";

 

%dependency /add com.github.javafaker:javafaker:\{version}

Adding dependency com.github.javafaker:javafaker:1.0.2

Dependency management ?

You can add dependencies using %dependency /add and after adding all dependencies you can call %dependency /resolve

%dependency /add com.github.javafaker:javafaker:1.0.2
%dependency /resolve

Adding dependency com.github.javafaker:javafaker:1.0.2
Solving dependencies
Resolved artifacts count: 5
Add to classpath: /home/ati/work/rapaio-jupyter-kernel/target/mima_cache/com/github/javafaker/javafaker/1.0.2/javafaker-1.0.2.jar
Add to classpath: /home/ati/work/rapaio-jupyter-kernel/target/mima_cache/org/apache/commons/commons-lang3/3.5/commons-lang3-3.5.jar
Add to classpath: /home/ati/work/rapaio-jupyter-kernel/target/mima_cache/org/yaml/snakeyaml/1.23/snakeyaml-1.23-android.jar
Add to classpath: /home/ati/work/rapaio-jupyter-kernel/target/mima_cache/com/github/mifmif/generex/1.0.2/generex-1.0.2.jar
Add to classpath: /home/ati/work/rapaio-jupyter-kernel/target/mima_cache/dk/brics/automaton/automaton/1.11-8/automaton-1.11-8.jar

When added you can import and use the dependency.

import com.github.javafaker.Faker;
var faker = new Faker();
faker.name().fullName()

Hayley Anderson

Resolving conflict dependencies

You there are conflicts you can manage them with optional. Let's take an example which have conflicts:

%dependency /add com.google.guava:guava:20.0 --optional
%dependency /add com.google.inject:guice:4.2.2
%dependency /add com.google.guava:guava:25.1-android
%dependency /resolve

Help on magic commands

The magic %help provides more examples and guidance.

JShell commands

Some JShell commands are implemented. For example you can inspect which variables are defined

%jshell /vars

or the types you defined in this session

%jshell /types

Execute bash commands

You can execute bash scripting commands. Here we display the java version number.

%%bash
java --version

openjdk 22.0.2 2024-07-16
OpenJDK Runtime Environment Corretto-22.0.2.9.1 (build 22.0.2+9-FR)
OpenJDK 64-Bit Server VM Corretto-22.0.2.9.1 (build 22.0.2+9-FR, mixed mode, sharing)

You can even define variables. In fact all the lines below cell magic marker are executed as a bash script.

%%bash
name="John"
echo "Hello $name"

Hello John

Show an image for immediate inspection

%image https://www.google.com/logos/doodles/2024/paris-games-sailing-6753651837110529.4-law.gif

Display data

Jupyter notebooks uses outputs to display objects of various types. By default when an object is returned as the result of the last code operation, that result is displayed.
The object which is displayed can be anything. If the object has a display handler registered, than that renderer is used to transform the object into a displayable content. If there is no registered display handler than the object is transformed into a string and that will be displayed.
Previously we used magic commands to display an image. However for BufferedImages there is a registered handler and if you obtain an instance of a BufferedImage it will be displayed properly.

import javax.imageio.*;
display(ImageIO.read(new URL("https://www.google.com/logos/doodles/2024/paris-games-sailing-6753651837110529.4-law.gif")));

Displayed data has a mime type. You can use that to describe how the object should be interpreted. For example we display a markdown snippet and we direct the output interpretation of the snippet through MIME type.

display("text/markdown", "Markdown *test* **snippet**:\n* bullet 1\n* bullet 2")

Markdown test snippet:

• bullet 1
• bullet 2

display command returns an id which identifies the piece of output from the notebook which handles the display. Notice that we captured the id of the display. This id can be used to update the same display with a different content. For example we can update the content of that display with a html snippet, using the MIME type for interpretation.

String id = display("text/markdown", "Markdown *test* **snippet**:\n* bullet 1\n* bullet 2");

 

updateDisplay(id, "text/html", "Html <i>test</i> <b>snippet</b>:<p><ulist><li>bullet 1</li><li>bullet 2</li></ulist></p>")

A Java object is displayed as a String using Objects.toString. As such, if the object has an implementation of toString, that method will be called.

new Complex(10,Math.PI);

Complex[a=10.0, b=3.141592653589793]

---

Conclusion

La polyvalence des notebooks Jupyter s'étend au-delà de Python, l'intégration de noyaux comme rapaio-jupyter-kernel innove pour les développeurs Java. Ma fonctionnalité préférée est la possibilité d'écrire des HOW-TO de manière interactive en les documentant contextuellement, mais il existe de nombreux cas d'utilisation potentiels et c'est à vous de les explorer, alors explorons et faites-le-moi savoir.

J'espère que ces connaissances vous seront utiles, en attendant, profitez du codage ! ? 

? Mes expérimentations de notebooks Java sont sur Github ? 

---

Publié à l'origine sur https://bsorrentino.github.io le 6 septembre 2024.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!