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

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

  1. #1
    Chroniqueur Actualités

    Homme Profil pro
    Administrateur de base de données
    Inscrit en
    Mars 2013
    Messages
    8 614
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Canada

    Informations professionnelles :
    Activité : Administrateur de base de données

    Informations forums :
    Inscription : Mars 2013
    Messages : 8 614
    Points : 200 840
    Points
    200 840
    Par défaut La police Java d'Oracle frappe pour la première fois aux portes des entreprises du Fortune 200
    Oracle augmente fortement le prix des licences Java, s'appuyant désormais sur le nombre d'employés et non de processeurs.
    Une entreprise qualifie de « prédatrices » les stratégies d'Oracle

    Oracle est accusé de tactiques de licence « prédatrices » après avoir apporté des modifications au modèle d'abonnement Oracle Java SE qui pourraient obliger les entreprises à payer des dizaines de milliers de dollars de plus chaque mois pour se servir du même logiciel. Les experts du secteur ont souligné que les entreprises ayant une utilisation limitée de Java devraient fournir une licence par employé dans le cadre du nouveau modèle, un changement radical par rapport à celui qu'Oracle leur offrait auparavant qui était plutôt une facturation par utilisateur ou par processeur.

    Depuis le 23 janvier 2023, Oracle a remplacé les abonnements Oracle Java SE couramment achetés par les clients par un nouvel abonnement Oracle Java SE Universal.

    Oracle décrit l'abonnement Java SE Universal comme étant : « un abonnement mensuel simple et peu coûteux qui inclut la licence et le support Java SE pour une utilisation sur les postes de travail, les serveurs ou les déploiements dans le cloud. L'abonnement donne accès à des mises à jour de performances, de stabilité et de sécurité testées et certifiées pour Java SE, directement depuis Oracle. Il comprend également l'accès à My Oracle Support (MOS) 24h/24 et 7j/7, une prise en charge en 27 langues, des fonctionnalités de gestion, de surveillance et de déploiement de Java SE 8 Desktop, entre autres avantages ».

    « Les clients des anciens produits d'abonnement Java SE continuent de bénéficier de tous les avantages d'origine et peuvent renouveler selon leurs conditions et mesures existantes », a déclaré Oracle. Son annonce est accompagnée d'une liste de prix, qui montre que la principale différence entre le nouveau et l'ancien modèle est que Java sera concédé sous licence par employé, plutôt que par utilisateur ou par processeur, comme l'ancien modèle le permettait.

    Alors que l'abonnement précédent était concédé sous licence de deux manières différentes selon que le logiciel était utilisé sur un serveur ou sur un ordinateur de bureau (ordinateur personnel), le nouvel abonnement universel a de nouvelles conditions d'utilisation. Notez que ces conditions diffèrent des conditions précédentes d'Oracle "Employé" et sont les suivantes :

    Citation Envoyé par Oracle
    Employé pour Java SE Universal Subscription : est défini comme (i) tous vos employés à temps plein, à temps partiel, temporaires, et (ii) tous les employés à temps plein, à temps partiel et les employés temporaires de vos agents, sous-traitants et consultants qui soutiennent vos opérations commerciales internes. La quantité de licences requises est déterminée par le nombre d'Employés et pas seulement par le nombre réel d'employés qui utilisent les Logiciels. Pour ces licences Java SE Universal Subscription, la quantité de licence achetée doit, au minimum, être égale au nombre d'Employés à la date d'effet de votre commande. Dans le cadre de cette métrique d'employé pour les programmes d'abonnement universel Java SE, vous ne pouvez installer et/ou exécuter le(s) programme(s) d'abonnement universel Java SE que sur un maximum de 50 000 processeurs, si votre utilisation dépasse 50 000 processeurs, à l'exclusion des processeurs installés et/ ou s'exécutant sur des ordinateurs de bureau et portables, vous devez obtenir une licence supplémentaire auprès d'Oracle.
    En clair, les nouvelles conditions exigent que les clients achètent désormais suffisamment d'abonnements en fonction du nombre total d'employés du client, qu'ils utilisent/exploitent le logiciel directement, indirectement ou pas du tout. Un client avec un petit nombre d'installations et un nombre élevé d'employés pourrait voir des factures de plusieurs millions de dollars par an.

    À titre d'exemple, un client comptant 20 000 employés utilisant JAVA SE à quelque titre que ce soit dans le cadre des nouvelles conditions d'abonnement devra acheter des abonnements universels JAVA SE pour l'ensemble des 20 000 employés, à un tarif mensuel de 6,75 $, soit un total de 1,62 million de dollars par an.

    En outre, il est nécessaire d'octroyer une licence aux employés, agents, sous-traitants et travailleurs temporaires de tiers qui prennent en charge les opérations commerciales internes des clients, ce qui nécessitera un examen plus approfondi et peut-être d'augmenter considérablement le nombre.

    Pour les nouveaux clients, ce dernier modèle s'appliquera immédiatement et pour les clients existants, ce modèle pourrait s'appliquer lors du prochain renouvellement. Bien qu'Oracle puisse signaler que les clients existants pourraient être en mesure de renouveler selon les conditions précédentes, cela ne doit pas être considéré comme une garantie. Les coûts initiaux publiés pour le modèle sont les suivants :

    Nom : oracle.png
