Vos petites manies de développeurs

C'est une question de goût et d'habitude. Personnellement, je n'en ai pas non plus. J'ai horreur d'avoir une espèce de boite de dialogue qui s'ouvre dès que j'écris un mot et qui m'empêche de naviguer confortablement dans mon code avant même de finir d'écrire mon mot. Donc, non, tout le monde n'en utilise pas et ça n'est pas un handicap ni même un "problème".

+100

Pour la petite histoire, à un moment donné j'avais voulu tester visual studio. But du jeu, s'initier à C#. Je l'ai installé, et 1h après il était déjà désinstallé. Motif, dès qu'on tape "x = ", il y a 10 popup à la con pour te dire que la variable n'existe pas. Ca m'a saoulé direct. A peine on commence d'écrire qu'on se fait agresser.

Je ne trouve pas que Visual Studio soit si agressif. Quand tu fait une erreur dans ton code, il te la souligne juste en rouge, comme les erreurs d'orthographe dans un traitement de texte. Et non, il n'y a surement pas des popups (où alors tu l'avait très mal configuré). J'utilise Visual Studio au quotidien et je trouve que l'autocomplétion fait gagner pas mal de temps. Par exemple j'écris juste :

1

List<string> Names = new

j'appuie sur entrée et List<string> (); s'est ajouté tout seul. Multiplie ces 2 secondes par le nombre de fois où tu vas utiliser l'autocomplétion dans ton projet et ça commence à faire. Et puis tu évite bien des fautes de frappe.

Je choisis de ne pas en avoir parce que ça ne me plaît pas. Après, je ne suis pas dérangé quand j'ai à taper des noms de variables un peu longs, mais c'est le « refus de faire plaisir à ceux qui ne l'ont pas » qui m'irrite.

C'est tout aussi agressif la correction orthographique dans un traitement de texte wysiwyg.

Moi ça ne me déranges pas et ça me permet de voir où sont mes erreurs rapidement. Après, tu peux trouver ça agressif …

Donc finalement tous les dev auraient leurs petites manies. Ça serait peut être sympa de faire un sujet pour en discuter sans s'engueuler. … oh wait !

Bat' : l'autocomplétition te fait "théoriquement" gagner du temps, ces fameuses deux secondes, seulement si tu es capable d'écrire du code sans avoir besoin de t'arrêter/réflechir. Je ne pense pas que ce soit le cas, pour personne.

Là où elle est pratique, c'est lorsqu'on a oublié le nom d'une fonction, mais ici certains vont travailler avec la complétition, d'autres vont utiliser la complétition + une doc qui s'affiche, et les autres vont avoir la doc soit en tête, soit sur papier, soit sur une autre fenêtre/un autre écran, et c'est en cela que c'est vraiment une question de goût, d'habitude de travail.

Et non, il n'y a surement pas des popups (où alors tu l'avait très mal configuré).

La config d'origine est pourrie alors. Je ne l'avais pas vraiment configuré, c'était au premier lancement.

Là où elle est pratique, c'est lorsqu'on a oublié le nom d'une fonction, mais ici certains vont travailler avec la complétition, d'autres vont utiliser la complétition + une doc qui s'affiche, et les autres vont avoir la doc soit en tête, soit sur papier, soit sur une autre fenêtre/un autre écran, et c'est en cela que c'est vraiment une question de goût, d'habitude de travail.

Oui. Pour le coup eclipse est moins agressif, il n'ouvre rien si tu n'appuies pas sur Ctrl+Espace.

Ma préférence va quand même aux onglets de doc ouverts dans le navigateur. Que ce soit la javadoc, la MSDN, boost, cppreference.com, php.net, le W3C, la MDN, etc.

En fait je ne trouve pas tant d'utilité que ça à Ctrl+Espace. Soit on se rappelle le nom des méthodes et ses paramètres, soit on ne sait plus trop et il vaut mieux aller guigner vite fait dans la doc. Exception, le php, où j'ai quelques fonctions récalcitrantes dont je ne me souviens jamais l'ordre des paramètres (entres autres in_array, implode, explode, et d'autres fonctions de tableaux ou de chaînes).

Idem que d'autres avant. Je n'utilise pas l'auto-complétion, parce que je n'en ai jamais ressenti le besoin, et que j'aime coder avec des outils assez minimalistes, en l'occurrence un simple gedit. Du coup, quand je suis dans Examiner cet élément de Firefox et que je trifouille le code, je me sens agressé par toutes ces auto-complétions sauvages…

Je ne suis pas seul !
Personnellement, je n'utilise que très peu l'auto-complétion. Les seules fois ou je l'utilise, c'est généralement pour appeler mes fonctions.
En général, je préfère avoir une fenêtre où se trouve uniquement mon code. Au final, je m'y retrouve et je peux m'y concentrer plus rapidement qu'avec une fenêtre remplie de boutons,de barres d'outils, etc…

Je pense que l'intérêt de l'auto-complétion (et plus généralement des tas d'outils d'aide intégrés aux IDE) dépend pas mal du langage, du projet et de la qualité d'implémentation des fonctionnalités dans l'éditeur.

Par exemple avec IntelliJ / Android Studio (sur du Java donc), je tape :

1

List<Bidule>

Ça m'importe automatiquement Bidule dans les imports (et me demande lequel si j'en ai plusieurs dans différents packages. Ça me propose aussi bidules et biduleList comme nom de variables, tout en gérant intelligemment le raccourcissement de nom¹.

