OpenJDK

Java 27 : la fin du support de macOS x64 et dépréciation avec Java 28

Soumis par francoistonic le
Image

Comme annoncé, Java arrête le support de macOS x64, c'est-à-dire des Mac Intel. Ce retrait s'inscrit dans la JEP 541.

Java 27 : arrêt du support macOS x64 et fin du portage sur la plateforme, seul Apple Silicon est proposé. Azul et AWS continuent à proposer une version macOS x64. 

Java 28 ira plus loin :

  • macOS X64 est déprécié, annonçant le retrait de l'architecture
  • le retrait de l'architecture se fera dans une release à venir

Avec l'arrêt du support de l'architecture Intel par macOS, les langages suivent le mouvement. 

Java 27 : comment OpenJDK améliore les performances ?

Soumis par francoistonic le
Image

La performance est une quête sans fin des frameworks et des langages. À chaque version, l'équipe de .NETpublie un long document sur le sujet. Même chose côté Java : Inside Java publie les améliorations de performance dans le JDK 27.

Cette recherche de la performance se fait par des améliorations parfois majeures, parfois à la marge. Plus de 2 300 commits ont été faits sur le JDK 26 (librairies, JIT, GC, runtime). On comprend que les améliorations ne sont ni linéaires, ni globales.

Les améliorations liées à la librairie JDK

Parmi les améliorations majeures, nous trouvons la JEP 531 et la notion de Lazy Constants. L'objet calcule sa valeur à son premier accès et ne peut être initialisé qu’une seule fois. Avantage : simplification des constantes. Autre amélioration autour de la JDK, la suppression des méthodes de bas niveau isInitialized()et orElse() qui pouvaient poser problème dans le modèle d’initialisation.
 

À cela s’ajoute :

  • des copies plus rapides pour la HashMap ;
  • un traitement amélioré des textes ;
     
  • un formatage d'URL plus efficace : simplifiant la concaténation et optimisant les URL courantes.Selon les composants d’autorité, de requête et de fragment présents, les tests de performance ont été réalisés avec un gain de temps d’au moins 60 %. Les tests effectués uniquement avec l’interpréteur ont confirmé cette amélioration, démontrant ainsi qu’elle ne dépend pas exclusivement de l’exécution compilée ;
     
  • l'élimination d'un appel système quand les fichiers sont ouverts.

Amélioration du chiffrement

Le chiffrement est l'une des tâches les plus consommatrices. Le JDK 27 a beaucoup travaillé sur les algorithmes de chiffrement : AES/ECB, AVX2 SHA-3, ainsi qu'un meilleur chiffrement sur RISC-V, etc. 

La compilation a souvent été un problème sur Java ainsi que sur le runtime. Le JDK travaille sur l’API Vector, les Compact Object Headers (JEP 534) ou encore sur l’optimisation de la mémoire heap.
 

Source : https://inside.java/2026/09/28/performance-update-jdk27/

JEP 543 : la concurrence structurée devient définitive dans JDK 28

Soumis par francoistonic le
Image

La JEP 543, « Structured Concurrency », sera intégrée à JDK 28 : l'API StructuredTaskScope sort de preview et devient définitive, « sans autre changement » par rapport à JDK 27. C'est la fin du plus long cycle de preview d'un composant du projet Loom : incubation en JDK 19 (JEP 428) et 20, puis sept previews de JDK 21 à JDK 27.

Le principe est de : traiter « des groupes de tâches liées, exécutées dans des threads différents, comme une seule unité de travail ». Avec ExecutorService et Future, une méthode peut rendre la main alors que ses sous-tâches tournent encore, et une erreur n'apparaît qu'au moment du Future.get(). 

L'échec d'une sous-tâche déclenche l'interruption des autres (annulation coopérative : une sous-tâche qui ignore l'interruption retarde d'autant la fermeture), et le scope ne se ferme pas avant que tous ses threads soient terminés : plus de fuite de thread, et une pile d'appels lisible dans les dumps de threads.

L'exemple de la JEP :

Response handle() throws ExecutionException, InterruptedException {

    try (var scope = StructuredTaskScope.open()) {

        Subtask<String>  user  = scope.fork(() -> findUser());

        Subtask<Integer> order = scope.fork(() -> fetchOrder());

        scope.join();

        return new Response(user.get(), order.get());

    }

} 