Affichages : 348748
Taille : 17,7 Ko

    Lors de l'examen des déploiements de serveurs, les exigences relatives au nombre de processeurs (processeurs définis par Oracle) sont toujours requises, bien que peut-être moins soulignées, car en accordant une licence à tous les employés, les clients reçoivent une subvention allant jusqu'à 50 000 installations de processeur sans frais supplémentaires (des frais supplémentaires s'appliqueront aux clients avec des exigences de processeur plus élevées). Ces préoccupations précédentes des clients concernant les environnements virtualisés pourraient probablement toujours s'appliquer aux clients lors du calcul de cette limite, notant que la subvention de 50 000 processeurs est toujours régie et définie par les mêmes termes et définitions qui se sont révélés difficiles pour certains clients auparavant.

    Les réactions des professionnels

    Craig Guarente, fondateur et PDG du conseiller en licences logicielles Palisade Compliance

    Craig Guarente a déclaré : « Oracle déplace toujours les clients vers le nouveau modèle à un moment donné. De plus, quel est le prix ? Il n'y a aucun moyen pour qu'Oracle n'applique pas une politique perpétuelle d'augmentation des prix ».

    Ce changement pénaliserait les entreprises qui avaient passé des années à minimiser leur utilisation de Java, étant donné qu'elles seront désormais facturées par employé, quelle que soit la quantité de Java qu'elles utilisent.

    Il s'est laissé aller au calcul du coût pour deux scénarios.

    Nom : cle.png
Affichages : 7436
Taille : 145,2 Ko

    Scénario 1 : entreprise de taille moyenne avec une faible empreinte Java
    • Employés : 250
    • Utilisateurs Java Desktop : 20
    • Processeurs installés Java : 8
    • Ancien modèle : 3 000 $/an
    • Nouveau modèle : 45 000 $/an
    • Augmentation en pourcentage : 1 400 %


    « Dans l'ancien modèle d'abonnement, l'organisation payait 2,50 $/mois pour chacun des 20 utilisateurs de bureau et 25,00 $/mois pour chaque processeur sur lequel Java SE était installé et/ou en cours d'exécution. Dans le nouveau modèle, il n'y a pas de frais distincts pour le poste de travail et le serveur, mais désormais, chaque employé sera facturé pour l'abonnement Java.

    « Considérons maintenant une entreprise de taille similaire, mais avec une plus grande empreinte Java, et chaque employé nécessitant un accès au bureau ».

    Scénario 2 : entreprise de taille moyenne avec une large empreinte Java
    • Employés : 250
    • Utilisateurs Java Desktop : 250
    • Processeurs installés Java : 48
    • Ancien modèle : 21 900 $/an
    • Nouveau modèle : 45 000 $/an
    • Pourcentage d'augmentation : 105 %

    Même si chaque employé de l'entreprise utilise Java dans ce scénario, le prix de l'abonnement annuel fera plus que doubler !

    Les chiffres deviendront plus stupéfiants avec les grandes entreprises. Même l'exemple de tarification d'Oracle montre que la grande entreprise (28 000 employés et agents) aura une facture d'abonnement annuelle de 2 268 000 $ !

    À ce jour, nous avons déjà entendu de nos clients qu'ils sont contactés (harcelés) par leurs représentants commerciaux Java pour adopter ce "modèle d'abonnement plus facile à comprendre". Nous nous attendons à ce que des légions de vendeurs Oracle salivent pour verrouiller ces nouveaux abonnements avant la date limite de fin de trimestre de février pour leurs bonus personnels. Ce changement Java donne également à chaque représentant Oracle une excuse pour essayer d'auditer les clients sur l'ensemble de leur empreinte Oracle (base de données, middleware, Java, applications), donc se préparer maintenant est essentiel pour réduire les coûts inattendus potentiels.
    « Nous avons un client qui a un abonnement Java, un contrat de licence universel pour Oracle Java, pour toute l'entreprise. Cependant, avec la nouvelle tarification, leur coût pour Java est multiplié par 10. Nous avons effectué des analyses sur plusieurs autres entreprises et la moyenne que nous constatons est une augmentation de prix de 2 à 4 fois que cela entraînera parce que les clients ont été très bons pour minimiser l'utilisation d'Oracle Java et obtenir un prix inférieur. C'est ainsi que vous obtenez un effet de levier avec Oracle ».

    Il a ajouté : « Non seulement Oracle peut voir que vous avez téléchargé le logiciel, mais avec Java, ils peuvent voir que vous l'avez installé et que vous avez commencé à l'exécuter. Un client nous a contactés en disant : 'Hé, regardez ce que mon représentant Oracle a dit. Ils ont pu voir que nous téléchargeons ce genre de choses et que le renouvellement de l'abonnement Java a lieu en avril, alors ils veulent parler du nouveau modèle de tarification ».

    Guarente explique qu'un autre client a dit : « C'est une approche prédatrice, même pour Oracle ».

    Nick Walter, CTO chez House of Brick, spécialiste du support Oracle

    Nick Walter a déclaré : « Si Oracle fonctionne fidèlement à la forme des incidents passés de dépréciation d'un modèle de tarification ou d'une métrique de licence, ils feront probablement tout leur possible pour forcer les clients à adopter le nouveau modèle. Ils peuvent permettre aux gens de renouveler les métriques et l'accord existants, mais s'ils ont besoin d'acheter une licence incrémentielle, ils seront très probablement contraints d'opter pour le modèle le plus récent et le plus coûteux. »

    Sources : Oracle Java SE Universal Subscription FAQ, facturation, House of Brick

    Et vous ?

    Que pensez-vous de cette approche d'Oracle ?
    Comprenez-vous le client qui parle d'une approche prédatrice ?
    Contribuez au club : Corrections, suggestions, critiques, ... : Contactez le service news et Rédigez des actualités

  2. #2
    Expert confirmé Avatar de AoCannaille
    Inscrit en
    Juin 2009
    Messages
    1 418
    Détails du profil
    Informations forums :
    Inscription : Juin 2009
    Messages : 1 418
    Points : 4 757
    Points
    4 757
    Par défaut
    Que pensez-vous de cette approche d'Oracle ?
    On s'y attendais depuis le rachat de Sun. Oracle n'a que 2 stratégies sur ses produits acheté : les abandonner, ou les sur-facturer.


    Comprenez-vous le client qui parle d'une approche prédatrice ?
    Clairement, et rien de nouveau sous le soleil.

    J'ai l'impression qu'Oracle s'applique à traire tous les clients qui sont captifs de leur technologie. La seule chose qui peut en découler, c'est un ressentiment fort vis à vis d'eux et un écartement progressif de leurs solutions.
    Pour leur SGBD ça s'entend car ils sont sur un secteur assez peu concurrentiel sur des volumes extraordinaire (Même si je pense que leur tarification abusive est en partie à l'origine des nouvelles architectures à la mode décentralisé type microservices qui permettent de s'appuyer sur des modèles plus petits et donc sur des concurrents moins voraces).
    Par contre, pour un langage, en particulier un généraliste, alors c'est juste le condamner à mort. Il existe des concurrents génériques et pléthore de concurrent spécialisés. En somme jamais Java n'est irremplaçable.

    J'ai beau vomir cette stratégie, j'imagine qu'elle fonctionne, vu les résultats en bourse:
    Nom : Annotation 2023-02-01 105208.png
Affichages : 6964
Taille : 41,8 Ko

  3. #3
    Membre chevronné

    Profil pro
    Chef de Projet / Développeur
    Inscrit en
    Juin 2002
    Messages
    602
    Détails du profil
    Informations personnelles :
    Localisation : France, Loire Atlantique (Pays de la Loire)

    Informations professionnelles :
    Activité : Chef de Projet / Développeur
    Secteur : Santé

    Informations forums :
    Inscription : Juin 2002
    Messages : 602
    Points : 2 037
    Points
    2 037
    Par défaut
    Obliger à payer une licence pour un employé qui n'utilise pas le logiciel, je me demande ce que cela vaux face au droit français.
    Et même au US, je pense que cela va donner droit à un procès tant le système est inique.

    A long terme, je ne voit pas comment cela peut mener à autre chose que des utilisateurs vont passer de "réduire" à "supprimer" leur utilisation de des produits Oracle.
    (ce qui donnera droit à une nouvelle augmentation pour les derniers prisonniers du système)

    Je m'interroge sur la notion de "sous-traitant".
    Que si je suis tout seul, mais utilise un sous-traitant avec 250 salariés, je dois payer 251 licences ?
    --
    vanquish

  4. #4
    Membre régulier
    Homme Profil pro
    Développeur Java
    Inscrit en
    Juin 2022
    Messages
    16
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 39
    Localisation : Belgique

    Informations professionnelles :
    Activité : Développeur Java

    Informations forums :
    Inscription : Juin 2022
    Messages : 16
    Points : 73
    Points
    73
    Par défaut
    Ca montre bien qu'Oracle n'est plus une société IT depuis longtemps... à éviter comme la peste !

    Tout le monde ferait bien de migrer vers AdoptOpenJDK ou similaire.

    Je pense que les applis que ne fonctionneraient pas à cause de l'utilisation de technos propriétaires à Oracle doivent être rares... (genre Java Webstart, JavaFX et 2-3 trucs).

    Au pire utilisation de la dernière JVM 8 oracle qui avait une licence gratuite et ré-écriture, il faut absolument éviter toute dépendance envers ces voleurs.

  5. #5
    Membre habitué
    Avatar de RenardSpatial
    Homme Profil pro
    Ingénieur, Auteur
    Inscrit en
    Novembre 2018
    Messages
    18
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Autre

    Informations professionnelles :
    Activité : Ingénieur, Auteur

    Informations forums :
    Inscription : Novembre 2018
    Messages : 18
    Points : 125
    Points
    125
    Billets dans le blog
    2
    Par défaut Mais qui paie encore les licences Java à Oracle ?
    Avec toutes les alternatives basées sur OpenJDK, qui paie encore les licences Java à Oracle ? Même le support n’est plus un critère, puisque d’autres entreprises le vendent aussi.

    (PS : la « solution » qui consiste à continuer à utiliser la dernière version gratuite d’Oracle Java 8 n’en est pas une, pour d’évidentes raisons de sécurité).

  6. #6
    Expert confirmé
    Homme Profil pro
    Développeur
    Inscrit en
    Août 2003
    Messages
    1 304
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 37
    Localisation : France, Charente Maritime (Poitou Charente)

    Informations professionnelles :
    Activité : Développeur

    Informations forums :
    Inscription : Août 2003
    Messages : 1 304
    Points : 4 197
    Points
    4 197
    Par défaut
    Est-ce qu'OpenJDK ne va pas subir les foudres d'Oracle dans un avenir proche ?

    A l'avenir (proche ou lointain), je pense qu'il faudra absolument avoir Go ou Python ou Rust ou autre dans ses compétences afin d'anticiper un éventuel abandon du JAVA.

  7. #7
    Membre habitué
    Avatar de RenardSpatial
    Homme Profil pro
    Ingénieur, Auteur
    Inscrit en
    Novembre 2018
    Messages
    18
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Autre

    Informations professionnelles :
    Activité : Ingénieur, Auteur

    Informations forums :
    Inscription : Novembre 2018
    Messages : 18
    Points : 125
    Points
    125
    Billets dans le blog
    2
    Par défaut
    Citation Envoyé par smarties Voir le message
    Est-ce qu'OpenJDK ne va pas subir les foudres d'Oracle dans un avenir proche ?

    A l'avenir (proche ou lointain), je pense qu'il faudra absolument avoir Go ou Python ou Rust ou autre dans ses compétences afin d'anticiper un éventuel abandon du JAVA.
    Java ne craint pas grand-chose. Le précédent changement de licence avait déjà dire la même chose, la conséquence principale a été la multiplication des distributions alternatives. Idem lors de l’attaque des API Java dans Android.

  8. #8
    Membre éprouvé
    Homme Profil pro
    Administrateur systèmes et réseaux
    Inscrit en
    Août 2018
    Messages
    372
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 55
    Localisation : Autre

    Informations professionnelles :
    Activité : Administrateur systèmes et réseaux

    Informations forums :
    Inscription : Août 2018
    Messages : 372
    Points : 1 136
    Points
    1 136
    Par défaut
    Jawa est une usine à bugs critiques comme l'était le lecteur flash en son temps...

    Proposer ce type de modèle économique est extrêmement arriviste de leur part. D'abord on chercher à vous rendre dépendant d'un produit, puis une fois que c'est fait on vous le surfacture.

    Franchement si ils veulent scier la branche sur laquelle ils sont assis, tant pis pour eux, ce n'est pas moi qui vais les pleurer !!

    Les américains sont tristement de vrais requins en matière commerciale ;-(

  9. #9
    Membre habitué
    Avatar de RenardSpatial
    Homme Profil pro
    Ingénieur, Auteur
    Inscrit en
    Novembre 2018
    Messages
    18
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Autre

    Informations professionnelles :
    Activité : Ingénieur, Auteur

    Informations forums :
    Inscription : Novembre 2018
    Messages : 18
    Points : 125
    Points
    125
    Billets dans le blog
    2
    Par défaut
    Citation Envoyé par phil995511 Voir le message
    Jawa est une usine à bugs critiques comme l'était le lecteur flash en son temps...
    Tu as de vraies sources sur cette affirmation péremptoire, ou bien tu confonds avec Java dans le navigateur, qui est mort et enterré depuis des années ?

  10. #10
    Expert éminent sénior

    Homme Profil pro
    Directeur des systèmes d'information
    Inscrit en
    Avril 2002
    Messages
    2 808
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 64
    Localisation : Luxembourg

    Informations professionnelles :
    Activité : Directeur des systèmes d'information
    Secteur : Finance

    Informations forums :
    Inscription : Avril 2002
    Messages : 2 808
    Points : 19 023
    Points
    19 023
    Par défaut
    Citation Envoyé par phil995511 Voir le message
    Jawa est une usine à bugs critiques comme l'était le lecteur flash en son temps...
    Ta comparaison n'a aucun sens. Dans les grandes entreprises on fait du Java serveur Java EE pas du Java client (Applets).
    Coté Java serveur de très grandes entreprises utilisent Java comme par exemple Amadeus qui permet de gérer tous les systèmes de réservation aériens au niveau mondial en gérant des milliers de sites webs, donc rien à voir avec le blog de Kévin en PHP en Wordpress.
    Ne prenez pas la vie au sérieux, vous n'en sortirez pas vivant ...

  11. #11
    Rédacteur/Modérateur

    Avatar de bouye
    Homme Profil pro
    Information Technologies Specialist (Scientific Computing)
    Inscrit en
    Août 2005
    Messages
    6 845
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 47
    Localisation : Nouvelle-Calédonie

    Informations professionnelles :
    Activité : Information Technologies Specialist (Scientific Computing)
    Secteur : Agroalimentaire - Agriculture

    Informations forums :
    Inscription : Août 2005
    Messages : 6 845
    Points : 22 857
    Points
    22 857
    Billets dans le blog
    51
    Par défaut
    Citation Envoyé par totolehero777 Voir le message
    l'utilisation de technos propriétaires à Oracle doivent être rares... (genre Java Webstart, JavaFX et 2-3 trucs).
    Revois tes infos :
    • Java Web Start a été déprécie et arrêté il y a quelques temps déjà.
    • JavaFX est Open Source depuis 2011 (!) et est développé dans le cadre de l'OpenJFX qui est sous la bannière de l'OpenJDK depuis 10 ans déjà...



    Citation Envoyé par RenardSpatial Voir le message
    Avec toutes les alternatives basées sur OpenJDK, qui paie encore les licences Java à Oracle ?
    C'est une question que je me pose également. Mon passage a l'OpenJDK a été immédiat des le changement initial de licence du JDK d'Oracle qui forçait le passage a un support payant au bout d'un certain temps.
    Il doit plus rester grand monde a part des grosses entreprises qui ont un volume important de licence et qui ont besoin de faire remonter des bugs avec des correctifs rapides.
    Merci de penser au tag quand une réponse a été apportée à votre question. Aucune réponse ne sera donnée à des messages privés portant sur des questions d'ordre technique. Les forums sont là pour que vous y postiez publiquement vos problèmes.

    suivez mon blog sur Développez.

    Programming today is a race between software engineers striving to build bigger and better idiot-proof programs, and the universe trying to produce bigger and better idiots. So far, the universe is winning. ~ Rich Cook

  12. #12
    Membre émérite
    Profil pro
    Inscrit en
    Juin 2009
    Messages
    923
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Juin 2009
    Messages : 923
    Points : 2 836
    Points
    2 836
    Par défaut
    Non pas que j'aime Oracle, mais de l'autre côté, on ne peut reconnaître que facturer un certain nombre d'appli sur le nombre de processeurs relevait de la stupidité commercialement. Les applis Web Java consomment quasiment rien en processeur, c'est le client Web et la BDD qui font le gros du boulot en termes de processeur j'entend

  13. #13
    Membre régulier
    Homme Profil pro
    Développeur Java
    Inscrit en
    Juin 2022
    Messages
    16
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 39
    Localisation : Belgique

    Informations professionnelles :
    Activité : Développeur Java

    Informations forums :
    Inscription : Juin 2022
    Messages : 16
    Points : 73
    Points
    73
    Par défaut
    Citation Envoyé par bouye Voir le message
    Revois tes infos :
    • Java Web Start a été déprécie et arrêté il y a quelques temps déjà.
    • JavaFX est Open Source depuis 2011 (!) et est développé dans le cadre de l'OpenJFX qui est sous la bannière de l'OpenJDK depuis 10 ans déjà...
    Exact, donc il reste vraiment très peu de raisons de ne pas migrer vers une autre JVM... Avoir un support soi-disant plus rapide d'Oracle en cas de découverte d'un bug dans leur JVM je n'y crois pas trop

  14. #14
    Membre confirmé
    Profil pro
    Inscrit en
    Février 2008
    Messages
    167
    Détails du profil
    Informations personnelles :
    Localisation : France, Rhône (Rhône Alpes)

    Informations forums :
    Inscription : Février 2008
    Messages : 167
    Points : 471
    Points
    471
    Par défaut
    Je pense que la politique déplorable d'Oracle en matière de licences, va sonner le glas de Java.

    Quelles entreprises utilisent encore Java pour de nouveaux projets, au vu des risques juridiques sur la plateforme ?

    J'ai l'impression que beaucoup sont passés au .net, ou à d'autres langages comme le python, typescript, javascript, php (?) ou tout simplement revenu au C/C++.

    Mais je me trompe peut être.

  15. #15
    Membre extrêmement actif Avatar de ddoumeche
    Homme Profil pro
    Ingénieur recherche et développement
    Inscrit en
    Octobre 2007
    Messages
    1 676
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Singapour

    Informations professionnelles :
    Activité : Ingénieur recherche et développement

    Informations forums :
    Inscription : Octobre 2007
    Messages : 1 676
    Points : 2 007
    Points
    2 007
    Par défaut
    Citation Envoyé par jpouly Voir le message
    Je pense que la politique déplorable d'Oracle en matière de licences, va sonner le glas de Java.

    Quelles entreprises utilisent encore Java pour de nouveaux projets, au vu des risques juridiques sur la plateforme ?
    Ici on utilise encore java pour de très gros projets à plusieurs millions d'euros gérant des flottes immenses, et ce n'est pas prêt de s'arrêter vu l'explosion de l'internet des objets.
    Notre serveur de cartographie a été réécrit de C++ à Java pour des raisons de stabilité et de performances.

    Plus exactement nous avons terminé de migrer sur openjdk il y a 7 ans.

    Citation Envoyé par jpouly Voir le message
    J'ai l'impression que beaucoup sont passés au .net, ou à d'autres langages comme le python, typescript, javascript, php (?) ou tout simplement revenu au C/C++.
    .net pour du site web d'accord, pour de la haute performance sur Linux on repassera.
    La joie de l'âme est dans la planification -- Louis Hubert Liautey

  16. #16
    Modérateur
    Avatar de escartefigue
    Homme Profil pro
    bourreau
    Inscrit en
    Mars 2010
    Messages
    10 240
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Loir et Cher (Centre)

    Informations professionnelles :
    Activité : bourreau
    Secteur : Finance

    Informations forums :
    Inscription : Mars 2010
    Messages : 10 240
    Points : 39 273
    Points
    39 273
    Billets dans le blog
    9
    Par défaut
    Citation Envoyé par ddoumeche Voir le message
    Notre serveur de cartographie a été réécrit de C++ à Java pour des raisons de stabilité et de performances.
    Il me semble pourtant que C++ est généralement reconnu comme étant le plus performant des deux...

  17. #17
    Membre habitué
    Avatar de RenardSpatial
    Homme Profil pro
    Ingénieur, Auteur
    Inscrit en
    Novembre 2018
    Messages
    18
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Autre

    Informations professionnelles :
    Activité : Ingénieur, Auteur

    Informations forums :
    Inscription : Novembre 2018
    Messages : 18
    Points : 125
    Points
    125
    Billets dans le blog
    2
    Par défaut
    Citation Envoyé par escartefigue Voir le message
    Il me semble pourtant que C++ est généralement reconnu comme étant le plus performant des deux...
    En pratique, c’est un peu plus compliqué que ça.

    D’un point de vue performances pures, C++ est plus performant que Java, parce qu’il est compilé directement pour l’architecture cible et gère sa mémoire à la main (j’exclus les cas aux limites où cette gestion manuelle de la mémoire peut être plus lente que la gestion automatique de Java, je pars du principe qu’on a deux programmes comparables et surtout corrects).

    Cependant, C++ est beaucoup plus compliqué que Java, et ce dernier conserve d’excellentes performances calculatoires. En Java, si tu ne fais pas n’importe quoi, le CPU est un facteur très peu limitant – merci la compilation JIT très performante des JVM modernes (historiquement, de très gros éditeurs ont fait des gros programmes codés n’importe comment et qui avaient ce genre de problème). Tu vas consommer plus de RAM, mais dans beaucoup d’usages ça n’est pas tellement un problème (ça le devient de plus en plus avec le cloud et les microservices, assez curieusement). Et comme Java est sensiblement plus simple que C++, c’est beaucoup plus facile et moins cher de faire un programme « suffisamment efficace » et de le maintenir dans cet état qu’en C++. Ça explique le choix de Java dans beaucoup de moyens/gros logiciels côté serveur.

  18. #18
    Expert confirmé Avatar de AoCannaille
    Inscrit en
    Juin 2009
    Messages
    1 418
    Détails du profil
    Informations forums :
    Inscription : Juin 2009
    Messages : 1 418
    Points : 4 757
    Points
    4 757
    Par défaut
    Citation Envoyé par escartefigue Voir le message
    Il me semble pourtant que C++ est généralement reconnu comme étant le plus performant des deux...
    La réputation de Java sur ce sujet a beaucoup beaucoup d'inertie par rapport à ses premières versions, mais est surtout impacté par 2 facteurs importants : le temps de lancement de la JVM et le temps utilisé par le Garbage collector qui est difficilement gérable et qui dans les premières version, quand il se lançait dans le thread de l'IHM, faisait même freezer les fenêtres...

    Citation Envoyé par RenardSpatial Voir le message
    Et comme Java est sensiblement plus simple que C++, c’est beaucoup plus facile et moins cher de faire un programme « suffisamment efficace » et de le maintenir dans cet état qu’en C++.
    Si tu me permet d'étayer ton propos, je propose une petite analyse comparative d'algos C++ vs JAVA via "the benchmark game C++ vs Java" : https://benchmarksgame-team.pages.de.../gpp-java.html

    C++ est systématiquement devant sur tous les algos proposés, mais si tu compare la gueule du code du C++ le plus rapide et du java le plus rapide, ça n'a rien à voir.


    Au pif, mandelbrot :
    C++ le plus rapide, 0.89 secondes
    Code C++ : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    // The Computer Language Benchmarks Game
    // https://salsa.debian.org/benchmarksgame-team/benchmarksgame/
    //
    // Contributed by Kevin Miller ( as C code )
    //
    // Ported to C++ with minor changes by Dave Compton
    // Optimized to x86 by Kenta Yoshimura
    //
    // Compile with following g++ flags
    // Use '-O3 -ffp-contract=off -fno-expensive-optimizations' instead of '-Ofast',
    // because FMA is fast, but different precision to original version
    //   -Wall -O3 -ffp-contract=off -fno-expensive-optimizations -march=native -fopenmp --std=c++14 mandelbrot.cpp
     
    #include <immintrin.h>
    #include <stdio.h>
    #include <stdint.h>
     
    using namespace std;
     
    namespace {
     
    #if defined(__AVX512BW__)
        typedef __m512d Vec;
        Vec vec_init(double value)       { return _mm512_set1_pd(value); }
        bool vec_is_any_le(Vec v, Vec f) { return bool(_mm512_cmp_pd_mask(v, f, _CMP_LE_OS)); }
        int vec_is_le(Vec v1, Vec v2)    { return _mm512_cmp_pd_mask(v1, v2, _CMP_LE_OS); }
        const uint8_t k_bit_rev[] =
        {
            0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0, 0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0,
            0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8, 0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8,
            0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4, 0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4,
            0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC, 0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC,
            0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2, 0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2,
            0x0A, 0x8A, 0x4A, 0xCA, 0x2A, 0xAA, 0x6A, 0xEA, 0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA,
            0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6, 0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6,
            0x0E, 0x8E, 0x4E, 0xCE, 0x2E, 0xAE, 0x6E, 0xEE, 0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE, 0x7E, 0xFE,
            0x01, 0x81, 0x41, 0xC1, 0x21, 0xA1, 0x61, 0xE1, 0x11, 0x91, 0x51, 0xD1, 0x31, 0xB1, 0x71, 0xF1,
            0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9, 0x19, 0x99, 0x59, 0xD9, 0x39, 0xB9, 0x79, 0xF9,
            0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5, 0x15, 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5,
            0x0D, 0x8D, 0x4D, 0xCD, 0x2D, 0xAD, 0x6D, 0xED, 0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD,
            0x03, 0x83, 0x43, 0xC3, 0x23, 0xA3, 0x63, 0xE3, 0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3,
            0x0B, 0x8B, 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB, 0x1B, 0x9B, 0x5B, 0xDB, 0x3B, 0xBB, 0x7B, 0xFB,
            0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7, 0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7,
            0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF, 0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF
        };
    #elif defined(__AVX__)
        typedef __m256d Vec;
        Vec vec_init(double value)       { return _mm256_set1_pd(value); }
        bool vec_is_any_le(Vec v, Vec f) { Vec m = v<=f; return ! _mm256_testz_pd(m, m); }
        int vec_is_le(Vec v1, Vec v2)    { return _mm256_movemask_pd(v1 <= v2); }
        const uint8_t k_bit_rev[] =
        {
            0b0000, 0b1000, 0b0100, 0b1100, 0b0010, 0b1010, 0b0110, 0b1110,
            0b0001, 0b1001, 0b0101, 0b1101, 0b0011, 0b1011, 0b0111, 0b1111
        };
    #elif defined(__SSE4_1__)
        typedef __m128d Vec;
        Vec vec_init(double value)       { return _mm_set1_pd(value); }
        bool vec_is_any_le(Vec v, Vec f) { __m128i m = __m128i(v<=f); return ! _mm_testz_si128(m, m); }
        int vec_is_le(Vec v1, Vec v2)    { return _mm_movemask_pd(v1 <= v2); }
        const uint8_t k_bit_rev[] = { 0b00, 0b10, 0b01, 0b11 };
    #elif defined(__SSSE3__)
        typedef __m128d Vec;
        Vec vec_init(double value)       { return _mm_set1_pd(value); }
        bool vec_is_any_le(Vec v, Vec f) { return bool(_mm_movemask_pd(v<=f)); }
        int vec_is_le(Vec v1, Vec v2)    { return _mm_movemask_pd(v1 <= v2); }
        const uint8_t k_bit_rev[] = { 0b00, 0b10, 0b01, 0b11 };
    #endif
     
        constexpr int k_vec_size = sizeof(Vec) / sizeof(double);
     
        // Return true iff all of 8 members of vector v1 is
        // NOT less than or equal to v2.
        bool vec_all_nle(const Vec* v1, Vec v2)
        {
            for ( auto i = 0; i < 8/k_vec_size; i++ ) {
                if ( vec_is_any_le(v1[i], v2) ) {
                    return false;
                }
            }
            return true;
        }
     
        // Return 8 bit value with bits set iff cooresponding
        // member of vector value is less than or equal to limit.
        unsigned pixels(const Vec* value, Vec limit)
        {
            unsigned res = 0;
            for ( auto i = 0; i < 8/k_vec_size; i++ ) {
                res <<= k_vec_size;
                res |= k_bit_rev[vec_is_le(value[i], limit)];
            }
            return res;
        }
     
        //
        // Do one iteration of mandelbrot calculation for a vector of eight
        // complex values.  Using Vec to work with groups of doubles speeds
        // up computations.
        //
        void calcSum(Vec* real, Vec* imag, Vec* sum, const Vec* init_real, Vec init_imag)
        {
            for ( auto vec = 0; vec < 8/k_vec_size; vec++ ) {
                auto r2 = real[vec] * real[vec];
                auto i2 = imag[vec] * imag[vec];
                auto ri = real[vec] * imag[vec];
     
                sum[vec] = r2 + i2;
     
                real[vec]=r2 - i2 + init_real[vec];
                imag[vec]=ri + ri + init_imag;
            }
        }
     
        //
        // Do 50 iterations of mandelbrot calculation for a vector of eight
        // complex values.  Check occasionally to see if the iterated results
        // have wandered beyond the point of no return (> 4.0).
        //
        unsigned mand8(bool to_prune, const Vec* init_real, Vec init_imag)
        {
            Vec k4_0 = vec_init(4.0);
            Vec real[8 / k_vec_size];
            Vec imag[8 / k_vec_size];
            Vec sum[8 / k_vec_size];
            for ( auto k = 0; k < 8/k_vec_size; k++ ) {
                real[k] = init_real[k];
                imag[k] = init_imag;
            }
     
            if ( to_prune ) {
                // 4*12 + 2 = 50
                for ( auto j = 0; j < 12; j++ ) {
                    for ( auto k = 0; k < 4; k++ ) {
                        calcSum(real, imag, sum, init_real, init_imag);
                    }
                    if ( vec_all_nle(sum, k4_0) ) {
                        return 0; // prune
                    }
                }
                calcSum(real, imag, sum, init_real, init_imag);
                calcSum(real, imag, sum, init_real, init_imag);
            } else {
                // 6*8 + 2 = 50
                for ( auto j = 0; j < 8; j++ ) {
                    for ( auto k = 0; k < 6; k++ ) {
                        calcSum(real, imag, sum, init_real, init_imag);
                    }
                }
                calcSum(real, imag, sum, init_real, init_imag);
                calcSum(real, imag, sum, init_real, init_imag);
            }
     
            return pixels(sum, k4_0);
        }
     
    } // namespace
     
    int main(int argc, char ** argv)
    {
        // get width/height from arguments
     
        auto wid_ht = 16000;
        if ( argc >= 2 ) {
            wid_ht = atoi(argv[1]);
        }
     
        // round up to multiple of 8
        wid_ht = -(-wid_ht & -8);
        auto width = wid_ht;
        auto height = wid_ht;
     
        // allocate memory for pixels.
        auto dataLength = height*(width>>3);
        auto pixels = new uint8_t[dataLength];
     
        // calculate initial x values, store in r0
        Vec r0[width / k_vec_size];
        double* r0_ = reinterpret_cast<double*>(r0);
        for ( auto x = 0; x < width; x++ ) {
            r0_[x] = 2.0 / width * x - 1.5;
        }
     
        // generate the bitmap
     
        // process 8 pixels (one byte) at a time
        #pragma omp parallel for schedule(guided)
        for ( auto y = 0; y < height; y++ ) {
            // all 8 pixels have same y value (iy).
            auto iy = 2.0 / height *  y - 1.0;
            Vec init_imag = vec_init(iy);
            auto rowstart = y*width/8;
            bool to_prune = false;
            for ( auto x = 0; x < width; x += 8 ) {
                auto res = mand8(to_prune, &r0[x/k_vec_size], init_imag);
                pixels[rowstart + x/8] = res;
                to_prune = ! res;
            }
        }
     
        // write the data
        printf("P4\n%d %d\n", width, height);
        fwrite(pixels, 1, dataLength, stdout);
        delete[] pixels;
     
        return 0;
    }

    Java le plus rapide, 4.39secondes
    Code Java : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    /* The Computer Language Benchmarks Game
       https://salsa.debian.org/benchmarksgame-team/benchmarksgame/
       
       modified by Henco Appel
    */
     
    import java.io.*;
    import java.util.concurrent.atomic.*;
    import java.util.stream.*;
     
    public final class mandelbrot {
     
       static final byte getByte(final double[] Crb, final double CibY, final int x){
          int res=0;
          for(int i=0;i<8;i+=2){
             double Zr1=Crb[x+i];
             double Zi1=CibY;
     
             double Zr2=Crb[x+i+1];
             double Zi2=CibY;
     
             int b=0;
             int j=49;do{
                double nZr1=Zr1*Zr1-Zi1*Zi1+Crb[x+i];
                Zi1=Zr1*Zi1+Zr1*Zi1+CibY;
                Zr1=nZr1;
     
                double nZr2=Zr2*Zr2-Zi2*Zi2+Crb[x+i+1];
                Zi2=Zr2*Zi2+Zr2*Zi2+CibY;
                Zr2=nZr2;
     
                if(Zr1*Zr1+Zi1*Zi1>4){b|=2;if(b==3)break;}
                if(Zr2*Zr2+Zi2*Zi2>4){b|=1;if(b==3)break;}
             }while(--j>0);
             res=(res<<2)+b;
          }
          return (byte)(res^-1);
       }
     
       public static void main(String[] args) throws Exception {
          int N=6000;
          if (args.length>=1)
    		  N=Integer.parseInt(args[0]);
     
          double[] Crb=new double[N+7];
          double invN=2.0/N;
    	  for(int i=0;i<N;i++){  Crb[i]=i*invN-1.5; }
    	  int lineLen = (N-1)/8 + 1;
    	  byte[] data = new byte[N*lineLen];
    	  IntStream.range(0,N).parallel().forEach(y -> {
    		  double Ciby = y*invN-1.0;
    		  int offset = y*lineLen;
    		  for(int x=0; x<lineLen; x++)
    			  data[offset+x] = getByte(Crb, Ciby, x*8);
    	  });
     
          OutputStream stream = new BufferedOutputStream(System.out);
          stream.write(("P4\n"+N+" "+N+"\n").getBytes());
          stream.write(data);
          stream.close();
       }
    }


    C++ beaucoup moins abscon, 3.89 sec :
    Code C++ : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    /*   
       The Computer Language Benchmarks Game
       https://salsa.debian.org/benchmarksgame-team/benchmarksgame/
     
       contributed by Paolo Bonzini
       further optimized by Jason Garrett-Glaser
       OpenMP by The Anh Tran
       10-11-2010, modified by The Anh Tran:
          _ copy bit shift idea from C entry
    */
     
    #include <cassert>
    #include <cstdio>
    #include <cstdlib>
    #include <algorithm>
    #include <sched.h>
    #include <memory.h>
     
    #include <omp.h>
    #include <sys/types.h>
     
    #define L2_CACHE_LINE   64
    #define ALIGN         __attribute__ ((aligned(L2_CACHE_LINE)))
     
     
    typedef unsigned char   byte;
    typedef double         v2d   __attribute__ ((vector_size(16)));
    typedef int32_t       v4i   __attribute__ ((vector_size(16)));
     
    const v2d v10      = { 1.0, 1.0 };
    const v2d v15      = { 1.5, 1.5 };
    const v2d v40      = { 4.0, 4.0 };
     
    v2d inv_2n;   // {2.0/N, 2.0/N}
     
     
    int
    GetThreadCount()
    {
       cpu_set_t cs;
       CPU_ZERO(&cs);
       sched_getaffinity(0, sizeof(cs), &cs);
     
       int count = 0;
       for (int i = 0; i < CPU_SETSIZE; ++i)
          count += CPU_ISSET(i, &cs);
     
       return count;
    }
     
     
    void
    mandelbrot(int N, byte* data)
    {
       ALIGN int row_processed = 0;
     
       #pragma omp parallel default(shared) num_threads(GetThreadCount())
       {
          int y = 0;
          while ((y = __sync_fetch_and_add(&row_processed, 1)) < N)
          {
             byte* row_output = data + y * (N >> 3);
     
             v2d Civ = {y, y};
             Civ = Civ * inv_2n - v10;
     
                for (int x = 0; x < N; x += 2)
                {
                v2d   Crv = {x+1, x};
                Crv = Crv * inv_2n - v15;
                v2d Zrv = Crv;
                v2d Ziv = Civ;
                v2d Trv = Crv * Crv;
                v2d Tiv = Civ * Civ;
     
                int result = 3; // assume that 2 elements belong to MB set
                int i = 1;
     
                while ( result && (i++ < 50) )
                {
                   v2d ZZ = Zrv * Ziv;
                   Zrv = Trv - Tiv + Crv;
                   Ziv = ZZ + ZZ + Civ;
                   Trv = Zrv * Zrv;
                   Tiv = Ziv * Ziv;
     
                   // trv + tiv <= 4.0
                   v2d delta = (v2d)__builtin_ia32_cmplepd( (Trv + Tiv), v40 );
                   result = __builtin_ia32_movmskpd(delta);              
                }
     
                {
                   int bit_shift = 6 - (x & 7);
                   row_output[x >> 3] |= static_cast<byte>(result << bit_shift);
                }
             }
          }
       }
    }


    En résumé, à maintenabilité équivalente, le java n'est pas significativement plus lent que le C++, et ça dépendra donc des usages et des priorités de chaque projet.

  19. #19
    Membre extrêmement actif Avatar de ddoumeche
    Homme Profil pro
    Ingénieur recherche et développement
    Inscrit en
    Octobre 2007
    Messages
    1 676
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Singapour

    Informations professionnelles :
    Activité : Ingénieur recherche et développement

    Informations forums :
    Inscription : Octobre 2007
    Messages : 1 676
    Points : 2 007
    Points
    2 007
    Par défaut
    Citation Envoyé par escartefigue Voir le message
    Il me semble pourtant que C++ est généralement reconnu comme étant le plus performant des deux...
    Le principal facteur de performance sera toujours l'algorithme, la différence de performance brute entre les deux est infinitésimale depuis longtemps.

    Sur des parties extrêmement critiques du code, on peut envisager de conserver le C voir le C++ (qui sera toujours plus lent que son ancêtre) mais sur 99.9% du code le C++ n'apportera rien. Et sera plus un boulet qu'autre chose, car sur un serveur, on ne peux le monitorer, on ne peux le remplacer à chaud.

    Ce n'est pas pour rien que tout le monde est passé sur Java voila 20 ans.

    Mais si je voulais écrire une sonde monitorant un process comme par exemple l'état d'un script ou d'un processus donné comme par exemple la génération de cartes, et devant être lancé à intervalle régulier, je le ferais en bash voir en C. Comme le chirurgien disposant de nombreux outils pour procéder à une trépanation, l'informaticien dispose de nombreux languages pour réaliser son travail.
    La joie de l'âme est dans la planification -- Louis Hubert Liautey

  20. #20
    Expert éminent
    Avatar de pachot
    Homme Profil pro
    Developer Advocate YugabyteDB
    Inscrit en
    Novembre 2007
    Messages
    1 821
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 53
    Localisation : Suisse

    Informations professionnelles :
    Activité : Developer Advocate YugabyteDB
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Novembre 2007
    Messages : 1 821
    Points : 6 443
    Points
    6 443
    Billets dans le blog
    1
    Par défaut
    Citation Envoyé par RenardSpatial Voir le message
    (PS : la « solution » qui consiste à continuer à utiliser la dernière version gratuite d’Oracle Java 8 n’en est pas une, pour d’évidentes raisons de sécurité).
    Pourquoi colporter des fausses rumeurs? Toutes les versions sont gratuites. C'est le support d'ancienne version qui nécessitent une souscription.

    Java 17 est long-term support jusqu'en 2029, les updates sécurité sont gratuits.
    C'est pourtant clair:
    https://www.oracle.com/news/announce...17-2021-09-14/
    Oracle JDK 17 and future JDK releases are provided under a free-to-use license until a full year after the next LTS release. Oracle will also continue providing Oracle OpenJDK releases under the open-source General Public License (GPL), as it has since 2017.
    Il y a plein de raisons de critiquer le licensing Oracle, ça sert à rien d'en inventer
    Franck Pachot - Developer Advocate Yugabyte 🚀 Base de Données distribuée, open source, compatible PostgreSQL
    🗣 twitter: @FranckPachot - 📝 blog: blog.pachot.net - 🎧 podcast en français : https://anchor.fm/franckpachot

Discussions similaires

  1. [2008R2] Prix des licences
    Par happyboon dans le forum MS SQL Server
    Réponses: 1
    Dernier message: 29/01/2014, 11h51
  2. Prix des licences
    Par demido dans le forum Forum général ERP
    Réponses: 0
    Dernier message: 22/01/2011, 09h00
  3. Prix des licences Oracle
    Par badrel dans le forum Oracle
    Réponses: 2
    Dernier message: 02/01/2006, 23h21
  4. [info]Licence des produits Java
    Par XavierZERO dans le forum Général Java
    Réponses: 12
    Dernier message: 16/01/2004, 16h27

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo