Blog de Ludovic Baillet

À plusieurs reprises il m’est arrivé d’atteindre des limites peu connues en utilisant le .NET framework.

Récemment encore, en travaillant sur un problème d’optimisation, j’avais mis en place un algorithme de type BFS afin de chercher la solution la plus efficace à un problème. Du fait de l’explosion combinatoire du problème, mon pauvre programme pourtant en mode 64 bits tombait sur une exception de type « mémoire insuffisante« . Le souci est qu’au moment de l’exception, mon programme consommait à peine 10 Go de mémoire et qu’il me restait 16 Go de libre sur ma machine de 32 Go. Rageant.

Comme je travaille de plus en plus avec le .NET core, aussi bien sous Windows que sous Linux, j’ai voulu tester mon programme en le basculant pour .NET core 5 et voir s’il y avait des différences en terme de performance et d’occupation mémoire. Je n’ai pas spécialement noté de différence sur ces 2 aspects là, mais j’ai découvert une différence majeure : plus d’exception. J’ai même pu laisser filer mon programme au-delà de la mémoire disponible (process testé à 44 Go avec 32 Go de RAM), Windows restant imperturbable.

En conclusion, tout nouveau développement en C# devrait cibler sans hésiter .NET Core au lieu de .NET framework, vu l’ensemble des avantages (notamment l’aspect multi-plateforme) et l’absence de perte.

Le terme que je veux mettre en avant est éphémère.

On ne s’en rend pas compte parce que l’informatique est ancrée dans le quotidien et que les améliorations et nouveautés s’enchaînent dans ce monde. Mais l’obsolescence est de plus en plus présente dans de nombreux domaines de l’informatique.

Quelques exemples pour étayer cette remarque.

Flash a disparu début 2021 après une longue période pendant laquelle ce composant était indispensable à nombre de sites internet et même des logiciels. Cette disparition entraîne de fait nombre de pages internet à ne plus fonctionner (sauf si évolution), nombre de logiciels à ne plus pouvoir fonctionner (sans alternative), et nombre de vidéos à ne plus pouvoir être lues.

Les langages de programmation évoluent de nos jour à un rythme inquiétant (et sans compter les nouveaux langages qui fleurissent chaque année). Ainsi, nombre de langages se sont lancés dans une course folle à enchaîner soit des nouveautés non négligeables sur un rythme semestriel, soit des nouveautés significatives sur un rythme triennal. En conséquence, relire un code source écrit il y a une dizaine d’année peut faire mal aux yeux. Également, le travail d’actualisation des connaissances pour les développeurs devient de plus en plus compliqué (sans compter les nouveaux frameworks qui apparaissent ou qui évoluent, ainsi que les nouveaux outils et les nouvelles pratiques). Et là encore, arriver à recompiler un ancien code source peut s’avérer difficile voire impossible de nos jours tant les évolutions sont rapides et brutales. On peut penser au langage python 2 qui n’a plus de support depuis 2020, certaines anciennes version de Swift.

