Créer un notebook avec Jupyter et Kotlin

Introduction

Récemment, j'ai commencé à plonger dans le monde de Kotlin, un langage de programmation moderne et polyvalent qui a retenu mon attention. Cependant, étant habitué à l'environnement interactif de Jupyter, qui permet des itérations rapides et une exploration fluide du code, je me demandais si quelque chose de similaire existait pour Kotlin.

À mon agréable surprise, j'ai découvert qu'il existe un noyau Jupyter pour Kotlin. Cet outil combine la puissance et l'élégance de Kotlin avec l'interactivité et la facilité d'utilisation de Jupyter, créant un environnement de développement idéal pour apprendre et expérimenter le langage.

Dans cet article, je partagerai mon expérience de mise en place d'un environnement Jupyter avec le support Kotlin, et j'irai même plus loin en créant un notebook qui vous permet de travailler avec plusieurs langues simultanément.

Créer un conteneur avec Kotlin

Installer le noyau Kotlin pour Jupyter est relativement simple, surtout si l'on utilise Docker pour créer un environnement contrôlé et reproductible. Regardons le Dockerfile que j'ai créé à cet effet – vérifiez les commentaires pour comprendre chaque étape :

Fichier Docker

Nous commençons par une image Jupyter officielle téléchargée depuis quay.io. Nous utilisons une version spécifique pour garantir la reproductibilité et étiquetons l'image comme noyau Kotlin pour une identification facile.

FROM quay.io/jupyter/base-notebook:2024-12-31 AS kotlin-kernel

On installe OpenJDK 21, nécessaire pour faire tourner Kotlin, l'installation se fait en root pour éviter les problèmes de permissions puis on passe en utilisateur non root pour assurer la sécurité de l'image.

USER root

RUN apt-get update && apt-get -y install openjdk-21-jdk

USER jovyan

Nous installons le noyau Kotlin pour Jupyter, cela nous permettra d'exécuter du code Kotlin dans notre notebook.

RUN pip install --user \
    kotlin-jupyter-kernel==0.12.0.322

Nous créons un répertoire pour stocker les cahiers.

RUN mkdir -p /home/jovyan/notebooks

Enfin, nous établissons la variable d'environnement NOTEBOOK_ARGS qui nous permet de configurer le notebook avec les options dont nous avons besoin, dans ce cas, nous ne voulons pas qu'un navigateur s'ouvre automatiquement et nous voulons que le répertoire du notebook soit /home/jovyan/ cahiers

ENV NOTEBOOK_ARGS="--no-browser --notebook-dir=/home/jovyan/notebooks"

Pour construire l'image Docker, nous exécutons :

docker build --target kotlin-kernel -t kotlin-kernel .

Cette commande crée l'image Docker et la marque comme kotlin-kernel.

Pour exécuter le conteneur :

docker run \
    -it \
    -p 8888:8888 \
    -v $(pwd)/notebooks:/home/jovyan/notebooks \
    kotlin-kernel

Cette commande :

• Exécutez le conteneur en mode interactif (-it).
• Mappe le port 8888 du conteneur au port 8888 de l'hôte (-p 8888:8888).
• Monte le répertoire local notebooks dans le répertoire :/home/jovyan/notebooks du conteneur (-v $(pwd)/notebooks::/home/jovyan/notebooks).

Une fois exécuté, vous pourrez accéder à JupyterLab dans votre navigateur et vous verrez que le Launcher dispose déjà de deux noyaux disponibles : Python et Kotlin.

Et en fait, on peut désormais créer des notebooks avec Kotlin !

La prochaine étape de l'interactivité

En approfondissant Kotlin, j'ai remarqué des similitudes intéressantes avec Python. Cela m'a amené à vouloir visualiser ces similitudes plus en détail, créant des comparaisons directes entre les deux langues. Je me demandais s'il serait possible d'exécuter du code Python et Kotlin sur le même notebook, et il s'avère que c'est possible.