Les deux appels partent en parallèle sur des threads virtuels ; join() attend les deux ; si findUser() échoue, fetchOrder() est annulé et l'exception remonte dans handle(). Les objectifs déclarés : « promouvoir un style de programmation concurrente qui élimine les risques courants, fuites de threads et délais d'annulation », et rendre le code concurrent observable.

 JDK 28 est attendu en mars 2027. Le code écrit contre la preview de JDK 27 compile tel quel, sans le flag --enable-preview.

JEP 543 : https://openjdk.org/jeps/543

Actualité par la rédaction de Programmez!

OpenJDK 27 : post-quantique, projet Valhalla et JDK 28

Soumis par francoistonic le
Image

OpenJDK 27 est disponible aujourd'hui. Cette nouvelle version propose 9 JEP notamment sur le post-quantique, l'IA et les évolutions du langage. Elle intègre JavaFX 27, Helidon 27 et au-delà, la JDK 28 est déjà en développement avec le projet Valhalla en perspective.

« La sécurité, la fiabilité et la capacité de Java à fonctionner à l’échelle de l’entreprise en font une base essentielle pour les agents d’IA qui nécessitent un accès fiable aux systèmes métier et aux données sensibles », a déclaré Arnal Dayaratna, vice-président de la recherche, développement logiciel, IDC. « Les outils de Java 27 pour le développement de l’IA et la cryptographie post-quantique renforcent son rôle au cœur du développement d’applications d’entreprise et aident les organisations à se préparer à une nouvelle génération d’applications et de menaces relatives à la sécurité à l’ère agentique. »

Les principales JEP

JEP 527 : Échange de clés hybride post-quantique pour TLS 1.3 : Aide les organisations à renforcer la protection des données sensibles et des communications critiques contre les menaces de type « collecter maintenant, déchiffrer plus tard », tout en permettant aux développeurs de répondre à l’évolution des exigences cryptographiques avec un minimum de perturbations pour les applications. Cette fonctionnalité est particulièrement importante pour les systèmes d’IA d’entreprise et les applications critiques qui nécessitent des communications sécurisées entre services de données, modèles, agents, API, plateformes cloud et environnements applicatifs distribués.

JEP 538 : Encodages PEM des objets cryptographiques (troisième aperçu) : Contribue à sécuriser davantage la gestion des éléments cryptographiques largement utilisés, tout en améliorant l’interopérabilité avec les outils et infrastructures de sécurité courants. Les applications Java peuvent ainsi s’intégrer plus facilement aux systèmes modernes d’authentification, de chiffrement et de gestion des certificats, ce qui favorise des déploiements d’IA d’entreprise sécurisés.

JEP 536 : Masquage des données JFR en cours de processus : Aide à diagnostiquer plus sûrement les systèmes de production en réduisant l’exposition d’informations sensibles. Cette fonctionnalité contribue au respect des exigences de conformité, de confidentialité et de sécurité tout en préservant la valeur opérationnelle des diagnostics JFR, ce qui est particulièrement pertinent pour les systèmes dotés d’IA susceptibles de traiter des données sensibles concernant des clients, des employés, les opérations ou des données réglementées.

JEP 537 : API Vector (12e incubateur) : Aide à améliorer le débit sans nécessiter de code natif spécialisé, en accélérant l’analytique, l’inférence d’IA ainsi que les charges de travail de calcul scientifique et multimédia. En accélérant le traitement des données et en produisant davantage d’informations et de valeur avec moins de matériel, l’API Vector améliore les performances des applications Java tout en préservant la portabilité, la maintenabilité et la sécurité attendues de Java.

JEP 533 : Concurrence structurée (septième aperçu) : Aide à réduire les risques de développement pour les applications cloud, les microservices et les applications dotées d’IA, en permettant aux développeurs de créer des services évolutifs et résilients comportant moins de défauts de concurrence. Cette fonctionnalité est pertinente pour les charges de travail d’IA qui coordonnent de nombreuses tâches parallèles, telles que les appels de modèles, la récupération de données, l’enrichissement, le classement, l’orchestration et la prise de décision en temps réel. En améliorant également la fiabilité, l’annulation, la gestion des erreurs et l’observabilité du code multithread, elle aide les développeurs à accélérer leurs projets.

