tag:linuxfr.org,2005:/users/reno/newsLinuxFr.org : les dépêches de reno2013-03-07T17:26:32+01:00/favicon.pngtag:linuxfr.org,2005:News/339382013-03-05T11:00:23+01:002013-03-05T13:38:29+01:00Ruby 2.0 est sortiLicence CC By‑SA http://creativecommons.org/licenses/by-sa/3.0/deed.fr<div><p>Pour fêter ses 20 ans, Ruby arrive en version 2.0 !</p>
<p>Malgré ce changement de version majeur, il y a moins de différences entre Ruby 2.0 et 1.9 qu'entre Ruby 1.9 et 1.8.<br />
La compatibilité avec les logiciels 1.9 est quasiment assurée. Cerise sur le gâteau : cette nouvelle version est considérée comme stable et on y trouve un certain nombre de nouveautés et d'optimisations.</p>
<p>Pour rappel : Ruby est un langage de programmation orienté objets, à typage dynamique et qui s'est inspiré de Lisp, Perl, Smalltalk, Eiffel, etc. Sa principale caractéristique est de mettre en avant les besoins humains avant ceux informatiques, et notamment le fun et la productivité. </p>
<p><abbr title="Note des modérateurs">NdM</abbr> : merci à reno pour son journal et _jordan_ pour ses compléments pour approfondir, ainsi qu'à YLD, Marc Quinton, Nicolas Blanco, Barret Michel, Nÿco, Katyucha pour leur participation.</p></div><ul><li>lien nᵒ 1 : <a title="http://linuxfr.org/users/reno/journaux/ruby-2-0-est-sorti" hreflang="fr" href="https://linuxfr.org/redirect/85426">Journal à l'origine de la dépêche</a></li><li>lien nᵒ 2 : <a title="http://linuxfr.org/news/sortie-de-ruby-192" hreflang="fr" href="https://linuxfr.org/redirect/85443">journal de sortie ruby 1.9.2</a></li><li>lien nᵒ 3 : <a title="http://blog.marc-andre.ca/2013/02/23/ruby-2-by-example/" hreflang="en" href="https://linuxfr.org/redirect/85444">nouveautés de ruby 2 par l'exemple</a></li><li>lien nᵒ 4 : <a title="http://www.ruby-lang.org/fr/news/2013/02/25/sortie-de-ruby-2-0-0-p0/" hreflang="fr" href="https://linuxfr.org/redirect/85445">Annonce officielle</a></li><li>lien nᵒ 5 : <a title="https://speakerdeck.com/shyouhei/whats-new-in-ruby-2-dot-0" hreflang="en" href="https://linuxfr.org/redirect/85446">What's new in ruby 2.0</a></li></ul><div><h2 id="sommaire">Sommaire</h2>
<ul><li>
<a href="#toc_0">Changements du langage</a>
<ul><li>
<a href="#toc_1">Paramètres par mot-clé</a>
</li>
<li>
<a href="#toc_2">UTF8</a>
</li>
<li>
<a href="#toc_3">Débogage</a>
</li>
<li>
<a href="#toc_4">Variables non utilisées</a>
</li>
<li>
<a href="#toc_5">Création de hash</a>
</li>
<li>
<a href="#toc_6">Chemin du dossier courant</a>
</li>
<li>
<a href="#toc_7">Création de tableaux de symboles</a>
</li>
<li>
<a href="#toc_8">Inclusion par précédence</a>
</li>
<li>
<a href="#toc_9">Onigmo : nouveau moteur d'expression régulière</a>
</li>
<li>
<a href="#toc_10">Refinements</a>
</li>
<li>
<a href="#toc_11"> Lazy Enumerator et Enumerable</a>
</li>
<li>
<a href="#toc_12">API de gestion asynchrone des exceptions</a>
</li>
</ul></li>
<li>
<a href="#toc_13">Optimisations des performances</a>
<ul><li>
<a href="#toc_14">Ramasse-miette</a>
</li>
<li>
<a href="#toc_15">Autres</a>
</li>
</ul></li>
<li>
<a href="#toc_16">Documentation</a>
</li>
<li>
<a href="#toc_17">Autres mises à jour notables</a>
</li>
</ul><h2 id="toc_0">Changements du langage</h2>
<h3 id="toc_1">Paramètres par mot-clé</h3>
<p>Le langage gère maintenant directement le passage de paramètres par mots clefs : c'était déjà possible avant, mais en utilisant un moyen détourné (via un Hash en paramètre).</p>
<p>Ci dessous un exemple de définition de méthode avec une valeur par défaut pour un argument "nommé".</p>
<pre>
<code class="ruby"><span class="c1"># Ruby 1.9 et précédents</span>
<span class="k">def</span> <span class="nf">render</span><span class="p">(</span><span class="n">source</span><span class="p">,</span> <span class="n">opts</span> <span class="o">=</span> <span class="p">{})</span>
<span class="n">opts</span> <span class="o">=</span> <span class="p">{</span><span class="n">fmt</span><span class="p">:</span> <span class="s1">'html'</span><span class="p">}</span><span class="o">.</span><span class="n">merge</span><span class="p">(</span><span class="n">opts</span><span class="p">)</span>
<span class="n">r</span> <span class="o">=</span> <span class="no">Renderer</span><span class="o">.</span><span class="n">for</span><span class="p">(</span><span class="n">opts</span><span class="o">[</span><span class="ss">:fmt</span><span class="o">]</span><span class="p">)</span>
<span class="n">r</span><span class="o">.</span><span class="n">render</span><span class="p">(</span><span class="n">source</span><span class="p">)</span>
<span class="k">end</span>
</code>
</pre><pre>
<code class="ruby"><span class="c1"># Ruby 2</span>
<span class="k">def</span> <span class="nf">render</span><span class="p">(</span><span class="n">source</span><span class="p">,</span> <span class="n">fmt</span><span class="p">:</span> <span class="s1">'html'</span><span class="p">)</span>
<span class="n">r</span> <span class="o">=</span> <span class="no">Renderer</span><span class="o">.</span><span class="n">for</span><span class="p">(</span><span class="n">fmt</span><span class="p">)</span>
<span class="n">r</span><span class="o">.</span><span class="n">render</span><span class="p">(</span><span class="n">source</span><span class="p">)</span>
<span class="k">end</span>
</code>
</pre>
<p>A noter que le passage de paramètres par mots clefs utilise la syntaxe de Ruby 1.9 pour définir les Hash.</p>
<pre>
<code class="ruby"><span class="c1"># Ruby 1.8</span>
<span class="n">my_hash</span> <span class="o">=</span> <span class="p">{</span> <span class="ss">:key1</span> <span class="o">=></span> <span class="mi">1</span><span class="p">,</span> <span class="ss">:key2</span> <span class="o">=></span> <span class="mi">3</span> <span class="p">}</span>
</code>
</pre><pre>
<code class="ruby"><span class="c1"># Ruby 1.9</span>
<span class="n">my_hash</span> <span class="o">=</span> <span class="p">{</span> <span class="n">key1</span><span class="p">:</span> <span class="mi">1</span><span class="p">,</span> <span class="n">key2</span><span class="p">:</span> <span class="mi">3</span> <span class="p">}</span>
</code>
</pre><h3 id="toc_2">UTF8</h3>
<p>Ruby 1.9 ayant introduit la prise en charge complète de l'UTF-8 au niveau des chaînes, Ruby 2.0 traite désormais les fichiers de code source dans cet encodage (ce qui peut poser des problèmes de compatibilité).</p>
<h3 id="toc_3">Débogage</h3>
<p>DTrace et SystemTap sont maintenant pris en charge pour instrumenter l'exécution des scripts.</p>
<h3 id="toc_4">Variables non utilisées</h3>
<p>Les variables commençant par <code>_</code> peuvent désormais être inutilisées dans vos sources sans causer de warning. C'est l'option <code>-w</code> qui permet d'activer cette fonction.</p>
<pre>
<code class="ruby"><span class="c1"># Ruby 1.9</span>
<span class="k">def</span> <span class="nf">foo</span>
<span class="n">_</span><span class="p">,</span> <span class="n">world</span> <span class="o">=</span> <span class="s1">'hello, world'</span><span class="o">.</span><span class="n">split</span><span class="p">(</span><span class="s1">', '</span><span class="p">)</span>
<span class="n">world</span>
<span class="k">end</span>
<span class="c1"># => pas d'avertissement</span>
<span class="c1"># Ruby 2.0</span>
<span class="k">def</span> <span class="nf">hi</span>
<span class="n">_hello</span><span class="p">,</span> <span class="n">world</span> <span class="o">=</span> <span class="s1">'hello, world'</span><span class="o">.</span><span class="n">split</span><span class="p">(</span><span class="s1">', '</span><span class="p">)</span>
<span class="n">world</span>
<span class="k">end</span>
<span class="c1"># => pas d'avertissement non plus.</span>
</code>
</pre><h3 id="toc_5">Création de hash</h3>
<p><code>to_Hash</code> permet de convertir une classe en hash. Cette méthode a été implémentée pour <code>nil</code>, <code>Struct</code> et <code>OpenStruct</code></p>
<pre>
<code class="ruby"><span class="c1"># Ruby 2.0:</span>
<span class="no">Car</span> <span class="o">=</span> <span class="no">Struct</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="ss">:make</span><span class="p">,</span> <span class="ss">:model</span><span class="p">,</span> <span class="ss">:year</span><span class="p">)</span> <span class="k">do</span>
<span class="k">def</span> <span class="nf">build</span>
<span class="c1">#...</span>
<span class="k">end</span>
<span class="k">end</span>
<span class="n">car</span> <span class="o">=</span> <span class="no">Car</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="s1">'Toyota'</span><span class="p">,</span> <span class="s1">'Prius'</span><span class="p">,</span> <span class="mi">2014</span><span class="p">)</span>
<span class="n">car</span><span class="o">.</span><span class="n">to_h</span> <span class="c1"># => {:make=>"Toyota", :model=>"Prius", :year=>2014}</span>
<span class="kp">nil</span><span class="o">.</span><span class="n">to_h</span> <span class="c1"># => {}</span>
</code>
</pre>
<p>Attention, cela n'a pas été implémenté pour les classes <code>Enumerable</code>/<code>Array</code></p>
<pre>
<code class="ruby"><span class="p">{</span><span class="n">hello</span><span class="p">:</span> <span class="s1">'world'</span><span class="p">}</span><span class="o">.</span><span class="n">map</span><span class="p">{</span><span class="o">|</span><span class="n">k</span><span class="p">,</span> <span class="n">v</span><span class="o">|</span> <span class="o">[</span><span class="n">k</span><span class="o">.</span><span class="n">to_s</span><span class="p">,</span> <span class="n">v</span><span class="o">.</span><span class="n">upcase</span><span class="o">]</span><span class="p">}</span>
<span class="o">.</span><span class="n">to_h</span> <span class="c1"># => NoMethodError:</span>
<span class="c1"># undefined method `to_h' for [["hello", "WORLD"]]:Array</span>
</code>
</pre><h3 id="toc_6">Chemin du dossier courant</h3>
<p><code>__dir__</code> retourne le chemin absolu du dossier du fichier en cours d'exécution.</p>
<h3 id="toc_7">Création de tableaux de symboles</h3>
<p>%i et %I ont été ajoutés pour la création de tableaux de symboles avec une syntaxe minimale.</p>
<pre>
<code class="ruby"><span class="c1"># Ruby 1.9:</span>
<span class="no">KEYS</span> <span class="o">=</span> <span class="o">[</span><span class="ss">:foo</span><span class="p">,</span> <span class="ss">:bar</span><span class="p">,</span> <span class="ss">:baz</span><span class="o">]</span>
<span class="c1"># Ruby 2.0:</span>
<span class="no">KEYS</span> <span class="o">=</span> <span class="o">%</span><span class="n">i</span><span class="o">[</span><span class="n">foo</span> <span class="n">bar</span> <span class="n">baz</span><span class="o">]</span>
</code>
</pre>
<p>de la même manière que %w et %W servaient à la création simplifiée de listes de chaîne de caractères :</p>
<pre>
<code class="ruby"><span class="no">KEYS</span> <span class="o">=</span> <span class="sx">%w[foo bar baz]</span>
<span class="no">KEYS</span> <span class="o">=</span> <span class="o">[</span><span class="s2">"foo"</span><span class="p">,</span> <span class="s2">"bar"</span><span class="p">,</span> <span class="s2">"baz"</span><span class="o">]</span>
</code>
</pre><h3 id="toc_8">Inclusion par précédence</h3>
<p>Lorsqu'un module est inclus dans un autre, il se retrouve automatiquement ajouté après la définition de celui qui l'inclut. Cela oblige à pas mal de gymnastique lorsque l'on veut "wrapper" des méthodes du conteneur.</p>
<pre>
<code class="ruby"><span class="k">class</span> <span class="nc">Template</span>
<span class="k">def</span> <span class="nf">initialize</span><span class="p">(</span><span class="n">erb</span><span class="p">)</span>
<span class="vi">@erb</span> <span class="o">=</span> <span class="n">erb</span>
<span class="k">end</span>
<span class="k">def</span> <span class="nf">render</span> <span class="n">values</span>
<span class="no">ERB</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="vi">@erb</span><span class="p">)</span><span class="o">.</span><span class="n">result</span><span class="p">(</span><span class="nb">binding</span><span class="p">)</span>
<span class="k">end</span>
<span class="k">end</span>
<span class="k">module</span> <span class="nn">RenderProfiler</span>
<span class="k">def</span> <span class="nc">self</span><span class="o">.</span><span class="nf">included</span> <span class="n">base</span>
<span class="n">base</span><span class="o">.</span><span class="n">send</span> <span class="ss">:alias_method</span><span class="p">,</span> <span class="ss">:render_without_profiling</span><span class="p">,</span> <span class="ss">:render</span>
<span class="n">base</span><span class="o">.</span><span class="n">send</span> <span class="ss">:alias_method</span><span class="p">,</span> <span class="ss">:render</span><span class="p">,</span> <span class="ss">:render_with_profiling</span>
<span class="k">end</span>
<span class="k">def</span> <span class="nf">render_with_profiling</span> <span class="n">values</span>
<span class="n">start</span> <span class="o">=</span> <span class="no">Time</span><span class="o">.</span><span class="n">now</span>
<span class="n">render_without_profiling</span><span class="p">(</span><span class="n">values</span><span class="p">)</span><span class="o">.</span><span class="n">tap</span> <span class="p">{</span>
<span class="vg">$stderr</span><span class="o">.</span><span class="n">puts</span> <span class="s2">"Rendered in </span><span class="si">#{</span><span class="no">Time</span><span class="o">.</span><span class="n">now</span> <span class="o">-</span> <span class="n">start</span><span class="si">}</span><span class="s2">s."</span>
<span class="p">}</span>
<span class="k">end</span>
<span class="k">end</span>
<span class="k">class</span> <span class="nc">Template</span>
<span class="kp">include</span> <span class="no">RenderProfiler</span>
<span class="k">end</span>
<span class="no">Template</span><span class="o">.</span><span class="n">ancestors</span>
<span class="c1">#=> [Template, RenderProfiler, Object, Kernel, BasicObject]</span>
</code>
</pre>
<p>Désormais il est possible d'inclure un module avant la défintion de son conteneur:</p>
<pre>
<code class="ruby"><span class="k">module</span> <span class="nn">RenderProfiler</span>
<span class="k">def</span> <span class="nf">render</span> <span class="n">values</span>
<span class="n">start</span> <span class="o">=</span> <span class="no">Time</span><span class="o">.</span><span class="n">now</span>
<span class="k">super</span><span class="p">(</span><span class="n">values</span><span class="p">)</span><span class="o">.</span><span class="n">tap</span> <span class="p">{</span>
<span class="vg">$stderr</span><span class="o">.</span><span class="n">puts</span> <span class="s2">"Rendered in </span><span class="si">#{</span><span class="no">Time</span><span class="o">.</span><span class="n">now</span> <span class="o">-</span> <span class="n">start</span><span class="si">}</span><span class="s2">s."</span>
<span class="p">}</span>
<span class="k">end</span>
<span class="k">end</span>
<span class="k">class</span> <span class="nc">Template</span>
<span class="n">prepend</span> <span class="no">RenderProfiler</span>
<span class="k">end</span>
<span class="no">Template</span><span class="o">.</span><span class="n">ancestors</span>
<span class="c1">#=> [RenderProfiler, Template, Object, Kernel, BasicObject]</span>
</code>
</pre>
<p>Exemples ci-dessus issus du <a href="http://benhoskin.gs/2013/02/24/ruby-2-0-by-example?utm_source=rubyweekly&utm_medium=email">blog de Ben Hoskings</a></p>
<h3 id="toc_9">Onigmo : nouveau moteur d'expression régulière</h3>
<p><a href="https://github.com/k-takata/Onigmo">Onigmo</a> remplace Oniguruma comme moteur d'expressions régulières (c'est un fork). Il permet d'utiliser certaines fonctionnalités présentes dans <a href="http://perldoc.perl.org/perlre.html">perl</a> depuis la version 5.10.<br />
Notamment l'expression conditionnelle <code>(?(condition)yes-pattern|no-pattern)</code> qui vaut <code>yes-pattern</code> si la condition est vérifiée, <code>no-pattern</code> sinon.</p>
<h3 id="toc_10">Refinements</h3>
<p>Les versions précédentes de Ruby permettent déjà de redéfinir des méthodes ou d'étendre des classes existantes. Le défaut principal de cette fonction très puissante est que les modifications de classes existantes se retrouvent dans tout un projet ainsi que les librairies utilisées. Les refinements, introduits dans Ruby 2.0 en fonctionnalité expérimentale, permettent d'effectuer ces modifications de manière "cloisonnée".</p>
<p>Magnus Holm en a donné un bon exemple dans un <a href="http://timelessrepo.com/refinements-in-ruby">article à ce sujet</a> (en anglais)</p>
<pre>
<code class="ruby"><span class="k">module</span> <span class="nn">TimeExtensions</span>
<span class="n">refine</span> <span class="no">Fixnum</span> <span class="k">do</span>
<span class="k">def</span> <span class="nf">minutes</span><span class="p">;</span> <span class="nb">self</span> <span class="o">*</span> <span class="mi">60</span><span class="p">;</span> <span class="k">end</span>
<span class="k">end</span>
<span class="k">end</span>
<span class="k">class</span> <span class="nc">MyApp</span>
<span class="n">using</span> <span class="no">TimeExtensions</span>
<span class="k">def</span> <span class="nf">initialize</span>
<span class="nb">p</span> <span class="mi">2</span><span class="o">.</span><span class="n">minutes</span>
<span class="k">end</span>
<span class="k">end</span>
<span class="no">MyApp</span><span class="o">.</span><span class="n">new</span> <span class="c1"># => 120</span>
<span class="nb">p</span> <span class="mi">2</span><span class="o">.</span><span class="n">minutes</span> <span class="c1"># => NoMethodError</span>
</code>
</pre>
<p>Dans cet exemple, plutôt que d'ajouter la méthode <code>minutes</code> dans la classe <code>Fixnum</code>, il l'a ajouté en tant que «raffinement» dans le module <code>TimeExtensions</code>. L'intérêt est que la méthode minutes n'existe que dans le bloc contenant <code>using TimeExtensions</code></p>
<h3 id="toc_11"> Lazy Enumerator et Enumerable</h3>
<p>Enumerators et Enumerables sont maintenant disponibles en version lazy (optimisation visant à retarder une opération jusqu'au moment où son résultat est nécessaire, ou bien au moment où des ressources sont inoccupées ) :</p>
<p>Enumerable#lazy et Enumerator::Lazy permettent de gérer des suites potentiellement infinies (lazy streams)</p>
<p>A cela s'ajoutent Enumerator#size et Range#size pour déterminer la taille par évaluation retardée (lazy evaluation)</p>
<h3 id="toc_12">API de gestion asynchrone des exceptions</h3>
<p>Une nouvelle API de gestion asynchrone des exceptions fait son apparition dans cette version 2.0.</p>
<h2 id="toc_13">Optimisations des performances</h2>
<h3 id="toc_14">Ramasse-miette</h3>
<p>Le ramasse-miettes a été optimisé par la technique du "bitmap marking". Il devrait radicalement réduire la mémoire occupée par les programmes ruby tournant sur serveur web. <a href="www.narihiro.info/index.en.html">Narihiro Nakamura</a> (en anglais) y travaillait depuis 2008.</p>
<p>L'idée principale est de profiter de la non-duplication de structures égales lors des forks (voir <a href="http://fr.wikipedia.org/wiki/Copy-On-Write" title="Définition Wikipédia">Copy-On-Write</a>). En ruby, les valeurs sont divisées en deux parties : les données (RArray, RHash, RFile …) et un ensemble de flags. On appelle ces valeurs des RValue (Ruby Value).</p>
<p>Les ensembles de flags sont souvent identiques d'une RValue à une autre. Le système ne devrait donc pas avoir à les dupliquer. Seulement, l'un des flags <code>FL_MARK</code>, est régulièrement modifié par le garbage collector pour indiquer les RValue recyclables. Comme celui-ci change très souvent de valeur, l'ensemble de flags varie, obligeant le système à dupliquer tout l'ensemble.</p>
<p>Narihiro Nakamura a donc sorti FL_MARK de la structure en regroupant tous les FL_MARK dans une collection de bit mappés à la RValue (d'où le "bitmap marking"). Ainsi Ruby peut régulièrement modifier FL_MARK sans toucher à l'ensemble de flags de la RValue.</p>
<p>Dès lors, le système n'a pas besoin de dupliquer les ensembles de <em>flags</em> lorsqu'ils sont parfaitement égaux pour deux RValue différentes. Vous l'aurez peut-être compris, ceci est valable lors des appels de <em>fork</em> qui, dans les systèmes UNIX, ne dupliquent pas la mémoire tant qu'elle est identique aux deux processus.</p>
<p>Pour plus d'informations à ce sujet, je vous invite à lire cet <a href="http://patshaughnessy.net/2012/3/23/why-you-should-be-excited-about-garbage-collection-in-ruby-2-0">article</a> très intéressant (en anglais).</p>
<h3 id="toc_15">Autres</h3>
<p>D'autres optimisations ont été faites pour améliorer la vitesse de démarrage notamment sur <code>Kernel#require</code>, les calculs sur des nombres à virgule flottante et sur la machine virtuelle. Cela profite déjà grandement au framework web <a href="http://fr.wikipedia.org/wiki/Ruby on Rails" title="Définition Wikipédia">Ruby on Rails</a>.</p>
<h2 id="toc_16">Documentation</h2>
<p>D'après le site <a href="http://www.ruby-lang.org/fr">ruby-lang.org</a> : « Un effort important à également été produit pour améliorer la documentation, ce qui a été une demande régulière de la part de la communauté. Le volume de documentation rdoc pour les modules et les méthodes a ainsi notablement augmenté : 75% de la 2.0.0 est couvert, tandis que la 1.9.3 plafonnait vers les 60%. Par ailleurs, vous pouvez retrouver une description de la syntaxe ruby en appelant : »</p>
<pre>
<code class="sh"><span class="nv">$ </span>ri ruby:syntax
</code>
</pre>
<p>L'ouvrage de référence sur Ruby (le <a href="http://pragprog.com/book/ruby4/programming-ruby-1-9-2-0?utm_source=rubyweekly&utm_medium=email">"pickaxe"</a>) sort, lui, dans une nouvelle édition qui couvre désormais Ruby 2.0.</p>
<h2 id="toc_17">Autres mises à jour notables</h2>
<p>La <a href="http://rubyweekly.us1.list-manage.com/track/click?u=0618f6a79d6bb9675f313ceb2&id=a8b6aae57a&e=09fa53f0f6">version 2.0.0 de RubyGems et la version 1.3 de Bundler</a> accompagnent la sortie de Ruby 2.0, elles ajoutent la gestion de cette dernière, tout en restant compatible avec les 1.9.x.</p>
<p>De même, l'équipe de <em>Ruby on Rails</em> sort une <a href="http://weblog.rubyonrails.org/2013/2/27/Rails-3-2-13-rc1-has-been-released/?utm_source=rubyweekly&utm_medium=email">version 3.2.13-rc1</a> compatible Ruby 2.0 ainsi qu'une <a href="http://rubyweekly.us1.list-manage.com/track/click?u=0618f6a79d6bb9675f313ceb2&id=7228c96e3d&e=09fa53f0f6">version 4 en bêta</a> pour qui Ruby 2 sera l'environnement de prédilection.</p></div><div><a href="https://linuxfr.org/news/ruby-2-0-est-sorti.epub">Télécharger ce contenu au format EPUB</a></div> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/97540/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/news/ruby-2-0-est-sorti#comments">ouvrir dans le navigateur</a>
</p>
reno_jordan_YLDMarc Quintonbaud123Nicolas BlancobarmicNÿcoKatyuchahttps://linuxfr.org/nodes/97540/comments.atomtag:linuxfr.org,2005:News/218412007-01-04T08:49:48+01:002007-01-04T08:49:48+01:00Le langage D 1.00 est disponible !<div>D est un langage de programmation "système". Combinant la rapidité et la puissance du C/C++ avec un confort de développement pour le programmeur voisin de celui fourni par Ruby ou Python.
<br />
<br />
D est un langage voisin du C++, mais où les fonctionnalités auraient été intégrées avec goût. Pour Walter Bright, le créateur de D, il n'y a pas une fonctionnalité particulière qui définit D, c'est le tout qui facilite le développement et la maintenance sans avoir à abandonner la vitesse du C/C++.</div><ul><li>lien nᵒ 1 : <a title="http://www.digitalmars.com/d/" hreflang="en" href="https://linuxfr.org/redirect/49998">D Programming Language</a></li><li>lien nᵒ 2 : <a title="http://www.digitalmars.com/d/comparison.html" hreflang="en" href="https://linuxfr.org/redirect/49999">Comparaison de D avec C, C++, C#, Java</a></li><li>lien nᵒ 3 : <a title="http://www.digitalmars.com/d/exception-safe.html" hreflang="en" href="https://linuxfr.org/redirect/50000">Scope guards</a></li><li>lien nᵒ 4 : <a title="http://fr.wikipedia.org/wiki/D_%28langage%29" hreflang="fr" href="https://linuxfr.org/redirect/50008">D sur Wikipédia</a></li><li>lien nᵒ 5 : <a title="http://dmoz.org/Computers/Programming/Languages/D/" hreflang="en" href="https://linuxfr.org/redirect/50009">D sur dmoz</a></li><li>lien nᵒ 6 : <a title="http://www.digitalmars.com/d/faq.html" hreflang="en" href="https://linuxfr.org/redirect/50017">FAQ sur D</a></li></ul><div>Pour ceux qui viennent du C/C++, D fournit :<ul><li>un ramasse miettes (Garbage Collector) par "défaut", bien qu'on puisse gérer soi-même la mémoire en cas de besoin.
<br />
</li><li>une syntaxe de programmation des templates plus propre et plus puissante.
<br />
</li><li>pas de préprocesseur, le langage fournit des fonctionnalités similaires.
<br />
</li><li>le support de la programmation par contrat.
<br />
</li><li>gère les tableaux dynamiques, les tableaux associatifs ce qui fournit une meilleure syntaxe.
<br />
</li><li>"scope guards" (que je ne sais pas traduire): une alternative au classique try/finally permettant d'écrire du code plus robuste en cas d'exception (cf le lien).</li></ul>
<br />
Tout cela et bien d'autres choses avec une vitesse d'exécution similaire au C/C++ mais avec des temps de compilation très rapides.
<br />
<br />
Pour ceux qui viennent du C#/Java, la liste est plus courte, mais un gros avantage: pas de machine virtuelle ou d'interpréteur.
<br />
Voir le lien vers le comparatif pour une liste plus complète.
<br />
<br />
Il n'y pas un mais deux (!) compilateurs pour développer en D :<ul><li>DMD (Digital Mars reference compiler, Windows & Linux, x86): compilateur gratuit dont seul le frontal est libre.
<br />
</li><li>GDC: compilateur totalement libre basé sur GCC.</li></ul>
<br />
Mon avis personnel : une bonne alternative au C++ (ou de Java/C#), avec une communauté importante, mais encore un manque de bibliothèques.</div><div><a href="https://linuxfr.org/news/le-langage-d-100-est-disponible.epub">Télécharger ce contenu au format EPUB</a></div> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/21150/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/news/le-langage-d-100-est-disponible#comments">ouvrir dans le navigateur</a>
</p>
renohttps://linuxfr.org/nodes/21150/comments.atomtag:linuxfr.org,2005:News/122422003-04-29T23:58:57+02:002003-04-29T23:58:57+02:00« The Unix-Haters Handbook » est disponible en ligne<div>Vu sur Slashdot, le livre « The Unix-Haters Handbook » est disponible en ligne. Je suis en train de le lire et je trouve la plupart des critiques assez pertinentes, et souvent encore valables aujourd'hui malheureusement.
<br />
<br />
Il est toujours bon de lire des critiques, cela permet d'éviter de tomber dans les écueils de la pensée unique.</div><ul><li>lien nᵒ 1 : <a title="http://research.microsoft.com/~daniel/unix-haters.html" hreflang="en" href="https://linuxfr.org/redirect/23953">Le sommaire du livre</a></li><li>lien nᵒ 2 : <a title="http://www.simson.net/ref/ugh.pdf" hreflang="en" href="https://linuxfr.org/redirect/24037">The Unix-Haters Handbook</a></li><li>lien nᵒ 3 : <a title="http://slashdot.org/article.pl?sid=03/04/26/2354245&mode=thread&tid=133&tid=186" hreflang="en" href="https://linuxfr.org/redirect/24038">La dépêche sur Slashdot</a></li></ul><div>Le sommaire :
<br />
<br />
* Foreword, by Donald Norman
<br />
* Preface
<br />
* Anti-Foreword, by Dennis Ritchie
<br />
* Part 1: User Friendly?
<br />
o 1 Unix. The World's First Computer Virus
<br />
o 2 Welcome, New User! Like Russian Roulette with Six Bullets Loaded
<br />
o 3 Documentation? What Documentation?
<br />
o 4 Mail. Don't Talk to Me, I'm Not a Typewriter
<br />
o 5 Snoozenet. I Post, Therefore I Am
<br />
o 6 Terminal Insanity. Curses! Foiled Again!
<br />
o 7 The X-Windows Disaster. How to Make a 50-MIPS Workstation Run Like a 4.77MHz IBM PC
<br />
* Part 2: Programmer's System?
<br />
o 8 csh, pipes, and find. Power Tools for Power Fools
<br />
o 9 Programming. Hold Still, This Won't Hurt a Bit
<br />
o 10 C++. The COBOL of the 90s
<br />
* Part 3: Sysadmin's Nightmare
<br />
o 11 System Administration. Unix's Hidden Cost
<br />
o 12 Security. Oh, I'm Sorry, Sir, Go Ahead, I didn't Realize You Were Root
<br />
o 13 The File System. Sure It Corrupts Your Files, But Look How Fast It Is!
<br />
o 14 NFS. Nightmare File System
<br />
* Part 4: Et Cetera
<br />
o A Epilogue. Enlightenment Through Unix
<br />
o B Creators Admit C, Unix Were Hoax
<br />
o C The Rise of Worse is Better, by Richard P. Gabriel
<br />
o D Bibliography
<br />
</div><div><a href="https://linuxfr.org/news/the-unix-haters-handbook-est-disponible-en-ligne.epub">Télécharger ce contenu au format EPUB</a></div> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/11577/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/news/the-unix-haters-handbook-est-disponible-en-ligne#comments">ouvrir dans le navigateur</a>
</p>
Renohttps://linuxfr.org/nodes/11577/comments.atomtag:linuxfr.org,2005:News/42652001-07-16T23:35:25+02:002001-07-16T23:35:25+02:00Un synthétiseur vocal pour Konqueror<div>George Russell a créé Speaker: un plug-in pour Konqueror permettant la synthése vocale à partir de texte.
<br />
C'est un premier jet, le but étant à terme de rendre Konqueror utilisable par les personnes mal-voyantes (pas d'embéter les kollégues de bureau ;-).
<br />
<br />
Note: N'oubliez pas de regarder la section Logiciel pour les autres annonces.</div><ul><li>lien nᵒ 1 : <a title="http://dot.kde.org/995252059/" hreflang="en" href="https://linuxfr.org/redirect/6900">L'article sur dot.kde</a></li><li>lien nᵒ 2 : <a title="http://linuxfr.org/section/Logiciel,0,-1,2.php3" hreflang="fr" href="https://linuxfr.org/redirect/6901">Section Logiciel</a></li></ul><div></div><div><a href="https://linuxfr.org/news/un-synthetiseur-vocal-pour-konqueror.epub">Télécharger ce contenu au format EPUB</a></div> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/4229/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/news/un-synthetiseur-vocal-pour-konqueror#comments">ouvrir dans le navigateur</a>
</p>
RenoXhttps://linuxfr.org/nodes/4229/comments.atom