On peut aussi penser aux célèbres applets java qui étaient tant présentes au début du web : elles vont être définitivement retirées de la version 17 de java (cf. https://openjdk.java.net/jeps/398).

Les logiciels suivent le même chemin : certains disparaissent (Outlook Express, Internet Explorer, etc.). On peut aussi évoquer une liste impressionnante de projets abandonnés par Google : https://killedbygoogle.com.

Toutes ces évolutions conduisent inévitablement à devoir migrer sans cesse les données, changer les logiciels et les habitudes. Et même parfois, ça conduit à des pertes de données/fonctionnalités définitives. Une forme d’obsolescence à marche forcée. Et pourtant cette tendance ne devrait pas s’inverser, bien au contraire.

Scénario : nous sommes en 2020, et maven affiche quantité de warnings (suivis de quelques erreurs) du genre :

[WARNING] Failed to retrieve plugin descriptor for org.apache.maven.plugins:maven-compiler-plugin:2.4: Plugin org.apache.maven.plugins:maven-compiler-plugin:2.4 or one of its dependencies could not be resolved: Failed to read artifact descriptor for org.apache.maven.plugins:maven-compiler-plugin:jar:2.4
Downloading from central: https://repo.maven.apache.org/maven2/org/apache/maven/plugins/maven-resources-plugin/2.5/maven-resources-plugin-2.5.pom

Nous sommes donc en 2020, et l’usage du https devient la norme partout. Dans ce cas, il y a essentiellement 2 solutions :

• Configurer un mirror « http » du settings.xml de maven
• Configurer maven pour qu’il utilise le https

Parmi les nouveautés du langage Rust version 1.4.7, on découvre donc une nouvelle constante peu connue : Tau. Cette constante vaut le double de la constante π (Pi). Il existe de nombreux débats (sur Internet) essayant de faire croire que la constante π aurait dû valoir le double, au motif que beaucoup d’équations réclament le double de π et non simplement π. Hélas pour ces empêcheurs de tourner en rond, beaucoup d’autres équations n’ont besoin que d’un simple Pi. Notamment la plus belle équation : e ^i.π + 1 = 0.

Le langage Rust suit donc le langage python qui avait introduit cette constante dans va version 3.6.

Alors que les langages Java et C# ne disposent que d’un nombre infime de constantes mathématiques (e et π), Rust en possède beaucoup (https://doc.rust-lang.org/std/f64/consts/index.html). Idem pour C++ version 20 (https://en.cppreference.com/w/cpp/numeric/constants).

Pour le moment, Javascript résiste à Tau, tout comme bien d’autres langages.

L’utilisation du bureau à distance est usuelle en télétravail. Les problèmes arrivent rapidement quand les raccourcis Windows restent en local et ne sont pas transmis à l’ordinateur distant.

Heureusement, il existe d’autres raccourcis pour émuler Alt+Tab, Alt+Print Screen, Ctrl+Alt+Del, etc.

En voici une courte liste : https://www.itprotoday.com/windows-8/top-10-remote-desktop-keyboard-shortcuts

Hélas, rien n’est prévu pour l’« inception », c’est-à-dire quand on prend le contrôle à distance d’un Windows depuis un Windows lui-même pris en contrôle à distance. Dans ce cas, il faut reconnaître que certains outils spécialisés font nettement mieux que le contrôle à distance basique de Windows. Mais les outils spécialisés sont souvent très coûteux.

Le film Hacker / Code poursuite sorti il y a quelques mois est un des rares films montrant un ordinateur quantique. À nouveau c’est l’occasion d’évoquer l’aspect programmation informatique au cinéma.

L’héroïne du film se met à écrire un algorithme pour un ordinateur quantique, et chose surprenante, on voit clairement son écran. Mais c’est une grande déception.

On voit en effet une petite fenêtre de programmation dans laquelle est écrit un simple JSON au format Jupyter Notebook (cf. https://ipython.org/ipython-doc/dev/notebook/nbformat.html). En tout cas, rien à voir avec la programmation pour ordinateur quantique.

Chose plus surprenante, l’intitulé de la fenêtre. Il s’agit de « C:\python27\python.exe ». Il s’agit donc du binaire principal du célèbre langage à la popularité grandissante, Python. Mais version 2.7.

Or, la version 2.7 de Python n’est plus supportée depuis le 1er janvier 2020, c’est-à-dire au moment de la sortie du film.

En conclusion : encore un film qui évoque l’informatique, mais qui caricature le sujet et qui est à côté de la plaque.

Clairement, le film Rogue Warfare 2 ne sera pas le meilleur de la décennie, enfin ce n’est que mon point de vue. Les critiques semblent toutefois aller dans mon sens. À défaut de parler de la qualité du film, je vais plutôt évoquer la programmation informatique au cinéma à travers ce film.

En effet, ce film met en scène une militaire donnant une leçon de programmation et même de piratage à un de ses collègues. Nous voyons clairement son écran défiler, arrêtons nous sur cette simple image tirée du film :

Ça bouge pas mal dans toutes les fenêtres, et surtout la fenêtre centrale qui utilise un thème sombre avec une police de couleur verte, le tout défilant de haut en bas. Probablement pour avoir un effet type Matrix. Dans l’inconscient, ça peut jouer d’associer son image avec une image qui véhicule le futur, la science fiction.

Si on regarde en détail le code source de la zone centrale, on voit qu’il s’agit de PHP, avec une ligne telle que celle-ci :

$_SESSION['username'] = 'tutorialspoint';

Cela semble être tiré directement de l’exemple de connexion en PHP fourni par le site TutorialsPoint :
http://www.tutorialspoint.com/php/php_login_example.htm

Donc, rien à voir avec ce que l’actrice explique être en train de faire (créer / lancer un programme espion).

De plus, le copier/coller de code source peut être dangereux. En effet, on voit ce code :

if ($_POST['username'] == 'tutorialspoint' && $_POST['password'] == '1234')

Clairement, il s’agit d’une violation de type CWE-259: Use of Hard-coded password. Évidemment, c’est à ne pas faire.

Concernant la fenêtre en haut à gauche, on voit du code C sur la zone droite, et la version assembleur en cours de debug dans la zone gauche :

nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;
/* Make sure we always allocate at least one indirect block pointer */
nblocks = nblocks ? : 1;

Ce code est connu, il s’agit de la gestion des groupes dans le noyau Linux, dont on peut voir le code source complet sur git : https://github.com/torvalds/linux/commit/30639b6af85a92491b22dd14c17b14ca11da60e6#diff-d426d46610ed4fa039bbbfd367c2c186

À noter : qu’il existe un site dédié à ce code source ! En effet, pour qui veut passer pour un hacker comme au cinéma, il suffit de taper frénétiquement au clavier depuis le site http://hackertyper.com. De nouveau, thème sombre et police de couleur verte. Les stéréotypes de la programmation informatique ont hélas la vie dure.

Le Rust est un langage de programmation qui se prête peu à l’exercice de Code golf. Par ailleurs les astuces permettant de réduire au maximum la taille des sources en Rust sont très peu documentées. Voici quelques techniques utiles.

• Réutiliser une String

Supposons que l’on veuille réutiliser une string.

    let mut s=String::new();
    // Do some stuff with s
    s=String::new();

Alors, la dernière ligne peut-être remplacée par la ligne suivante qui est plus courte de 6 caractères :

    s.clear();

• Initialisation multiple

Supposons que l’on doive initialiser les variables x et y avec le contenu des 3e et 4e valeurs d’un tableau n :

    let mut x=n[2];
    let mut y=n[3];

Alors, on peut écrire la même chose en une seule ligne et en économisant un peu :

    let(mut x,mut y)=(n[2],n[3]);

• Réduire std::io

Souvent, les concours de Code golf nécessitent :

    use std::io;

Il est possible d’économiser 1 caractère :

    use std::*;

• Omettre le point-virgule final

En général, le programme se finit par un print/println tel que :

    println!("{}",n);

Le point-virgule terminal n’est pas nécessaire, ce qui permet d’économiser un caractère.