JEP 532 : Types primitifs dans les motifs, instanceof et switch (cinquième aperçu) : Aide les équipes à intégrer plus rapidement l’inférence d’IA à la logique métier, avec moins d’erreurs de codage, en rendant Java plus uniforme et expressif. Cela améliore la productivité des développeurs et la clarté du code pour les applications fortement axées sur les données et la prise de décision, notamment les workflows d’IA, d’analytique et de traitement d’événements utilisant à la fois des données primitives et des objets.

JEP 531 : Constantes paresseuses (troisième aperçu) : Aide à améliorer l’efficacité des ressources en offrant un meilleur contrôle du moment de l’initialisation, tout en conservant les avantages des constantes en matière de performances et de correction. Cela peut améliorer l’expérience utilisateur et réduire les coûts d’exploitation des applications d’IA pour lesquelles la réactivité, l’évolutivité et l’efficacité des ressources sont essentielles.

JEP 534 : En-têtes d’objets compacts par défaut : Aide à accélérer la modernisation des applications en réduisant la surcharge mémoire de la JVM grâce à l’activation par défaut des en-têtes d’objets compacts. Les clients peuvent ainsi exécuter leurs applications existantes sur un JDK plus récent tout en réduisant leur empreinte mémoire. Pour ceux qui exploitent de vastes parcs Java, cela peut accroître la densité des applications, réduire les coûts d’infrastructure et améliorer l’évolutivité des services cloud, des microservices ainsi que des charges de travail gourmandes en données ou dotées d’IA.

JEP 523 : Faire de G1 le ramasse-miettes par défaut dans tous les environnements : Aide à simplifier la migration et la modernisation des applications en offrant aux développeurs des performances prévisibles et une cohérence opérationnelle entre les environnements de déploiement. Les équipes peuvent ainsi exécuter avec davantage de confiance les applications Java cloud, les microservices et les applications dotées d’IA, avec moins de différences de configuration propres à chaque environnement.

OpenJDK prépare peu à peu aux projets Valhalla et Leyden : 

"Le projet Valhalla donne aux développeurs une visibilité précoce sur les travaux visant à combler l’écart historique entre les objets Java et les types primitifs, en commençant par les classes et objets de valeur, qui pourraient bénéficier aux charges de travail fortement axées sur les données dans l’analytique, les services financiers, le calcul scientifique et l’IA. Livré par étapes, le projet vise à rendre la représentation des données Java plus dense et plus efficace tout en préservant le modèle de programmation Java. Valhalla offre aux développeurs et aux entreprises un aperçu des futures améliorations destinées aux applications gourmandes en données, notamment dans l’analytique, les services financiers, le calcul scientifique et les systèmes dotés d’IA.

Oracle fait également progresser le projet Leyden afin d’améliorer le temps de démarrage, le délai nécessaire pour atteindre les performances maximales et l’empreinte mémoire, notamment grâce à la compilation anticipée. Ensemble, les projets Valhalla et Leyden illustrent la manière dont Java continue d’évoluer grâce à des innovations de plateforme soigneusement conçues."

Autre nouveauté : Helidon 27. Il s'agit d'un framework Java open source cloud-native destiné à l’écriture de microservices s’exécutant sur un cœur Web rapide alimenté par les threads virtuels Java. 

Sur la partie JavaFX, cette version apporte d'importantes évolutions : JavaFX 27 contribue à améliorer les performances, la facilité d’utilisation et l’accessibilité grâce à un pipeline de rendu Metal sur macOS, à des contrôles d’édition de texte plus riches et à des améliorations continues de l’accessibilité. Intégré à Java Verified Portfolio, JavaFX bénéficie du support commercial d’Oracle, ce qui aide les clients à créer et à maintenir des interfaces utilisateur Java modernes avec davantage de confiance.

OpenJDK 27 et 28 : roadmap et JEP

Soumis par francoistonic le
Image

OpenJDK 27 se rapproche. La version finale est attendue le 15 septembre. 

Les JEP qui seront intégrées :

