This is the page where I will put all my tips and tricks for Jekyll and Github Pages.

Si comme moi tu en as assez de faire des programmes types “ligne de commande” en Java et d’être obligé de les lancer avec ce genre de choses :

$ java -jar demo-app-v1.0.0-SNAPSHOT.jar arg1 arg2 arg3`

Ce petit article devrait te plaire. Tu pourras alors faire directement ça :

$ ./demo-app arg1 arg2 arg3

Appétissant !

Dans ce petit tutoriel, je vais donc générer un exécutable :

• pour Linux et MacOSX,
• pour Windows, un .EXE,
• sous forme de Runnable JAR, classique.

Cela nécessite toutefois la présence d’un Runtime JAVA (JRE et/ou JDK) sur la machine qui l’exécutera, bien qu’il existe aussi des solutions pour embarquer un JRE.

Les solutions, que je vais décrire, n’utilisent pas GRAALVM et sa compilation native.

If, like me, you are tired of making command line programs in Java and having to run them with this kind of things:

$ java -jar demo-app-v1.0.0-SNAPSHOT.jar arg1 arg2 arg3`

This little article should please you. You will then be able to do this directly:

$ ./demo-app arg1 arg2 arg3

Appetizing!

In this little tutorial, I will generate an executable file :

• for Linux and MacOSX,
• for Windows, an .EXE,
• as a classic Runnable JAR.

However, this requires the presence of a JAVA Runtime (JRE and/or JDK) on the machine that will run it, although there are also solutions to embed a JRE.

The solutions I will describe do not use GRAALVM and its native compilation.

Retour en 1986, Nom de Zeus ! Je vais t’expliquer comment fonctionnait le bootsector sur les disquettes 3’1/2 double faces, sur THOMSON TO8.

L’objectif : comprendre la structure du bootsector pour y déposer un petit programme écrit en assembleur et qui s’exécutera automatiquement.

Quand on se (re)plonge dans la programmation de l’Atari ST et notamment de l’affichage des pixels à l’écran, on se rend vite compte qu’on a pris de bien mauvaises habitudes avec nos ordinateurs “modernes”, où la structure en mémoire est très simple en comparaison.

Cet article, illustré de programmes en C, va vous permettre de comprendre ENFIN cet agencement particulièrement étonnant pour ne pas dire étrange.

Retrouvez mon ami Fred, qui a délaissé un peu son Amiga pour venir du côté obscur de l’Atari ST, dans sa quête d’affichage de pixels !

Dans la série “comment compiler à partir de Linux pour une autre machine”, l’objectif de ce mini-tutorial est d’obternir un .BIN pour Thomson MO5 avec l’assembleur C6809.

Le fichier exécutable sera testé avec l’émulateur DCMOTO de Daniel Coulom avant d’être transféré sur un véritable MO5.

L’objectif de ce petit tutorial est de compiler 2 programmes C pour TOS puis GEM, à partir de Linux.

Les fichiers exécutables seront testés avec l’émulateur HATARI, avant d’être réllement exécutés sur un Atari ST en “plastique et en os”.

The objective of this little tutorial is to compile two C programs for TOS and then GEM, from Linux.

The executable files will be tested with the HATARI emulator, before being actually executed on an Atari ST in “plastic and bones”.

Ce tutoriel Quarkus-JPA-PostgreSQL met en oeuvre :

• une API Rest partielle (GET) avec JAX-RS et Quarkus sur une source de données JPA
• des tests unitaires
• des tests d’intégration au niveau API (http) avec un PostGreSQL lancé par un plugin maven Docker
• une distribution native, compilée avec GraalVM et une image docker de l’application compilée

Réalisé sous Linux Mint 19 mais devrait convenir à de nombreuses distributions, voire à Windows.

Java 12 est sorti le 20/03/19, apportant une nouvelle façon d’écrire des structures de contrôle switch/case. Cela m’a donné une idée, certes un peu étrange, de revoir le traditionnel switch/case d’un point de vue programmation fonctionnelle en s’appuyant sur des lambdas et une petite classe Switch, le tout en JAVA 8 !

Attention toutefois, il est certain que cette approche est beaucoup moins performante qu’un switch/case classique, mais je ne renonce pas à la beauté du geste.

Versions de cet article :

• 04/10/2019 : première publication.
• 26/02/2020 : suite à idée judicieuse postée sur les forums “developpez.com”, voir la partie “Let’s go further …”

Java 12 was released on 20/03/19, bringing a new way to write switch/case control structures. This gave me an idea, admittedly a bit strange, to revisit the traditional switch/case from a functional programming point of view by using lambdas and a small Switch class, all in JAVA 8!

Be careful though, it is certain that this approach is much less efficient than a classic switch/case, but I don’t give up the beauty of the gesture.

Versions of this article:

• 04/10/2019: first publication.
• 26/02/2020 : following a judicious idea posted on “developpez.com” forums, see the “Let’s go further …” part.

Cela fait des années que je place différemment mes accolades { }, à contre-courant de ce qui se fait généralement en Java, faisant ainsi ressembler mon code à du C/C++. Ce billet est l’occasion de faire une sorte d’introspection sur ma pratique : Est-elle bonne ? Est-elle désuète ? Pourquoi je n’aime pas le style SUN ? Est-ce que mon style est utile ou inutile ?

Que de questions auxquelles ce billet va tenter de répondre.

• Version 1 parue le 16/12/2017
• Version 2 parue le 06/08/2018 : accès concurrents, PermGen / Meta spaces, Holder interne

L’objectif de ce billet est de présenter une implémentation simple en Java du pattern Singleton.

Je ne traiterai donc pas de l’utilité ni des recommandations d’usage liées à celui-ci mais bien de mise en oeuvre (codage pour les intimes) en Java Standard Edition (JSE).

Cet article va vous permettre de découvrir Deltaspike Data Module, une alternative à Spring Data dans le monde CDI et dans notre cas en CDI 2.0.

Cette accroche est parlante pour ceux qui connaissent Spring Data mais peut-être pas pour les autres : Deltaspike Data va permettre d’avoir très simplement une fonctionnalité de CRUD (Create, Read, Update, Delete) sur des entités JPA et bien plus encore en vous faisant économiser énormément de temps de développement et de bugs potentiels !

Comme tout système s’appuyant sur des inputs, il est très important de contrôler les arguments des méthodes quand on élabore une API, qu’elle soit locale sous forme de JAR ou distante via un service REST, afin de non seulement la rendre plus robuste et stable mais aussi de se prémunir de certaines attaques.

Cependant, en Java de base, c’est particulièrement laborieux, rébarbatif et cela engendre une fainéantise exacerbée. Conséquences directes et désastreuses : baisse de la qualité, de la robustesse du code et créations potentielles de failles de sécurité.

Cet article tente de faire le tour de la question, sans prétention, en ratissant assez large. C’est à dire en allant de Java classique jusqu’à Bean Validation et JAX-RS, en passant par une implémentation spécifique “Faite Maison”.

NodeJS se targue de pouvoir monter en quelques lignes de code un simple serveur HTTP. Effectivement, créer ce genre de serveur est vraiment simple et particulièrement utile pour du déploiement dans le Cloud.

Et Java dans tout ça ? A la traîne ? Has-Been ?

“Si à 50 ans t’as pas de Rolex et/ou si tu sais pas faire de TypeScript, t’as raté ta vie !”

Fort heureusement, je vais vous montrer qu’avec JShell, apparu avec Java 9, en 10 lignes de code environ, vous obtiendrez un serveur HTTP Asynchrone, performant, en ayant à portée de main tout ce que vous offre Java 10, ses modules, ainsi qu’historiquement, toutes les bibliothèques JAR de son écosystème !

“Il me faut un repo Maven dédié !”. Voilà ce qui m’est venu en tête quand j’ai dû changer de machine récemment alors que tous les artefacts maven que je produisais étaient capitalisés dans le .m2/repository de mon home. Autant dire “Pas capitalisés”.

Bien sûr, j’utilise un repo Nexus au boulot mais je change d’activité et je vais devenir plus mobile, il me faut donc une solution.

J’aurais pu prendre une image Docker et la déployer sur AWS ou équivalent : la solution de facilité qui demande toutefois un peu de “ressource” financière.

Et je le vois, là, rose, toutes diodes allumées, connecté à ma box, servant de proxy Squid de temps en temps. Mon Raspberry PI 1, je l’entends encore me dire “Moi je peux, moi je peux, moi je peux !” en trépignant dans son joli boitier.

Comme tout bon développeur Java, je suis un gros consommateur des solutions fournies par l’Eclipse Foundation. Je ne vais en citer que quelques-unes : Eclipse IDE, EclipseLink, Eclipse GlassFish, Jetty, Eclipse EGit, Eclipse Maven Integration, etc.

Il était donc temps, au lieu d’attendre en ronchonnant qu’un patch ne soit développé, de contribuer en fournissant un correctif à un projet.

Ce court billet va vous présenter quelles instructions sont exécutées dans vos classes Java, lorsque que vous en réclamez une instance.

Dans mon parcours professionnel, j’ai été formateur de jeunes développeurs pendant sept années. Ces derniers venaient d’horizons différents, parfois sans aucune compétence en terme de programmation.

Afin de rendre ludique l’apprentissage des fondamentaux de l’algorithmique et de Java, je les ai fait participer à la création d’un jeu video : Xenon Reborn, inspiré du célèbre jeu Xenon des Bitmap Brothers.

Je vais vous présenter succinctement les deux façons natives en JPA pour déclarer des NamedQuery.

On verra alors que ces deux solutions ont des défauts et je vous proposerai alors une 3ème qui me paraît plus satisfaisante, fondée sur une “enum”.

I will present in this post the Lombok library which I’m currently using for quite every development in Java. After 4 years dealing with it, I wish I could share some experience and give some advice.

As an excerpt, here is my best : don’t use @Data but you’ll need to be patient and to read the conclusion to know why.

Dans ce billet, je vais présenter la bibliothèque Lombok dont je ne peux plus me passer pour mes développements Java. Cela fait maintenant plus de 4 ans que je l’utilise et tout n’est pas rose. Ce sera donc l’occasion de partager aussi certaines recommandations.

J’en donne une : n’utilisez pas @Data et je vais vous expliquer pourquoi. Un peu de patience.