IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)

Vous êtes nouveau sur Developpez.com ? Créez votre compte ou connectez-vous afin de pouvoir participer !

Vous devez avoir un compte Developpez.com et être connecté pour pouvoir participer aux discussions.

Vous n'avez pas encore de compte Developpez.com ? Créez-en un en quelques instants, c'est entièrement gratuit !

Si vous disposez déjà d'un compte et qu'il est bien activé, connectez-vous à l'aide du formulaire ci-dessous.

Identifiez-vous
Identifiant
Mot de passe
Mot de passe oublié ?
Créer un compte

L'inscription est gratuite et ne vous prendra que quelques instants !

Je m'inscris !

Malgré OpenJDK, 70% des correctifs et fonctionnalités Java proviennent d'Oracle,
Selon des statistiques d'Oracle sur les problèmes résolus dans JDK 11 - JDK 20 par organisation

Le , par Stéphane le calme

1PARTAGES

7  0 
Oracle a publié Java 20 et affirme que depuis Java 11 en 2018, il a contribué à plus de 70 % des correctifs et des fonctionnalités, mesurés par les problèmes du système de suivi des problèmes JIRA.

« Sur les 21 604 problèmes JIRA marqués comme résolus dans Java 11 à Java 20 au moment de leur disponibilité générales, 15 420 ont été résolus par des personnes travaillant pour Oracle tandis que 6 184 ont été apportés par des développeurs individuels et des développeurs travaillant pour d'autres organisations », a déclaré la société. Dans le cas du JDK 20, 1 595 des 2 314 numéros ont été complétés par Oracle, ce qui approche les 69 %.


Plus tôt ce mois-ci, Oracle a annoncé la disponibilité générale de Java 20 (ou JDK 20). Parmi les principales fonctionnalités de JDK 20, nous pouvons citer :

  • Scoped values : Cette API permet de partager des données immuables au sein d'un même thread ou entre plusieurs threads. Ces valeurs sont préférables aux variables locales aux threads, en particulier quand on utilise un grand nombre de threads virtuels. Scope Value permet de partager des données de manière sûre et efficace entre les composants d'un grand programme sans recourir aux arguments de méthode.
  • Record Patterns : ils améliorent le langage de programmation Java avec des motifs pour déconstruire les valeurs d'enregistrement Record Values. Les motifs d'enregistrement (record patterns) et les motifs de type (type patterns) peuvent être imbriqués pour permettre une forme déclarative, puissante et composable de navigation et de traitement des données.
  • Structured Concurrency : Cette API vient simplifier la programmation multithread et traite plusieurs tâches exécutées dans différents threads comme une seule unité de travail. La gestion et l'annulation des erreurs sont rationalisées, ce qui améliore la fiabilité et l'observabilité. Le seul changement depuis son incubation dans le JDK 19 est que StructuredTaskScope a été mis à jour pour prendre en charge l'héritage des Scoped Values par les threads créés dans la portée d'une tâche.
  • Correspondance de modèles pour les expressions et déclarations switch : La fonctionnalité permet l'expression concise et sûre de requêtes complexes orientées données. Elle pourra évoluer en continu avec les Record Patterns, ce qui permettra des améliorations continues basées sur l'expérience et le feedback. Parmi les principales modifications apportées au Pattern matching for switch, on peut citer une grammaire simplifiée pour les étiquettes de switch et la prise en charge de l'inférence des arguments de type pour les generic patterns et les record patterns dans les déclarations et expressions de switch. De plus, un switch exhaustif sur une classe enum provoque désormais une MatchException plutôt qu'une IncompatibleClassChangeError si aucune étiquette de switch ne s'applique au moment de l'exécution.


Java 20, statistiques

Dans un billet de blog, Oracle a déclaré : « Comme nous l'avons fait avec les versions précédentes, avec Java 20, nous célébrons les contributions de nombreuses personnes et organisations de la communauté OpenJDK - nous construisons tous Java, ensemble ! »

Rapport de correction JDK 20

Le taux de changement au fil du temps dans les versions du JDK est resté largement constant pendant des années, mais sous la cadence de six mois, le rythme auquel les fonctionnalités et les améliorations prêtes pour la production sont livrées a fortement augmenté.

