Comment utiliser Hyperfine pour comparer les performances de rg et ag
Qu’est-ce que Hyperfine ?
Hyperfine est un outil en ligne de commande qui permet de mesurer et de comparer les performances d’autres commandes. Il est particulièrement utile pour évaluer la vitesse d’exécution de différentes commandes ou scripts, en fournissant des statistiques détaillées comme le temps moyen, l’écart-type, et la plage de temps d’exécution.
Présentation de rg (ripgrep)
Ripgrep, souvent abrégé en rg, est un outil de recherche de texte ultra-rapide. Il est conçu pour parcourir rapidement des fichiers et des répertoires à la recherche de motifs spécifiques. Ripgrep est connu pour sa rapidité et sa capacité à ignorer les fichiers non pertinents, comme ceux dans les répertoires .git ou node_modules.
Présentation de ag (The Silver Searcher)
The Silver Searcher, ou ag, est un autre outil de recherche de texte, similaire à ack, mais plus rapide. Il est optimisé pour la recherche dans des projets de code, en ignorant automatiquement les fichiers et répertoires non pertinents. Bien qu’il soit rapide, il est souvent surpassé par rg en termes de performances.
Comparaison des performances avec Hyperfine
Pour comparer les performances de rg et ag, nous pouvons utiliser Hyperfine avec la commande suivante :
Les résultats montrent que rg est significativement plus rapide que ag :
rg a un temps moyen d’exécution de 256.6 ms.
ag a un temps moyen d’exécution de 910.3 ms.
En résumé, rg est environ 3.55 fois plus rapide que ag dans ce scénario.
Pourquoi utiliser rg plutôt que ag ?
La comparaison effectuée avec Hyperfine démontre clairement que rg est plus performant que ag pour la recherche de texte. Si la vitesse est un critère important pour vous, rg est donc un choix évident. De plus, rg offre une meilleure gestion des fichiers ignorés et une intégration plus fluide avec les outils modernes de développement.
Automatiser le nettoyage des branches Git avec un alias : Guide pratique
Travailler avec Git implique souvent de gérer de nombreuses branches, locales et distantes. Au fil du temps, il est courant que des branches distantes soient supprimées, laissant des branches locales obsolètes. Pour simplifier le nettoyage de ces branches, vous pouvez créer un alias Git qui automatise ce processus. Dans cet article, nous vous expliquons comment faire, ainsi que les avantages et les inconvénients de cette méthode.
Créer un alias Git pour nettoyer les branches locales
Voici la commande pour créer un alias Git nommé prune-all qui nettoie automatiquement les branches locales obsolètes :
Une fois cet alias configuré, vous pouvez simplement exécuter :
git prune-all
Cette commande va :
Mettre à jour les références locales et supprimer les branches distantes supprimées (git fetch --prune).
Identifier les branches locales qui n’ont plus de branche distante associée (git branch -vv | grep ": gone]").
Extraire les noms de ces branches (sed).
Supprimer les branches locales (xargs -r git branch -d).
Pourquoi utiliser cet alias ?
Cet alias offre plusieurs avantages :
Gain de temps : Plus besoin d’exécuter manuellement plusieurs commandes pour nettoyer les branches locales.
Automatisation : Le processus est entièrement automatisé, ce qui réduit les erreurs humaines.
Propreté du dépôt : Vous gardez votre dépôt local propre et synchronisé avec le dépôt distant.
Les précautions à prendre
Bien que cet alias soit très utile, il est important de comprendre ses limites et les risques potentiels :
Utilisation de git branch -d : L’alias utilise git branch -d pour supprimer les branches locales. Cela signifie que Git refusera de supprimer une branche si elle contient des commits non fusionnés. C’est une sécurité pour éviter de perdre du travail.
Risque de suppression accidentelle : Si vous utilisez git branch -D (avec un D majuscule) à la place de -d, les branches seront supprimées de force, même si elles contiennent des commits non fusionnés. Soyez prudent si vous modifiez l’alias pour utiliser -D.
Vérification manuelle : Avant d’exécuter l’alias, il peut être utile de vérifier les branches qui seront supprimées en exécutant :
Cet alias est particulièrement utile dans les situations suivantes :
Vous travaillez sur un projet avec de nombreuses branches, et vous voulez garder votre dépôt local propre.
Vous collaborez avec une équipe et les branches distantes sont fréquemment supprimées après fusion.
Vous voulez automatiser une tâche répétitive pour gagner du temps.
Conclusion
Créer un alias Git pour nettoyer les branches locales est une excellente façon d’automatiser une tâche fastidieuse et de garder votre dépôt propre. En utilisant git branch -d, vous ajoutez une couche de sécurité pour éviter de perdre du travail non fusionné. Cependant, soyez conscient des risques si vous décidez d’utiliser git branch -D à la place.
N’hésitez pas à essayer cet alias et à l’adapter à vos besoins. Bonne gestion de branches !
Vous avez des questions ou des suggestions ? Laissez un commentaire ci-dessous !
Sous Mint, Lorsque mon PC démarre, je veux qu’il « monte » automatiquement mes disques et qu’il fasse quelques vérifications au passage (dossier existant etc).
Problème : il arrive parfois la même chose que sous Windows, à savoir que si le mount ne fonctionne pas, il faut le faire à la main.
J’ai donc essayé de suivre plusieurs tutoriels et la plupart disaient d’ajouter dans les tâches planifiées (« cronjob« ) une ligne qui commençait par @reboot.
Je ne sais pas pourquoi, mais sur ma version de Mint, il ne connaissait pas @reboot.
Après pas mal de recherches, voici ce que j’ai trouvé, et qui fonctionne parfaitement :
Éditer /etc/rc.local
Lui ajouter la ligne de commande que l’on veut faire
Donc mon fichier /etc/rc.local j’ai donc deux lignes de code : /home/olivier/apply.config.perso.sh -f /home/olivier/boot.log
exit 0
(J’ai enlevé les commentaires très importants qu’il y a dans le fichier, à vous de les lire !)
Le code précédent signifie « lance le script /home/olivier/apply.config.perso.sh« .
Et je me suis fait mon script, soit /home/olivier/apply.config.perso.sh :
(Il prend en compte le paramètre « -f » pour préciser le fichier de sortie, comme cela je logue tout, on n’est jamais assez prudent). # ----------------------------------------------
# command line options
# first save args to pass them later on to other scripts:
args=("$@")
while [ "$1" != "" ]; do
case $1 in
-f | --file ) shift
# test if output_filename starts with "-":
if [[ "$1" =~ ^-.* ]]; then
usage
exit
fi
# from that point on:
# direct all stdout and stderr to $1:
exec &>>$1
;;
-u ) # ignored here, for mount script (later in there)
;;
-h | --help ) usage
exit
;;
* ) usage
exit 1
esac
shift
done
echo "`(date '+%Y.%m.%d-%Hh%Mm%Ss')` $filename > Applying my own configuration..."
sudo -Hu olivier gsettings set org.cinnamon.settings-daemon.peripherals.keyboard delay 120
sudo -Hu olivier gsettings set org.cinnamon.settings-daemon.peripherals.keyboard repeat-interval 18
if mountpoint -q "/mnt/Olivier"; then
echo "`(date '+%Y.%m.%d-%Hh%Mm%Ss')` $filename > Already mounted, nothing to do."
else
delay=1
while ! mountpoint -q "/mnt/Olivier"; do
echo "`(date '+%Y.%m.%d-%Hh%Mm%Ss')` $filename > Trying to mount..."
# re-pass the same arguments via "${args[@]}"
/home/olivier/mount.diskstation.sh "${args[@]}"
sleep $delay
if [ "$delay" -gt 60 ]; then
echo "`(date '+%Y.%m.%d-%Hh%Mm%Ss')` $filename > Couldn't mount! Too long! Exiting."
exit 1
fi
delay=$((delay+5))
done
echo "`(date '+%Y.%m.%d-%Hh%Mm%Ss')` $filename > Successful mount."
fi
echo "`(date '+%Y.%m.%d-%Hh%Mm%Ss')` $filename > Done."
Explications :
Les deux ordres gsettings set org.cinnamon.settings-daemon.peripherals.keyboard modifient la vitesse de mon clavier (qui n’est, de base, pas assez rapide pour moi).
L’ordre /home/olivier/mount.diskstation.sh monte mon disque.
Ensuite je fais une boucle qui vérifie si mon « mount » est réussi ou pas : tant que ce n’est pas le cas, il attend un « compteur » qu’il augmente de 5s à chaque boucle, et tout ça au maximum 60 fois. Si vraiment il n’y arrive pas, il logue le problème et quitte.
Tout fonctionne parfaitement depuis maintenant 2 ans !
Je vais faire un résumé de ce que j’ai trouvé un peu partout, et pourquoi j’ai choisi mon prompt tel que je l’ai fait.
Visuellement, avoir quelque chose de coloré est extrêmement parlant. Il me fallait absolument utiliser les couleurs possibles du prompt pour rapidement mettre en évidence ce qui m’intéresse ;
Le bash a sa syntaxe qui est très efficace mais pas forcément facile à appréhender ;
Comme pour tout ce qu’on cherche sur Internet en termes de développement, il y a à boire et à manger… et cela semble devenir vrai aussi pour Linux. J’espère vraiment (x 450e+6654) me tromper.
Ce que j’ai trouvé et qui fonctionne selon mes tests. Ici, bien sûr, peut être qu’il y a d’autres solutions, mais celle que je donne ici a fonctionné sur tous les shells que j’ai testé (Ubuntu, Mint mais aussi CentOS).
Séquence invisible
Toute séquence qu’on ne veut pas visible doit être entourée par \[ et \].
Fin de l’histoire. Je vais pas pleurer en disant que j’ai passé un sacré paquet de temps à trouver ça alors que c’est très simple. Ah si je pleure ? Bon ok.
Changer de couleur
Pour changer de couleur, il faut imaginer qu’on change simplement de stylo. Simple, me direz-vous ? Mais après avoir lu et travaillé dans le Web où on ouvre puis on ferme une balise, ici, non. Il faut envoyer une séquence spéciale : \033puis ouvrir un crochet qu’on ne va pas fermer, c’est codé en dur, il faut l’accepter tel quel : [. Et ensuite, un chiffre : 0 pour dire qu’on veut une couleur foncée, ou 1 pour dire qu’on la veut un peu plus claire (ex : le noir devient gris) puis un point virgule ;. Ensuite, il faut donner un chiffre compris entre 30 et 36 pour préciser la couleur. Et vous croyez que c’est terminé ? Non ! Il faut terminer par la lettre m. Si vous avez bien lu, vous devriez instantanément comprendre l’exemple suivant : \[\033[1;31m\]. Oui oui, le crochet au milieu ne se ferme jamais. Respirez, calmez-vous. C’est la vie. Il faut faire avec.
Pour toutes les couleurs, j’ai tout mis dans mon mémo qui remplace ma mémoire trop remplie (je préfère dire « trop remplie » que « défaillante », mais parfois j’hésite entre les deux…).
Restorer la couleur d’origine
Oui c’est en h1 parce que c’est aussi important que les deux paragraphes précédents : pour restaurer la couleur d’origine, cela ressemble un peu à l’ordre précédent : entourer par des crochets échappés, une séquence de couleur qui n’a pas deux valeurs mais une seule : 0. Cela donne : \[\033[0m\].
Donc votre code qui change votre prompt devrait toujours se terminer par « remettre la couleur d’origine », soit \[\033[0m\]. Ce n’est que mon point de vue…
Mon prompt
Vous allez me dire « mais pourquoi il fait tout un article sur un prompt ? ». Réponse : c’est comme mon clavier : j’ai passé beaucoup de temps à l’apprendre et le configurer, parce que je sais que sur du long terme ça va m’être très rentable. Passer plusieurs semaines pour gagner plusieurs mois, ça vaut le coup, fin de l’histoire. Donc, voici ma réflexion qui explique mon choix de prompt. J’aurais tout autant pu vous répondre un grand classique indétrônable : le diable est dans les détails.
J’ai très souvent besoin de savoir globalement l’heure qu’il est. J’aimerais bien, dans mon prompt, je sache l’heure qu’il est. Si je tape quelque chose, je valide, hop j’ai la nouvelle heure. Pratique, pas « mortellement pratique », mais sympa. De plus, 6 caractères utilisés pour HH:MM[espace] c’est négligeable. Par contre, j’aimerais que visuellement, ça ne soit pas polluant. C’est pratique, mais pas important. La couleur la plus sombre possible dans le prompt c’est « noir éclairci », soit premier chiffre = éclairci = 1 et second chiffre = noir = 30. Donc mon premier ordre c’est « noir éclairci + heure », donc : \[\033[1;30m\]\t
La seconde chose, qu’on retrouve partout, c’est bien sûr, qui est connecté, donc l’utilisateur. Là, ça devient plus important. Mais pas le plus important pour moi (surtout sur la fin du prompt où on voit en méga surbrillance, si on est superuser ou utilisateur normal) : c’est une couleur foncée 0 et qui peut avoir un pendant « éclairci » plus agréable pour préciser l’hôte (j’en parle juste après) : j’ai choisi purple = 35. La séquence échappée du user en cours est \u. Ici aussi, si vous avez suivi, ça donne, couleur + user en cours : \[\033[0;35m\]\u
Ensuite, séparateur entre l’utilisateur et l’hôte. Le classique « @ » qui ne doit pas être gênant, même couleur que l’heure : « noir éclairci », soit \[\033[1;30m\]@
L’hôte. Oui, le grand classique c’est «[userconnecté]@[hôte]», et si des millions de geeks linux ont choisi cela c’est que c’est parlant. Mais ici, comme je gère pas mal de machines, selon moi, il faudrait que l’hôte soit un peu plus visible que le user en cours. Donc même couleur que le user, mais avec «1» au lieu de «0». Sachant que la séquence échappée de l’hôte est \h on obtient : \[\033[1;35m\]\h
Avant dernière chose (pour moi) : le path. Là, bon sang, il faut que ça pète. Il faut que le yeux le voient même si on commence à s’endormir (petit clin d’œil à ceux qui mangent kebab-frites avant de commencer les cours avec moi). Un bon rouge, bien éclairci. Allez on le fait rapide : pour exécuter un ordre à chaque appel de prompt, l’astuce est d’échapper le $ et de mettre entre parenthèses l’ordre shell qu’on veut lancer : ici, on est sur du Linux, c’est instantané. La solution, donc : rouge vif + $(pwd) version « échappée » : \[\033[1;31m\]\$(pwd)
Dernière information : la plus cruciale, toujours présente sur tous les paths : quel type d’utilisateur est connecté : \$. Il est substitué par # si vous êtes root, sinon $. Là, il faut qu’on ait les yeux qui brûlent. Lunettes de soleil. Du jaune, le plus visible possible (= « 1« ). Un bon jaune qui fait pleurer les yeux, mais ça ne prend qu’un caractère, qui est IMHO, d’une importance cruciale : \[\033[1;33m\]\$
Voici donc mon bash résumé en une ligne, que je mets dans tous mes .bashrc. Si vous ne savez pas ce qu’est un .bashrc, je vous laisse chercher, ce n’est pas le but de l’article.
Voici ce que donne mon prompt, et même si ici il n’est pas super vendeur, en pratique, je n’ai pas trouvé quelque chose de plus efficace visuellement parlant, si vous avez des idées / suggestions, améliorations, commme d’habitude, je suis preneur :
Le code de mon prompt, volontairement en minuscules juste pour vous faire râler :
PS : pour ceux qui ne savent pas ce que « IMHO » signifie, ne le dites à personne, et allez vite chercher sur Internet. Promis on ne le dira à personne. C’est comme « RTFM ». Promis. Chut. [silence gêné].
Une fois cela terminé, allez récupérer ce qui va vous changer la vie : wsltty.
C’est un outil qui remplace le shell Ubuntu de Windows, mais qui est mieux sur tous les plans.
Et là vous aurez un shell qui ressemble au mintty de Cygwin (mon shell préféré).
C’est tout simple sous Linux.
Il faut juste savoir, pour ceux qui commencent à faire quelques lignes de commande sous Linux, que le « backquotes », donc le ` demande à exécuter quelque chose et le remplacer par le résultat de l’exécution.
Exemple : si vous tapez `(date '+%Y.%m.%d-%Hh%Mm%Ss')` alors il exécutera l’ordre date, et le remplacera par la date en cours.
Exemple concret :
tar cjf "`(date '+%Y.%m.%d-%Hh%Mm%Ss')`.monarchive.tar.bz2" htdocs/*
Vous archivera tout le dossier htdocs dans l’archive : 2018.02.06-09h45m05s.monarchive.tar.bz2
Plein de personnes utilisent « calc » sous Windows. C’est bien.
Mais, comme la plupart des outils Windows : Linux c’est 20x moins ergonomique, mais 20x puissant.
Bah comme Linux en général, en fait…
Let me introduce bc.
C’est le « calc » de Windows, mais en plus laid et en 20 x plus puissant que la calculatrice Windows (déjà dit).
Le seul truc bizarre de bc c’est qu’il ne fait que des calculs en entier.
En bref : bc -l et hop tout est en flottant et fonctionne.
To make a long story short: bc -l and everything is ok.