Mais ça marche particulièrement bien parce que cet IDE a tendance à lire dans tes pensées et parce que Java fait partie des langages qu'on peut le plus automatiser de cette manière. Et ça a un cout : un Android Studio (basé sur IntelliJ) mange tranquillement 1,5 Go de RAM en fonctionnement normal ainsi que pas mal de CPU.

Au final, j'utilise massivement les fonctionnalités suivantes et j'ai du mal quand elles sont absentes :

• Coloration syntaxique
• Auto-complétion
• Détection d'erreurs et avertissements paranoïaques (très important : souvent les réglages par défaut sont très tolérants)
• Voir la doc de "cette fonction là en particulier" (je n'utilise plus la doc non-intégrée que dans les cas où je dois parcourir un ensemble de fonctionnalités d'un coup).
• Voir le code derrière une méthode / classe / whatever (y compris dans les libs et la lib standard, y'a énormément à gagner à jeter des coups d'œil à la lib standard en Java ou Android).
• Retrouver tous les usages de la classe / méthode / variable
• Débogueur
• Formatage de code (quand il est correct) / auto-imports

L'intérêt de tout ça n'est pas vraiment "taper moins sur son clavier" (un argument que j'ai lu plusieurs fois dans les anti-autocomplétion) mais :

• Moins d'erreurs de frappe
• Moins d'erreurs d'inattention
• Meilleure qualité de code
• Je me concentre sur ce que fait le code et pas sur les contraintes du langage – et j'ai plus de temps pour ce faire.

À noter que du coup les concepts comme "les noms de champ commencent par tel caractère et les variables statiques par tel autre" n'existent pas chez moi.

C'est un bel exemple de ce en quoi l'autocomplétition est utile, mais par contre je ne suis pas sûr d'être d'accord sur "l'IDE a tendance à lire dans tes pensées", c'est plutôt tes pensées qui s'adapte aux automatismes de l'IDE. En particulier, ça devient plus facile de donner des noms génériques à des variables que des noms vraiment pertinents (même si ce n'est pas la règle générale).

@unidan je ne vois pas où tu veux en venir ?

Il veut dire que ce n'est pas l'IDE qui est intelligent au point de comprendre ce que tu souhaites, mais que c'est toi qui t'es adapté aux mécanismes de l'IDE, et que tu as l'habitude de ses réactions.

J'infirme cette supposition : je n'utilise Android Studio que depuis peu, et la pertinence de ses propositions m'a bluffé par rapport à celles d'Eclipse. Y compris les tous premiers jours.

Stranger : de l'autre côté, est-ce que c'est pas mieux de travailler avec une documentation bien fournie et qui facilite la réutilisation des fonctionnalités, plutot que d'y aller au petit bonheur la chance et l'autocomplétition au risque de réimplémenter des choses qui existent déjà ?

PS : je ne contredis pas l'utilité de l'autocomplétition, c'est un outil de confort et ce n'est pas pour rien que les ide l'implémentent, mais simplement que certains arguments pour l'autocomplétition ne sont pas toujours pertinent.

SpaceFox : il faudrait que je vois ça alors !

Je rajouterai à la bonne liste de SpaceFox : le refactoring.

Dans un code très conséquent, changer le nom d'une classe ou d'une variable peut devenir vraiment vraiment pénible (et dans un langage non compilé c'est encore pire, on ne peut pas faire confiance au compilateur pour nous indiquer des références qu'on aurait pu oublier). Changer un nom de package, namespace ou autre peut vite devenir une torture.

Dans ce cas, laisser l'IDE faire permet vraiment de travailler l'esprit tranquille. Franchement, il est extrêmement rare que je ne change pas le nom d'une classe dans la vie d'un projet. Le refactoring automatique d'un IDE m'aide vraiment énormément.

On s'éloigne de l'auto-complétion mais il me semblait utile (puisque c'est aussi une de mes petites manies) de mentionner ce fait.

Et je plussoie également le message de Stranger. Quand on travaille avec des libs récentes, (en version SNAPSHOT) ce qui est mon cas en ce moment. Je sais que la doc en ligne, même auto-générée, ne reflète pas nécessairement la dernière version du projet que j'ai checkout. L'auto-complétion m'aide énormément, pour ça et mon code qui n'est pas encore documenté. Je ne connais pas par coeur les primitives de certaines classes que j'ai écrites, notamment si une propriété est accessible publiquement ou pas encore, si j'ai écrit ou non telle ou telle surcharge de méthode de convenience. Si elle n'existe pas encore, l'IDE me propose de la créer automatiquement, m'amène sur son implémentation, et j'écris dedans.

Après, +1 également pour IntelliJ, même si les raccourcis et l'organisation des menus sont une vraie vraie galère à prendre en main.

Mes petites manies:

• Environnement minimal: terminal avec bspwm pour la gestion des fenêtres, vim comme éditeur et zsh
• Je me sers pas de l'autocomplétion, je fais surtout de petits projets
• J'utilise pas mal le raccourci K de vim qui permet d'ouvrir la manpage de la fonction sous le curseur
• Quand c'est du C, clang avec -Weverything en debug, pour corriger le max de warnings possibles. En général il me reste que des histoires de padding.
• valgrind FTW
• J'essaie de faire des petits commits pour bien pouvoir bisect ensuite le cas échéant
• Je passe beaucoup de temps à bidouiller mes dotfiles
• J'aime bien coder dans le silence absolu (j'éteins mes appareils auditifs et oui je sais c'est de la triche :p)

Ca apporte quoi de plus qu'une bonne vieille regex ? J'ai jamais utilisé de gros IDE, donc je connais pas leurs systèmes de refactoring.

Juste pour savoir, vous utilisez quelle version d'Intellij ?