Au lieu de créer des dizaines de milliers de correctifs et de fournir près d'une centaine de JEP (propositions d'amélioration du JDK) toutes les quelques années, comme nous l'avons fait avec les versions majeures d'antan, les améliorations sont fournies dans des versions de fonctionnalités plus légères selon un calendrier de six mois plus gérable et prévisible. Les changements vont de nouvelles fonctionnalités importantes à de petites améliorations en passant par la maintenance de routine, les corrections de bogues et les améliorations de la documentation. Chaque modification est représentée dans un seul commit pour un seul problème dans le système de bogues JDK.

Sur les 21 604 problèmes JIRA marqués comme résolus dans Java 11 à Java 20 au moment de leur disponibilité générale, 15 420 ont été résolus par des personnes travaillant pour Oracle tandis que 6 184 ont été apportés par des développeurs individuels et des développeurs travaillant pour d'autres organisations. En parcourant les problèmes et en rassemblant les données d'organisation des cessionnaires, on obtient le tableau suivant des organisations parrainant le développement de contributions en Java*:


Problèmes résolus dans JDK 11 - JDK 20 par organisation

Dans Java 20, sur les 2 314 problèmes JIRA marqués comme corrigés, 1 595 ont été résolus par Oracle, tandis que 719 ont été apportés par d'autres membres de la communauté Java. Oracle tient à remercier les développeurs travaillant pour des organisations telles qu'Alibaba, Amazon, ARM, Google, Huawei, IBM, Intel, ISCAS, Red Hat, SAP et Tencent pour leurs contributions notables. Nous sommes également reconnaissants de voir les contributions de petites organisations telles que Bellsoft et Loongson, ainsi que de développeurs indépendants qui ont collectivement contribué à 7*% des correctifs de Java 20.

Nous sommes également reconnaissants aux nombreux développeurs expérimentés qui ont examiné les modifications proposées, aux premiers utilisateurs qui ont essayé les versions à accès anticipé et signalé des problèmes, et aux professionnels dévoués qui ont fourni des commentaires sur les listes de diffusion OpenJDK.

En clair

Le deuxième contributeur le plus important depuis 2018 est Red Hat, selon les statistiques, suivi des indépendants, puis de SAP. Dans les statistiques du JDK 20, les indépendants sont légèrement en avance sur Red Hat, avec SAP toujours à la quatrième place.

Il s'agit d'une mesure quelque peu grossière, car plusieurs personnes de différentes organisations peuvent contribuer à un problème ; mais cela ne montre rien d'autre qu'Oracle qui consacre beaucoup de ressources à Java, qu'il décrit comme le « langage de programmation n°1 pour les tendances technologiques d'aujourd'hui ». C'est peut-être une exagération, puisque la plupart des enquêtes le placent derrière JavaScript et Python, mais si le contexte est celui des applications d'entreprise, cela reste extrêmement important.

L'une des raisons de l'accent mis sur les correctifs peut être qu'il n'y a pas grand-chose de nouveau dans JDK 20, à moins que vous ne comptiez les Preview mis à jour. Les grosses fonctionnalités qu'attendent les développeurs, comme les threads virtuels (Project Loom), ou le remplacement de JNI Java Native Interface (Project Panama), ne sont pas encore définitives. La correspondance de modèles (Project Amber) a également un aperçu mis à jour. Scoped Values, qui fait partie du projet Loom, apparaît pour la première fois dans le JDK en tant « qu'incubateur », la première étape d'une nouvelle fonctionnalité majeure.

Peu importe qu'il s'agisse d'une version légère pour les fonctionnalités, car il ne s'agit pas d'une version de support à long terme (LTS), d'ailleurs elle sera remplacée dans six mois par JDK 21, qui sera une version LTS. La cadence des versions LTS est maintenant de deux ans.

La sortie du JDK 20 s'accompagne de nouvelles versions d'autres implémentations d'OpenJDK. Amazon a publié Corretto 20 et a déclaré que « les points forts d'OpenJDK 20 incluent une deuxième Preivew des Record Patterns, qui sont utilisés pour travailler plus facilement avec des objets basés sur des enregistrements ».