523:Make G1 the Default Garbage Collector in All Environments527:Post-Quantum Hybrid Key Exchange for TLS 1.3531:Lazy Constants (Third Preview)532:Primitive Types in Patterns, instanceof, and switch
(Fifth Preview)
533:Structured Concurrency (Seventh Preview)534:Compact Object Headers by Default536:JFR In-Process Data Redaction537:Vector API (Twelfth Incubator)538:PEM Encodings of Cryptographic Objects (Third Preview)La JDK 27 intègre 3 JEP dans le core code Java (531, 533 et 537), 3 concernent HotSpot (523, 534 et 536), 2 ciblent la sécurité (527 et 538) dont le post quantique. OpenJDK 28 : mars 2027La JDK suivante est planifiée pour mars 2027. 5 JEP sont déjà annoncées : 401, 535, 539, 540 et 541. La 541 annonce le retrait du x86 de la version macOS. La 542 (PEM encodings pour les objets chiffrés) est indiquée comme cible mais le planning peut encore changer. Actuellement la JDK 28 est en build 9. 

OpenJDK bannit les contributions générées par IA, GraalVM plus souple

Soumis par francoistonic le

La prise de position sur les contributions et pull requests générées par IA se multiplie. La gouvernance d'OpenJDK avait publié un « Interim Policy on Generative AI » le 9 avril dernier. La position est très claire : "Les contributions à la communauté OpenJDK ne doivent pas inclure de contenu généré, en tout ou en partie, par des LLM, des modèles de diffusion ou de type deep learning. Dans ce contexte, le terme « contenu » inclut, sans s'y limiter, le code source, les textes et les images présents dans les dépôts Git d'OpenJDK, les demandes d'extraction GitHub, les messages électroniques, les pages wiki et les tickets JBS."

OpenJDK autorise les contributions de la communauté à utiliser les outils d'IA à titre privé pour examiner du code OpenJDK ou d'autres éléments. Mais ils ne peuvent les utiliser pour des contributions directes.

Parmi les effets néfastes, OpenJDK met en avant le risque de submerger les reviewers d'OpenJDK avec des contenus ou du code généré en "masse" par l'IA. Autre point soulevé, la propriété intellectuelle du contenu généré. L'Oracle Contributor Agreement dit que la propriété d'une contribution doit appartenir à l'auteur.

Par contre, GraalVM, qui est indépendant de la gouvernance d'OpenJDK, autorise l'usage de l'IA : les contributeurs GraalVM peuvent utiliser des agents de codage ou similaires pour préparer une contribution. GraalVM s'inspire directement de la politique du noyau Linux et de son tag : « Assisted-by ». Mais GraalVM n'impose pas une indication spécifique, bien qu'elle soit encouragée pour la transparence. Mais attention, GraalVM fait confiance au contributeur utilisant un outil d'IA. Il doit relire, comprendre et vérifier que le contenu généré est correct. Dans le cas contraire, la contribution générée par IA pourra être refusée.

La FAQ complète

What are the risks to reviewer burden of using generative AI tools?

  1. Generative AI tools, by their nature, make it easy to create large quantities of plausible-looking code, with plausible-looking tests, which is nonetheless incorrect or, even if it is correct, is poorly designed and therefore difficult to maintain. Reviewing submissions of such code can easily become a drain on the already limited time of human reviewers. For this reason, some open-source communities have limited, if not banned, the submission of code created by generative AI tools.

  2. What are the risks to safety and security of using generative AI tools?

    The JDK, developed and maintained in the OpenJDK Community, is the primary implementation of the Java Platform. It sits at the foundation of mission-critical systems in businesses, governments, and other organizations around the world. Safety and security are paramount. Plausible-looking but incorrect code would put these critical properties at risk.

  3. What are the intellectual-property risks of using generative AI tools?

    The Oracle Contributor Agreement (OCA) requires that a contributor own the intellectual property rights in each contribution and be able to grant those rights to Oracle, without restriction. Most generative AI tools, however, are trained on copyrighted and licensed content, and their output can include content that infringes those copyrights and licenses, so contributing such content would violate the OCA. Whether a user of a generative AI tool has IP rights in content generated by the tool is the subject of active litigation.

  4. Despite these risks, generative AI tools can provide significant value. Are OpenJDK contributors forbidden from using them altogether?

    No. As the policy says, you are welcome to use such tools to help comprehend, debug, and review OpenJDK code and other content. Anecdotal evidence from other communities suggests that analysis of existing code, rather than creation of new code, is where generative AI tools shine for established projects with large code bases. This is consistent with our experience thus far.

  5. What does it mean to use generative AI tools “privately”?

    The intent of that term is to emphasize that you may use such tools on your own, without contributing the content that they generate. It does not mean that you cannot, e.g., share and discuss the output of such tools with a colleague. When sharing such content, consider adding prominent comments that identify it as being AI-generated.

  6. Is it okay to continue using the spell-checking, grammar-checking, auto-completion, and refactoring features in my editor or IDE?

    Yes, so long as they are not based on large language models or similar deep-learning systems.

  7. Is it okay to use a generative AI tool to review draft JEPs, JavaDoc, or other documents, so long as I write all of the text myself?

    Yes. This is clearly a case of using a generative AI tool to review content, which is fine.

  8. If I use a generative AI tool to create 100 lines of code, and then edit ten of those lines myself, may I contribute the result?

    No. Your contribution would still include, in part, AI-generated code.

  9. Can we improve any of our tooling to help remind contributors of this policy?

    Yes. We will shortly reconfigure Skara to add a checkbox to the body of each pull request on GitHub. When you create a pull request, you must check the box to affirm that your contribution is in accordance with the policy. More details, including how to add the checkbox to the body of an existing pull request, are available in the wiki.

  10. In an OpenJDK Project, is it okay to add a feature that calls out to an external AI service?

    That depends upon the service’s terms of use, so this amounts to a legal question. Be aware that many such terms place strict limits on how the service may be used. Consult your attorney, or your employers’ attorney, as appropriate, and make sure that everyone with a vested interest in your Project has also consulted appropriate attorneys.

  11. As a Reviewer in an OpenJDK Project, am I responsible for detecting when a contributor has submitted code or other content created with a generative AI tool?

    In this role you are already expected to do your best to ensure that incoming contributions are consistent with OpenJDK Community policies and conventions. In general, reliably distinguishing human-generated content from AI-generated content is impossible. If, however, you see evidence that content in a contribution was created with a generative AI tool, then it is your responsibility to notify the contributor of that fact. If the contributor does not respond positively and remove the content, please bring that to the attention of the appropriate Project Lead.

  12. What are some tell-tale clues of content created by generative AI tools?

    Sometimes it is obvious, for example when a commit message in the personal fork from which a contributor initiates a pull request includes a Co-Authored-By trailer line that gives credit to a specific generative AI tool. Other times it is more subtle, for example when a contributor’s comments in a pull-request conversation or an e-mail message are in a chatty, verbose style inconsistent with their past writing. Other clues include highly structured comments with multiple headings, unnecessary comments in code, gratuitously defensive programming, and the use of emoji characters.

    Generative AI tools are evolving rapidly, so clues that are effective indicators today might not be effective indicators tomorrow. In general, if something in a pull request seems uncannily cheerful or meticulous then you could be looking at AI-generated content.

Source : https://openjdk.org/legal/ai

Java 27 : la roadmap se précise, JEP

Soumis par francoistonic le

Le développement de Java 27 va rentrer dans une phase active. Actuellement disponible en build 17, la prochaine JDK a désormais un calendrier plus précis :

1ere phase de développement : 4 juin

2e phase : 16 juillet

1ere version Release Candidate : 6 août

RC finale : 20 août

Disponibilité générale : 14 septembre. 

Pour le moment, très peu de choses sont annoncées :

JEP 527 : post quantique

Java 26 est disponible : sécurité, optimisation, IA et JEP

Soumis par francoistonic le
Image

Java 26 est officiellement disponible. Cette version mise sur la sécurité, le chiffrement et l'IA. Le support commercial de JavaFX et d’Helidon est désormais disponible dans le nouvel Oracle Java Verified Portfolio, une collection complète d’outils, de frameworks, de bibliothèques et de services liés au JDK.

Les principales JEP de Java 26

JEP 530 : Types primitifs dans les patterns, instanceof et switch (quatrième aperçu) : aide les développeurs à gagner en productivité et à rationaliser le développement d’applications intégrant l’inférence IA, en rendant Java plus uniforme et plus expressif. Cette évolution supprime plusieurs restrictions liées aux types primitifs qui compliquaient l’utilisation de pattern matching, instanceof et switch. Pour améliorer encore la productivité, elle renforce également la définition de l’exactitude inconditionnelle et applique des contrôles de dominance plus stricts dans les constructions switch, permettant au compilateur d’identifier et de réduire un plus large éventail d’erreurs de codage. 

JEP 522 : Ramasse-miette G1 : amélioration du débit grâce à une réduction de la synchronisation : aide les développeurs à traiter davantage de tâches en moins de temps en améliorant l’efficacité de la mémoire. Cela réduit la synchronisation entre les threads de l’application et ceux du garbage collector, ce qui augmente le débit avec le ramasse-miette G1. En s’exécutant plus vite et en prenant en charge davantage d’utilisateurs sans matériel supplémentaire, Java améliore l’efficacité, réduit les coûts d’infrastructure et offre une expérience utilisateur plus fluide.

JEP 516 : Mise en cache anticipée des objets avec n’importe quel ramasse-miette : améliore la productivité des développeurs et l’efficacité des ressources en accélérant le démarrage des applications Java avec n’importe quel ramasse-miette (garbage collector). Cela permet le chargement séquentiel en mémoire d’objets Java préinitialisés mis en cache à partir d’un format neutre, indépendant du ramasse-miette. Cela améliore également le cache anticipé, permettant à la HotSpotJava Virtual Machine d’optimiser les temps de démarrage et de warm-up et d’être utilisée avec n’importe quel ramasse-miette, dont ZGC à faible latence. Les développeurs peuvent ainsi réduire les délais de démarrage des applications, faire évoluer leurs applications plus rapidement et offrir une meilleure expérience utilisateur. 

JEP 500 : Préparation au fait que final signifie réellement final : aide les développeurs à renforcer la sécurité et la fiabilité des applications en empêchant des modifications involontaires, des altérations ou des erreurs accidentelles dans des systèmes métier critiques. Cette approche émet des avertissements en cas d’utilisation de la réflexion approfondie (deep reflection) pour modifier des champs final et permet aux développeurs de modifier des champs final lorsque c’est indispensable, afin d’éviter à la fois les avertissements actuels et les restrictions à venir. Ce changement essentiel renforce le principe « d’intégrité par défaut » de Java, axé sur la protection des données sensibles et de la logique métier, la réduction des risques cachés et la diminution de la probabilité de bugs ou de vulnérabilités de sécurité. 

JEP 517 : HTTP/3 pour l’API du client HTTP : aide les développeurs à gagner en productivité en facilitant l’écriture de code interagissant avec des serveurs HTTP. Cette mise à jour de l’API du client HTTP prend en charge le protocole HTTP/3, permettant aux bibliothèques et aux applications d’interagir avec des serveurs HTTP/3 avec des modifications de code minimales. En supprimant ces goulots d’étranglement courants et en accélérant la récupération des données avec une latence réduite, elle permet aux microservices et aux applications Java pilotées par des API d’obtenir de meilleures performances et des connexions réseau plus fiables.

JEP 526 : Constantes paresseuses (deuxième aperçu) : aide les développeurs à gagner en productivité et à utiliser les ressources plus efficacement en offrant davantage de flexibilité quant au moment de leur initialisation, ce qui est particulièrement utile pour les applications d’IA et orientées données. Grâce à une nouvelle API pour les constantes paresseuses, des objets qui contiennent des données non modifiables, la JVM traite ces constantes comme de véritables constantes afin d’obtenir les mêmes performances que lors de la déclaration d’un champ final. En outre, en permettant aux applications Java et à leurs services cloud native et basés sur l’IA de démarrer plus rapidement et d’utiliser plus efficacement les ressources de calcul, elle aide les développeurs à réaliser des déploiements agiles et scalables, générant des économies et une meilleure expérience pour les utilisateurs finaux.

JEP 525 : Concurrence structurée (sixième aperçu) : aide les développeurs à améliorer la maintenabilité, la fiabilité et l’observabilité du code multithread, ce qui est particulièrement utile pour renforcer la scalabilité et la résilience des workloads d’IA et cloud native. Elle simplifie la programmation concurrente via une API de concurrence structurée, qui traite des groupes de tâches liées s’exécutant dans différents threads comme une unité de travail unique et contribue à réduire les risques courants liés à l’annulation et à l’arrêt, tels que les fuites de threads et les délais d’annulation. 

JEP 529 : API vectorielle (11e incubation) : aide les développeurs à améliorer les performances et le rapport coût-efficacité de leurs applications Java en leur permettant de produire davantage d’analyses et de valeur avec moins de matériel. L’API vectorielle décrit des calculs vectoriels qui sont compilés de manière fiable à l’exécution en instructions vectorielles optimales sur les architectures CPU prises en charge, ce qui accélère le traitement des workloads d’analyse de données, d’inférence IA et de calcul scientifique. Les développeurs peuvent ainsi obtenir des performances supérieures à celles de calculs scalaires équivalents, souvent utilisés dans les scénarios d’inférence IA et de calcul. 

JEP 524 : Encodages PEM d’objets cryptographiques (deuxième aperçu) : aide les développeurs à gagner en productivité et à renforcer la sécurité des applications Java sur des formats de sécurité largement utilisés grâce à une nouvelle API d’encodage. L’API encode les objets représentant les clés cryptographiques, les certificats et les listes de révocation de certificats dans le format de transport de courrier largement utilisé et optimisé pour la confidentialité, puis le décode pour les retransformer en objets. Cela réduit le risque d’erreurs, simplifie la conformité et améliore la portabilité et l’interopérabilité des applications Java sécurisées, en rationalisant la configuration et l’intégration de la cryptographie pour les besoins des entreprises, du cloud et des exigences réglementaires.

JEP 504 : Suppression de l’Applet API : aide les développeurs à réduire l’empreinte de leurs installations et de leur code source, et à améliorer les performances, la stabilité et la sécurité des applications en supprimant l’Applet API, dépréciée en vue de sa suppression dans JDK 17 et désormais retirée de la plateforme.

En plus des 10 JEP, Java 26 apporte des dizaines de mises à jour qui aident les entreprises à renforcer la sécurité, la fiabilité et les performances de leurs applications. Avec Java 26, les entreprises peuvent désormais rationaliser le chiffrement sécurisé avec le mécanisme standard du secteur de chiffrement par clé public hybride (HPKE), pérenniser leurs chaînes d’approvisionnement grâce à la signature de JAR compatible avec l’ère post-quantique, et bénéficier d’une meilleure prise en charge des standards mondiaux grâce aux mises à jour vers Unicode 17.0 et CLDR v48. De plus, des contrôles renforcés pour les algorithmes de chiffrement et les keystores hérités consolident encore la sécurité et la conformité, aidant les entreprises à moderniser leurs environnements en toute confiance.

Un peu de Project Valhalla avec la JEP 401

Soumis par francoistonic le

Le projet Valhalla fut parlé de lui depuis 10 ans. Il apparait de plus en plus comme une illusion même les équipes cherchent à intégrer des "morceaux" de Valhalla en attendant peut-être son support complet. La JEP 401 injecte un peu de Valhalla à la JDK. La JEP 401 arrive maintenant en Build 27-jep401ea3+1+1. C'est en dire en preview. La JEP 401 apporte la notion de Value Classes and Objects. La early access n'est qu'une étape d'une potentielle intégration dans la JDK. En octobre 2025, OpenJDK indiquait juste les premières builds de Value Classes and objects...

Cette mise à jour d'octobre précisait : Valhalla repose sur 5 fonctions distinctes. A savoir : 

- Value Classes and Objects : introduire des objets dépourvus d'identité et peuvent recevoir des encodages optimisés

- Null Checking : pour mieux gérer les flux null en compilation et en runtime

- Array Enhancements

- Unifying Primitives and classes

- Paratremeic JVM

La JEP 401 a pour but de : 

- Permettre aux développeurs d'opter pour un modèle de programmation pour les domain values où les objets sont différenciés uniquement par les valeurs de leurs champs, à l'instar de la distinction entre les entiers 3 et 4.- migration des classes existantes représentant des domain values vers ce modèle. Migrer les classes appropriées de la JDK, telles que `Integer` et `LocalDate`, vers le statut de classes de valeurs.- Optimiser la flexibilité de la JVM pour le stockage des domain values afin d'améliorer le poids mémoire, la localité des données et l'efficacité du ramasse-miettes.Cette build repose sur une build partielle de la JDK 27. Et vous qu'en pensez-vous ? Pour en savoir plus : https://openjdk.org/jeps/401Documentation Value Classes and Objects : https://openjdk.org/projects/valhalla/value-objects