tag:linuxfr.org,2005:/users/nonolaperoLinuxFr.org : les contenus de Nonolapéro2021-12-06T09:57:31+01:00/favicon.pngtag:linuxfr.org,2005:News/407652021-12-02T16:01:01+01:002021-12-02T18:39:44+01:00La version 8.1 de PHP et création de la fondation PHPLicence CC By‑SA http://creativecommons.org/licenses/by-sa/4.0/deed.fr<div><p>En fin d’année 2021 et sur la lancée habituelle PHP passe en version 8.1. Tout comme les autres versions, elle sera maintenue activement pendant deux années et elle recevra seulement des correctifs de sécurité une année de plus.</p>
<p><img src="//img.linuxfr.org/img/68747470733a2f2f692e696d6775722e636f6d2f3769595a3759552e6a7067/7iYZ7YU.jpg" alt="Élephant PHP sur un ordinateur portable" title="source : Ben Griffiths via Unsplash https://unsplash.com/photos/2Rd-hwT2xQ0 | Source : https://i.imgur.com/7iYZ7YU.jpg"></p>
</div><ul><li>lien nᵒ 1 : <a title="https://www.php.net/" hreflang="en" href="https://linuxfr.org/redirect/109460">Site officiel</a></li><li>lien nᵒ 2 : <a title="https://externals.io/" hreflang="en" href="https://linuxfr.org/redirect/109461">Liste de diffusion</a></li><li>lien nᵒ 3 : <a title="https://www.php.net/releases/8.1/en.php" hreflang="en" href="https://linuxfr.org/redirect/109462">Page officielle PHP 8.1</a></li></ul><div><h2 class="sommaire">Sommaire</h2>
<ul class="toc">
<li>
<a href="#toc-quoi-de-neuf">Quoi de neuf</a><ul>
<li>
<a href="#toc-les-nouveaut%C3%A9s-majeures">Les nouveautés majeures</a><ul>
<li><a href="#toc-les-types-%C3%A9num%C3%A9r%C3%A9s">Les types énumérés</a></li>
<li><a href="#toc-propri%C3%A9t%C3%A9s-de-classe-en-lecture-seule">Propriétés de classe en lecture seule</a></li>
<li><a href="#toc-les-types-intersection-purs">Les types intersection purs</a></li>
</ul>
</li>
<li>
<a href="#toc-autres-nouveaut%C3%A9s">Autres nouveautés</a><ul>
<li><a href="#toc-du-code-asynchrone-avec-les-fibers">Du code asynchrone avec les Fibers</a></li>
<li><a href="#toc-new-dans-le-constructeur-et-des-constantes-finales"><code>new</code> dans le constructeur et des constantes finales</a></li>
<li><a href="#toc-des-performances-en-hausse">Des performances en hausse</a></li>
</ul>
</li>
<li><a href="#toc-pour-la-suite">Pour la suite</a></li>
</ul>
</li>
<li>
<a href="#toc-les-changements-au-niveau-de-la-communaut%C3%A9">Les changements au niveau de la communauté</a><ul>
<li><a href="#toc-migration-progressive-sur-github">Migration progressive sur Github</a></li>
<li><a href="#toc-cr%C3%A9ation-de-la-fondation-php">Création de la fondation PHP</a></li>
</ul>
</li>
</ul>
<h2 id="toc-quoi-de-neuf">Quoi de neuf</h2>
<h3 id="toc-les-nouveautés-majeures">Les nouveautés majeures</h3>
<h4 id="toc-les-types-énumérés">Les types énumérés</h4>
<p>Jusqu’à présent cette structure n’était pas présente nativement dans le langage, elle était néanmoins implémentée dans diverses bibliothèques. C’est la bonne occasion de se débarrasser des classes remplies de constantes.</p>
<pre><code class="php"><span class="o"><?</span><span class="nx">php</span>
<span class="nx">enum</span> <span class="nx">IP</span>
<span class="p">{</span>
<span class="k">case</span> <span class="nx">V4</span><span class="p">;</span>
<span class="k">case</span> <span class="nx">V6</span><span class="p">;</span>
<span class="p">}</span>
<span class="c1">// la méthode statique cases() est automatiquement implémentée</span>
<span class="nx">IP</span><span class="o">::</span><span class="na">cases</span><span class="p">();</span> <span class="c1">// [IP::V4, IP::V6]</span>
<span class="nv">$versionOf</span> <span class="o">=</span> <span class="nx">fn</span><span class="p">(</span><span class="nx">string</span> <span class="nv">$address</span><span class="p">)</span><span class="o">:</span> <span class="o">?</span><span class="nx">IP</span> <span class="o">=></span> <span class="p">{</span>
<span class="nx">match</span><span class="p">(</span><span class="k">true</span><span class="p">){</span>
<span class="k">case</span> <span class="nx">isIpV4</span><span class="p">(</span><span class="nv">$address</span><span class="p">)</span> <span class="o">=></span> <span class="nx">IP</span><span class="o">::</span><span class="na">V4</span><span class="p">,</span>
<span class="k">case</span> <span class="nx">isIpV6</span><span class="p">(</span><span class="nv">$address</span><span class="p">)</span> <span class="o">=></span> <span class="nx">IP</span><span class="o">::</span><span class="na">V6</span><span class="p">,</span>
<span class="k">default</span> <span class="o">=></span> <span class="k">null</span>
<span class="p">}</span>
<span class="p">};</span>
<span class="nv">$versionOf</span><span class="p">(</span><span class="s2">"192.168.0.1); // IP::V4</span></code></pre>
<h4 id="toc-propriétés-de-classe-en-lecture-seule">Propriétés de classe en lecture seule</h4>
<p>Cette fonctionnalité, qui existe déjà dans d’autres langages (C# et TypeScript), fait son arrivée. Elle vous permettra d’avoir un objet dont les propriétés ne pourront plus être modifiées après l’instanciation. Ça va désormais être rapide pour créer des DTO.</p>
<pre><code class="php"><span class="k">class</span> <span class="nc">QuelBeauDTO</span>
<span class="p">{</span>
<span class="k">public</span> <span class="k">function</span> <span class="fm">__construct</span><span class="p">(</span><span class="k">public</span> <span class="nx">readonly</span> <span class="nx">string</span> <span class="nv">$message</span><span class="p">){}</span>
<span class="p">}</span>
<span class="nv">$dto</span> <span class="o">=</span> <span class="k">new</span> <span class="nx">QuelBeauDTO</span><span class="p">(</span><span class="s2">"LinuxFR"</span><span class="p">);</span>
<span class="k">echo</span><span class="p">(</span><span class="nv">$dto</span><span class="o">-></span><span class="na">message</span><span class="p">);</span> <span class="c1">// LinuxFR</span>
<span class="nv">$dto</span><span class="o">-></span><span class="na">message</span> <span class="o">=</span> <span class="s2">"Vive les moules"</span><span class="p">;</span> <span class="c1">//Fatal error: Uncaught Error: Cannot modify readonly property QuelBeauDTO::$message</span></code></pre>
<h4 id="toc-les-types-intersection-purs">Les types intersection purs</h4>
<p>Après les types unions lors de la version précédente, voici l’intersection. Une bonne solution pour favoriser la composition d’interface et améliorer la modularité de nos développements.</p>
<pre><code class="php"><span class="k">interface</span> <span class="nx">A</span><span class="p">{</span> <span class="k">function</span> <span class="nf">a</span><span class="p">()</span><span class="o">:</span> <span class="nx">string</span><span class="p">;}</span>
<span class="k">interface</span> <span class="nx">B</span><span class="p">{</span> <span class="k">function</span> <span class="nf">b</span><span class="p">()</span><span class="o">:</span> <span class="nx">string</span><span class="p">;}</span>
<span class="k">class</span> <span class="nc">Coucou</span> <span class="k">implements</span> <span class="nx">A</span><span class="p">,</span> <span class="nx">B</span>
<span class="p">{</span>
<span class="k">function</span> <span class="fm">__construct</span><span class="p">(</span><span class="k">private</span> <span class="nx">readonly</span> <span class="nx">string</span> <span class="nv">$a</span><span class="p">,</span> <span class="k">private</span> <span class="nx">readonly</span> <span class="nx">string</span> <span class="nv">$b</span><span class="p">){}</span>
<span class="k">function</span> <span class="nf">a</span><span class="p">()</span><span class="o">:</span> <span class="nx">string</span>
<span class="p">{</span>
<span class="k">return</span> <span class="nv">$this</span><span class="o">-></span><span class="na">a</span><span class="p">;</span>
<span class="p">}</span>
<span class="k">function</span> <span class="nf">b</span><span class="p">()</span><span class="o">:</span> <span class="nx">string</span>
<span class="p">{</span>
<span class="k">return</span> <span class="nv">$this</span><span class="o">-></span><span class="na">b</span><span class="p">;</span>
<span class="p">}</span>
<span class="p">}</span>
<span class="nv">$ab</span> <span class="o">=</span> <span class="k">new</span> <span class="nx">Coucou</span><span class="p">(</span><span class="s2">"coucou"</span><span class="p">,</span> <span class="s2">"toto"</span><span class="p">);</span>
<span class="nv">$fn</span> <span class="o">=</span> <span class="nx">fn</span><span class="p">(</span><span class="nx">A</span><span class="o">&</span><span class="nx">B</span> <span class="nv">$ab</span><span class="p">)</span><span class="o">:</span> <span class="nx">string</span> <span class="o">=></span> <span class="s2">"</span><span class="si">{</span><span class="nv">$ab</span><span class="o">-></span><span class="na">a</span><span class="p">()</span><span class="si">}</span><span class="s2"> </span><span class="si">{</span><span class="nv">$ab</span><span class="o">-></span><span class="na">b</span><span class="p">()</span><span class="si">}</span><span class="s2">"</span><span class="p">;</span>
<span class="k">echo</span><span class="p">(</span><span class="nv">$fn</span><span class="p">(</span><span class="nv">$ab</span><span class="p">));</span> <span class="c1">// coucou toto</span></code></pre>
<p>La notion de pureté vient du fait que pour le moment il n’est pas possible d’avoir une signature du genre : <code>A&B|C</code>. Une discussion houleuse s’est tenue quelques jours avant le gel des fonctionnalités sur la possibilité d’avoir des <code>null</code> et la syntaxe qui l’accompagnerait. Pour rappel, les types union ont intégré le langage en version 8.0.</p>
<h3 id="toc-autres-nouveautés">Autres nouveautés</h3>
<h4 id="toc-du-code-asynchrone-avec-les-fibers">Du code asynchrone avec les Fibers</h4>
<p>Jusqu’à présent, la gestion du code asynchrone était gérée du côté des bibliothèques, les plus connues étant <a href="https://amphp.org/">Amp</a>, <a href="https://reactphp.org/">ReactPHP</a> et <a href="https://www.swoole.co.uk/">Swoole</a>. Chaque solution avait implémenté les logiques nécessaires à leur sauce. Avec l’arrivée des fibres dans le langage, les cartes sont rebattues et chacun devra apporter des modifications pour profiter de la partie native. D’ailleurs ReactPHP et Amp se sont associés pour écrire une couche d’abstraction nommée <a href="https://revolt.run/">Revolt</a>.</p>
<h4 id="toc-new-dans-le-constructeur-et-des-constantes-finales">
<code>new</code> dans le constructeur et des constantes finales</h4>
<p>Les constantes finales ne peuvent pas être redéfinies dans une classe enfant (mais qui utilise l’héritage ???) et il est possible d’intégrer des <code>new</code> directement dans le constructeur.</p>
<pre><code class="php"><span class="k">class</span> <span class="nc">A</span> <span class="p">{</span>
<span class="k">private</span> <span class="k">final</span> <span class="k">const</span> <span class="no">A</span> <span class="o">=</span> <span class="s2">"toto"</span><span class="p">;</span>
<span class="k">public</span> <span class="k">function</span> <span class="fm">__construct</span><span class="p">(</span><span class="k">private</span> <span class="nx">DatetimeImmutable</span> <span class="nv">$now</span> <span class="o">=</span> <span class="k">new</span> <span class="nx">DateTimeImmutable</span><span class="p">()){};</span>
<span class="p">}</span>
<span class="k">class</span> <span class="nc">B</span> <span class="nx">extend</span> <span class="nx">A</span><span class="p">{</span>
<span class="k">private</span> <span class="k">final</span> <span class="k">const</span> <span class="no">A</span> <span class="o">=</span> <span class="s2">"tata"</span><span class="p">;</span> <span class="c1">//Fatal error: B::A cannot override final constant A::A</span>
<span class="p">}</span></code></pre>
<h4 id="toc-des-performances-en-hausse">Des performances en hausse</h4>
<p>À chaque version, des optimisations sont trouvées et il en résulte de meilleurs résultats sur différents comparatifs. Cette version ne déroge pas à la règle. <a href="https://github.com/kocsismate/php-version-benchmarks/blob/main/docs/results/2021_11_25_10_08_1_aws_arm64_c6g_4xlarge/result.md">Un récent comparatif</a> sur des temps de traitement d’une série de 250 requêtes trouve un temps de réponse diminué d’une vingtaine de pourcents pour une application Symfony ou Laravel et une poignée de pourcents pour un site Wordpress.</p>
<h3 id="toc-pour-la-suite">Pour la suite</h3>
<p>Pour ceux qui tournent sur du PHP 7.4, il va falloir songer à passer en version 8.0 dans l’année. Pour rappel, une version est maintenue pendant trois ans (deux ans de maintenance active, un an de maintenance de sécurité). Pour cela, il faut baisser les seuils d’alerte au minimum, corriger ce qui provoque les bouts de code concernés par des alertes à la main ou automatiquement avec des outils du genre <a href="https://getrector.org">Rector</a>. </p>
<p>À l’heure de la rédaction de ces lignes, peu de choses seront incluses dans la prochaine version, mais on peut déjà voir que cela ne sera toujours une somme de choses pour rendre <a href="https://wiki.php.net/rfc/shell_exec_result_code_param">le langage plus cohérent</a>, de suppression de possibilités pour écrire <a href="https://wiki.php.net/rfc/deprecate_dynamic_properties">des choses atroces</a>, de <a href="https://www.php.net/manual/en/function.array-is-list">simples utilitaires</a> pour ne pas réinventer la roue, etc.</p>
<h2 id="toc-les-changements-au-niveau-de-la-communauté">Les changements au niveau de la communauté</h2>
<p>PHP est un langage communautaire, à ma connaissance, il n’y a pas d’entreprise qui emploie des personnes pour travailler à plein temps sur le langage. Le langage évolue donc au gré des volontés diverses et variées de proposer des nouvelles fonctionnalités et de les implémenter. Globalement, l’évolution et la maintenance du langage ne tient qu’à une poignée de motivé(e)s. Comme pour la plupart des projets communautaires, toute aide est la bienvenue que ce soit sous la forme de traduction, de documentation, de rapports de bug, pour rajouter du code c’est un poil plus compliqué, car il faut être familier avec le C à la sauce PHP !</p>
<h3 id="toc-migration-progressive-sur-github">Migration progressive sur Github</h3>
<p>L’infrastructure vieillissante du projet arrivant au bout de sa vie et un <a href="https://externals.io/message/113981#114043">incident de sécurité</a> ce printemps ont poussé à stopper les contributions sur le service git du projet. Alors que le dépôt sur Github servait de miroir, il est devenu la source principale. La <a href="https://wiki.php.net/rfc/github_issues">gestion des bugs</a> va également se déplacer au même endroit.</p>
<h3 id="toc-création-de-la-fondation-php">Création de la fondation PHP</h3>
<p>Jusqu’à présent il n’y avait aucune structure officielle chapeautant le projet et rare ont été les personnes payées pour développer le langage. Ces derniers temps ce nombre ne s’élevait qu’à deux, ce qui pour un langage aussi utilisé que PHP est surprenant, voire désolant. L’un des deux principaux développeurs du projet (Nikita Popov) tant au niveau du code, que des discussions autour des évolutions prévoit de réduire la voilure. Depuis trois ans, il était rémunéré par JetBrains pour travailler sur PHP. Cette fin d’engagement a poussé différentes personnes à finaliser la mise en place d’une fondation afin de supporter financièrement des contributeurs. Vous trouverez plus de détails dans <a href="https://blog.jetbrains.com/phpstorm/2021/11/the-php-foundation/">cette annonce</a>. C’est donc une très bonne nouvelle et il faut espérer que <a href="https://opencollective.com/phpfoundation">les dons des entreprises et des particuliers</a> permettront d’intégrer, de diversifier et consolider le socle des contributeurs.</p>
</div><div><a href="https://linuxfr.org/news/la-version-8-1-de-php-et-creation-de-la-fondation-php.epub">Télécharger ce contenu au format EPUB</a></div> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/126068/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/news/la-version-8-1-de-php-et-creation-de-la-fondation-php#comments">ouvrir dans le navigateur</a>
</p>
NonolapéroxdelatourFlorent ZaraXavier Teyssierwindu.2bBenoît Sibaudpalm123Pierre Jarillonhttps://linuxfr.org/nodes/126068/comments.atomtag:linuxfr.org,2005:News/397322020-03-18T14:50:21+01:002020-03-21T03:06:19+01:00Java 14 tombe le masqueLicence CC By‑SA http://creativecommons.org/licenses/by-sa/4.0/deed.fr<div><p>À quelques jours du printemps, une nouvelle version de Java arrive avec son lot de corrections, améliorations, nouveautés et retraits. Voilà six mois que <a href="//linuxfr.org/news/sortie-d-openjdk-13">Java 13</a> a apporté ses quelques nouveautés. Cette nouvelle itération est bien plus riche aussi bien sur les fonctionnalités définitives que sur celles en cours de maturation. Au programme pas moins de <a href="https://openjdk.java.net/projects/jdk/14/">16 JEP</a> intègrent le langage. Seulement une partie sera détaillée dans la suite de dépêche.</p>
</div><ul><li>lien nᵒ 1 : <a title="https://openjdk.java.net/projects/jdk/14/" hreflang="en" href="https://linuxfr.org/redirect/105889">Les JEPs OpenJDK 14</a></li><li>lien nᵒ 2 : <a title="https://builds.shipilev.net/backports-monitor/release-notes-14.txt" hreflang="en" href="https://linuxfr.org/redirect/105933">L’ensemble des améliorations et des corrections</a></li></ul><div><h2 class="sommaire">Sommaire</h2>
<ul class="toc">
<li>
<a href="#toc-les-nouveaut%C3%A9s-d%C3%A9finitives">Les nouveautés définitives</a><ul>
<li><a href="#toc-temps-de-d%C3%A9marrage-et-empreintem%C3%A9moire">Temps de démarrage et empreinte mémoire</a></li>
<li>
<a href="#toc-du-c%C3%B4t%C3%A9-des-ramassemiettes">Du côté des ramasse‑miettes</a><ul>
<li><a href="#toc-g1">G1</a></li>
<li><a href="#toc-les-ramassemiettes-exp%C3%A9rimentaux">Les ramasse‑miettes expérimentaux</a></li>
</ul>
</li>
<li><a href="#toc-switch-statement-et-switchexpression">Switch statement et switch expression</a></li>
<li><a href="#toc-jdk-flight-recorder-event-streaming">JDK Flight Recorder Event Streaming</a></li>
<li><a href="#toc-des-nullpointerexception-plusexplicites">Des NullPointerException plus explicites</a></li>
</ul>
</li>
<li>
<a href="#toc-nouveaut%C3%A9s-en-pr%C3%A9visualisation">Nouveautés en prévisualisation</a><ul>
<li><a href="#toc-records">Records</a></li>
<li><a href="#toc-pattern-matching-instanceof">Pattern Matching instanceof</a></li>
<li><a href="#toc-outils-dempaquetage">Outils d’empaquetage</a></li>
<li><a href="#toc-les-blocs-de-texte-secondeit%C3%A9ration">Les blocs de texte, seconde itération</a></li>
</ul>
</li>
<li><a href="#toc-les-mises-au-placard-et-lesd%C3%A9parts">Les mises au placard et les départs</a></li>
<li><a href="#toc-dans-les-prochaines-versions">Dans les prochaines versions</a></li>
</ul>
<h2 id="toc-les-nouveautés-définitives">Les nouveautés définitives</h2>
<p>Avec la nouvelle cadence de versionnage, les nouveautés arrivent plus tôt mais dans un état non définitif et profitent des retours d’expérience des utilisateurs.</p>
<h3 id="toc-temps-de-démarrage-et-empreintemémoire">Temps de démarrage et empreinte mémoire</h3>
<p>Depuis plusieurs versions, les temps de démarrage et l’empreinte mémoire diminuent. Il est possible d’espérer un gain d’une dizaine de pourcents sur le temps de démarrage, c’est toujours ça de pris ! Côté empreinte mémoire, en revanche, la baisse est plus conséquente, de l’ordre de 30 % à 40 %. Ces améliorations sont natives, il n’est pas nécessaire d’ajouter des options. Pour plus de détails, une <a href="//linuxfr.org/users/nonolapero/liens/presentation-sur-l-amelioration-des-performances-de-java-depuis-plusieurs-versions">présentation</a> et un <a href="https://cl4es.github.io/2019/11/20/OpenJDK-Startup-Update.html">article</a>.</p>
<h3 id="toc-du-côté-des-ramassemiettes">Du côté des ramasse‑miettes</h3>
<h4 id="toc-g1">G1</h4>
<p>G1 est le ramasse‑miettes par défaut depuis Java 8 et il progresse de version en version à tous les niveaux (temps de réponse, gestion de la mémoire). Je vous laisse regarder cette <a href="https://fosdem.org/2020/schedule/event/g1/">présentation</a> ou le <a href="http://cr.openjdk.java.net/%7Esjohanss/slides/fosdem_2020_-_g1.pdf">support</a>. Cette progression est une bonne raison pour ne plus rester sur Java 8, car aucune amélioration n’est portée sur les versions antérieures.</p>
<h4 id="toc-les-ramassemiettes-expérimentaux">Les ramasse‑miettes expérimentaux</h4>
<p>ZGC (disponible depuis Java 11) fonctionne sur les trois principaux systèmes d’exploitation et il devrait bientôt ne plus être expérimental si l’on en croit cette <a href="https://openjdk.java.net/jeps/8209683">JEP</a>. L’idée derrière ZGC est de proposer un ramasse‑miettes à faible latence et qui peut aussi bien gérer des petites ou des grosses quantités de mémoire.<br>
Shenandoah est un autre ramasse‑miettes à faible latence intégré depuis Java 12, son objectif est d’avoir des temps de pause identiques quelle que soit la quantité de mémoire à libérer. Si vous voulez savoir comment ça fonctionne et avoir un état d’avancement du projet, je vous laisse regarder cette <a href="https://fosdem.org/2020/schedule/event/shenandoah/">présentation</a> et pour les explications plus détaillées c’est <a href="https://developers.redhat.com/blog/2020/03/04/shenandoah-gc-in-jdk-14-part-1-self-fixing-barriers/">ici (partie 1)</a>, puis <a href="https://developers.redhat.com/blog/2020/03/09/shenandoah-gc-in-jdk-14-part-2-concurrent-roots-and-class-unloading/">là (partie 2)</a>.</p>
<h3 id="toc-switch-statement-et-switchexpression">Switch statement et switch expression</h3>
<p>Les <em>switch expression</em> et <em>switch statement</em> sont arrivées dans la version 12, ont été revues dans la version 13 et sont définitives dans cette version 14 (voir la <a href="https://openjdk.java.net/jeps/361">JEP 361</a>).</p>
<p>Avant, on devait écrire :</p>
<pre><code class="java"><span class="kd">public</span> <span class="kd">enum</span> <span class="n">Event</span> <span class="o">{</span>
<span class="n">PLAY</span><span class="o">,</span> <span class="n">PAUSE</span><span class="o">,</span> <span class="n">STOP</span>
<span class="o">}</span>
<span class="n">String</span> <span class="n">log</span><span class="o">;</span>
<span class="k">switch</span> <span class="o">(</span><span class="n">event</span><span class="o">)</span> <span class="o">{</span>
<span class="k">case</span> <span class="n">PLAY</span><span class="o">:</span>
<span class="n">log</span> <span class="o">=</span> <span class="s">"User has triggered the play button"</span><span class="o">;</span>
<span class="k">break</span><span class="o">;</span>
<span class="k">case</span> <span class="n">STOP</span><span class="o">:</span>
<span class="k">case</span> <span class="n">PAUSE</span><span class="o">:</span>
<span class="n">log</span> <span class="o">=</span> <span class="s">"User needs a break"</span><span class="o">;</span>
<span class="k">break</span><span class="o">;</span>
<span class="k">default</span><span class="o">:</span>
<span class="n">String</span> <span class="n">message</span> <span class="o">=</span> <span class="n">event</span><span class="o">.</span><span class="na">toString</span><span class="o">();</span>
<span class="n">LocalDateTime</span> <span class="n">now</span> <span class="o">=</span> <span class="n">LocalDateTime</span><span class="o">.</span><span class="na">now</span><span class="o">();</span>
<span class="n">log</span> <span class="o">=</span> <span class="s">"Unknown event "</span> <span class="o">+</span> <span class="n">message</span> <span class="o">+</span>
<span class="s">" logged on "</span> <span class="o">+</span> <span class="n">now</span><span class="o">;</span>
<span class="k">break</span><span class="o">;</span>
<span class="o">}</span></code></pre>
<p>Et maintenant, cette syntaxe est possible :</p>
<pre><code class="java"><span class="n">var</span> <span class="n">log</span> <span class="o">=</span> <span class="k">switch</span> <span class="o">(</span><span class="n">event</span><span class="o">)</span> <span class="o">{</span>
<span class="k">case</span> <span class="n">PLAY</span> <span class="o">-></span> <span class="s">"User has triggered the play button"</span><span class="o">;</span>
<span class="k">case</span> <span class="n">STOP</span><span class="o">,</span> <span class="n">PAUSE</span> <span class="o">-></span> <span class="s">"User needs a break"</span><span class="o">;</span>
<span class="k">default</span> <span class="o">-></span> <span class="o">{</span>
<span class="n">String</span> <span class="n">message</span> <span class="o">=</span> <span class="n">event</span><span class="o">.</span><span class="na">toString</span><span class="o">();</span>
<span class="n">LocalDateTime</span> <span class="n">now</span> <span class="o">=</span> <span class="n">LocalDateTime</span><span class="o">.</span><span class="na">now</span><span class="o">();</span>
<span class="n">yield</span> <span class="s">"Unknown event "</span> <span class="o">+</span> <span class="n">message</span> <span class="o">+</span>
<span class="s">" logged on "</span> <span class="o">+</span> <span class="n">now</span><span class="o">;</span>
<span class="o">}</span>
<span class="o">};</span></code></pre>
<p>Avec cette nouvelle forme :</p>
<ul>
<li>il n’y a plus de risque d’oublier un <code>break</code> en cours de chemin ;</li>
<li>il n’est plus nécessaire d’instancier une variable à vide ;</li>
<li>c’est plus court !</li>
</ul>
<p>Autre fait notable, le cas par défaut n’est plus obligatoire lorsque toutes les possibilités d’un <code>enum</code> sont traitées. Par précaution, en rajouter un peut protéger s’il y a un ajout dans l’énumération.</p>
<p>Le mélange des syntaxes est aussi possible avec des risques d’erreurs comme le montre l’exemple suivant :</p>
<pre><code class="java"><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="k">switch</span> <span class="o">(</span><span class="n">day</span><span class="o">)</span> <span class="o">{</span>
<span class="k">case</span> <span class="n">MONDAY</span> <span class="o">-></span> <span class="o">{</span>
<span class="n">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="s">"Monday"</span><span class="o">);</span>
<span class="c1">// ERROR! Block doesn't contain a yield statement</span>
<span class="o">}</span>
<span class="k">default</span> <span class="o">-></span> <span class="mi">1</span><span class="o">;</span>
<span class="o">};</span>
<span class="n">i</span> <span class="o">=</span> <span class="k">switch</span> <span class="o">(</span><span class="n">day</span><span class="o">)</span> <span class="o">{</span>
<span class="k">case</span> <span class="n">MONDAY</span><span class="o">,</span> <span class="n">TUESDAY</span><span class="o">,</span> <span class="n">WEDNESDAY</span><span class="o">:</span>
<span class="n">yield</span> <span class="mi">0</span><span class="o">;</span>
<span class="k">default</span><span class="o">:</span>
<span class="n">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="s">"Second half of the week"</span><span class="o">);</span>
<span class="c1">// ERROR! Group doesn't contain a yield statement</span>
<span class="o">};</span></code></pre>
<p>Chacun se fera son avis sur ces nouvelles formes, car autant un <code>switch case</code> à l’ancienne est pénible à écrire, autant avec les nouvelles possibilités il va falloir s’accorder sur le style à suivre sur un projet. </p>
<h3 id="toc-jdk-flight-recorder-event-streaming">JDK Flight Recorder Event Streaming</h3>
<p>Dans Java 11, Oracle a libéré <a href="https://openjdk.java.net/jeps/328">Flight Recorder</a> (FR) qui permet de suivre l’activité d’une application du sol au plafond, c’est‑à‑dire des appels processeur aux méthodes utilisées pour faire de l’affichage, en passant par le ramasse‑miettes et par le compilateur à la volée. Pour diverses explications, du code et des démos, allez voir cette <a href="https://www.infoq.com/presentations/monitoring-jdk-jfr/">conférence</a> ou encore <a href="https://blogs.oracle.com/javamagazine/java-flight-recorder-and-jfr-event-streaming-in-java-14">cet article</a>. Toutefois, pour découvrir l’outil rapidement, il faut lancer votre application avec <code>java -XX:StartFlightRecording:filename=/tmp/monAppli.jfr -jar monAppli.jar</code>, interagir avec durant quelques instants et l’arrêter. Il est aussi possible de démarrer les enregistrements sur une application déjà en fonctionnement avec <code>jcmd MainClass JFR.start</code>. Ensuite, vous pouvez profiter d’un résumé des évènements enregistrés avec <code>$JAVA_HOME/bin/jfr summary /tmp/monAppli.jfr | less</code> ; pour une analyse plus poussée, <a href="https://adoptopenjdk.net/jmc.html">Java Mission Control</a> est bien plus adapté.<br>
Le JDK Flight Recorder Event Streaming apporte la possibilité de profiter directement de ces mesures sans passer par la case écriture dans un fichier et lecture à partir de ce dernier. Ça peut sembler basique, mais ça ouvre de nombreuses possibilités pour monitorer de façon déportée différents services (un <a href="https://github.com/gunnarmorling/jfr-custom-events">exemple</a> avec du Grafana et du Quarkus).</p>
<h3 id="toc-des-nullpointerexception-plusexplicites">Des NullPointerException plus explicites</h3>
<p>Dorénavant, les développeurs Java auront moins d’excuses pour passer de longs moments à décortiquer les NPE, car elles indiqueront quel objet est <code>null</code>. Cette fonctionnalité existe depuis 2006 dans le JDK de SAP, et la plus grande ouverture des contributions à Java a permis de la rendre disponible au plus grand nombre. Pour Java 14, il faudra activer l’option <code>-XX:+ShowCodeDetailsInExceptionMessages</code> afin d’en profiter et, à partir de Java 15, l’option sera activée par défaut.</p>
<h2 id="toc-nouveautés-en-prévisualisation">Nouveautés en prévisualisation</h2>
<h3 id="toc-records">Records</h3>
<p>La verbosité du langage n’est plus à démontrer et, pour alléger la charge, des efforts sont faits, notamment avec de l’inférence de type avec le mot clé <code>var</code> au moment de déclarer une variable. Les <em>records</em> vont dans ce sens‑là, mais en plus ils permettent de transporter de la donnée de manière immutable. Voici un petit exemple de code :</p>
<pre><code class="java"><span class="kd">public</span> <span class="n">record</span> <span class="nf">Bouchot</span><span class="o">(</span><span class="n">String</span> <span class="n">nom</span><span class="o">){}</span></code></pre>
<p>C’est tout, une seule ligne pour créer un <em>record</em> ! Derrière, le langage se débrouille pour générer les méthodes <code>equals()</code>, <code>toString()</code> et <code>hashCode()</code>. Pour accéder au nom d’un bouchot (que l’on aura déclaré comme ceci : <code>var monBouchot = new Bouchot("DLFP")</code>, il suffit de faire <code>monBouchot.nom()</code>. Un <em>record</em> reste une classe Java, avec quelques limitations toutefois, il est donc possible de rajouter des contraintes sur le constructeur, par exemple refuser les <code>null</code> ou écrire votre propre méthode <code>toString()</code>, si la version générée ne vous convient pas.</p>
<pre><code class="java"><span class="kd">public</span> <span class="n">record</span> <span class="nf">Bouchot</span><span class="o">(</span><span class="n">String</span> <span class="n">nom</span><span class="o">){</span>
<span class="kd">public</span> <span class="n">Bouchot</span> <span class="o">{</span>
<span class="k">if</span><span class="o">(</span><span class="kc">null</span> <span class="o">==</span> <span class="n">nom</span><span class="o">){</span>
<span class="k">throw</span> <span class="k">new</span> <span class="n">IllegalArgumentException</span><span class="o">(</span><span class="s">"Crois‑tu qu’une moule puisse s’accrocher à null ?"</span><span class="o">);</span>
<span class="o">}</span>
<span class="o">}</span>
<span class="o">}</span></code></pre>
<p>Une chose intéressante à savoir est que les <em>records</em> ont été définis en prenant en compte le futur du langage aussi bien du côté développeur (types scellés, <em>pattern matching</em> et déconstruction) que de la machinerie interne (<em>inline type</em>). Pour aller plus loin, je vous laisse lire cet <a href="https://www.infoq.com/articles/java-14-feature-spotlight/">article</a>.</p>
<h3 id="toc-pattern-matching-instanceof">Pattern Matching instanceof</h3>
<p>Java est le dernier des principaux langages fonctionnant sur la JVM à ne pas implémenter le <em>pattern matching</em>. Pour cette première, il commence modestement en apportant un peu plus de légèreté syntaxique.</p>
<pre><code class="java"><span class="c1">// Avant avec le cast</span>
<span class="k">if</span> <span class="o">(</span><span class="n">obj</span> <span class="k">instanceof</span> <span class="n">Bouchot</span><span class="o">)</span> <span class="o">{</span>
<span class="n">Bouchot</span> <span class="n">b</span> <span class="o">=</span> <span class="o">(</span><span class="n">Bouchot</span><span class="o">)</span> <span class="n">obj</span><span class="o">;</span>
<span class="n">var</span> <span class="n">nom</span> <span class="o">=</span> <span class="n">b</span><span class="o">.</span><span class="na">nom</span><span class="o">();</span>
<span class="o">}</span>
<span class="c1">//Après</span>
<span class="k">if</span> <span class="o">(</span><span class="n">obj</span> <span class="k">instanceof</span> <span class="n">Bouchot</span> <span class="n">b</span><span class="o">)</span> <span class="o">{</span>
<span class="n">var</span> <span class="n">nom</span> <span class="o">=</span> <span class="n">b</span><span class="o">.</span><span class="na">nom</span><span class="o">();</span>
<span class="o">}</span></code></pre>
<p>L’étape suivante est de combiner le <em>pattern matching</em> avec les <em>switch expressions</em> et de pouvoir déconstruire les <em>records</em>. Tout le programme est détaillé dans la <a href="https://openjdk.java.net/jeps/375">JEP 375</a> et en voici un avant‑goût :</p>
<pre><code class="java"><span class="n">record</span> <span class="nf">Point</span><span class="o">(</span><span class="kt">int</span> <span class="n">x</span><span class="o">,</span> <span class="kt">int</span> <span class="n">y</span><span class="o">)</span> <span class="o">{}</span>
<span class="k">if</span> <span class="o">(</span><span class="n">obj</span> <span class="k">instanceof</span> <span class="nf">Point</span><span class="o">(</span><span class="n">var</span> <span class="n">a</span><span class="o">,</span> <span class="n">var</span> <span class="n">b</span><span class="o">))</span> <span class="o">{</span>
<span class="n">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="n">a</span><span class="o">+</span><span class="n">b</span><span class="o">);</span>
<span class="o">}</span></code></pre>
<h3 id="toc-outils-dempaquetage">Outils d’empaquetage</h3>
<p>L’idéal de Java qui était, si je ne me trompe pas, compile ton application une seule fois et elle fonctionnera partout, semble ne plus trop être à l’ordre du jour. La démarche est plus, livre ton application avec les modules Java strictement nécessaires et, optionnellement, le JRE qui va avec. Le but étant la diminution de la taille des applications mais aussi l’amélioration de la réactivité et de la sécurité, car moins de code sera chargé et donc exposé. Comme d’habitude, les détails sont à lire dans la <a href="https://openjdk.java.net/jeps/343">JEP 343</a>.</p>
<h3 id="toc-les-blocs-de-texte-secondeitération">Les blocs de texte, seconde itération</h3>
<p>Après une première implémentation dans la version précédente de Java, en voici une nouvelle (<a href="https://openjdk.java.net/jeps/368">JEP 368</a>). Le principe est d’avoir une solution élégante pour se débarrasser des concaténations sur plusieurs lignes, de se battre avec les échappements divers et variés et surtout améliorer la lisibilité.</p>
<pre><code class="java"><span class="n">String</span> <span class="n">query</span> <span class="o">=</span> <span class="s">"""</span>
<span class="s"> SELECT `EMP_ID`, `LAST_NAME` FROM `EMPLOYEE_TB`</span>
<span class="s"> WHERE `CITY` = 'INDIANAPOLIS'</span>
<span class="s"> ORDER BY `EMP_ID`, `LAST_NAME`;</span>
<span class="s"> """</span><span class="o">;</span></code></pre>
<p>C’est aussi utilisable en combinaison avec d’autres bibliothèques, voici un exemple d’utilisation avec <a href="https://blog.jooq.org/2020/03/05/using-java-13-text-blocks-for-plain-sql-with-jooq">JOOQ</a>. </p>
<p>Avec cette seconde version, viennent des caractères d’échappement des lignes pour jongler avec les lignes trop longues ou gérer plus finement les retours à la ligne.</p>
<p>Dans l’exemple suivant toutes les lignes feront six caractères :</p>
<pre><code class="java"><span class="n">String</span> <span class="n">colors</span> <span class="o">=</span> <span class="s">"""</span>
<span class="s"> red \s</span>
<span class="s"> green\s</span>
<span class="s"> blue \s</span>
<span class="s"> """</span><span class="o">;</span></code></pre>
<h2 id="toc-les-mises-au-placard-et-lesdéparts">Les mises au placard et les départs</h2>
<p>Ironie de l’histoire, l’architecture créée par la même société que le langage est dépréciée et ne sera rapidement plus supportée. Pour les rares qui ont encore du Solaris et du <a href="https://fr.wikipedia.org/wiki/Architecture_SPARC">SPARC</a>, c’est bientôt la fin pour faire tourner des machines virtuelles Java (JVM) modernes. Les détails sont présents dans la <a href="https://openjdk.java.net/jeps/362">JEP 362</a>. Même processus pour le ramasse‑miettes <em>Concurrent Mark Sweep</em> dans le but de laisser plus de temps au développement des autres ramasse‑miettes, les détails dans la <a href="https://openjdk.java.net/jeps/291">JEP 291</a>.</p>
<p>Suppression des outils Pack200, suite à leur placardisation dans Java 11, ils sont remplacés par les outils <code>jlink</code>, plus d’informations dans la <a href="https://openjdk.java.net/jeps/367">JEP 367</a>.</p>
<h2 id="toc-dans-les-prochaines-versions">Dans les prochaines versions</h2>
<p>La seconde version du <em>pattern matching</em> de <em>instanceof</em>, les types scellés, la version définitive des blocs de texte. Je vous laisse regarder <a href="https://github.com/forax/do-synthetic-methods-dream-of-electric-switch-expressions/blob/master/slideshow/chapter09-future.ipynb">cette diapo</a> de Rémi Forax (un contributeur d’OpenJDK). Pour une vision plus « sous le capot », Brian Goetz (un architecte du langage) a rédigé <a href="http://cr.openjdk.java.net/%7Ebriangoetz/valhalla/sov/01-background.html">deux articles</a> sur les évolutions de Java.</p>
</div><div><a href="https://linuxfr.org/news/java-14-tombe-le-masque.epub">Télécharger ce contenu au format EPUB</a></div> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/119599/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/news/java-14-tombe-le-masque#comments">ouvrir dans le navigateur</a>
</p>
Nonolapérotheojouedubanjoolivier-mauryBenoît SibaudDavy DefaudYsabeau 🧶 🧦https://linuxfr.org/nodes/119599/comments.atomtag:linuxfr.org,2005:News/394892019-11-29T04:33:49+01:002019-11-29T11:56:07+01:00PHP 7.4Licence CC By‑SA http://creativecommons.org/licenses/by-sa/4.0/deed.fr<div><p>Il y a bien longtemps qu’une nouvelle version de PHP n’avait pas été commentée ici. En fait, depuis la sortie de la version 7.0 qui s’est faite dans la douleur après l’abandon de la version 6. Le langage sort désormais avec une nouvelle version chaque fin d’année. La rétrocompatibilité est un point qui n’est pas négligé d’une version à l’autre, d’où une évolution plutôt lente.<br>
La majorité des logiciels peut migrer sans trop d’appréhension. Depuis plusieurs versions, l’amélioration des performances est un point essentiel du fait de la concurrence avec HHVM, développé par Facebook. Au final, cette version, qui est la dernière de la branche 7, apporte un système de type plus fort, plus de performance et fait en sorte de diminuer le code cérémonial, aka <em>boilerplate</em>.</p>
</div><ul><li>lien nᵒ 1 : <a title="https://stitcher.io/blog/new-in-php-74" hreflang="en" href="https://linuxfr.org/redirect/105049">Une revue d’une grande partie des nouveautés</a></li><li>lien nᵒ 2 : <a title="https://www.php.net/" hreflang="en" href="https://linuxfr.org/redirect/105050">Site officiel de PHP</a></li><li>lien nᵒ 3 : <a title="https://afup.org/talks/3120-tout-pour-se-preparer-a-php-7-4" hreflang="fr" href="https://linuxfr.org/redirect/105250">Tout pour se préparer à PHP 7.4 (conférence forum PHP 2019)</a></li><li>lien nᵒ 4 : <a title="https://wiki.php.net/rfc#php_74" hreflang="en" href="https://linuxfr.org/redirect/105302">Liste des RFC de la version</a></li><li>lien nᵒ 5 : <a title="https://afup.org/talks/3015-php-8-et-just-in-time-compilation" hreflang="fr" href="https://linuxfr.org/redirect/105317">PHP 8 et le JIT (conférence forum PHP 2019)</a></li></ul><div><h2 class="sommaire">Sommaire</h2>
<ul class="toc">
<li>
<a href="#toc-r%C3%A9duction-de-la-verbosit%C3%A9-du-langage">Réduction de la verbosité du langage</a><ul>
<li><a href="#toc-null-coalescing-assignment-operator">Null coalescing assignment operator</a></li>
<li><a href="#toc-fonctions-fl%C3%A9ch%C3%A9es">Fonctions fléchées</a></li>
</ul>
</li>
<li>
<a href="#toc-%C3%89volution-de-la-syntaxe">Évolution de la syntaxe</a><ul>
<li><a href="#toc-s%C3%A9parateur-dunit%C3%A9">Séparateur d’unité</a></li>
<li><a href="#toc-les-op%C3%A9rateurs-ternaires-imbriqu%C3%A9s-ne-sont-plus-associ%C3%A9s-par-lagauche">Les opérateurs ternaires imbriqués ne sont plus associés par la gauche</a></li>
</ul>
</li>
<li><a href="#toc-un-typage-pluspr%C3%A9sent">Un typage plus présent</a></li>
<li>
<a href="#toc-am%C3%A9liorations-des-performances">Améliorations des performances</a><ul>
<li><a href="#toc-foreign-function-interface">Foreign Function Interface</a></li>
<li><a href="#toc-pr%C3%A9chargement">Préchargement</a></li>
</ul>
</li>
<li>
<a href="#toc-la-suite">La suite ?</a><ul>
<li><a href="#toc-p-bringing-peace-to-thegalaxy">P++, Bringing Peace to the Galaxy</a></li>
<li><a href="#toc-php8">PHP 8</a></li>
<li><a href="#toc-2029">2029</a></li>
</ul>
</li>
</ul>
<p>La version PHP 7.4 apporte de nombreuses fonctionnalités et en supprime une :</p>
<ul>
<li>
<a href="https://wiki.php.net/rfc/null_coalesce_equal_operator"><em>null coalescing assignment operator</em></a>, proposé par Midori Kocak ;</li>
<li>
<a href="https://wiki.php.net/rfc/arrow_functions_v2">fonctions fléchées 2.0</a>, proposées par Nikita Popov, Levi Morrison et Bob Weinand (<a href="https://github.com/php/php-src/pull/3941" title="Pull Request">PR</a>) ;</li>
<li>
<a href="https://wiki.php.net/rfc/typed_properties_v2">propriétés typées 2.0</a>, proposées par Nikita Popovet et Bob Weinand (<a href="https://github.com/php/php-src/pull/3734" title="Pull Request">PR</a>) ;</li>
<li>
<a href="https://wiki.php.net/rfc/preload">préchargement</a>, proposé par Dmitry Stogov ;</li>
<li>
<a href="https://wiki.php.net/rfc/improve-openssl-random-pseudo-bytes">amélioration d’<code>openssl_random_pseudo_bytes()</code></a>, proposée par Sammy Kaye Powers (<a href="https://github.com/php/php-src/pull/3649" title="Pull Request">PR</a>) ;</li>
<li>
<a href="https://wiki.php.net/rfc/weakrefs">références faibles</a> (<em>weak references</em>), proposées par <em>krakjoe</em> ;</li>
<li>
<a href="https://wiki.php.net/rfc/permanent_hash_ext">extension de hachage toujours disponible</a>, proposée par Kalle Sommer Nielsen ;</li>
<li>
<a href="https://wiki.php.net/rfc/ffi">FFI</a> (<em>Foreign Function Interface</em>), proposé par Dmitry Stogov ;</li>
<li>
<a href="https://wiki.php.net/rfc/password_registry">registre de hachage de mot de passe</a>, proposé par Sara Golemon (<a href="https://github.com/php/php-src/pull/3609" title="Pull Request">PR</a>) ;;</li>
<li>
<a href="https://wiki.php.net/rfc/mb_str_split">ajout de <code>mb_str_split()</code></a> pour couper une chaîne de caractères sur plusieurs octets, proposé par Rumi Legal (<a href="https://github.com/php/php-src/pull/3715">P</a> <a href="https://github.com/php/php-src/pull/3808">R</a>) ;</li>
<li>
<a href="https://wiki.php.net/rfc/reference_reflection">réflectivité pour les références</a> proposée par Nikita Popov (<a href="https://github.com/php/php-src/pull/3550" title="Pull Request">PR</a>) ;</li>
<li>
<a href="https://wiki.php.net/rfc/custom_object_serialization">nouveau mécanisme de sérialisation</a>, proposé par Nikita Popov (<a href="https://github.com/php/php-src/pull/3761">PR</a>) ;</li>
<li>
<a href="https://wiki.php.net/rfc/jit">fin de la prise en charge du format</a> <a href="https://fr.wikipedia.org/wiki/Web_Distributed_Data_eXchange">WDDX</a>, proposée par Dmitry Stogov et Zeev Suraski (<a href="http://git.php.net/?p=php-src.git;a=commit;h=6bbb18a0b6bef11222caaa55c00abdbcbb55d54b">51 fichiers supprimés</a>).</li>
</ul>
<h2 id="toc-réduction-de-la-verbosité-du-langage">Réduction de la verbosité du langage</h2>
<h3 id="toc-null-coalescing-assignment-operator">Null coalescing assignment operator</h3>
<p>Cette nouveauté évite de dupliquer le nom de la variable de part et d’autre de l’opérateur d’affectation. Par exemple, les deux lignes suivantes ont le même comportement :</p>
<pre><code class="php"><span class="nv">$this</span><span class="o">-></span><span class="na">request</span><span class="o">-></span><span class="na">data</span><span class="p">[</span><span class="s1">'comments'</span><span class="p">][</span><span class="s1">'user_id'</span><span class="p">]</span> <span class="o">=</span> <span class="nv">$this</span><span class="o">-></span><span class="na">request</span><span class="o">-></span><span class="na">data</span><span class="p">[</span><span class="s1">'comments'</span><span class="p">][</span><span class="s1">'user_id'</span><span class="p">]</span> <span class="o">??</span> <span class="s1">'value'</span><span class="p">;</span>
<span class="nv">$this</span><span class="o">-></span><span class="na">request</span><span class="o">-></span><span class="na">data</span><span class="p">[</span><span class="s1">'comments'</span><span class="p">][</span><span class="s1">'user_id'</span><span class="p">]</span> <span class="o">??=</span> <span class="s1">'value'</span><span class="p">;</span></code></pre>
<h3 id="toc-fonctions-fléchées">Fonctions fléchées</h3>
<p>Cette nouveauté a été définie dans cette <a href="https://wiki.php.net/rfc/arrow_functions_v2">RFC</a>. Elle vise, entre autres, à rendre l’usage du côté fonctionnel du langage plus agréable. Oui, oui, PHP a <a href="https://apiumhub.com/tech-blog-barcelona/functional-php/">quelques marges d’amélioration</a> à ce niveau‑là !</p>
<p>Ici, il sera plus agréable de remplacer les bons vieux <code>foreach()</code> pour traiter les tableaux par des <code>array_map()</code> ou des <code>array_filter()</code>. Globalement ça s’inspire des fonctions fléchées du JavaScript.</p>
<pre><code class="php"><span class="nv">$double</span> <span class="o">=</span> <span class="nb">array_map</span><span class="p">(</span><span class="nx">fn</span><span class="p">(</span><span class="nv">$e</span><span class="p">)</span> <span class="o">=></span> <span class="mi">2</span> <span class="o">*</span> <span class="nv">$e</span><span class="p">,</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">]);</span>
<span class="nv">$utilisateursMineurs</span> <span class="o">=</span> <span class="nb">array_filter</span><span class="p">(</span><span class="nv">$users</span><span class="p">,</span> <span class="nx">fn</span><span class="p">(</span><span class="nx">User</span> <span class="nv">$user</span><span class="p">)</span> <span class="o">=></span> <span class="nv">$user</span><span class="o">-></span><span class="na">age</span> <span class="o"><</span> <span class="mi">18</span><span class="p">);</span></code></pre>
<p>Nous pouvons noter la cohérence du langage entre les deux fonctionnalités, l’ordre d’appel entre le tableau et la méthode de retour n’est pas le même.</p>
<h2 id="toc-Évolution-de-la-syntaxe">Évolution de la syntaxe</h2>
<h3 id="toc-séparateur-dunité">Séparateur d’unité</h3>
<p>Il est possible d’ajouter un séparateur d’unité pour les nombres afin de les rendre plus lisibles. Par exemple, <code>$milliard = 1000000000</code> pourra s’écrire <code>$milliard = 1_000_000_000</code>. En revanche, attention à l’utilisation, il y a des risques de ne pas affecter la bonne valeur.</p>
<h3 id="toc-les-opérateurs-ternaires-imbriqués-ne-sont-plus-associés-par-lagauche">Les opérateurs ternaires imbriqués ne sont plus associés par la gauche</h3>
<p>PHP était un des rares langages à proposer une associativité des ternaires par la gauche. Et pour éviter aux développeurs de se prendre les pieds dans le tapis, elle disparaît. Le mieux étant tout de même d’éviter les ternaires imbriqués.</p>
<h2 id="toc-un-typage-plusprésent">Un typage plus présent</h2>
<p>Depuis la version 7.0, le typage est de plus en plus présent au sein du langage. Il est possible de typer les arguments et le type de retour d’une méthode. Dorénavant, il sera aussi possible de spécifier le type des attributs d’une classe.</p>
<pre><code class="php"><span class="k">class</span> <span class="nc">Sportif</span>
<span class="p">{</span>
<span class="k">private</span> <span class="nx">Sport</span> <span class="nv">$sport</span> <span class="o">=</span> <span class="s1">'cyclimse'</span><span class="p">;</span>
<span class="k">private</span> <span class="nx">Humain</span> <span class="nv">$humain</span><span class="p">;</span>
<span class="k">public</span> <span class="k">function</span> <span class="fm">__construct</span><span class="p">(</span><span class="nx">Humain</span> <span class="nv">$humain</span><span class="p">,</span> <span class="nx">Sport</span> <span class="nv">$sport</span><span class="p">)</span>
<span class="p">{</span>
<span class="nv">$this</span><span class="o">-></span><span class="na">humain</span> <span class="o">=</span> <span class="nv">$humain</span><span class="p">;</span>
<span class="nv">$this</span><span class="o">-></span><span class="na">sport</span> <span class="o">=</span> <span class="nv">$sport</span><span class="p">;</span>
<span class="p">}</span>
<span class="k">public</span> <span class="k">function</span> <span class="nf">entrainer</span><span class="p">()</span><span class="o">:</span><span class="nx">void</span>
<span class="p">{</span>
<span class="nv">$this</span><span class="o">-></span><span class="na">humain</span><span class="o">-></span><span class="na">ajouteEntrainement</span><span class="p">(</span><span class="nv">$this</span><span class="o">-></span><span class="na">sport</span><span class="p">);</span>
<span class="p">}</span></code></pre>
<p>Ces ajouts sur les types facilitent la compréhension du code. En revanche, sans contrainte, PHP a un typage dynamique, donc le code suivant n’a pas forcément un résultat intuitif :</p>
<pre><code class="php"><span class="nv">$somme</span> <span class="o">=</span> <span class="k">function</span> <span class="p">(</span><span class="nx">int</span> <span class="nv">$a</span><span class="p">,</span> <span class="nx">int</span> <span class="nv">$b</span><span class="p">)</span><span class="o">:</span> <span class="nx">int</span> <span class="p">{</span><span class="k">return</span> <span class="nv">$a</span> <span class="o">+</span> <span class="nv">$b</span><span class="p">;</span> <span class="p">};</span>
<span class="k">echo</span> <span class="nv">$somme</span><span class="p">(</span><span class="s2">"1"</span><span class="p">,</span> <span class="mf">2.1</span><span class="p">);</span> <span class="c1">// affiche 3</span></code></pre>
<p>En forçant une évaluation stricte des types en plaçant <code>declare(strict_types=1);</code> en début de fichier, le code déclenche une erreur sur le typage. Ainsi, le développeur est forcé à prêter plus attention aux arguments passés aux méthodes.</p>
<p>En PHP 8, s’ajouteront les <a href="https://wiki.php.net/rfc/union_types_v2">types unions</a>, et espérons qu’ils seront accompagnés par des énumérations.</p>
<h2 id="toc-améliorations-des-performances">Améliorations des performances</h2>
<p>Comme à chaque fois depuis la version 7.0, les performances natives du langage s’améliorent. Il est actuellement un des langages interprétés les plus rapides. Il faut néanmoins relativiser, car un langage qui va vite c’est une chose, mais si du temps est perdu à attendre le retour d’une requête en base de données ou, pire, depuis le réseau, les gains côté PHP ne sont pas très utiles. C’est d’ailleurs une des raisons pour lesquelles le JIT ne sera pas activé par défaut en PHP 8.</p>
<h3 id="toc-foreign-function-interface">Foreign Function Interface</h3>
<p>L’idée est ici de pouvoir appeler un programme en C depuis un script PHP, un peu à l’idée de ce qu’il est possible de faire en Python en écrivant du CPython.</p>
<p>Il sera possible d’écrire des choses du genre (<a href="https://github.com/dstogov/php-ffi">source</a>) :</p>
<pre><code class="php"><span class="nv">$libc</span> <span class="o">=</span> <span class="nx">FFI</span><span class="o">::</span><span class="na">cdef</span><span class="p">(</span><span class="s2">"</span>
<span class="s2"> int printf(const char *format, ...);</span>
<span class="s2"> const char * getenv(const char *);</span>
<span class="s2"> unsigned int time(unsigned int *);</span>
<span class="s2"> typedef unsigned int time_t;</span>
<span class="s2"> typedef unsigned int suseconds_t;</span>
<span class="s2"> struct timeval {</span>
<span class="s2"> time_t tv_sec;</span>
<span class="s2"> suseconds_t tv_usec;</span>
<span class="s2"> };</span>
<span class="s2"> struct timezone {</span>
<span class="s2"> int tz_minuteswest;</span>
<span class="s2"> int tz_dsttime;</span>
<span class="s2"> };</span>
<span class="s2"> int gettimeofday(struct timeval *tv, struct timezone *tz);</span>
<span class="s2">"</span><span class="p">,</span> <span class="s2">"libc.so.6"</span><span class="p">);</span>
<span class="nv">$libc</span><span class="o">-></span><span class="na">printf</span><span class="p">(</span><span class="s2">"Hello World from %s!</span><span class="se">\n</span><span class="s2">"</span><span class="p">,</span> <span class="s2">"PHP"</span><span class="p">);</span>
<span class="nb">var_dump</span><span class="p">(</span><span class="nv">$libc</span><span class="o">-></span><span class="na">getenv</span><span class="p">(</span><span class="s2">"PATH"</span><span class="p">));</span>
<span class="nb">var_dump</span><span class="p">(</span><span class="nv">$libc</span><span class="o">-></span><span class="na">time</span><span class="p">(</span><span class="k">null</span><span class="p">));</span>
<span class="nv">$tv</span> <span class="o">=</span> <span class="nv">$libc</span><span class="o">-></span><span class="na">new</span><span class="p">(</span><span class="s2">"struct timeval"</span><span class="p">);</span>
<span class="nv">$tz</span> <span class="o">=</span> <span class="nv">$libc</span><span class="o">-></span><span class="na">new</span><span class="p">(</span><span class="s2">"struct timezone"</span><span class="p">);</span>
<span class="nv">$libc</span><span class="o">-></span><span class="na">gettimeofday</span><span class="p">(</span><span class="nx">FFI</span><span class="o">::</span><span class="na">addr</span><span class="p">(</span><span class="nv">$tv</span><span class="p">),</span> <span class="nx">FFI</span><span class="o">::</span><span class="na">addr</span><span class="p">(</span><span class="nv">$tz</span><span class="p">));</span>
<span class="nb">var_dump</span><span class="p">(</span><span class="nv">$tv</span><span class="o">-></span><span class="na">tv_sec</span><span class="p">,</span> <span class="nv">$tv</span><span class="o">-></span><span class="na">tv_usec</span><span class="p">,</span> <span class="nv">$tz</span><span class="p">);</span></code></pre>
<p>Cette fonctionnalité ouvre la possibilité d’effectuer des traitements qui habituellement ne se font pas en PHP. D’ailleurs, voici un <a href="https://github.com/vdechenaux/PhpWebcam">exemple d’utilisation</a>.</p>
<h3 id="toc-préchargement">Préchargement</h3>
<p>L’idée est de charger des fichiers afin que PHP crée un « binaire ». En contre‑partie, la mise à jour du binaire devra attendre un prochain démarrage et le temps de démarrage sera un peu plus long. Ce préchargement est donc intéressant pour les fichiers qui évoluent rarement, globalement ceux du cadriciel. En fonction des projets, il peut être intéressant de ne précharger que les fichiers les plus utilisés, comme le montre <a href="https://github.com/composer/composer/issues/7777#issuecomment-440268416">ce commentaire</a>.</p>
<h2 id="toc-la-suite">La suite ?</h2>
<h3 id="toc-p-bringing-peace-to-thegalaxy">P++, Bringing Peace to the Galaxy</h3>
<p>En août 2019, la communauté s’était posé la question sur la création d’une variante du PHP : <a href="https://wiki.php.net/pplusplus/faq">P++</a> (c’est un nom temporaire et on peut aussi lire PHP++). L’idée était de nettoyer le langage de ses aspects pas toujours cohérents, mais conservés pour des raisons de compatibilité. Un peu comme pour le langage <a href="https://fr.wikipedia.org/wiki/Raku_(langage_de_programmation)">Raku</a> créé initialement pour rendre le langage <a href="https://fr.wikipedia.org/wiki/Perl_(langage)">Perl</a> plus accessible. Le moteur d’exécution de PHP pourrait alors interpréter indifféremment un PHP <em>Classic</em> <code><?php ?></code> et un P++ <code><?p++ ?></code>. Benjamin Eberlei <a href="https://beberlei.de/2019/08/14/pplusplus_is_a_bad_idea.html">propose</a> d’utiliser <code><?php declare(std=20); ?></code>.</p>
<p>Un <a href="https://www.strawpoll.me/18448151">sondage ouvert à tous</a> montre que 60 % des répondants souhaitent un PHP 8 rétrocompatible, et un petit 20 % pour passer à P++. Les mainteneurs se sont aussi exprimés lors d’un <a href="https://wiki.php.net/rfc/p-plus-plus#vote">sondage plus formel</a>, et P++ ne verra pas le jour, car trop d’énergie à investir sur deux langages, la fragmentation de la communauté PHP…</p>
<h3 id="toc-php8">PHP 8</h3>
<p>En fin d’année prochaine, PHP 8 devrait débarquer avec quelques gros changements. Le plus important est, peut‑être, la <a href="https://fr.wikipedia.org/wiki/Compilation_%C3%A0_la_vol%C3%A9e">compilation à la volée</a> (<em>JIT</em>) <a href="https://wiki.php.net/rfc/jit">proposée par Dmitry Stogov</a>.</p>
<p>En 2011, Facebook annonçait des performances incroyables avec <a href="https://en.wikipedia.org/wiki/HHVM">HHVM</a>, son implémentation d’un moteur d’exécution PHP exploitant la compilation à la volée. Mais cette technique pour optimiser l’exécution de PHP n’avait pas été retenue pour le moteur d’exécution de référence. Néanmoins, PHP 7 a pu bénéficier d’autres mécanismes pour améliorer ses performances, rattraper HHVM et susciter un regain d’intérêt pour PHP.</p>
<p>Aujourd’hui, près de dix ans plus tard, il ne reste plus beaucoup d’options pour continuer d’améliorer les performances de PHP. Bien que la compilation à la volée ne devrait pas beaucoup améliorer la performance du rendu des pages Web, cette technique apporte deux avantages :</p>
<ul>
<li>une très bonne approche pour l’utilisation de PHP dans du calcul intensif, et cela devrait permettre d’utiliser PHP dans des domaines où on ne le considérait pas comme une option ;</li>
<li>permettre de basculer des pans entiers du code PHP par l’équivalent dans un langage plus proche du processeur (comme le langage C) lors de cette compilation à la volée.</li>
</ul>
<p>Cette compilation à la volée a failli être <a href="https://github.com/zendtech/php-src/tree/jit-dynasm-7.4">intégrée</a> dans PHP 7.4 en mode expérimental. Ce changement correspond au plus <a href="https://github.com/php/php-src/commit/9a06876072b9ccb023d4a14426ccb587f10882f3">grand <em>commit</em></a> de l’histoire de PHP.</p>
<p>La future version PHP 8 apportera également d’autres améliorations que nous aurons plaisir à partager dans un an…</p>
<h3 id="toc-2029">2029</h3>
<p>Utilisera‐t‐on PHP dans dix ans, en 2029 ?</p>
<p>D’après le site <em>W3Techs</em>, PHP est encore et toujours <a href="https://w3techs.com/technologies/overview/programming_language/all">le langage le plus utilisé</a> côté serveur Web. Les statistiques sont mises à jour quotidiennement. Voici les chiffres lors de la rédaction de cette dépêche :</p>
<ul>
<li>79 % PHP ;</li>
<li>11 % ASP.NET ;</li>
<li> 5 % Java et Scala ;</li>
<li> 3 % Ruby (vive <em>LinuxFr.org</em>) ;</li>
<li> 2 % HTML (fichiers statiques) ;</li>
<li> 1 % Python ;</li>
<li> 1 % JavaScript.</li>
</ul>
<p>Pour la méthodologie utilisée, lire les <a href="https://w3techs.com/technologies">explications fournies par <em>W3Techs</em></a>.</p>
<p>Avec un zoom sur les <a href="https://w3techs.com/technologies/details/pl-php/all/all">versions de PHP</a> :</p>
<ul>
<li>PHP 3 0,0x % 😱 plus maintenu depuis 19 ans !</li>
<li>PHP 4 0,5 % 😵 plus maintenu depuis 11 ans !</li>
<li>PHP 5 58 % 😮 plus maintenu depuis un an ;</li>
<li>PHP 6 0 % 🤐 version abandonnée, jamais sortie ;</li>
<li>PHP 7 42 % 😀 version actuelle ;</li>
<li>PHP 8 0 % 🤩 sortie prévue dans un an.</li>
</ul>
</div><div><a href="https://linuxfr.org/news/php-7-4.epub">Télécharger ce contenu au format EPUB</a></div> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/118316/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/news/php-7-4#comments">ouvrir dans le navigateur</a>
</p>
NonolapéroOliverDavy DefaudYves BourguignonZeroHeureNils RatusznikDafydJulien Jorgewindu.2bChristophe "CHiPs" PETITbobble bubbleYsabeau 🧶 🧦dourouc05https://linuxfr.org/nodes/118316/comments.atomtag:linuxfr.org,2005:Diary/387992019-11-26T20:09:45+01:002019-11-26T20:09:45+01:00Java perdra une partie de sa verbosité à la fin de l’hiverLicence CC By‑SA http://creativecommons.org/licenses/by-sa/4.0/deed.fr<p>Il y a quelque semaines paraissait la version 13 du langage avec des nouveautés sympathiques mais qui ne cassaient pas trois pattes à un canard_/° =. <br>
La prochaine version prévue pour la fin de l’hiver s’annonce nettement plus étoffée avec pas moins de 13 JEP au moment d’écrire ces lignes.</p>
<h3 id="toc-records"><a href="https://openjdk.java.net/jeps/359">Records</a></h3>
<p>On pourra trouver les Records qui permettront d’encapsuler de manière immutable de la donnée en une ligne.</p>
<pre><code class="java"><span class="n">record</span> <span class="nf">Moule</span><span class="o">(</span><span class="n">String</span> <span class="n">pseudo</span><span class="o">,</span> <span class="n">Tribune</span> <span class="n">tribune</span><span class="o">){}</span></code></pre>
<p>Les accesseurs, equals, hashCode et toString n’ont pas besoin d’être précisés car le langage se débrouille tout seul. Il n’est pas interdit d’ajouter des méthodes pour éviter de construire un objet invalide, par exemple.</p>
<h3 id="toc-le-début-de-commencement-du-pattern-matching">Le début de commencement du <a href="https://openjdk.java.net/jeps/305">Pattern Matching</a>
</h3>
<p>Alors que le filtrage par motif existe en Scala, Clojure, Groovy et Kotlin soit les principaux autres langage fonctionnant sur la JVM, il fait enfin son apparition en Java. Pour le moment ça reste timide puisqu’il est limité à la méthode <code>instanceof</code>. Dans les versions suivantes il sera disponible à d’autres endroits. En Java 14, il sera possible d’écrire :</p>
<pre><code class="java"><span class="n">String</span> <span class="n">formatted</span> <span class="o">=</span> <span class="s">"unknown"</span><span class="o">;</span>
<span class="k">if</span> <span class="o">(</span><span class="n">obj</span> <span class="k">instanceof</span> <span class="n">Integer</span> <span class="n">i</span><span class="o">)</span> <span class="o">{</span>
<span class="n">formatted</span> <span class="o">=</span> <span class="n">String</span><span class="o">.</span><span class="na">format</span><span class="o">(</span><span class="s">"int %d"</span><span class="o">,</span> <span class="n">i</span><span class="o">);</span>
<span class="o">}</span>
<span class="k">else</span> <span class="k">if</span> <span class="o">(</span><span class="n">obj</span> <span class="k">instanceof</span> <span class="n">Byte</span> <span class="n">b</span><span class="o">)</span> <span class="o">{</span>
<span class="n">formatted</span> <span class="o">=</span> <span class="n">String</span><span class="o">.</span><span class="na">format</span><span class="o">(</span><span class="s">"byte %d"</span><span class="o">,</span> <span class="n">b</span><span class="o">);</span>
<span class="o">}</span>
<span class="k">else</span> <span class="k">if</span> <span class="o">(</span><span class="n">obj</span> <span class="k">instanceof</span> <span class="n">Long</span> <span class="n">l</span><span class="o">)</span> <span class="o">{</span>
<span class="n">formatted</span> <span class="o">=</span> <span class="n">String</span><span class="o">.</span><span class="na">format</span><span class="o">(</span><span class="s">"long %d"</span><span class="o">,</span> <span class="n">l</span><span class="o">);</span>
<span class="o">}</span>
<span class="k">else</span> <span class="k">if</span> <span class="o">(</span><span class="n">obj</span> <span class="k">instanceof</span> <span class="n">Double</span> <span class="n">d</span><span class="o">)</span> <span class="o">{</span>
<span class="n">formatted</span> <span class="o">=</span> <span class="n">String</span><span class="o">.</span><span class="na">format</span><span class="o">(</span><span class="s">"double %f"</span><span class="o">,</span> <span class="n">d</span><span class="o">);</span>
<span class="o">}</span>
<span class="k">else</span> <span class="k">if</span> <span class="o">(</span><span class="n">obj</span> <span class="k">instanceof</span> <span class="n">String</span> <span class="n">s</span><span class="o">)</span> <span class="o">{</span>
<span class="n">formatted</span> <span class="o">=</span> <span class="n">String</span><span class="o">.</span><span class="na">format</span><span class="o">(</span><span class="s">"String %s"</span><span class="o">,</span> <span class="n">s</span><span class="o">);</span>
<span class="o">}</span></code></pre>
<p>Ça ne reste pas bien folichon mais ce qui est prévu c’est de pouvoir écrire :</p>
<pre><code class="java"><span class="n">String</span> <span class="n">formatted</span> <span class="o">=</span>
<span class="k">switch</span> <span class="o">(</span><span class="n">obj</span><span class="o">)</span> <span class="o">{</span>
<span class="k">case</span> <span class="n">Integer</span> <span class="n">i</span> <span class="o">-></span> <span class="n">String</span><span class="o">.</span><span class="na">format</span><span class="o">(</span><span class="s">"int %d"</span><span class="o">,</span> <span class="n">i</span><span class="o">)</span>
<span class="k">case</span> <span class="n">Byte</span> <span class="n">b</span> <span class="o">-></span> <span class="n">String</span><span class="o">.</span><span class="na">format</span><span class="o">(</span><span class="s">"byte %d"</span><span class="o">,</span> <span class="n">b</span><span class="o">);</span>
<span class="k">case</span> <span class="n">Long</span> <span class="n">l</span> <span class="o">-></span> <span class="n">String</span><span class="o">.</span><span class="na">format</span><span class="o">(</span><span class="s">"long %d"</span><span class="o">,</span> <span class="n">l</span><span class="o">);</span>
<span class="k">case</span> <span class="n">Double</span> <span class="n">d</span> <span class="o">-></span> <span class="n">String</span><span class="o">.</span><span class="na">format</span><span class="o">(</span><span class="s">"double %f"</span><span class="o">,</span> <span class="n">d</span><span class="o">);</span>
<span class="k">case</span> <span class="n">String</span> <span class="n">s</span> <span class="o">-></span> <span class="n">String</span><span class="o">.</span><span class="na">format</span><span class="o">(</span><span class="s">"String %s"</span><span class="o">,</span> <span class="n">s</span><span class="o">);</span>
<span class="k">default</span> <span class="o">-></span> <span class="n">obj</span><span class="o">.</span><span class="na">toString</span><span class="o">();</span>
<span class="o">};</span></code></pre>
<p>Avec ces deux nouveautés, j’ai l’impression que <a href="https://projectlombok.org/">Lombok</a> va pouvoir se rhabiller.</p>
<p>Et vous dans la <a href="https://openjdk.java.net/projects/jdk/14/">liste des nouveautés</a>, qu’est-ce qui vous fait envie à part tester le dernier framework JavaScript à la mode ou rester sur Kotlin ?</p>
<div><a href="https://linuxfr.org/users/nonolapero/journaux/java-perdra-une-partie-de-sa-verbosite-a-la-fin-de-l-hiver.epub">Télécharger ce contenu au format EPUB</a></div> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/118735/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/users/nonolapero/journaux/java-perdra-une-partie-de-sa-verbosite-a-la-fin-de-l-hiver#comments">ouvrir dans le navigateur</a>
</p>
Nonolapérohttps://linuxfr.org/nodes/118735/comments.atomtag:linuxfr.org,2005:Diary/387352019-10-22T22:21:22+02:002019-10-22T22:21:22+02:00Elm sort en version 0.19.1Licence CC By‑SA http://creativecommons.org/licenses/by-sa/4.0/deed.fr<p>Alors que la <a href="/redaction/news/elm-toujours-plus-simple-avec-les-versions-0-17-0-18-et-0-19">dépêche</a> concernant les versions 0.17, 0.17 et 0.19 attend toujours d'être terminée. Le langage <a href="https://elm-lang.org/news/the-syntax-cliff">Elm</a> atteint la version 0.19.1. <br>
La principale nouveauté vient du compilateur qui apporte encore plus d'aide pour résoudre les problèmes qu'il rencontre dans votre code. Je vous laisse parcourir le lien précédent pour plus de détails ou les différents contenu avec le tag <a href="/tags/elm/public">elm</a>.</p>
<p>Pour ceux qui ne savent pas ce qu'est Elm, il s'agit d'un langage fonctionnel, fortement typé qui compile vers le Javascript. Il promet de ne plus avoir d'erreur au runtime. Côté outillage, il possède une ligne de commande interactive pour tester des bouts de code, un compilateur à la volée pour voir les modifications au fur et à mesure.</p>
<p>En plus d'avoir inspiré <a href="https://fr.wikipedia.org/wiki/React" title="Définition Wikipédia">React</a>, Elm a son pendant qui tourne sur la <a href="https://fr.wikipedia.org/wiki/Common%20Language%20Runtime" title="Définition Wikipédia">Common Language Runtime</a> en F# avec <a href="https://elmish.github.io/elmish/">Elmish</a>.</p>
<p>Il semblerait que les gens qui s'y mettent ont du mal à faire machine arrière, voici un <a href="https://www.grenat.eu/blog/ce-que-jaime-en-elm">témoignage</a>. J'avais croisé un tweet qui disait qu'une entreprise avait commencé à utiliser le langage l'été 2018 dans leurs logiciel et récemment il avait viré React.</p>
<p>Des gens ont des retours positifs comme négatifs sur le langage ?</p>
<div><a href="https://linuxfr.org/users/nonolapero/journaux/elm-sort-en-version-0-19-1.epub">Télécharger ce contenu au format EPUB</a></div> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/118427/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/users/nonolapero/journaux/elm-sort-en-version-0-19-1#comments">ouvrir dans le navigateur</a>
</p>
Nonolapérohttps://linuxfr.org/nodes/118427/comments.atomtag:linuxfr.org,2005:Diary/386902019-09-30T07:32:37+02:002019-09-30T07:32:37+02:00Enfin des NullPointerException plus explicites en JavaLicence CC By‑SA http://creativecommons.org/licenses/by-sa/4.0/deed.fr<p>Comme il était énoncé dans la fin de la <a href="//linuxfr.org/news/sortie-d-openjdk-13">dépêche sur OpenJDK 13</a>. La prochaine version du langage le plus utilisé du monde®, les <em>NullPointerExceptions</em> seront plus détaillées afin d’aider le développeur à trouver où ses doigts ont fourché.<br>
Les détails sont à lire dans la <a href="https://openjdk.java.net/jeps/358">JEP 358</a> dont j’ai extrait deux exemples :</p>
<blockquote>
<p>For example, an NPE from the assignment statement a.i = 99; would generate this message:</p>
<p>Exception in thread "main" java.lang.NullPointerException: <br>
Cannot assign field 'i' because 'a' is null.<br>
at Prog.main(Prog.java:5)</p>
<p>If the more complex statement a.b.c.i = 99; throws an NPE, the message would dissect the statement and pinpoint the cause by showing the full access path which led up to the null:</p>
<p>Exception in thread "main" java.lang.NullPointerException: <br>
Cannot read field 'c' because 'a.b' is null.<br>
at Prog.main(Prog.java:5)</p>
</blockquote>
<p>Le bémol c’est que Java 14 ne sera pas une LTS, la prochaine est la 17 il me semble. Ce n’est donc pas demain la veille que la plupart des développeurs profiteront de cette évolution.</p>
<div><a href="https://linuxfr.org/users/nonolapero/journaux/enfin-des-nullpointerexception-plus-explicites-en-java.epub">Télécharger ce contenu au format EPUB</a></div> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/118226/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/users/nonolapero/journaux/enfin-des-nullpointerexception-plus-explicites-en-java#comments">ouvrir dans le navigateur</a>
</p>
Nonolapérohttps://linuxfr.org/nodes/118226/comments.atomtag:linuxfr.org,2005:News/394542019-09-24T09:51:26+02:002019-09-26T13:38:17+02:00Sortie d’OpenJDK 13Licence CC By‑SA http://creativecommons.org/licenses/by-sa/4.0/deed.fr<div><p>Le 17 septembre 2019 est sortie cette nouvelle version d’OpenJDK. Elle comporte son lot de nouveautés, de fonctionnalités en préversion et des retraits. C’est aussi l’occasion de réécriture de certains composants, notamment <a href="https://openjdk.java.net/jeps/353">l’API Socket</a> pour l’inclusion des fils d’exécution — <em>threads</em> — locaux (<em>aka</em> <a href="https://openjdk.java.net/projects/loom/">Fibers</a>). Les notes de version vous permettront d’avoir plus de détails.</p>
</div><ul><li>lien nᵒ 1 : <a title="https://jdk.java.net/13/release-notes" hreflang="en" href="https://linuxfr.org/redirect/104885">Notes de version</a></li><li>lien nᵒ 2 : <a title="https://adoptopenjdk.net/" hreflang="en" href="https://linuxfr.org/redirect/104886">AdoptOpenJDK</a></li><li>lien nᵒ 3 : <a title="https://www.youtube.com/watch?v=HrQWyS1EGLU" hreflang="fr" href="https://linuxfr.org/redirect/104891">Vidéo sur les dernières nouveautés et celles à venir</a></li></ul><div><h2 class="sommaire">Sommaire</h2>
<ul class="toc">
<li>
<a href="#toc-dynamique-de-d%C3%A9veloppement">Dynamique de développement</a><ul>
<li><a href="#toc-contributions">Contributions</a></li>
<li><a href="#toc-rythme-de-publication-et-dur%C3%A9e-demaintenance">Rythme de publication et durée de maintenance</a></li>
</ul>
</li>
<li>
<a href="#toc-dans-les-%C3%A9pisodes-pr%C3%A9c%C3%A9dents">Dans les épisodes précédents</a><ul>
<li>
<a href="#toc-quelques-nouveaut%C3%A9s-apparues">Quelques nouveautés apparues</a><ul>
<li><a href="#toc-mot-clef-var">Mot clef « var »</a></li>
<li><a href="#toc-nouvelle-m%C3%A9thode-pour-les-collecteurs-collectorsteeing">Nouvelle méthode pour les collecteurs « Collectors::teeing »</a></li>
</ul>
</li>
</ul>
</li>
<li>
<a href="#toc-nouveaut%C3%A9s">Nouveautés</a><ul>
<li>
<a href="#toc-dynamic-cds-archive-jep350">Dynamic CDS Archive </a><a href="https://openjdk.java.net/jeps/350">JEP 350</a>
</li>
<li><a href="#toc-zgc-uncommit-unusedmemory">ZGC : uncommit unused memory</a></li>
<li><a href="#toc-divers">Divers</a></li>
</ul>
</li>
<li>
<a href="#toc-nouveaut%C3%A9s-en-pr%C3%A9version">Nouveautés en préversion</a><ul>
<li><a href="#toc-expressions-switch">Expressions switch</a></li>
<li><a href="#toc-text-block">Text Block</a></li>
</ul>
</li>
<li><a href="#toc-futur">Futur</a></li>
</ul>
<h2 id="toc-dynamique-de-développement">Dynamique de développement</h2>
<h3 id="toc-contributions">Contributions</h3>
<p>Bien qu’Oracle reste le principal contributeur au projet, depuis les dernières versions, Red Hat et d’autres sociétés prennent en charge une part significative du travail, aux environs de 30 % des tickets pour la version 13. Plus de détails dans les billets du blog d’Oracle concernant la sortie des versions <a href="https://blogs.oracle.com/java-platform-group/the-arrival-of-java-12">12</a> et <a href="https://blogs.oracle.com/java-platform-group/the-arrival-of-java-13">13</a>.</p>
<h3 id="toc-rythme-de-publication-et-durée-demaintenance">Rythme de publication et durée de maintenance</h3>
<p>Depuis la sortie d’OpenJDK 9, le rythme de publication est passé à une version tous les six mois avec une maintenance raccourcie pour les versions sans support étendu (actuellement 9, 10, 12 et 13). À l’heure actuelle, les versions 8 et 11 ont un support de longue durée. Selon les distributions du JDK (Red Hat, IBM, Azul, Amazon, etc.) c’est encore différent.</p>
<h2 id="toc-dans-les-épisodes-précédents">Dans les épisodes précédents</h2>
<h3 id="toc-quelques-nouveautés-apparues">Quelques nouveautés apparues</h3>
<h4 id="toc-mot-clef-var">Mot clef « var »</h4>
<p>La version 10 a vu l’apparition du mot clef <code>var</code> qui permet l’inférence de type et dont l’usage a été étendu aux <a href="https://fr.wikipedia.org/wiki/Lambda-calcul">expressions lambda</a> dans la version 11. Cela permet de ne pas avoir à déclarer le type s’il est évident ou d’avoir à écrire un type trop verbeux. Il existe une liste de bonnes pratiques (<a href="https://openjdk.java.net/projects/amber/LVTIstyle.html">ici</a> ou <a href="https://openjdk.java.net/projects/amber/LVTIFAQ.html">là</a>) pour éviter de rendre le code illisible.</p>
<h4 id="toc-nouvelle-méthode-pour-les-collecteurs-collectorsteeing">Nouvelle méthode pour les collecteurs « Collectors::teeing »</h4>
<p>Depuis la version 12, la méthode statique <code>Collectors::teeing</code> permet de récupérer dans un flux deux informations différentes et ensuite d’appeler une méthode pour exploiter les données obtenues. <a href="https://blog.codefx.org/java/teeing-collector/">Cet article</a> en anglais apporte plus de détails.</p>
<h2 id="toc-nouveautés">Nouveautés</h2>
<p>Dans cette version les évolutions définitives sont principalement des mises à jour côté sécurité, des correctifs divers et variés ainsi que des améliorations de la machine virtuelle Java (JVM).</p>
<h3 id="toc-dynamic-cds-archive-jep350">Dynamic CDS Archive <a href="https://openjdk.java.net/jeps/350">JEP 350</a>
</h3>
<p>C’est une extension d’un module libéré par Oracle dans le JDK 10 (<em>Application Class‑Data Sharing</em> <a href="https://openjdk.java.net/jeps/310">JEP 310</a>). Ce module permet des temps de chargement raccourcis et une empreinte mémoire plus faible en partageant certaines classes entre les processus Java. Cette extension simplifie l’usage du module grâce à quelques options :</p>
<ul>
<li>archivage à l’arrêt ;</li>
<li>chargement d’une archive au démarrage.</li>
</ul>
<h3 id="toc-zgc-uncommit-unusedmemory">ZGC : uncommit unused memory</h3>
<p>ZGC est un ramasse‑miettes expérimental à faible latence. Il est présent depuis le JDK 11. Désormais, la mémoire peut être rendue au système d’exploitation en configurant les options. C’est bien pratique puisque désormais la taille maximale du <a href="https://fr.wikipedia.org/wiki/Tas_(allocation_dynamique)">tas</a> (<em>heap</em>) est passée de 4 à 16 Tio.</p>
<h3 id="toc-divers">Divers</h3>
<p>Intégration d’Unicode 12.1, vous pourrez désormais avoir un émoji <a href="https://emojipedia.org/safety-vest/">gilet jaune</a>. Pour les personnes plus versées dans les aspects sécurité, la lecture du <a href="https://seanjmullan.org/blog/2019/08/05/jdk13">blog de Sean Mullan</a> est une bonne chose.</p>
<h2 id="toc-nouveautés-en-préversion">Nouveautés en préversion</h2>
<p>Il s’agit de fonctionnalités à découvrir et qui nécessitent une activation à la compilation. Elles sont d’ailleurs amenées à ne pas rester en l’état. Par exemple, les <em>switch expressions</em> en sont à leur seconde itération.</p>
<h3 id="toc-expressions-switch">Expressions switch</h3>
<p>Cette fonctionnalité est définie par la <a href="http://openjdk.java.net/jeps/325">JEP 325</a>. Il s’agit d’une des solutions pour rendre le code Java moins verbeux, et donc limiter le risque d’erreurs. Ainsi, le code :</p>
<pre><code class="java"><span class="k">switch</span> <span class="o">(</span><span class="n">day</span><span class="o">)</span> <span class="o">{</span>
<span class="k">case</span> <span class="n">MONDAY</span><span class="o">:</span>
<span class="k">case</span> <span class="n">FRIDAY</span><span class="o">:</span>
<span class="k">case</span> <span class="n">SUNDAY</span><span class="o">:</span>
<span class="n">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="mi">6</span><span class="o">);</span>
<span class="k">break</span><span class="o">;</span>
<span class="k">case</span> <span class="n">TUESDAY</span><span class="o">:</span>
<span class="n">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="mi">7</span><span class="o">);</span>
<span class="k">break</span><span class="o">;</span>
<span class="k">case</span> <span class="n">THURSDAY</span><span class="o">:</span>
<span class="k">case</span> <span class="n">SATURDAY</span><span class="o">:</span>
<span class="n">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="mi">8</span><span class="o">);</span>
<span class="k">break</span><span class="o">;</span>
<span class="k">case</span> <span class="n">WEDNESDAY</span><span class="o">:</span>
<span class="n">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="mi">9</span><span class="o">);</span>
<span class="k">break</span><span class="o">;</span>
<span class="o">}</span></code></pre>
<p>Peut désormais s’écrire de la manière suivante :</p>
<pre><code class="java"><span class="k">switch</span> <span class="o">(</span><span class="n">day</span><span class="o">)</span> <span class="o">{</span>
<span class="k">case</span> <span class="n">MONDAY</span><span class="o">,</span> <span class="n">FRIDAY</span><span class="o">,</span> <span class="n">SUNDAY</span> <span class="o">-></span> <span class="n">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="mi">6</span><span class="o">);</span>
<span class="k">case</span> <span class="n">TUESDAY</span> <span class="o">-></span> <span class="n">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="mi">7</span><span class="o">);</span>
<span class="k">case</span> <span class="n">THURSDAY</span><span class="o">,</span> <span class="n">SATURDAY</span> <span class="o">-></span> <span class="n">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="mi">8</span><span class="o">);</span>
<span class="k">case</span> <span class="n">WEDNESDAY</span> <span class="o">-></span> <span class="n">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="mi">9</span><span class="o">);</span>
<span class="o">}</span></code></pre>
<p>Ou encore si l’on veut affecter un résultat à une variable :</p>
<pre><code class="java"><span class="kt">int</span> <span class="n">numberOfLetters</span> <span class="o">=</span> <span class="k">switch</span> <span class="o">(</span><span class="n">dayOfWeek</span><span class="o">)</span> <span class="o">{</span>
<span class="k">case</span> <span class="n">MONDAY</span><span class="o">:</span>
<span class="k">case</span> <span class="n">FRIDAY</span><span class="o">:</span>
<span class="k">case</span> <span class="n">SUNDAY</span><span class="o">:</span>
<span class="n">yield</span> <span class="mi">6</span><span class="o">;</span>
<span class="k">case</span> <span class="n">TUESDAY</span>
<span class="n">yield</span> <span class="mi">7</span><span class="o">;</span>
<span class="k">case</span> <span class="n">THURSDAY</span>
<span class="k">case</span> <span class="n">SATURDAY</span>
<span class="n">yield</span> <span class="mi">8</span><span class="o">;</span>
<span class="k">case</span> <span class="n">WEDNESDAY</span>
<span class="n">yield</span> <span class="mi">9</span><span class="o">;</span>
<span class="k">default</span><span class="o">:</span>
<span class="k">throw</span> <span class="k">new</span> <span class="n">IllegalStateException</span><span class="o">(</span><span class="s">"Huh?: "</span> <span class="o">+</span> <span class="n">day</span><span class="o">);</span>
<span class="o">};</span></code></pre>
<h3 id="toc-text-block">Text Block</h3>
<p>Cette fonctionnalité est définie par la <a href="http://openjdk.java.net/jeps/355">JEP 355</a>. Les blocs de texte étaient initialement prévus pour la version 12 du JDK, mais au dernier moment ils ont été retirés faute de consensus sur le délimiteur et le comportement. L’idée est d’avoir du texte dont il est préférable de conserver le formatage pour des raisons de facilité d’écriture.<br>
Par exemple, au lieu d’écrire :</p>
<pre><code class="java"><span class="n">String</span> <span class="n">html</span> <span class="o">=</span> <span class="s">"<html>\n"</span> <span class="o">+</span>
<span class="s">" <body>\n"</span> <span class="o">+</span>
<span class="s">" <p>Hello, world</p>\n"</span> <span class="o">+</span>
<span class="s">" </body>\n"</span> <span class="o">+</span>
<span class="s">"</html>\n"</span><span class="o">;</span>
<span class="n">String</span> <span class="n">query</span> <span class="o">=</span> <span class="s">"SELECT `EMP_ID`, `LAST_NAME` FROM `EMPLOYEE_TB`\n"</span> <span class="o">+</span>
<span class="s">"WHERE `CITY` = 'INDIANAPOLIS'\n"</span> <span class="o">+</span>
<span class="s">"ORDER BY `EMP_ID`, `LAST_NAME`;\n"</span><span class="o">;</span></code></pre>
<p>Il est possible d’écrire :</p>
<pre><code class="java"><span class="n">String</span> <span class="n">html</span> <span class="o">=</span> <span class="s">"""</span>
<span class="s"> <html></span>
<span class="s"> <body></span>
<span class="s"> <p>Hello, world</p></span>
<span class="s"> </body></span>
<span class="s"> </html></span>
<span class="s"> """</span><span class="o">;</span>
<span class="n">String</span> <span class="n">query</span> <span class="o">=</span> <span class="s">"""</span>
<span class="s"> SELECT `EMP_ID`, `LAST_NAME` FROM `EMPLOYEE_TB`</span>
<span class="s"> WHERE `CITY` = 'INDIANAPOLIS'</span>
<span class="s"> ORDER BY `EMP_ID`, `LAST_NAME`;</span>
<span class="s"> """</span><span class="o">;</span></code></pre>
<p>Ce <a href="http://cr.openjdk.java.net/%7Ejlaskey/Strings/TextBlocksGuide_v9.html">guide exhaustif en anglais</a> à destination des développeurs décrit les cas d’usage avec les bonnes et les mauvaises pratiques.</p>
<h2 id="toc-futur">Futur</h2>
<p>Avec le nouveau rythme de publication des JDK, les nouveautés arrivent de manière plus progressive. Ainsi, dans les prochaines versions, voici les améliorations qui devraient rendre le langage meilleur :</p>
<ul>
<li>les <em><a href="https://openjdk.java.net/jeps/359">Records</a></em>, qui seront une sorte de <em>data class</em> telle que présente dans d’autres langages ;</li>
<li>les <em><a href="https://openjdk.java.net/jeps/360">Sealed type</a></em>, qui seront des types algébriques permettant de restreindre les possibilités ;</li>
<li>des <em><a href="https://openjdk.java.net/jeps/358">NullPointerException</a></em> plus explicites.</li>
</ul>
</div><div><a href="https://linuxfr.org/news/sortie-d-openjdk-13.epub">Télécharger ce contenu au format EPUB</a></div> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/118158/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/news/sortie-d-openjdk-13#comments">ouvrir dans le navigateur</a>
</p>
NonolapéroZeroHeuretheojouedubanjoYsabeau 🧶 🧦Davy DefaudCeteraxofJulien Jorgehttps://linuxfr.org/nodes/118158/comments.atomtag:linuxfr.org,2005:Diary/382292018-11-21T13:56:30+01:002018-11-21T13:56:30+01:00Pijul 0.11Licence CC By‑SA http://creativecommons.org/licenses/by-sa/4.0/deed.fr<p>Il y a un peu plus d'une année, un <a href="//linuxfr.org/users/benoit_in/journaux/pijul-un-nouveau-gestionnaire-de-source">journal</a> nous présentait <a href="https://pijul.org/">Pijul</a>, un nouveau gestionnaire de code source en cours de développement. Il est écrit en Rust. Pierre-Étienne Meunier, un des auteur, a largement commenté le journal. </p>
<p>Une volonté du projet est de fonctionner sur la majorité des plateformes, d'où l'écriture d'une bibliothèque SSH (en Rust également) qui tourne correctement sur Windows. Une plateforme de partage de base de code est disponible : <a href="https://nest.pijul.com/">https://nest.pijul.com/</a></p>
<p>Pijul se base sur une théorie des patches (je recopie ça mais je ne sais pas trop à quoi ça correspond !) mais le journal cité et la <a href="https://pijul.org/manual/why_pijul.html">documentation</a> apportera des éléments de réponse aux plus curieux.</p>
<p>Le principal apport de cette nouvelle version semble être le clonage partiel avec la commande <code>pijul clone --path</code> ainsi qu'une refonte architecturale pour une amélioration du service rendu.</p>
<p>Vous pouvez suivre l'actualité du projet sur leur blog : <a href="https://pijul.org/posts/">https://pijul.org/posts/</a></p>
<div><a href="https://linuxfr.org/users/nonolapero/journaux/pijul-0-11.epub">Télécharger ce contenu au format EPUB</a></div> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/115777/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/users/nonolapero/journaux/pijul-0-11#comments">ouvrir dans le navigateur</a>
</p>
Nonolapérohttps://linuxfr.org/nodes/115777/comments.atomtag:linuxfr.org,2005:Diary/358682015-05-20T16:54:32+02:002015-05-20T16:54:32+02:00[Bookmark] Qt fête ses vingt ansLicence CC By‑SA http://creativecommons.org/licenses/by-sa/4.0/deed.fr<p>Dans la lignée de GCompris, de Subsurface, de LXDE ou de Wireshark, d'après vous quel sera le prochain gros logiciel à dire adieu à GTK ?</p>
<p>Un lien puisque c'est un journal bookmark : <a href="http://www.qt.io/qt20/">http://www.qt.io/qt20/</a></p>
<p><img src="//img.linuxfr.org/img/687474703a2f2f64336870397564377976777a79302e636c6f756466726f6e742e6e65742f77702d636f6e74656e742f75706c6f6164732f323031352f30352f51745f323079656172735f696e666f677261706869635f6269672e6a7067/Qt_20years_infographic_big.jpg" alt="Titre de l'image" title="Source : http://d3hp9ud7yvwzy0.cloudfront.net/wp-content/uploads/2015/05/Qt_20years_infographic_big.jpg"></p><div><a href="https://linuxfr.org/users/nonolapero/journaux/bookmark-qt-fete-ses-vingt-ans.epub">Télécharger ce contenu au format EPUB</a></div> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/105803/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/users/nonolapero/journaux/bookmark-qt-fete-ses-vingt-ans#comments">ouvrir dans le navigateur</a>
</p>
Nonolapérohttps://linuxfr.org/nodes/105803/comments.atomtag:linuxfr.org,2005:News/348892014-01-19T10:23:54+01:002014-01-19T10:23:54+01:00Pandas, une bibliothèque pour manipuler facilement des donnéesLicence CC By‑SA http://creativecommons.org/licenses/by-sa/3.0/deed.fr<div><p>À l'occasion de la sortie de la version 0.13, je vous présente cette bibliothèque basée sur Python qui permet de travailler simplement et efficacement avec des données structurées. Jusqu'à présent, les versions se sont enchaînées rapidement mais celle-ci arrive plusieurs mois après la précédente. On peut donc espérer qu'un code développé pour cette nouvelle version demandera moins de maintenance.</p>
<p><img src="//img.linuxfr.org/img/687474703a2f2f70616e6461732e7079646174612e6f72672f5f7374617469632f70616e6461735f6c6f676f2e706e67/pandas_logo.png" alt="Logo pandas" title="Source : http://pandas.pydata.org/_static/pandas_logo.png"></p>
<p>Les principales possibilités sont :</p>
<ul>
<li>récupérer des données depuis des fichiers CSV, tableaux Excel, des pages web, HDF5, <a href="http://pandas.pydata.org/pandas-docs/dev/io.html">etc.</a> ;</li>
<li>grouper, découper, alléger, déplacer, écrire les données ;</li>
<li>ces données peuvent être à une ou deux dimensions, avec des manques, ou encore temporelles avec ou sans périodicité.</li>
</ul><p>Pour peu que les données soient correctement formatées, pandas peut s'en sortir même dans le cas où la quantité dépasse les capacités de votre machine en <a href="http://pandas.pydata.org/pandas-docs/dev/io.html#iterating-through-files-chunk-by-chunk">traitant les sources morceaux par morceaux</a>.</p>
<p>Le développement de cette bibliothèque s'inscrit dans la problématique de disposer d'outils pour manipuler de gros volumes de données dans le but de leur exploitation scientifique ou commerciale.</p>
<p><em>Note : pandas fonctionne avec la même base de code sur Python 2 et 3 mais ce n'est, peut-être, pas le cas de toutes les dépendances.</em></p></div><ul><li>lien nᵒ 1 : <a title="http://pandas.pydata.org/" hreflang="en" href="https://linuxfr.org/redirect/88738">Site officiel</a></li><li>lien nᵒ 2 : <a title="https://github.com/pydata/pandas" hreflang="en" href="https://linuxfr.org/redirect/88739">Page GitHub</a></li><li>lien nᵒ 3 : <a title="http://pandas.pydata.org/pandas-docs/stable/whatsnew.html" hreflang="en" href="https://linuxfr.org/redirect/88740">Les nouveautés détaillées</a></li><li>lien nᵒ 4 : <a title="http://vimeo.com/59324550" hreflang="en" href="https://linuxfr.org/redirect/88741">Vidéo de présentation</a></li><li>lien nᵒ 5 : <a title="http://scipy.org/" hreflang="en" href="https://linuxfr.org/redirect/88742">SciPy : portail des outils Python pour la science</a></li><li>lien nᵒ 6 : <a title="http://pandas.pydata.org/pandas-docs/dev/10min.html#min" hreflang="en" href="https://linuxfr.org/redirect/88782">Découvrir pandas en 10 minutes</a></li><li>lien nᵒ 7 : <a title="http://shop.oreilly.com/product/0636920023784.do" hreflang="en" href="https://linuxfr.org/redirect/89005">O'Reilly - Python for data analysis</a></li><li>lien nᵒ 8 : <a title="http://www.youtube.com/watch?v=w26x-z-BdWQ" hreflang="en" href="https://linuxfr.org/redirect/89006">Vidéo plus détaillée (3h)</a></li></ul><div><h2 id="pourquoi-pandas">Pourquoi pandas</h2>
<p>L'objectif de pandas est d'être le meilleur outil statistique qui soit aussi bien performant, facile d'utilisation et flexible. Le logiciel existe depuis 2008 mais son développement s'est fortement accéléré avec la publication de la version 0.3 en février 2011 (le nombre de modifications pour cette version dépassait celui des modifications depuis le début de projet). Depuis les nouveautés et les corrections de bugs s'enchaînent à un rythme élevé comme le montre la paga <a href="http://pandas.pydata.org/pandas-docs/dev/whatsnew.html">What's new</a>.<br>
Pour mieux comprendre la mécanique interne de pandas, je vous suggère de consulter le blog de <a href="http://wesmckinney.com/blog/">Wes McKinney</a>, le leader du projet.</p>
<h2 id="comparaison-avec-r">Comparaison avec R</h2>
<p>Les statisticiens dans la salle doivent se demander pourquoi pandas a été développé alors que R fonctionne très bien. <code>pandas</code> se base sur les bonnes idées de R et s'attache à apporter les fonctionnalités manquantes. Du côté écosystème, R possède l'inestimable <a href="http://cran.r-project.org/">CRAN </a> qui est le dépôt des différents paquets venant enrichir la bibliothèque de base, tandis que <code>pandas</code> profite de l'engouement autour des outils scientifiques en Python. L'aspect généraliste de Python permet également de développer l'intégralité d'une application avec un seul langage ce qui n'est pas le cas de R. Reste la licence de R (GPL) qui peut sembler un obstacle pour certaines finalités, Pandas étant sous licence BSD.</p>
<h2 id="ressources">Ressources</h2>
<p>Bien que la documentation soit étoffée, pour ceux qui souhaitent être accompagnés sur des cas concrets, il existe un <a href="https://github.com/jvns/pandas-cookbook">livre de recettes</a> ou bien un <a href="https://bitbucket.org/hrojas/learn-pandas">tutoriel</a>. Voici également <a href="https://github.com/pydata/pandas/issues/5837">une page</a> qui rassemble des liens qui seront intégrés à la documentation officielle dans la version suivante.</p>
<h2 id="Écosystème">Écosystème</h2>
<p>Pandas ne vit pas dans un monde cloisonné et sert de base ou de complément à <a href="http://pandas.pydata.org/pandas-docs/stable/ecosystem.html">d'autres logiciels</a> que ce soit pour manipuler des données géographiques, faire des statistiques ou encore tendre à remplacer <a href="http://matplotlib.org">matplotlib</a> pour certains usages.</p>
<h2 id="politique-de-développement">Politique de développement</h2>
<p>Cette version ayant mis un peu de temps à sortir (surtout, il y a eu quelques couacs entre l'étiquetage de cette version 0.13, la mise à jour du site et la mise à disposition sur <a href="https://pypi.python.org/pypi/pandas">PyPi</a>), il a été décidé que la prochaine devrait voir le jour dans trois mois sans attendre que les nouvelles fonctionnalités soient terminées.</p></div><div><a href="https://linuxfr.org/news/pandas-une-bibliotheque-pour-manipuler-facilement-des-donnees.epub">Télécharger ce contenu au format EPUB</a></div> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/100621/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/news/pandas-une-bibliotheque-pour-manipuler-facilement-des-donnees#comments">ouvrir dans le navigateur</a>
</p>
Nonolapéro_PhiX_Benoît Sibaudkarteum59NÿcoJiehongolivierwebpalm123Benoîtmornikhttps://linuxfr.org/nodes/100621/comments.atomtag:linuxfr.org,2005:News/349182014-01-09T23:20:17+01:002014-01-11T22:00:22+01:00KDE SC 4.12, 4.11.5 et Frameworks 5Licence CC By‑SA http://creativecommons.org/licenses/by-sa/3.0/deed.fr<div><p>KDE SC, c'est KDE Software Compilation. La nouvelle version 4.12, sortie il y a quelques jours, livre quelques nouveautés dans les applications — surtout dans KDE PIM en fait, car les développeurs les plus actifs se concentrent sur le passage à <a href="http://dot.kde.org/2013/09/25/frameworks-5">KDE Framework 5</a>, dont une <a href="http://dot.kde.org/2014/01/07/frameworks-5-tech-preview">version de démonstration</a> vient de paraître (des <a href="http://community.kde.org/Frameworks/Binary_Packages">binaires</a> sont disponibles pour les plus curieux). Une cinquième version de stabilisation de la plateforme KDE SC 4.11 est également sortie, rappelons que la version 4.11 sera maintenue à long terme.</p></div><ul><li>lien nᵒ 1 : <a title="http://kde.org/announcements/4.12/" hreflang="en" href="https://linuxfr.org/redirect/88846">Annonce officielle de KDE SC 4.12</a></li><li>lien nᵒ 2 : <a title="http://dot.kde.org/2014/01/07/frameworks-5-tech-preview" hreflang="en" href="https://linuxfr.org/redirect/88997">KDE Framework 5 Tech Preview sur "le dot"</a></li><li>lien nᵒ 3 : <a title="http://www.kde.org/announcements/announce-4.11.5.php" hreflang="en" href="https://linuxfr.org/redirect/88998">KDE SC 4.11.5</a></li><li>lien nᵒ 4 : <a title="https://linuxfr.org/news/kde-sc-4-11" hreflang="fr" href="https://linuxfr.org/redirect/89001">Dépêche sur la précédente version</a></li></ul><div><h2 class="sommaire">Sommaire</h2>
<ul class="toc">
<li>
<a href="#kde-sc-412">KDE SC 4.12</a><ul>
<li><a href="#kde-pim">KDE PIM</a></li>
<li><a href="#dolphin">Dolphin</a></li>
<li><a href="#kate">Kate</a></li>
<li><a href="#gwenview">Gwenview</a></li>
<li><a href="#okular">Okular</a></li>
<li><a href="#konsole">Konsole</a></li>
<li><a href="#kwallet">KWallet</a></li>
</ul>
</li>
<li><a href="#et-la-suite-kde-sc-13-kde-sc-14-">Et la suite ? KDE SC 13, KDE SC 14, …</a></li>
<li>
<a href="#kde-framework-5">KDE Framework 5</a><ul>
<li><a href="#aper%C3%A7u-de-la-technologie-plasma-2">Aperçu de la technologie Plasma 2</a></li>
</ul>
</li>
<li><a href="#kde-sc-4115">KDE SC 4.11.5</a></li>
</ul><h2 id="kde-sc-412">KDE SC 4.12</h2>
<p>Sortie le 18 décembre, elle concerne surtout les applications. Depuis <a href="//linuxfr.org/news/kde-sc-4-11">KDE SC 4.11</a> Kwin et Plasma sont seulement stabilisés, c'est-à-dire qu'il n'y aura plus que des corrections de bogues, dans la branche 4.11. Votre installation contiendra désormais un bout de 4.11 avec des applications en 4.12! La plateforme elle-même (les bibliothèques) reçoit quelques améliorations et optimisations diverses, assez mineures.</p>
<h3 id="kde-pim">KDE PIM</h3>
<p>Un important travail a été réalisé dans la suite de logiciels KDE PIM (Personal Information Management), grâce à <a href="http://www.aegiap.eu/kdeblog">Laurent Montel</a>, avec des corrections de bugs, des optimisations, et l'amélioration de fonctionnalités existantes. Mais on trouve aussi quelques nouveautés :</p>
<ul>
<li>le client de courriel Kmail réduit les désagréments en incorporant un bloqueur de publicité (AdBlock) pour les messages en HTML, et en détectant les "scams" sur les URL raccourcies ;</li>
<li>après l'éditeur graphique de filtres Sieve, Laurent Montel poursuit ses efforts et vous permet de convertir les filtres existants de Kmail en script Sieve! Ce n'est <a href="http://www.aegiap.eu/kdeblog/2013/08/new-in-kdepim-4-12-sieve-12/">pas parfait ni complet</a> (le protocole Sieve ne permet pas tout) mais c'est un début ;</li>
<li>un <a href="http://www.aegiap.eu/kdeblog/2013/11/new-in-kdepim-4-12-kaddressbook/">nouvel éditeur de thèmes</a> pour le carnet d'adresse KAddressBook : ContactThemeEditor ;</li>
<li>l'aperçu avant impression et les styles d'impression (définis avec des fichiers html) dans KAddressBook ;</li>
<li>grosse révision de KNotes (<a href="http://www.aegiap.eu/kdeblog/2013/11/what-news-in-kdepim-4-12-knotes/">ouh là là la chasse aux bugs!</a>) qui marche enfin et bénéficie lui aussi de l'aperçu et des styles d'impression ;</li>
<li>PimSettingExporter qui permet d'exporter et d'importer les paramètres et les données, reçoit <a href="http://www.aegiap.eu/kdeblog/2013/11/semaine-44/">plein de perfectionnements</a> qui le rendent fiable et utilisable avec toute la suite KDEPim.</li>
</ul><p>Un filtre Kmail:<br><img src="//img.linuxfr.org/img/687474703a2f2f7777772e6165676961702e65752f6b6465626c6f672f77702d636f6e74656e742f75706c6f6164732f323031332f30382f636f6e766572742d746f2d7369657665312e706e67/convert-to-sieve1.png" alt="Un filtre Kmail" title="Source : http://www.aegiap.eu/kdeblog/wp-content/uploads/2013/08/convert-to-sieve1.png"><br>
Conversion en script Sieve:<br><img src="//img.linuxfr.org/img/687474703a2f2f7777772e6165676961702e65752f6b6465626c6f672f77702d636f6e74656e742f75706c6f6164732f323031332f30382f636f6e766572742d746f2d7369657665322e706e67/convert-to-sieve2.png" alt="Conversion en script Sieve" title="Source : http://www.aegiap.eu/kdeblog/wp-content/uploads/2013/08/convert-to-sieve2.png"></p>
<h3 id="dolphin">Dolphin</h3>
<p>Des nouveautés pas forcément très visibles pour le gestionnaire de fichiers. Le temps de démarrage et l'utilisation de la mémoire sont en baisse.</p>
<p>Les efforts se sont surtout tournés vers la mise en commun d’information. Par exemple, souvent les fichiers d’un même répertoire ont les mêmes droits d’accès, et seuls les droits d’accès qui diffèrent seront stockés par fichier. Ces efforts sont particulièrement intéressants pour les dossiers contenant beaucoup de fichiers.</p>
<p>Enfin, des efforts ont encore été faits pour améliorer la vitesse d’affichage des fichiers en améliorant l’algorithme de tri naturel. En effet, Dolphin trie les fichiers de façon naturelle :</p>
<p>file1.txt<br>
file2.txt<br>
…<br>
file9.txt<br>
file10.txt</p>
<p>plutôt que :<br>
file1.txt<br>
file10.txt<br>
file2.txt<br>
…</p>
<h3 id="kate">Kate</h3>
<p>L'éditeur de texte continue son bonhomme de chemin en préparant la transition vers la version 5 de KDE. <em>La</em> nouveauté c'est surtout le mode « à la VIM » qui ne se contente plus de la navigation au clavier mais embarque un système de macros ainsi que <a href="http://kate-editor.org/2013/09/06/kate-vim-progress/">d'autres améliorations</a>. Ces sympathiques petites choses ont poussé Aaron Seigo, un important développeur de KDE, <a href="http://aseigo.blogspot.fr/2013/11/kate-has-won.html">à enfin passer de VIM à Kate</a>. Mais on notera aussi un bidule attendu depuis longtemps et assez spectaculaire, <a href="http://kate-editor.org/2013/09/09/multi-line-text-editing-in-kate/">l'édition multi-ligne en mode bloc</a> — c'est bô l'informatique :<br><img src="//img.linuxfr.org/img/687474703a2f2f6b6174652d656469746f722e6f72672f77702d636f6e74656e742f75706c6f6164732f323031332f30392f6d756c74696c696e652d65646974696e672e676966/multiline-editing.gif" alt="Édition multi-ligne en mode bloc" title="Source : http://kate-editor.org/wp-content/uploads/2013/09/multiline-editing.gif"></p>
<p>Et le meilleur, c’est que ces améliorations sont aussi disponibles dans KDevelop et les autres applications utilisant la technologie Kate (KatePart).</p>
<h3 id="gwenview">Gwenview</h3>
<p>Pas grand chose de neuf à se mettre sous la dent, seulement une meilleure utilisation de l'espace pour afficher les métadonnées des images. Pour la prochaine version, la visionneuse d'image sera capable d'afficher les <em>previews</em> contenues dans les fichiers RAW de nos appareils photos numériques.</p>
<h3 id="okular">Okular</h3>
<p>La visionneuse de document prend désormais en charge le son et les vidéos pour le format de livre électronique epub.</p>
<p>La gestion de l'impression a aussi été améliorée, en prenant en compte la marge de l'imprimante, ce qui permet de ne pas avoir des documents redimensionnés à l'impression.</p>
<h3 id="konsole">Konsole</h3>
<p>On peut désormais ouvrir directement les liens grâce à la combinaison Ctrl-clic.</p>
<p>Konsole nous avertit lorsqu’on essaie de fermer un terminal contenant un processus actif, il liste désormais les processus en question.</p>
<h3 id="kwallet">KWallet</h3>
<p>Le portefeuille de mots de passe de KDE peut maintenant sauvegarder vos données avec GPG.</p>
<h2 id="et-la-suite-kde-sc-13-kde-sc-14-">Et la suite ? KDE SC 13, KDE SC 14, …</h2>
<p>Laurent Montel a déjà préparé plein de grosses nouveautés pour KDEPIM:</p>
<ul>
<li>Knotes réécrit (plein de bugs virés, en particulier la fausse incorporation dans Kontact) et <a href="http://www.aegiap.eu/kdeblog/2013/12/semaine-48-2/">porté vers Akonadi</a> ;</li>
<li>la nouvelle interface de SieveEditor permettra d’éditer les scripts sieve sans avoir à utiliser Akonadi ;</li>
<li>
<a href="http://www.aegiap.eu/kdeblog/2013/12/semaine-48-2/">l'utilisation de DropBox & Co</a> pour l'envoi de gros fichiers en pièce jointe ;</li>
<li>l'impression encore améliorée dans KAdressBook ;</li>
<li>import export avec PimSettingExporter ;</li>
<li>KHotNewstuff pour importer des modèles de scripts Sieve.</li>
</ul><h2 id="kde-framework-5">KDE Framework 5</h2>
<p>Il est sorti? Et non! C'est une <em><a href="http://dot.kde.org/2014/01/07/frameworks-5-tech-preview">technology preview</a></em>! après 3 ans de travail sur la modularisation et le portage vers Qt5, l'équipe de KDE livre une pré-version de son framework de développement. Il y aura désormais des sorties mensuelles jusqu'à la bêta prévue pour avril et la sortie finale en juin. </p>
<p>Pour l'occasion Jos Poortvliet s'est fendu d'un <a href="http://www.linux.com/news/software/applications/755768-kde-frameworks-5-a-big-deal-for-free-software">article de présentation sur linux.com</a>. Sans prétendre à faire aussi bien, voici une petite explication sur le but de tout ça.</p>
<p>Très grossièrement <em>Framework 5</em> succède aux KDELibs qui ont été modularisées dans le but de les rendre plus indépendantes les unes des autres. Cela permet à un développeur de ne pas réinventer la roue. Par exemple s'il a besoin d'une application de décompression, il y a une petite bibliothèque du <em>Framework 5</em>, sans autre dépendance que Qt5, qui peut s'en charger.</p>
<p>Ainsi beaucoup de KDELibs sont devenues de simples ajouts à Qt apportant de nouvelles fonctionnalités de toutes sortes — et sur plusieurs plateformes. Plus encore certains composants font maintenant partie de Qt grâce au projet open-Qt. Leur indépendance permet de n'installer que <a href="http://community.kde.org/Frameworks/List">les composants</a> dont on a besoin au lieu d'un gros paquet de KDELibs.</p>
<p>Il y a en fait 3 catégories dans le framework ou 3 niveaux d'indépendances : le fonctionnel (sans dépendances), l'intégration (les dépendances dépendent de la plateforme ou du système) et les solutions qui dépendent de certains démons. Ça a été beaucoup mieux présenté <a href="http://dot.kde.org/2013/09/25/frameworks-5">sur le dot en septembre</a>.</p>
<h3 id="aperçu-de-la-technologie-plasma-2">Aperçu de la technologie Plasma 2</h3>
<p>KDE est découpé en trois, d'un côté les applications, de l'autre le Framework 5 et enfin l'interface (ou les interfaces) Plasma. Un <a href="http://dot.kde.org/2013/12/20/plasma-2-technology-preview">aperçu de Plasma 2</a> est sorti le 20 décembre.</p>
<h2 id="kde-sc-4115">KDE SC 4.11.5</h2>
<p>Une version de maintenance pour <a href="https://bugs.kde.org/buglist.cgi?query_format=advanced&short_desc_type=allwordssubstr&short_desc=&long_desc_type=substring&long_desc=&bug_file_loc_type=allwordssubstr&bug_file_loc=&keywords_type=allwords&keywords=&bug_status=RESOLVED&bug_status=VERIFIED&bug_status=CLOSED&emailtype1=substring&email1=&emailassigned_to2=1&emailreporter2=1&emailcc2=1&emailtype2=substring&email2=&bugidtype=include&bug_id=&votes=&chfieldfrom=2013-06-01&chfieldto=Now&chfield=cf_versionfixedin&chfieldvalue=4.11.5&cmdtype=doit&order=Bug+Number&field0-0-0=noop&type0-0-0=noop&value0-0-0=">corriger une vingtaine de bugs</a> et complèter les traductions. Ca concerne surtout KDEPIM, l'outil de modélisation UML Umbrello, Okular, Konqueror et Dolphin. En outre la calculette plasma gère l'alphabet grec et Okular imprime correctement les pages avec un titre trèèèès long. Konqueror enfin s'en sort mieux avec les web fonts.</p></div><div><a href="https://linuxfr.org/news/kde-sc-4-12-4-11-5-et-frameworks-5.epub">Télécharger ce contenu au format EPUB</a></div> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/100714/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/news/kde-sc-4-12-4-11-5-et-frameworks-5#comments">ouvrir dans le navigateur</a>
</p>
NonolapéroZeroHeureBenoît SibaudmisaflowoprandiXavier Teyssierpalm123ariasuniNÿcoclaudexhttps://linuxfr.org/nodes/100714/comments.atomtag:linuxfr.org,2005:News/347292013-10-25T04:19:27+02:002019-03-09T13:09:15+01:00Wireshark passe à QtLicence CC By‑SA http://creativecommons.org/licenses/by-sa/3.0/deed.fr<div><p><a href="https://fr.wikipedia.org/wiki/Wireshark" title="Définition Wikipédia">Wireshark</a>, le célèbre logiciel d'analyse de paquets réseau, va progressivement passer d'une <a href="https://blog.wireshark.org/2013/10/switching-to-qt/">interface en GTK vers une interface en Qt</a>. La raison invoquée est que de plus en plus d'utilisateurs sont sur autre chose que Linux et que certains voudraient bien l'avoir sur leur tablette (iPad ou basée sur Android) mais également que GTK a un mauvais rendu sur OSX ou Windows. Dans les commentaires du blog, il y a même une <a href="https://blog.wireshark.org/2013/10/switching-to-qt/comment-page-1/#comment-2367">intervention de Miguel de Icaza</a> pour défendre son bébé mais ça n'a pas l'air de prendre.</p>
<p><img src="//img.linuxfr.org/img/687474703a2f2f61736b2e77697265736861726b2e6f72672f757066696c65732f77736261646765403138367835372e706e67/wsbadge@186x57.png" alt="Logo Wireshark" title="Source : http://ask.wireshark.org/upfiles/wsbadge@186x57.png"></p>
<p>Après <a href="https://plus.google.com/105872806106213007611/posts/MwiTc3cHKgi">Subsurface</a>, <a href="/users/kekun/journaux/lxde-razor-qt-et-qt-et-gtk">LXDE</a> et Wireshark quelle sera la prochaine appli à délaisser GTK au profit de Qt ?</p>
<p><abbr title="Note des modérateurs">NdM</abbr> : <em>merci à Nonolapéro pour son journal.</em></p>
</div><ul><li>lien nᵒ 1 : <a title="http://linuxfr.org/users/nonolapero/journaux/c-est-au-tour-de-wireshark-de-passer-a-qt" hreflang="fr" href="https://linuxfr.org/redirect/88154">Journal à l'origine de la dépêche</a></li><li>lien nᵒ 2 : <a title="https://blog.wireshark.org/2013/10/switching-to-qt/" hreflang="en" href="https://linuxfr.org/redirect/88155">Annonce du passage de Wireshark en Qt</a></li><li>lien nᵒ 3 : <a title="https://blog.wireshark.org/2013/10/switching-to-qt/comment-page-1/#comment-2367" hreflang="en" href="https://linuxfr.org/redirect/88156">Commentaire de Miguel de Icaza sur le passage en Qt de Wireshark</a></li><li>lien nᵒ 4 : <a title="http://www.wireshark.org/" hreflang="en" href="https://linuxfr.org/redirect/88157">Site web de Wireshark</a></li></ul><div><p>Le port est en cours. Ce qui fonctionne pour le moment : </p>
<ul>
<li>tout ce qui est compris dans les menus « Fichiers » et « Édition » ;</li>
<li>la capture de trafic, ainsi que son filtrage et inspection ;</li>
<li>l'édition des préférences ;</li>
<li>le suivi des <em>streams</em> ;</li>
<li>la visualisation des graphiques de flux TCP.</li>
</ul>
<p><img src="//img.linuxfr.org/img/68747470733a2f2f626c6f672e77697265736861726b2e6f72672f77702d636f6e74656e742f75706c6f6164732f323031332f31302f6f73782d71742e706e67/osx-qt.png" alt="Capture d'écran de Wireshark en Qt sous Mac OS" title="Source : https://blog.wireshark.org/wp-content/uploads/2013/10/osx-qt.png"></p>
<p>Le reste ne fonctionne pas encore, à savoir : les options de capture, les graphiques d'Entrée/Sortie, les graphiques de flux, l'analyse de la VoIP, etc. bref, encore du boulot en perspective</p>
</div><div><a href="https://linuxfr.org/news/wireshark-passe-a-qt.epub">Télécharger ce contenu au format EPUB</a></div> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/100094/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/news/wireshark-passe-a-qt#comments">ouvrir dans le navigateur</a>
</p>
NonolapéroFlorent ZaraBenoît SibaudXavier Teyssierbubar🦥https://linuxfr.org/nodes/100094/comments.atomtag:linuxfr.org,2005:Diary/344272013-10-22T09:58:41+02:002019-03-09T13:08:38+01:00C'est au tour de Wireshark de passer à QtLicence CC By‑SA http://creativecommons.org/licenses/by-sa/3.0/deed.fr<p><a href="https://fr.wikipedia.org/wiki/Wireshark" title="Définition Wikipédia">Wireshark</a>, le célèbre logiciel d'inspection du réseau, va progressivement passer d'une <a href="https://blog.wireshark.org/2013/10/switching-to-qt/">interface en GTK vers une interface en Qt</a>. La raison invoquée est que de plus en plus d'utilisateurs sont sur autre chose que Linux et que certains voudraient bien l'avoir sur leur tablette (iPad ou basée sur Android) mais également que GTK sur autre chose que Linux c'est un peu pourri tout de même sur OSX ou Windows. Dans les commentaires du blog, il y a même une <a href="https://blog.wireshark.org/2013/10/switching-to-qt/comment-page-1/#comment-2367">intervention de Miguel de Icaza</a> pour défendre son bébé mais ça n'a pas l'air de prendre.</p>
<p>Après <a href="https://plus.google.com/105872806106213007611/posts/MwiTc3cHKgi">Subsurface</a>, <a href="/users/kekun/journaux/lxde-razor-qt-et-qt-et-gtk">LXDE</a> et WireShark qu'elle sera la prochaine appli à délaisser GTK au profit de Qt ?</p>
<div><a href="https://linuxfr.org/users/nonolapero/journaux/c-est-au-tour-de-wireshark-de-passer-a-qt.epub">Télécharger ce contenu au format EPUB</a></div> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/100065/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/users/nonolapero/journaux/c-est-au-tour-de-wireshark-de-passer-a-qt#comments">ouvrir dans le navigateur</a>
</p>
Nonolapérohttps://linuxfr.org/nodes/100065/comments.atomtag:linuxfr.org,2005:Diary/343632013-10-02T14:50:06+02:002013-10-02T14:50:06+02:00L'interpréteur de Python 3.4 sera plus interactifLicence CC By‑SA http://creativecommons.org/licenses/by-sa/3.0/deed.fr<p>En regardant <a href="http://docs.python.org/3.4/whatsnew/3.4.html">les nouveautés de la prochaine version de Python</a> prévue pour février 2014, dans la section <em>Other improvements</em> j'ai pu lire que la console de Python aura le complément avec la touche Tab activé par défaut. Il ne sera plus forcément obligatoire d'installer une autre console pour avoir quelque chose d'un peu utilisable. Je me demande d'ailleurs si une coloration syntaxique est prévue à plus long terme.</p>
<p>C'est donc un <a href="http://bugs.python.org/issue5845">vœux</a> datant d'avril 2009 qui est exhaussé par <a href="/users/pitrou">Antoine Pitrou_<</a> et Éric Araujo.</p>
<p>Pour continuer dans le cocorico, une grosse contribution de la part de <a href="/users/haypo">Victor Stinner_<</a> (<a href="http://www.python.org/dev/peps/pep-0446/">PEP 446</a>) fait également son entrée dans le code de Python.</p>
<p>J'espère qu'ils nous en parlerons dans la dépêche concernant cette version 3.4. </p>
<p>Puisque que l'on parle d'interpréteur Python, IPython vient de <a href="http://ipython.org/microsoft-donation-2013.html">recevoir une donation de 100 000 $</a> de la part de Microsoft via NumFOCUS. Cette donation est, par ailleurs, sans engagement ce qui offre la possibilité aux développeurs de dépenser cette somme comme bon leur semble.</p><div><a href="https://linuxfr.org/users/nonolapero/journaux/l-interpreteur-de-python-3-4-sera-plus-interactif.epub">Télécharger ce contenu au format EPUB</a></div> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/99839/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/users/nonolapero/journaux/l-interpreteur-de-python-3-4-sera-plus-interactif#comments">ouvrir dans le navigateur</a>
</p>
Nonolapérohttps://linuxfr.org/nodes/99839/comments.atomtag:linuxfr.org,2005:Diary/343382013-09-24T10:09:18+02:002013-09-24T10:09:18+02:00Effort d'ouverture de la part de NvidiaLicence CC By‑SA http://creativecommons.org/licenses/by-sa/3.0/deed.fr<p>Une bonne nouvelle pour les utilisateurs du pilote libre Nouveau pour les cartes vidéos Nvidia car de la documentation va être fournie pour améliorer l'expérience des utilisateurs qui l'utilise. L'annonce est lisible sur la <a href="http://thread.gmane.org/gmane.comp.freedesktop.xorg.nouveau/14293">liste de diffusion de Nouveau</a> mais il est signalé que ce qui est disponible doit déjà être connu des développeurs.<br>
Ce geste ressemble à celui d'AMD qui diffuse de la documentation sur ses GPU mais comme l'explique <a href="/news/entretien-avec-jerome-glisse-developpeur-des-pilotes-graphiques-radeon-pour-red-hat">Jérome Glisse dans son interview</a> celle arrive un peu tard à son goût.<br>
Les effets de cette libération ne sont pas attendre dans l'immédiat mais à plus long terme et avec la collaboration des gens de chez Nvidia ça devrait payer. Sûrement que <a href="/users/mupuf">Martin Peres alias mupuf<</a> nous en dira plus dans les semaines ou mois à venir.</p><div><a href="https://linuxfr.org/users/nonolapero/journaux/effort-d-ouverture-de-la-part-de-nvidia.epub">Télécharger ce contenu au format EPUB</a></div> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/99733/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/users/nonolapero/journaux/effort-d-ouverture-de-la-part-de-nvidia#comments">ouvrir dans le navigateur</a>
</p>
Nonolapérohttps://linuxfr.org/nodes/99733/comments.atom