Source : Inside Java

Et vous ?

Quelle lecture faites-vous de ces statistiques ?
Comment pouvez-vous les interpréter ?
Que pensez-vous du fait que ça soit Oracle qui les publient ?
Ces statistiques gagneraient-elles à être plus étayées ?
Ce format favorise-t-il Oracle ? Dans quelle mesure ?

Une erreur dans cette actualité ? Signalez-nous-la !

Avatar de foxzoolm
Membre régulier https://www.developpez.com
Le 25/03/2023 à 11:25

List<Point> points=....
for ( Point(int x, int y): points ){
...
}
la question est : le sucre syntaxique fit-il grossir ?

perso je trouve se genre d'annotation extrêmement dangereuse...
le principe de la POO (selon moi) etant de garder les methodes et les datas le plus proche possible (syntaxiquement)...

voir des x, y se balander dans le code sans lien avec l'objet... SIC!!!
4  0 
Avatar de thelvin
Modérateur https://www.developpez.com
Le 25/03/2023 à 17:27
Citation Envoyé par professeur shadoko Voir le message
Si mes souvenirs sont bons parmi les principes avancés à l'intérieur de l'équipe initiale Java il y avait: méfions nous des "facilités d'écriture"! au risque d'être bavards pas d'implicites, pas de raccourcis! ça fait déjà un bout de temps que ces principes sont partis à la poubelle.
Oui ben ça nous a filé les lambdas et le instanceof pattern.
Le moins que l'on puisse dire est que mettre ces principes à la poubelle a été, jusqu'à maintenant, très bénéfique.
4  0 
Avatar de professeur shadoko
Membre chevronné https://www.developpez.com
Le 25/03/2023 à 9:04
Citation Envoyé par miaous Voir le message
avec JEP 432 : Record Patterns (deuxième préversion) pour un record Point (int x, int y)
tu pourras ecrire
Code : Sélectionner tout
1
2
3
4
5
6
List<Point> points=....
for ( Point(int x, int y): points ){
System.out.println(" " +x ", " +y );

}
équivalent à:

Code : Sélectionner tout
1
2
3
4
5
6
7
8
List<Point> points=....
for ( Point p: points ){
int x=p.x();
int y=p.y();
System.out.println(" " +x ", " +y );

}
Si mes souvenirs sont bons parmi les principes avancés à l'intérieur de l'équipe initiale Java il y avait: méfions nous des "facilités d'écriture"! au risque d'être bavards pas d'implicites, pas de raccourcis! ça fait déjà un bout de temps que ces principes sont partis à la poubelle.
0  0 
Avatar de professeur shadoko
Membre chevronné https://www.developpez.com
Le 26/03/2023 à 17:15
Citation Envoyé par thelvin Voir le message
Oui ben ça nous a filé les lambdas et le instanceof pattern.
Le moins que l'on puisse dire est que mettre ces principes à la poubelle a été, jusqu'à maintenant, très bénéfique.
pas de pb pour le instanceof mais pour le cas de lambda mes sentiments sont très partagés: c'est pratique mais une source d'effets de bord pas très explicites. Je rêve d'une forme syntaxique dans laquelle ce qui est modifiable dans le contexte soit bien spécifié (au risque d'être horriblement bavard).
0  0 
Avatar de bouye
Rédacteur/Modérateur https://www.developpez.com
Le 27/03/2023 à 5:37
C'est une question d'habitude a prendre, on a le même soucis avec les accesseurs des champs des record qui laissent tomber le prefix get (is pour les boolean) et se contentent de reprendre le nom de la variable a l'identique.
0  0 
Avatar de floyer
Membre averti https://www.developpez.com
Le 27/03/2023 à 16:16
Les lambda peuvent être très utile dans une approche fonctionnelle. On a une collection, et on déduit une autre collection avec map ou filter. Une approche «*purement fonctionnelle*» évite justement des effets de bord. Évidemment la fonction lambda peut avoir un effet de bord en interagissant avec les objets qui lui sont proposés, mais pas plus qu’un bloc équivalent dans une boucle for.
0  0