J'ai découvert une extension (et le noyau Jupyter) appelée SoS (Script of Scripts) qui permet cette fonctionnalité. J'ai décidé de l'ajouter à mon conteneur avec le noyau Kotlin. Voici les ajouts au Dockerfile :

Mise à jour du fichier Docker

Nous installons SoS, qui nous permettra d'exécuter du code Python et Kotlin dans le même notebook.

FROM quay.io/jupyter/base-notebook:2024-12-31 AS kotlin-kernel

Grâce à ces ajouts, nous pouvons désormais créer et exécuter notre conteneur amélioré :

USER root

RUN apt-get update && apt-get -y install openjdk-21-jdk

USER jovyan

Lorsque vous accédez à JupyterLab maintenant, vous verrez trois noyaux disponibles : Python, Kotlin et SoS.

Et maintenant nous pouvons exécuter du code Python et Kotlin dans le même notebook :

Personnalisation supplémentaire

Pour améliorer l'expérience visuelle et distinguer facilement les cellules de différentes langues, j'ai décidé de personnaliser l'apparence des cellules.

Jupyter Notebook vous permet d'ajouter du CSS personnalisé, ce qui nous permet d'ajouter des dégradés à gauche de chaque cellule, en fonction de la langue.

Voici le CSS que j'ai utilisé :

RUN pip install --user \
    kotlin-jupyter-kernel==0.12.0.322

Pour implémenter cette personnalisation, j'ai enregistré le CSS dans un fichier appelé custom.css et je l'ai ajouté au Dockerfile :

RUN mkdir -p /home/jovyan/notebooks

De plus, il faut préciser à la commande jupyter lab que l'on souhaite utiliser ce CSS personnalisé, en ajoutant l'indicateur --custom-css à la commande d'exécution.

ENV NOTEBOOK_ARGS="--no-browser --notebook-dir=/home/jovyan/notebooks"

Erreurs et comment les masquer

Lors de l'utilisation du noyau multilingue, une erreur apparaît parfois lors de l'exécution d'une cellule Kotlin. Cette erreur s'affiche de manière aléatoire et, même si je n'ai pas encore pu identifier son origine ni comment la résoudre définitivement, j'ai trouvé une solution temporaire pour améliorer l'expérience utilisateur.

Pour masquer cette erreur ennuyeuse, j'ai décidé d'utiliser CSS. J'ai ajouté la ligne suivante au fichier custom.css mentionné ci-dessus :

FROM quay.io/jupyter/base-notebook:2024-12-31 AS kotlin-kernel

Cette ligne de CSS masque les messages d'erreur spécifiques à Kotlin dans le notebook. Bien que ce ne soit pas une solution idéale car elle pourrait masquer des erreurs importantes, elle améliore considérablement l'expérience visuelle lorsque l'on travaille avec des notebooks Kotlin, en particulier face à cette erreur récurrente et apparemment inoffensive.

Conclusion

Dans cet article, nous avons exploré comment créer un environnement de développement interactif pour Kotlin à l'aide de Jupyter Notebooks.

Nous commençons par la configuration de base d'un conteneur Docker avec support Kotlin, puis évoluons vers un environnement plus sophistiqué qui permet l'exécution de code dans plusieurs langues au sein d'un même notebook.

De plus, nous avons vu comment personnaliser l'apparence de nos cahiers pour améliorer l'expérience visuelle et la lisibilité, et comment "masquer" certaines erreurs courantes qui peuvent survenir lors de l'utilisation de ces cahiers.

Cela facilite non seulement l'apprentissage de Kotlin, mais permet également des comparaisons directes avec d'autres langages comme Python, ce qui peut être extrêmement utile pour les développeurs qui passent à Kotlin ou qui travaillent régulièrement avec plusieurs langages de programmation

.

Ressources supplémentaires

Pour ceux qui souhaitent explorer davantage ou répliquer cet environnement, j'ai mis à disposition tout le code utilisé dans ce projet dans mon référentiel GitHub.

J'espère que ce guide vous sera utile dans votre parcours d'apprentissage avec Kotlin et Jupyter.

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!